@primate/core 0.4.6 → 0.6.0

package/lib/private/fail.js

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

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

@@ -1,62 +0,0 @@
-import type App from "#App";
-import type BuildApp from "#build/App";
-import type Render from "#frontend/Render";
-import type ServerView from "#frontend/ServerView";
-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 "#serve/App";
-import FileRef from "@rcompat/fs/FileRef";
-import type MaybePromise from "@rcompat/type/MaybePromise";
-export default abstract class FrontendModule<S = ServerView> 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, file?: FileRef) => MaybePromise<string>;
-    };
-    css?: {
-        filter: RegExp;
-    };
-    conditions: string[];
-    static schema: import("pema").ObjectType<{
-        fileExtensions: import("pema").OptionalType<import("pema").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>;
-    prebuild(app: BuildApp): void;
-    build(app: BuildApp, next: NextBuild): Promise<BuildApp>;
-}
-//# sourceMappingURL=Module.d.ts.map

package/lib/private/frontend/Module.js

@@ -1,250 +0,0 @@
-import fail from "#fail";
-import inline from "#inline";
-import location from "#location";
-import Module from "#Module";
-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 p from "pema";
-async function normalize(path, frontend) {
-    const file = new FileRef(path);
-    const basename = path.slice(0, -file.fullExtension.length);
-    return `p_${await hash(`${basename}.${frontend}`)}`;
-}
-export default class FrontendModule extends Module {
-    #options;
-    render = async (view, props) => ({ body: await view(props) });
-    root;
-    compile = {};
-    css;
-    conditions = [];
-    #mode = "development";
-    static schema = p({
-        fileExtensions: p.array(p.string).optional(),
-        spa: p.boolean.default(true),
-        ssr: p.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 && (this.#mode !== "development" || !this.client);
-    }
-    get spa() {
-        return this.#options.spa;
-    }
-    #load(name, props, app) {
-        if (!this.ssr)
-            return { view: null, name, props };
-        const view = app.loadView(name);
-        return { view, name, props };
-    }
-    ;
-    async #render(server, client, app) {
-        const { body, head = "", headers = {} } = this.ssr
-            ? await this.render(server.view, server.props)
-            : { body: "", head: "" };
-        if (!this.client) {
-            return { body, head, headers };
-        }
-        const app_asset = app.assets.find(asset => asset.src?.includes("app") && asset.src.endsWith(".js"));
-        if (!app_asset)
-            throw fail("Could not find app.js in assets");
-        const app_script = `<script type="module" src="${app_asset.src}"></script>`;
-        const json_props = JSON.stringify({ frontend: this.name, ...client });
-        const hydrated = await inline(json_props, APPLICATION_JSON, "hydration");
-        const script_src = [hydrated.integrity];
-        return {
-            body,
-            head: head.concat(app_script, hydrated.head),
-            headers: app.headers({ "script-src": script_src }),
-        };
-    }
-    normalize(name) {
-        return normalize(name, this.name);
-    }
-    respond = (view, props = {}, options = {}) => async (app, { as_layout, layouts = [] } = {}, request) => {
-        if (as_layout) {
-            return this.#load(view, props, app);
-        }
-        const views = (await Promise.all(layouts
-            .map(layout => layout(app, { as_layout: true }, request))))
-            /* set the actual page as the last view */
-            .concat(this.#load(view, 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
-            ? {
-                views: await map(views, ({ name }) => this.normalize(name)),
-                props: views.map(c => c.props),
-                request: $request,
-            }
-            : { props, request: $request };
-        const client = {
-            view: this.layouts ? "root" : await this.normalize(view),
-            spa: this.spa,
-            ssr: this.ssr,
-            mode: app.mode,
-            ...$props,
-        };
-        if (this.spa && request.headers.get("Accept") === APPLICATION_JSON) {
-            const json_body = JSON.stringify(client);
-            return new Response(json_body, {
-                headers: {
-                    ...app.headers(),
-                    "Content-Type": APPLICATION_JSON,
-                    "Content-Length": String(app.body_length(json_body)),
-                    "Cache-Control": "no-store",
-                },
-                status: options.status ?? Status.OK,
-            });
-        }
-        if (!this.ssr) {
-            const { head } = await this.#render({ view: null, props: {} }, client, app);
-            return app.view({ body: "<div id=\"app\"></div>", head, ...options });
-        }
-        try {
-            const server = this.layouts
-                ? {
-                    view: app.loadView(this.rootname),
-                    props: {
-                        views: views.map(c => c.view),
-                        props: views.map(c => c.props),
-                        request: $request,
-                    },
-                }
-                : {
-                    view: app.loadView(view),
-                    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.views}/${view}`;
-            throw fail("error in view {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, conditions } = this;
-            const _normalize = this.normalize.bind(this);
-            if (this.client) {
-                app.frontends.set(name, [...fileExtensions]);
-                conditions.forEach(condition => app.conditions.add(condition));
-            }
-            app.plugin("client", {
-                name,
-                setup(build) {
-                    const resolveDir = app.root.path;
-                    const css_cache = new Map();
-                    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: new RegExp(`^${name}:css:`) }, args => {
-                            return { path: args.path, namespace: `${name}-css` };
-                        });
-                        build.onLoad({ filter: /.*/, namespace: `${name}-css` }, args => {
-                            const contents = css_cache.get(args.path);
-                            return contents ? { contents, loader: "css" } : null;
-                        });
-                    }
-                    const views_filter = new RegExp(`^${name}:views`);
-                    const views_base = app.root.join(location.views);
-                    build.onResolve({ filter: views_filter }, ({ path }) => {
-                        return { namespace: `${name}`, path };
-                    });
-                    build.onLoad({ filter: views_filter }, async () => {
-                        const views = await views_base
-                            .collect(c => fileExtensions.includes(c.fullExtension));
-                        let contents = "";
-                        for (const view of views) {
-                            const { path } = view.debase(views_base, "/");
-                            contents += `export { default as ${await _normalize(path)} }
-                from "#view/${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 css_path = `${name}:css:${args.path}`;
-                            css_cache.set(css_path, compiled.css);
-                            contents += `\nimport "${css_path}";`;
-                        }
-                        return { contents };
-                    });
-                },
-            });
-        }
-    }
-    init(app, next) {
-        this.#mode = app.mode;
-        return next(app);
-    }
-    prebuild(app) {
-        this.fileExtensions.forEach(e => {
-            app.bind(e, async (file, { context }) => {
-                if (context === "views" && !this.ssr)
-                    return "";
-                // production: just compile to JS, don't bundle yet
-                if (this.compile.server) {
-                    return await this.compile.server(await file.text(), file);
-                }
-                return await file.text();
-            });
-        });
-    }
-    async build(app, next) {
-        this.prebuild(app);
-        // compile root server
-        if (this.root !== undefined && this.compile.server !== undefined) {
-            const source = await this.compile.server(this.root.create(app.depth(), app.i18n_active));
-            app.addRoot(this.rootname, source);
-        }
-        this.publish(app);
-        return next(app);
-    }
-    ;
-}
-//# sourceMappingURL=Module.js.map

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

@@ -1,9 +0,0 @@
-import type Dict from "@rcompat/type/Dict";
-import type MaybePromise from "@rcompat/type/MaybePromise";
-type Render<V = unknown> = (view: V, 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/ServerView.d.ts

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

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

@@ -1,16 +0,0 @@
-import type Config from "#i18n/Config";
-import Module from "#Module";
-import type NextHandle from "#module/NextHandle";
-import type NextRoute from "#module/NextRoute";
-import type NextServe from "#module/NextServe";
-import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#serve/App";
-export default class I18NModule extends Module {
-    #private;
-    name: string;
-    constructor(config: Config);
-    serve(app: ServeApp, next: NextServe): import("@rcompat/type/MaybePromise").default<ServeApp>;
-    handle(request: RequestFacade, next: NextHandle): import("@rcompat/type/MaybePromise").default<Response>;
-    route(request: RequestFacade, next: NextRoute): import("@rcompat/type/MaybePromise").default<import("../response/ResponseLike.js").default>;
-}
-//# sourceMappingURL=Module.d.ts.map

package/lib/private/i18n/Module.js

@@ -1,122 +0,0 @@
-import AppError from "#AppError";
-import bye from "#bye";
-import cookie from "#cookie";
-import COOKIE_NAME from "#i18n/constant/COOKIE_NAME";
-import PERSIST_HEADER from "#i18n/constant/PERSIST_HEADER";
-import log from "#log";
-import Module from "#Module";
-import Status from "@rcompat/http/Status";
-function toLowerCase(string) {
-    return string.toLowerCase();
-}
-function pick(client, server) {
-    const lower = server.map(toLowerCase);
-    for (const raw of client.map(toLowerCase)) {
-        const locale = raw.trim();
-        if (!locale)
-            continue;
-        const exact = lower.indexOf(locale);
-        if (exact !== -1)
-            return server[exact];
-        const base = locale.split("-")[0];
-        const index = lower.findIndex(s => s === base || s.startsWith(`${base}-`));
-        if (index !== -1)
-            return server[index];
-    }
-    return undefined;
-}
-function fail(message, ...params) {
-    const error = new AppError(`{0} ${message}`, "[i18n]", ...params);
-    log.error(error);
-    bye();
-    process.exit(1);
-}
-export default class I18NModule extends Module {
-    name = "builtin/i18n";
-    #secure = false;
-    #defaultLocale;
-    #locales;
-    #persist = "cookie";
-    #currency;
-    constructor(config) {
-        super();
-        const defaultLocale = config.defaultLocale;
-        const locales = Object.keys(config.locales);
-        if (locales.length < 1)
-            fail("must have at least 1 locale");
-        if (defaultLocale === undefined)
-            fail("must have a default locale");
-        if (!locales.includes(defaultLocale))
-            fail("default locale not in locales");
-        this.#defaultLocale = defaultLocale;
-        this.#locales = locales;
-        this.#persist = config.persist ?? "cookie";
-        this.#currency = config.currency ?? "USD";
-    }
-    #configured(locale) {
-        return this.#locales.includes(locale);
-    }
-    serve(app, next) {
-        this.#secure = app.secure;
-        return next(app);
-    }
-    handle(request, next) {
-        const requested = request.headers.try(PERSIST_HEADER);
-        if (requested === undefined)
-            return next(request);
-        // only cookie-persistance is server-supported
-        if (this.#persist !== "cookie")
-            return new Response(null, {
-                headers: {
-                    "Content-Length": String(0),
-                },
-                status: Status.NO_CONTENT,
-            });
-        // only accept configured locales
-        if (!this.#configured(requested))
-            return new Response(null, {
-                headers: {
-                    "Content-Length": String(0),
-                },
-                status: Status.NO_CONTENT,
-            });
-        const header = cookie(COOKIE_NAME, requested, {
-            secure: this.#secure,
-            path: "/",
-            sameSite: "Strict",
-        });
-        return new Response(null, {
-            headers: {
-                "Set-Cookie": header,
-                "Content-Length": String(0),
-            },
-            status: Status.NO_CONTENT,
-        });
-    }
-    route(request, next) {
-        const server_locales = this.#locales;
-        const accept_language = request.headers.try("Accept-Language") ?? "";
-        const client_locales = accept_language
-            .split(",")
-            .map(s => s.split(";")[0].trim())
-            .filter(Boolean);
-        const mode = this.#persist;
-        const cookieLocale = mode === "cookie" ? request.cookies.try(COOKIE_NAME) : undefined;
-        const locale = cookieLocale ??
-            pick(client_locales, server_locales) ??
-            this.#defaultLocale;
-        return next({
-            ...request,
-            context: {
-                ...request.context,
-                i18n: {
-                    currency: this.#currency,
-                    mode,
-                    locale,
-                    locales: server_locales,
-                },
-            },
-        });
-    }
-}
-//# sourceMappingURL=Module.js.map

package/lib/private/i18n/index.d.ts

@@ -1,28 +0,0 @@
-import type API from "#i18n/API";
-import type Catalog from "#i18n/Catalog";
-import type Catalogs from "#i18n/Catalogs";
-import type Config from "#i18n/Config";
-import type TypeOf from "#i18n/TypeOf";
-import type Dict from "@rcompat/type/Dict";
-type EntryOf<Body extends string> = Body extends `${infer Name}:${infer Spec}` ? {
-    __name: Name & string;
-    __type: TypeOf<Spec>;
-} : {
-    __name: Body & string;
-    __type: string;
-};
-type EntriesOf<S extends string> = S extends `${infer _}{${infer Body}}${infer Rest}` ? EntryOf<Body> | EntriesOf<Rest> : never;
-type ParamsFromEntries<E> = [
-    E
-] extends [never] ? Dict : {
-    [K in E as K extends {
-        __name: infer N extends string;
-    } ? N : never]: K extends {
-        __type: infer T;
-    } ? T : never;
-};
-export default function i18n<const C extends Catalogs>(config: Config<C>): (<K extends string>(...args: K extends keyof (C[keyof C & string] extends Catalog ? C[keyof C & string] : never) & string ? [EntriesOf<(C[keyof C & string] extends Catalog ? C[keyof C & string] : never)[K]>] extends [never] ? [key: K] : [key: K, params: ParamsFromEntries<EntriesOf<(C[keyof C & string] extends Catalog ? C[keyof C & string] : never)[K]>>] : [`[i18n] Missing locale key "${K}".`]) => string) & API<C> & {
-    subscribe(run: (value: (<K extends string>(...args: K extends keyof (C[keyof C & string] extends Catalog ? C[keyof C & string] : never) & string ? [EntriesOf<(C[keyof C & string] extends Catalog ? C[keyof C & string] : never)[K]>] extends [never] ? [key: K] : [key: K, params: ParamsFromEntries<EntriesOf<(C[keyof C & string] extends Catalog ? C[keyof C & string] : never)[K]>>] : [`[i18n] Missing locale key "${K}".`]) => string) & API<C>) => void): () => void;
-};
-export {};
-//# sourceMappingURL=index.d.ts.map