@primate/core 0.1.9 → 0.2.0

package/lib/private/fail.js

@@ -0,0 +1,5 @@
+import AppError from "#AppError";
+export default function fail(message, ...params) {
+    return new AppError(message, ...params);
+}
+//# sourceMappingURL=fail.js.map

package/lib/private/frontend/Component.d.ts

@@ -0,0 +1,8 @@
+import type Dict from "@rcompat/type/Dict";
+type Component = {
+    component: unknown;
+    name: string;
+    props: Dict;
+};
+export type { Component as default };
+//# sourceMappingURL=Component.d.ts.map

package/lib/private/frontend/Component.js

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

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

@@ -0,0 +1,60 @@
+import type App from "#App";
+import type BuildApp from "#BuildApp";
+import type Render from "#frontend/Render";
+import type ServerComponent from "#frontend/ServerComponent";
+import type ViewResponse from "#frontend/ViewResponse";
+import Module from "#Module";
+import type Next from "#module/Next";
+import type NextBuild from "#module/NextBuild";
+import type NextServe from "#module/NextServe";
+import type ServeApp from "#ServeApp";
+import FileRef from "@rcompat/fs/FileRef";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+export default abstract class FrontendModule<S = ServerComponent> extends Module {
+    #private;
+    abstract client: boolean;
+    abstract layouts: boolean;
+    abstract defaultExtensions: string[];
+    render: Render<S>;
+    root?: {
+        create: (depth: number, i18n_active: boolean) => string;
+    };
+    compile: {
+        client?: (text: string, file: FileRef, root: boolean) => MaybePromise<{
+            css?: null | string;
+            js: string;
+        }>;
+        server?: (text: string) => MaybePromise<string>;
+    };
+    css?: {
+        filter: RegExp;
+    };
+    static schema: import("pema").ObjectType<{
+        fileExtensions: import("pema").OptionalType<import("pema/array").ArrayType<import("pema/string").StringType>>;
+        spa: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
+        ssr: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;
+    }>;
+    static options: {
+        fileExtensions: string[] | undefined;
+        spa: boolean;
+        ssr: boolean;
+    };
+    static input: {
+        fileExtensions?: string[] | undefined;
+        spa?: boolean | undefined;
+        ssr?: boolean | undefined;
+    } | undefined;
+    constructor(options?: typeof FrontendModule.schema.input);
+    get fileExtensions(): string[];
+    get package(): string;
+    get rootname(): string;
+    get ssr(): boolean;
+    get spa(): boolean;
+    normalize(name: string): Promise<string>;
+    respond: ViewResponse;
+    serve(app: ServeApp, next: NextServe): MaybePromise<ServeApp>;
+    publish(app: BuildApp): void;
+    init<T extends App>(app: T, next: Next<T>): MaybePromise<T>;
+    build(app: BuildApp, next: NextBuild): Promise<BuildApp>;
+}
+//# sourceMappingURL=Module.d.ts.map

package/lib/private/frontend/Module.js

@@ -0,0 +1,241 @@
+import AppError from "#AppError";
+import bundle from "#frontend/bundle-server";
+import inline from "#inline";
+import location from "#location";
+import Module from "#Module";
+import assert from "@rcompat/assert";
+import map from "@rcompat/async/map";
+import hash from "@rcompat/crypto/hash";
+import FileRef from "@rcompat/fs/FileRef";
+import APPLICATION_JSON from "@rcompat/http/mime/application/json";
+import Status from "@rcompat/http/Status";
+import pema from "pema";
+import array from "pema/array";
+import boolean from "pema/boolean";
+import string from "pema/string";
+async function normalize(path) {
+    return `p_${await hash(path)}`;
+}
+export default class FrontendModule extends Module {
+    #options;
+    render = async (component, props) => ({ body: await component(props) });
+    root;
+    compile = {};
+    css;
+    static schema = pema({
+        fileExtensions: array(string).optional(),
+        spa: boolean.default(true),
+        ssr: boolean.default(true),
+    });
+    static options = FrontendModule.schema.infer;
+    static input = FrontendModule.schema.input;
+    constructor(options) {
+        super();
+        this.#options = FrontendModule.schema.parse(options);
+    }
+    get fileExtensions() {
+        return this.#options.fileExtensions ?? this.defaultExtensions;
+    }
+    get package() {
+        return `@primate/${this.name}`;
+    }
+    get rootname() {
+        return `root_${this.name}`;
+    }
+    get ssr() {
+        return this.#options.ssr;
+    }
+    get spa() {
+        return this.#options.spa;
+    }
+    #load(name, props, app) {
+        const component = app.component(name);
+        return { component, name, props };
+    }
+    ;
+    async #render(server, client, app) {
+        const { body, head = "", headers = {} } = this.ssr
+            ? await this.render(server.component, server.props)
+            : { body: "", head: "" };
+        if (!this.client) {
+            return { body, head, headers };
+        }
+        const code = "import app from \"app\"; app.start();";
+        const inlined = await inline(code, "module");
+        const json_props = JSON.stringify({ frontend: this.name, ...client });
+        const hydrated = await inline(json_props, APPLICATION_JSON, "hydration");
+        const script_src = [inlined.integrity, hydrated.integrity];
+        return {
+            body,
+            head: head.concat(inlined.head, hydrated.head),
+            headers: app.headers({ "script-src": script_src }),
+        };
+    }
+    normalize(name) {
+        return normalize(name);
+    }
+    respond = (component, props = {}, options = {}) => async (app, { as_layout, layouts = [] } = {}, request) => {
+        if (as_layout) {
+            return this.#load(component, props, app);
+        }
+        const components = (await Promise.all(layouts
+            .map(layout => layout(app, { as_layout: true }, request))))
+            /* set the actual page as the last component */
+            .concat(this.#load(component, props, app));
+        const $request = {
+            context: request.context,
+            cookies: request.cookies.toJSON(),
+            headers: request.headers.toJSON(),
+            path: request.path.toJSON(),
+            query: request.query.toJSON(),
+            url: request.url,
+        };
+        const $props = this.layouts
+            ? {
+                components: await map(components, ({ name }) => normalize(name)),
+                props: components.map(c => c.props),
+                request: $request,
+            }
+            : { props, request: $request };
+        const client = {
+            component: this.layouts ? "root" : await normalize(component),
+            spa: this.spa,
+            ssr: this.ssr,
+            ...$props,
+        };
+        if (this.spa && request.headers.get("Accept") === APPLICATION_JSON) {
+            return new Response(JSON.stringify(client), {
+                headers: { ...app.headers(), "Content-Type": APPLICATION_JSON },
+                status: options.status ?? Status.OK,
+            });
+        }
+        try {
+            const server = this.layouts
+                ? {
+                    component: app.component(`${this.rootname}.js`),
+                    props: {
+                        components: components.map(c => c.component),
+                        props: components.map(c => c.props),
+                        request: $request,
+                    },
+                }
+                : {
+                    component: app.component(component),
+                    props,
+                    request: $request,
+                };
+            const { body, head, headers } = await this.#render(server, client, app);
+            return app.view({ body, head, headers, ...options });
+        }
+        catch (error) {
+            const path = `${location.components}/${component}`;
+            throw new AppError("error in component {0}\n{1}", path, error);
+        }
+    };
+    serve(app, next) {
+        this.fileExtensions.forEach(fe => app.register(fe, this.respond));
+        return next(app);
+    }
+    publish(app) {
+        if (this.compile.client) {
+            const { compile, css, fileExtensions, name, root } = this;
+            if (this.client) {
+                fileExtensions.forEach(fe => app.frontends.set(name, fe));
+            }
+            app.build.plugin({
+                name,
+                setup(build) {
+                    const resolveDir = app.root.path;
+                    if (root !== undefined) {
+                        const filter = new RegExp(`^${name}:root`);
+                        build.onResolve({ filter }, ({ path }) => {
+                            return { namespace: `${name}`, path };
+                        });
+                        build.onLoad({ filter }, async () => {
+                            const contents = (await compile.client(root.create(app.depth(), app.i18n_active), new FileRef("/tmp"), true)).js;
+                            return contents ? { contents, loader: "js", resolveDir } : null;
+                        });
+                    }
+                    if (css !== undefined) {
+                        build.onResolve({ filter: css.filter }, ({ path }) => {
+                            return { namespace: `${name}css`, path };
+                        });
+                        build.onLoad({ filter: css.filter }, ({ path }) => {
+                            const contents = app.build.load(FileRef.webpath(path));
+                            return contents
+                                ? { contents, loader: "css", resolveDir: resolveDir }
+                                : null;
+                        });
+                    }
+                    const components_filter = new RegExp(`^${name}:components`);
+                    build.onResolve({ filter: components_filter }, ({ path }) => {
+                        return { namespace: `${name}`, path };
+                    });
+                    build.onLoad({ filter: components_filter }, async () => {
+                        const components = await app.root
+                            .join(location.components)
+                            .collect(c => fileExtensions.includes(c.fullExtension));
+                        let contents = "";
+                        for (const component of components) {
+                            const { path } = component.debase(component.directory, "/");
+                            contents += `export { default as ${await normalize(path)} }
+                from "#component/${path}";\n`;
+                        }
+                        return { contents, resolveDir: app.root.path };
+                    });
+                    const filter = new RegExp(`(${fileExtensions.map(e => e.replace(".", "\\.")).join("|")})$`);
+                    build.onLoad({ filter }, async (args) => {
+                        const file = new FileRef(args.path);
+                        // Compile file to JavaScript and potentially CSS
+                        const compiled = await compile.client(await file.text(), file, false);
+                        let contents = compiled.js;
+                        if (css
+                            && compiled.css !== null
+                            && compiled.css !== undefined
+                            && compiled.css !== "") {
+                            const path = FileRef.webpath(`${args.path}css`);
+                            app.build.save(path, compiled.css);
+                            contents += `\nimport "${path}";`;
+                        }
+                        return { contents };
+                    });
+                },
+            });
+        }
+    }
+    init(app, next) {
+        this.fileExtensions.forEach(e => {
+            app.bind(e, async (file, { context }) => {
+                assert(context === "components", `${this.name}: only components supported`);
+                if (this.compile.server) {
+                    const original = file.debase(app.runpath("stage", "components"));
+                    const source = app.path.components.join(original);
+                    const code = await this.compile.server(await source.text());
+                    const bundled = await bundle({
+                        code,
+                        source,
+                        root: app.root,
+                        extensions: this.fileExtensions,
+                        compile: async (s) => this.compile.server(s),
+                    });
+                    await file.append(".js").write(bundled);
+                }
+            });
+        });
+        return next(app);
+    }
+    async build(app, next) {
+        // compile root server
+        if (this.root !== undefined && this.compile.server !== undefined) {
+            const filename = `${this.rootname}.js`;
+            const root = await this.compile.server(this.root.create(app.depth(), app.i18n_active));
+            const path = app.runpath(location.server, filename);
+            await path.write(root);
+            app.addRoot(path);
+        }
+        this.publish(app);
+        return next(app);
+    }
+    ;
+}
+//# sourceMappingURL=Module.js.map

package/lib/private/frontend/Publish.d.ts

@@ -0,0 +1,5 @@
+import type BuildApp from "#BuildApp";
+import type { Plugin } from "esbuild";
+type Publish = (app: BuildApp, extension: string) => Plugin;
+export { Publish as default };
+//# sourceMappingURL=Publish.d.ts.map

package/lib/private/frontend/Publish.js

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

package/lib/private/frontend/Render.d.ts

@@ -0,0 +1,9 @@
+import type Dict from "@rcompat/type/Dict";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+type Render<S = unknown> = (component: S, props: Dict) => MaybePromise<{
+    body: string;
+    head?: string;
+    headers?: Record<string, string>;
+}>;
+export type { Render as default };
+//# sourceMappingURL=Render.d.ts.map

package/lib/private/frontend/Render.js

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

package/lib/private/frontend/ServerComponent.d.ts

@@ -0,0 +1,5 @@
+import type Dict from "@rcompat/type/Dict";
+import type MaybePromise from "@rcompat/type/MaybePromise";
+type ServerComponent = (props: Dict) => MaybePromise<string>;
+export { ServerComponent as default };
+//# sourceMappingURL=ServerComponent.d.ts.map

package/lib/private/frontend/ServerComponent.js

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

package/lib/private/frontend/ServerData.d.ts

@@ -0,0 +1,7 @@
+import type Dict from "@rcompat/type/Dict";
+type ServerData<T> = {
+    component: T;
+    props: Dict;
+};
+export type { ServerData as default };
+//# sourceMappingURL=ServerData.d.ts.map

package/lib/private/frontend/ServerData.js

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

package/lib/private/frontend/ViewOptions.d.ts

@@ -0,0 +1,12 @@
+import type Dict from "@rcompat/type/Dict";
+export default interface ViewOptions extends ResponseInit {
+    csp?: {
+        script_src?: string[];
+        style_src?: string[];
+    };
+    head?: string;
+    page?: string;
+    partial?: boolean;
+    placeholders?: Omit<Dict, "body" | "head">;
+}
+//# sourceMappingURL=ViewOptions.d.ts.map

package/lib/private/frontend/ViewOptions.js

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

package/lib/private/frontend/ViewResponse.d.ts

@@ -0,0 +1,6 @@
+import type ViewOptions from "#frontend/ViewOptions";
+import type ResponseFunction from "#response/ResponseFunction";
+import type Dict from "@rcompat/type/Dict";
+type View = (name: string, props?: Dict, options?: ViewOptions) => ResponseFunction;
+export { View as default };
+//# sourceMappingURL=ViewResponse.d.ts.map

package/lib/private/frontend/ViewResponse.js

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

package/lib/private/frontend/bundle-server.d.ts

@@ -0,0 +1,11 @@
+import FileRef from "@rcompat/fs/FileRef";
+type Init = {
+    code: string;
+    source: FileRef;
+    root: FileRef;
+    extensions: string[];
+    compile: (src: string, file?: FileRef) => Promise<string>;
+};
+export default function bundleServer(init: Init): Promise<string>;
+export {};
+//# sourceMappingURL=bundle-server.d.ts.map

package/lib/private/frontend/bundle-server.js

@@ -0,0 +1,48 @@
+import FileRef from "@rcompat/fs/FileRef";
+import * as esbuild from "esbuild";
+export default async function bundleServer(init) {
+    const { code, source, root, extensions, compile } = init;
+    const filter = new RegExp(`(${extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
+    const plugin = {
+        name: "primate/bundle/server",
+        setup(build) {
+            // compile non-JS sources to JS
+            build.onLoad({ filter }, async (args) => {
+                const file = new FileRef(args.path);
+                const src = await file.text();
+                const contents = await compile(src, file);
+                return { contents, loader: "js", resolveDir: file.directory.path };
+            });
+            // externalise anything not relative nor "#component/"
+            build.onResolve({ filter: /.*/ }, args => {
+                const p = args.path;
+                const relative = p.startsWith("./") || p.startsWith("../");
+                const components = p.startsWith("#component/");
+                if (!relative && !components)
+                    return { path: p, external: true };
+                return null;
+            });
+        },
+    };
+    const result = await esbuild.build({
+        absWorkingDir: root.path,
+        tsconfig: root.join("tsconfig.json").path,
+        bundle: true,
+        write: false,
+        platform: "node",
+        format: "esm",
+        target: "esnext",
+        conditions: ["node", "default", "apekit"],
+        resolveExtensions: [".ts", ".js", ...extensions],
+        plugins: [plugin],
+        stdin: {
+            contents: code,
+            sourcefile: source.path,
+            resolveDir: source.directory.path,
+            loader: "js",
+        },
+        logLevel: "silent",
+    });
+    return result.outputFiles[0].text;
+}
+//# sourceMappingURL=bundle-server.js.map

package/lib/private/hash.d.ts

@@ -0,0 +1,3 @@
+declare function hash(data: string, algorithm?: string): Promise<string>;
+export default hash;
+//# sourceMappingURL=hash.d.ts.map

package/lib/private/hash.js

@@ -0,0 +1,10 @@
+import crypto from "@rcompat/crypto";
+const encoder = new TextEncoder();
+async function hash(data, algorithm = "sha-384") {
+    const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
+    const prefix = algorithm.replace("-", _ => "");
+    return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
+}
+;
+export default hash;
+//# sourceMappingURL=hash.js.map

package/lib/private/hook/build.d.ts

@@ -0,0 +1,4 @@
+import type BuildApp from "#BuildApp";
+declare const _default: (app: BuildApp) => Promise<BuildApp>;
+export default _default;
+//# sourceMappingURL=build.d.ts.map