Texa

import { Application, Router } from "https://deno.land/x/texa/mod.ts";

const app = new Application("127.0.0.1:3000");

const app = new Application("127.0.0.1:3000", {
    allowWebSocket: false
});

app.on("connection", async socket => {
    socket.on("message", async message => {
        // text message
    });
    socket.on("binary", async data => {
        // binary message
    });
    socket.on("ping", async data => {
        // ping event
    });
    socket.on("pong", async data => {
        // pong event
    });
    socket.on("close", async (closer, code, reason) => {
        // Close event
    });
});

app.use(
    async (req, res, next) => {
        let err: Error | null = null;
        try
        {
            await next();
        } catch (error)
        {
            err = error;
            await res.status(500).end("Internal server error, if you're a developer you can check the server logs.");
        }
        console.log(
            "%s %dms %s %s",                      // The log template.
            req.method,                           // The request method.
            Date.now() - req.at,                  // The amount of ms it took from start to finish.
            res.statusCode,                       // The status code that was sent back.
            req.url.pathname,                     // The requested resource.
            err !== null ? ` - ${err.stack}` : "" // Include an error if an error occured.
        );
    }
);

const router = new Router();
app.use(router);

router.get("/hello", async (req, res) => {
    await res.end("World");
});

router.use(
    async (req, res, next) => {
        // Do something.
        await next();
    }
);

router.use(
    "/path",
    async (req, res, next) => {
        res.end(req.url.pathname);
    }
);

router.get("/user/:param", async (req, res) => {
    console.log(req.params);
    // { param: ... }
});

"/:requiredParam"
"/:requiredParam(withRegex)"
"/:optionalParam?"
"/:optionalParam(withRegex)?"
"/:zeroOrMoreOccurances*"
"/:zeroOrMoreOccurances(withRegex)*"
"/:oneOrMoreOccurances+"
"/:oneOrMoreOccurances(withRegex)+"

import { Middleware } from "https://deno.land/x/texa/mod.ts";

class MyMiddleware extends Middleware
{
    public value: string = "World";
    
    public run: Middleware["run"] = async (req, res, next) => {
        res.headers.set("X-Hello", this.value);
        await next();
    };
}

const middleware = new MyMiddleware();
app.use(middleware);

middleware.value = "Something else now";

// Imports
import { Application, Router } from "https://deno.land/x/texa/mod.ts";

// Create application.
const app = new Router();

app.get("/", async (req, res) => {
    res.end("Welcome home!");
});

// Create http app.
const httpApp = new Application("0.0.0.0:80")
    .use(app);

// Create https app.
const httpsApp = new Application("0.0.0.0:443", {
    certFile: "/path/to/cert.pem",
    keyFile: "/path/to/key.pem"
}).use(app);

// Start listening for requests on both servers.
httpApp.start().catch(console.error);
httpApps.start().catch(console.error);

// Imports
import { Static } from "https://deno.land/x/texa/mod.ts";

// Use the static middleware.
app.use(
    // Arg 1. The directory to serve from, relative from <CWD>.
    new Static("www")
);

app.use(
    new Static("www", {
        handlers: {
            ejs: async (pathname, req, res) => {
                // Compute compiledEJS somehow..
                return [ compiledEJS, "text/html" ];
            }
        }
    })
);

app.use(
    new Static("www", {
        indexes: [ "index.html" ]
    })
);

app.use(
    new Static("www", {
        vanityExtensions: [ "html" ]
    })
);