@primate/core 0.1.10 → 0.2.1

package/lib/private/ServeApp.js

@@ -0,0 +1,305 @@
+import App from "#App";
+import DevModule from "#builtin/DevModule";
+import HandleModule from "#builtin/HandleModule";
+import fail from "#fail";
+import hash from "#hash";
+import I18NModule from "#i18n/Module";
+import location from "#location";
+import log from "#log";
+import reducer from "#reducer";
+import parse from "#request/parse";
+import RequestBag from "#request/RequestBag";
+import RequestBody from "#request/RequestBody";
+import router from "#route/router";
+import SessionModule from "#session/SessionModule";
+import tags from "#tags";
+import is from "@rcompat/assert/is";
+import FileRef from "@rcompat/fs/FileRef";
+import FileRouter from "@rcompat/fs/FileRouter";
+import TEXT_HTML from "@rcompat/http/mime/text/html";
+import serve from "@rcompat/http/serve";
+import Status from "@rcompat/http/Status";
+import entries from "@rcompat/record/entries";
+import pema from "pema";
+import record from "pema/record";
+import string from "pema/string";
+import uint from "pema/uint";
+const deroot = (pathname) => pathname.endsWith("/") && pathname !== "/"
+    ? pathname.slice(0, -1)
+    : pathname;
+// remove excess slashes
+const deslash = (url) => url.replaceAll(/\/{2,}/gu, _ => "/");
+const normalize = (pathname) => deroot(deslash(pathname));
+const to_csp = (config_csp, assets, override) => config_csp
+    // only csp entries in the config will be enriched
+    .map(([key, directives]) => 
+// enrich with application assets
+[key, assets[key] ? directives.concat(...assets[key]) : directives])
+    .map(([key, directives]) => 
+// enrich with explicit csp
+[key, override[key] ? directives.concat(...override[key]) : directives])
+    .map(([key, directives]) => `${key} ${directives.join(" ")}`)
+    .join(";");
+const render_head = (assets, head) => {
+    const fonts = assets.filter(asset => asset.src?.endsWith(".woff2"));
+    const rest = assets.filter(asset => !asset.src?.endsWith(".woff2")
+        && asset.type !== "js");
+    return rest.toSorted(({ type }) => -1 * Number(type === "importmap"))
+        .map(({ code, inline, integrity, src, type }) => type === "style"
+        ? tags.style({ code, href: src, inline })
+        : tags.script({ code, inline, integrity, src, type })).join("\n").concat("\n", head ?? "").concat("\n", fonts.map(font => tags.font({ href: font.src, type: "font/woff2" })).join("\n"));
+};
+const s_http = Symbol("s_http");
+;
+export default class ServeApp extends App {
+    #init;
+    #server;
+    #components;
+    #csp = {};
+    #assets = [];
+    #stores;
+    #frontends = {};
+    #router;
+    #builtins;
+    #i18n_config;
+    constructor(rootfile, init) {
+        super(new FileRef(rootfile).directory, init.config, init.mode);
+        this.#init = init;
+        this.#components = Object.fromEntries(init.components ?? []);
+        this.#stores = Object.fromEntries((init.stores?.map(([k, s]) => [k, s.default])) ?? []);
+        const http = this.#init.config.http;
+        this.#i18n_config = init.i18n_config;
+        this.set(s_http, {
+            host: http.host,
+            port: http.port,
+            ssl: this.secure ? {
+                cert: this.root.join(http.ssl.cert),
+                key: this.root.join(http.ssl.key),
+            } : {},
+        });
+        this.#router = FileRouter.init({
+            extensions: [".js"],
+            specials: {
+                error: { recursive: false },
+                guard: { recursive: true },
+                layout: { recursive: true },
+            },
+        }, init.files.routes.map(s => s[0]));
+        this.#builtins = {
+            dev: init.mode === "development" ? new DevModule(this) : undefined,
+            handle: new HandleModule(this),
+            session: new SessionModule(this),
+            i18n: init.i18n_config ? new I18NModule(init.i18n_config) : undefined,
+        };
+    }
+    ;
+    get secure() {
+        const ssl = this.config("http.ssl");
+        return ssl.key !== undefined && ssl.cert !== undefined;
+    }
+    loader() {
+        return this.#init.loader;
+    }
+    serve(pathname) {
+        return this.loader().serve(pathname);
+    }
+    get assets() {
+        return this.#assets;
+    }
+    get modules() {
+        const { session, i18n } = this.#builtins;
+        return [session, i18n, ...super.modules].filter(m => m !== undefined);
+    }
+    get url() {
+        const { host, port } = this.config("http");
+        return `http${this.secure ? "s" : ""}://${host}:${port}`;
+    }
+    ;
+    get router() {
+        return this.#router;
+    }
+    get frontends() {
+        return { ...this.#frontends };
+    }
+    get files() {
+        return this.#init.files;
+    }
+    get stores() {
+        return this.#stores;
+    }
+    get i18n() {
+        return this.#i18n_config;
+    }
+    component(name) {
+        const base = name.slice(0, name.lastIndexOf((".")));
+        const component = this.#components[base];
+        if (component === undefined) {
+            throw fail("missing component {0}", `${location.components}/${name}`);
+        }
+        return (component.default ?? component);
+    }
+    ;
+    headers(csp = {}) {
+        const http_csp = Object.entries(this.config("http.csp") ?? {});
+        return {
+            ...this.config("http.headers") ?? {},
+            ...http_csp.length === 0 ? {} : {
+                "Content-Security-Policy": to_csp(http_csp, this.#csp, csp),
+            },
+        };
+    }
+    ;
+    render(content) {
+        const { body, head, page, partial, placeholders = {} } = content;
+        ["body", "head"].forEach(key => is(placeholders[key]).undefined());
+        return partial ? body : Object.entries(placeholders)
+            // replace given placeholders, defaulting to ""
+            .reduce((rendered, [key, value]) => rendered
+            .replaceAll(`%${key}%`, value?.toString() ?? ""), this.page(page))
+            // replace non-given placeholders, aside from %body% / %head%
+            .replaceAll(/(?<keep>%(?:head|body)%)|%.*?%/gus, "$1")
+            // replace body and head
+            .replace("%body%", body)
+            .replace("%head%", render_head(this.#assets, head));
+    }
+    page(page) {
+        return this.loader().page(page);
+    }
+    respond(body, init) {
+        const { headers, status } = pema({
+            headers: record(string, string),
+            status: uint.values(Status).default(Status.OK),
+        }).parse(init);
+        return new Response(body, {
+            headers: {
+                "Content-Type": TEXT_HTML, ...this.headers(), ...headers,
+            }, status: status,
+        });
+    }
+    ;
+    view(options) {
+        // split render and respond options
+        const { headers = {}, status = Status.OK, statusText, ...rest } = options;
+        return this.respond(this.render(rest), { headers, status });
+    }
+    ;
+    media(content_type, response = {}) {
+        return {
+            headers: { ...response.headers, "Content-Type": content_type },
+            status: response.status ?? Status.OK,
+        };
+    }
+    ;
+    async publish({ code, inline = false, src, type = "" }) {
+        if (inline || type === "style") {
+            this.#assets.push({
+                code: inline ? code : "",
+                inline,
+                integrity: await hash(code),
+                src: FileRef.join(this.#init.config.http.static.root, src ?? "").path,
+                type,
+            });
+        }
+        // rehash assets_csp
+        this.create_csp();
+    }
+    ;
+    create_csp() {
+        this.#csp = this.#assets.map(({ integrity, type: directive }) => [`${directive === "style" ? "style" : "script"}-src`, integrity])
+            .reduce((csp, [directive, hash]) => ({ ...csp, [directive]: csp[directive].concat(`'${hash}'`) }), { "script-src": [], "style-src": [] });
+    }
+    ;
+    register(extension, viewFunction) {
+        if (this.#frontends[extension] !== undefined) {
+            throw fail("double file extension {0}", extension);
+        }
+        this.#frontends[extension] = viewFunction;
+    }
+    ;
+    async start() {
+        this.#assets = await Promise.all(this.#init.assets.map(async (asset) => {
+            const code = asset.type === "importmap"
+                ? JSON.stringify(asset.code, null, 2)
+                : asset.code;
+            return {
+                ...asset,
+                code,
+                integrity: await hash(code),
+            };
+        }));
+        const modules = [
+            this.#builtins.dev,
+            ...this.modules,
+            this.#builtins.handle,
+        ].filter(m => m !== undefined);
+        const handle = (request) => reducer(modules, request, "handle");
+        this.#server = await serve(async (request) => {
+            try {
+                return await handle(parse(request));
+            }
+            catch (error) {
+                log.error(error);
+                return new Response(null, { status: Status.INTERNAL_SERVER_ERROR });
+            }
+        }, this.get(s_http));
+        log.system("started {0}", this.url);
+    }
+    ;
+    stop() {
+        this.#server.stop();
+        log.system("stopped {0}", this.url);
+    }
+    ;
+    upgrade(request, actions) {
+        return this.#server.upgrade(request, actions);
+    }
+    async route(request) {
+        const { original, url } = request;
+        const pathname = normalize(url.pathname);
+        const route = this.router.match(original);
+        if (route === undefined) {
+            log.info("no {0} route to {1}", original.method, pathname);
+            return;
+        }
+        const verb = original.method.toLowerCase();
+        const { errors = [], guards = [], layouts = [] } = entries(route.specials)
+            .map(([key, value]) => [`${key}s`, value ?? []])
+            .map(([key, value]) => [key, value.map(v => {
+                const verbs = router.get(v);
+                const routeHandler = verbs[verb];
+                if (routeHandler === undefined) {
+                    throw fail("route {0} has no {1} verb", route.path, verb);
+                }
+                return routeHandler.handler;
+            })])
+            .get();
+        const verbs = router.get(route.path);
+        const routePath = verbs[verb];
+        if (routePath === undefined) {
+            throw fail("route {0} has no {1} verb", route.path, verb);
+        }
+        const parseBody = routePath.options.parseBody;
+        const body = parseBody ?? this.config("request.body.parse")
+            ? await RequestBody.parse(original, url)
+            : RequestBody.none();
+        return {
+            errors,
+            guards,
+            handler: routePath.handler,
+            layouts,
+            request: {
+                ...request,
+                body,
+                path: new RequestBag(route.params, "path", {
+                    normalize: k => k.toLowerCase(),
+                    raw: url.pathname,
+                }),
+            },
+        };
+    }
+    get session() {
+        return this.#init.session_config;
+    }
+    ;
+}
+//# sourceMappingURL=ServeApp.js.map

package/lib/private/ServeInit.d.ts

@@ -0,0 +1,29 @@
+import type Asset from "#asset/Asset";
+import type Config from "#config/Config";
+import type I18NConfig from "#i18n/Config";
+import type Loader from "#Loader";
+import type Mode from "#Mode";
+import type SessionConfig from "#session/Config";
+import type Dict from "@rcompat/type/Dict";
+type Import = {
+    default: unknown;
+} & Dict;
+type BuildFiles = {
+    routes: [string, {
+        default: any;
+    }][];
+};
+type ServeInit = {
+    assets: Asset[];
+    components?: [string, Import][];
+    stores?: [string, Import][];
+    config: Config;
+    files: BuildFiles;
+    loader: Loader;
+    mode: Mode;
+    target: string;
+    session_config: SessionConfig;
+    i18n_config?: I18NConfig;
+};
+export type { ServeInit as default };
+//# sourceMappingURL=ServeInit.d.ts.map

package/lib/private/ServeInit.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ServeInit.js.map

package/lib/private/asset/Asset.d.ts

@@ -0,0 +1,11 @@
+import type Dict from "@rcompat/type/Dict";
+export default interface Asset {
+    code: {
+        imports: Dict;
+    } | string;
+    inline: boolean;
+    integrity: string;
+    src?: string;
+    type: string;
+}
+//# sourceMappingURL=Asset.d.ts.map

package/lib/private/asset/Asset.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Asset.js.map

package/lib/private/asset/Font.d.ts

@@ -0,0 +1,8 @@
+export default interface Font {
+    as: string;
+    crossorigin: string;
+    href: string;
+    rel: "preload";
+    type: string;
+}
+//# sourceMappingURL=Font.d.ts.map

package/lib/private/asset/Font.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Font.js.map

package/lib/private/asset/Script.d.ts

@@ -0,0 +1,9 @@
+export default interface Script {
+    code: string;
+    id?: string;
+    inline: boolean;
+    integrity: string;
+    src?: string;
+    type: string;
+}
+//# sourceMappingURL=Script.d.ts.map

package/lib/private/asset/Script.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Script.js.map

package/lib/private/asset/Style.d.ts

@@ -0,0 +1,6 @@
+export default interface Style {
+    code: string;
+    href?: string;
+    inline: boolean;
+}
+//# sourceMappingURL=Style.d.ts.map

package/lib/private/asset/Style.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Style.js.map

package/lib/private/backend/Module.d.ts

@@ -0,0 +1,18 @@
+import Module from "#Module";
+export default abstract class BackendModule extends Module {
+    #private;
+    abstract defaultExtension: string;
+    static schema: import("pema").ObjectType<{
+        fileExtension: import("pema").OptionalType<import("pema/string").StringType>;
+    }>;
+    static options: {
+        fileExtension: string | undefined;
+    };
+    static input: {
+        fileExtension?: string | undefined;
+    } | undefined;
+    constructor(options?: typeof BackendModule.schema.input);
+    get fileExtension(): string;
+    get package(): string;
+}
+//# sourceMappingURL=Module.d.ts.map

package/lib/private/backend/Module.js

@@ -0,0 +1,22 @@
+import Module from "#Module";
+import pema from "pema";
+import string from "pema/string";
+export default class BackendModule extends Module {
+    #options;
+    static schema = pema({
+        fileExtension: string.optional(),
+    });
+    static options = BackendModule.schema.infer;
+    static input = BackendModule.schema.input;
+    constructor(options) {
+        super();
+        this.#options = BackendModule.schema.parse(options);
+    }
+    get fileExtension() {
+        return this.#options.fileExtension ?? this.defaultExtension;
+    }
+    get package() {
+        return `@primate/${this.name}`;
+    }
+}
+//# sourceMappingURL=Module.js.map

package/lib/private/build.d.ts

@@ -0,0 +1,4 @@
+import type Mode from "#Mode";
+declare const _default: (mode: Mode, target: string) => Promise<true | undefined>;
+export default _default;
+//# sourceMappingURL=build.d.ts.map

package/lib/private/build.js

@@ -0,0 +1,45 @@
+import BuildApp from "#BuildApp";
+import bye from "#bye";
+import default_config from "#config/index";
+import fail from "#fail";
+import log from "#log";
+import root from "@rcompat/package/root";
+import empty from "@rcompat/record/empty";
+const no_config = (config) => config === undefined || empty(config);
+const find_config = async (project_root) => {
+    const ts_config = project_root.join("config/app.ts");
+    if (await ts_config.exists())
+        return ts_config;
+    const js_config = project_root.join("config/app.js");
+    if (await js_config.exists())
+        return js_config;
+};
+const get_config = async (project_root) => {
+    const config = await find_config(project_root);
+    if (config !== undefined) {
+        try {
+            const imported = await config.import("default");
+            if (no_config(imported))
+                throw fail("empty config file at {0}", config);
+            return imported;
+        }
+        catch (error) {
+            throw fail("error in config file {0}", error);
+        }
+    }
+    return default_config();
+};
+export default async (mode, target) => {
+    try {
+        const package_root = await root();
+        const config = await get_config(package_root);
+        const app = await new BuildApp(package_root, config, mode).init(target);
+        await app.buildInit();
+        return true;
+    }
+    catch (error) {
+        log.error(error);
+        bye();
+    }
+};
+//# sourceMappingURL=build.js.map

package/lib/private/builtin/DevModule.d.ts

@@ -0,0 +1,11 @@
+import Module from "#Module";
+import type NextHandle from "#module/NextHandle";
+import type RequestFacade from "#request/RequestFacade";
+import type ServeApp from "#ServeApp";
+export default class DevModule extends Module {
+    #private;
+    name: string;
+    constructor(app: ServeApp);
+    handle(request: RequestFacade, next: NextHandle): import("@rcompat/type/MaybePromise").default<Response>;
+}
+//# sourceMappingURL=DevModule.d.ts.map

package/lib/private/builtin/DevModule.js

@@ -0,0 +1,32 @@
+import Module from "#Module";
+import reload_defaults from "@rcompat/build/reload/defaults";
+import reload_path from "@rcompat/build/reload/path";
+function pass(address, request) {
+    return fetch(address, {
+        body: request.body,
+        duplex: "half",
+        headers: request.headers,
+        method: request.method,
+    });
+}
+export default class DevModule extends Module {
+    name = "builtin/dev";
+    #paths;
+    #reload_url;
+    constructor(app) {
+        super();
+        const assets = app.assets
+            .filter(asset => asset.type !== "importmap")
+            .map(asset => asset.src);
+        const http = app.config("http");
+        this.#paths = ([reload_path]).concat(assets);
+        this.#reload_url = `http://${http.host}:${reload_defaults.port}`;
+    }
+    handle(request, next) {
+        const { pathname } = new URL(request.url);
+        return this.#paths.includes(pathname)
+            ? pass(`${this.#reload_url}${pathname}`, request.original)
+            : next(request);
+    }
+}
+//# sourceMappingURL=DevModule.js.map

package/lib/private/builtin/HandleModule.d.ts

@@ -0,0 +1,10 @@
+import Module from "#Module";
+import type RequestFacade from "#request/RequestFacade";
+import type ServeApp from "#ServeApp";
+export default class HandleModule extends Module {
+    #private;
+    name: string;
+    constructor(app: ServeApp);
+    handle(request: RequestFacade): Promise<Response>;
+}
+//# sourceMappingURL=HandleModule.d.ts.map

package/lib/private/builtin/HandleModule.js

@@ -0,0 +1,15 @@
+import route from "#request/route";
+import Module from "#Module";
+export default class HandleModule extends Module {
+    name = "builtin/handle";
+    #app;
+    constructor(app) {
+        super();
+        this.#app = app;
+    }
+    async handle(request) {
+        return await this.#app.serve(request.url.pathname)
+            ?? route(this.#app, request);
+    }
+}
+//# sourceMappingURL=HandleModule.js.map

package/lib/private/bye.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => boolean;
+export default _default;
+//# sourceMappingURL=bye.d.ts.map

package/{src → lib}/private/bye.js

@@ -1,5 +1,5 @@
-import print from "@rcompat/cli/print";
 import dim from "@rcompat/cli/color/dim";
 import yellow from "@rcompat/cli/color/yellow";
-
+import print from "@rcompat/cli/print";
 export default () => print(dim(yellow("~~ bye\n")));
+//# sourceMappingURL=bye.js.map

package/lib/private/client/App.d.ts

@@ -0,0 +1,4 @@
+export default class ClientApp {
+    start(): void;
+}
+//# sourceMappingURL=App.d.ts.map

package/lib/private/client/App.js

@@ -0,0 +1,12 @@
+// @ts-expect-error esbuild vfs
+import * as frontends from "#frontends";
+export default class ClientApp {
+    start() {
+        const hydration = document.getElementById("hydration")?.textContent;
+        if (hydration !== undefined) {
+            const { component, frontend, ...data } = JSON.parse(hydration);
+            frontends[frontend]?.mount(component, data);
+        }
+    }
+}
+//# sourceMappingURL=App.js.map

package/lib/private/client/Data.d.ts

@@ -0,0 +1,9 @@
+import type Dict from "@rcompat/type/Dict";
+type ClientData<T extends Dict = Dict> = {
+    component: string;
+    request: Dict;
+    spa: boolean;
+    ssr: boolean;
+} & T;
+export type { ClientData as default };
+//# sourceMappingURL=Data.d.ts.map

package/lib/private/client/Data.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Data.js.map

package/lib/private/client/ValidateInit.d.ts

@@ -0,0 +1,13 @@
+import type Dict from "@rcompat/type/Dict";
+import type JSONPointer from "@rcompat/type/JSONPointer";
+import type JSONValue from "@rcompat/type/JSONValue";
+type ValidateInit<T> = {
+    headers?: Dict<string>;
+    initial: T;
+    map?: (value: T) => JSONValue;
+    method: "DELETE" | "PATCH" | "POST" | "PUT";
+    path?: JSONPointer;
+    url: string;
+};
+export type { ValidateInit as default };
+//# sourceMappingURL=ValidateInit.d.ts.map

package/lib/private/client/ValidateInit.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidateInit.js.map

package/lib/private/client/ValidateUpdater.d.ts

@@ -0,0 +1,3 @@
+type ValidateUpdater<T> = (previous: T) => T;
+export type { ValidateUpdater as default };
+//# sourceMappingURL=ValidateUpdater.d.ts.map

package/lib/private/client/ValidateUpdater.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidateUpdater.js.map

package/lib/private/client/ValidationError.d.ts

@@ -0,0 +1,6 @@
+import type Issue from "pema/Issue";
+type ValidationError = {
+    issues?: ReadonlyArray<Issue>;
+} & Error;
+export type { ValidationError as default };
+//# sourceMappingURL=ValidationError.d.ts.map

package/lib/private/client/ValidationError.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ValidationError.js.map

package/lib/private/client/spa/index.d.ts

@@ -0,0 +1,6 @@
+import type ClientData from "#client/Data";
+import type Dict from "@rcompat/type/Dict";
+type Updater<T extends Dict> = (json: ClientData<T>, after?: () => void) => void;
+declare const _default: <T extends Dict>(updater: Updater<T>) => void;
+export default _default;
+//# sourceMappingURL=index.d.ts.map