@primate/core 0.4.5 → 0.5.0

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

@@ -8,8 +8,8 @@ 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";
+import type { FileRef } from "@rcompat/fs";
+import type { MaybePromise } from "@rcompat/type";
 export default abstract class FrontendModule<S = ServerView> extends Module {
     #private;
     abstract client: boolean;
@@ -24,16 +24,16 @@ export default abstract class FrontendModule<S = ServerView> extends Module {
             css?: null | string;
             js: string;
         }>;
-        server?: (text: string, file?: FileRef) => MaybePromise<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>;
+        fileExtensions: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
+        spa: import("pema").DefaultType<import("pema").BooleanType, true>;
+        ssr: import("pema").DefaultType<import("pema").BooleanType, true>;
     }>;
     static options: {
         fileExtensions: string[] | undefined;

package/lib/private/frontend/Module.js

@@ -2,14 +2,14 @@ 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 fn from "@rcompat/fn";
+import fs from "@rcompat/fs";
+import MIME from "@rcompat/http/mime";
 import Status from "@rcompat/http/Status";
 import p from "pema";
 async function normalize(path, frontend) {
-    const file = new FileRef(path);
+    const file = fs.ref(path);
     const basename = path.slice(0, -file.fullExtension.length);
     return `p_${await hash(`${basename}.${frontend}`)}`;
 }
@@ -59,14 +59,21 @@ export default class FrontendModule extends Module {
             ? await this.render(server.view, server.props)
             : { body: "", head: "" };
         if (!this.client) {
+            if (app.mode === "development") {
+                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>`;
+                return { body, head: head.concat(app_script), headers };
+            }
             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 props = JSON.stringify({ frontend: this.name, ...client });
+        const hydrated = await inline(props, MIME.APPLICATION_JSON, "hydration");
         const script_src = [hydrated.integrity];
         return {
             body,
@@ -83,19 +90,12 @@ export default class FrontendModule extends Module {
         }
         const views = (await Promise.all(layouts
             .map(layout => layout(app, { as_layout: true }, request))))
-            /* set the actual page as the last view */
+            // 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 $request = request.toJSON();
         const $props = this.layouts
             ? {
-                views: await map(views, ({ name }) => this.normalize(name)),
+                views: await fn.async.map(views, ({ name }) => this.normalize(name)),
                 props: views.map(c => c.props),
                 request: $request,
             }
@@ -107,12 +107,12 @@ export default class FrontendModule extends Module {
             mode: app.mode,
             ...$props,
         };
-        if (this.spa && request.headers.get("Accept") === APPLICATION_JSON) {
+        if (this.spa && request.headers.get("Accept") === MIME.APPLICATION_JSON) {
             const json_body = JSON.stringify(client);
             return new Response(json_body, {
                 headers: {
                     ...app.headers(),
-                    "Content-Type": APPLICATION_JSON,
+                    "Content-Type": MIME.APPLICATION_JSON,
                     "Content-Length": String(app.body_length(json_body)),
                     "Cache-Control": "no-store",
                 },
@@ -151,6 +151,9 @@ export default class FrontendModule extends Module {
         return next(app);
     }
     publish(app) {
+        if (app.mode === "development") {
+            app.frontends.set(this.name, [...this.fileExtensions]);
+        }
         if (this.compile.client) {
             const { compile, css, fileExtensions, name, root, conditions } = this;
             const _normalize = this.normalize.bind(this);
@@ -169,7 +172,7 @@ export default class FrontendModule extends Module {
                             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;
+                            const contents = (await compile.client(root.create(app.depth(), app.i18n_active), fs.ref("/tmp"), true)).js;
                             return contents ? { contents, loader: "js", resolveDir } : null;
                         });
                     }
@@ -188,8 +191,10 @@ export default class FrontendModule extends Module {
                         return { namespace: `${name}`, path };
                     });
                     build.onLoad({ filter: views_filter }, async () => {
-                        const views = await views_base
-                            .collect(c => fileExtensions.includes(c.fullExtension));
+                        const views = await views_base.files({
+                            recursive: true,
+                            filter: c => fileExtensions.includes(c.fullExtension),
+                        });
                         let contents = "";
                         for (const view of views) {
                             const { path } = view.debase(views_base, "/");
@@ -200,7 +205,7 @@ export default class FrontendModule extends Module {
                     });
                     const filter = new RegExp(`(${fileExtensions.map(e => e.replace(".", "\\.")).join("|")})$`);
                     build.onLoad({ filter }, async (args) => {
-                        const file = new FileRef(args.path);
+                        const file = fs.ref(args.path);
                         // compile file to JavaScript and potentially CSS
                         const compiled = await compile.client(await file.text(), file, false);
                         let contents = compiled.js;
@@ -239,7 +244,7 @@ export default class FrontendModule extends Module {
         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));
+            const source = await this.compile.server(this.root.create(app.depth(), app.i18n_active), fs.ref(`root:${this.name}`));
             app.addRoot(this.rootname, source);
         }
         this.publish(app);

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

@@ -1,5 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
-import type MaybePromise from "@rcompat/type/MaybePromise";
+import type { Dict, MaybePromise } from "@rcompat/type";
 type Render<V = unknown> = (view: V, props: Dict) => MaybePromise<{
     body: string;
     head?: string;

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

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type ServerData<V> = {
     view: V;
     props: Dict;

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

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

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

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type View = {
     view: unknown;
     name: string;

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

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default interface ViewOptions extends ResponseInit {
     csp?: {
         script_src?: string[];

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

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

package/lib/private/hash.js

@@ -1,4 +1,3 @@
-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));

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

@@ -1,4 +1,7 @@
-import type Dict from "@rcompat/type/Dict";
-type Catalog = Dict<string>;
+import type { Dict } from "@rcompat/type";
+type CatalogValue = string | {
+    [key: string]: CatalogValue;
+} | CatalogValue[];
+type Catalog = Dict<CatalogValue>;
 export type { Catalog as default };
 //# sourceMappingURL=Catalog.d.ts.map

package/lib/private/i18n/Formatter.js

@@ -1,21 +1,22 @@
 import fail from "#fail";
 import ordinals from "#i18n/ordinals";
 import toIntlUnit from "#i18n/toIntlUnit";
-import is from "@rcompat/assert/is";
+import assert from "@rcompat/assert";
 export default class Formatter {
     #locale;
     constructor(locale) {
-        is(locale).string();
+        assert.string(locale);
         this.#locale = locale;
     }
     get locale() {
         return this.#locale;
     }
     set locale(locale) {
-        is(locale).string();
+        assert.string(locale);
         this.#locale = locale;
     }
     number(number) {
+        assert.number(number);
         try {
             return new Intl.NumberFormat(this.#locale).format(number);
         }
@@ -24,6 +25,7 @@ export default class Formatter {
         }
     }
     date(date) {
+        assert.date(date);
         try {
             return new Intl.DateTimeFormat(this.#locale).format(date);
         }
@@ -32,6 +34,8 @@ export default class Formatter {
         }
     }
     currency(currency, amount) {
+        assert.string(currency);
+        assert.number(amount);
         const options = { style: "currency", currency };
         try {
             return new Intl.NumberFormat(this.#locale, options).format(amount);
@@ -41,6 +45,7 @@ export default class Formatter {
         }
     }
     ordinal(number) {
+        assert.number(number);
         try {
             const n = Math.trunc(number);
             const rules = new Intl.PluralRules(this.#locale, { type: "ordinal" });
@@ -58,9 +63,14 @@ export default class Formatter {
         }
     }
     relative(milliseconds, options) {
-        const defaults = { numeric: "auto", style: "long", ...options };
+        assert.number(milliseconds);
+        assert.maybe.dict(options);
+        assert.maybe.string(options?.numeric);
+        assert.maybe.string(options?.style);
+        const numeric = options?.numeric ?? "auto";
+        const style = options?.style ?? "long";
         try {
-            const rtf = new Intl.RelativeTimeFormat(this.#locale, defaults);
+            const rtf = new Intl.RelativeTimeFormat(this.#locale, { numeric, style });
             const s = Math.round(milliseconds / 1000);
             const abs = Math.abs(s);
             if (abs >= 31536000)
@@ -82,6 +92,7 @@ export default class Formatter {
         }
     }
     list(items) {
+        assert.array(items);
         try {
             return new Intl.ListFormat(this.#locale).format(items);
         }
@@ -90,9 +101,10 @@ export default class Formatter {
         }
     }
     unit(value, u) {
-        const unit = toIntlUnit(u);
-        if (unit === undefined)
-            throw fail("unit {0} not supported", u);
+        assert.number(value);
+        assert.string(u);
+        const intl_unit = toIntlUnit(u);
+        const unit = assert.defined(intl_unit, fail("unit {0} not supported", u));
         const options = { style: "unit", unit };
         try {
             return new Intl.NumberFormat(this.#locale, options).format(value);

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

@@ -9,8 +9,8 @@ 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>;
+    serve(app: ServeApp, next: NextServe): import("@rcompat/type").MaybePromise<ServeApp>;
+    handle(request: RequestFacade, next: NextHandle): Promise<Response>;
+    route(request: RequestFacade, next: NextRoute): import("@rcompat/type").MaybePromise<import("../response/ResponseLike.js").default>;
 }
 //# sourceMappingURL=Module.d.ts.map

package/lib/private/i18n/Module.js

@@ -3,6 +3,7 @@ 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 storage from "#i18n/storage";
 import log from "#log";
 import Module from "#Module";
 import Status from "@rcompat/http/Status";
@@ -60,10 +61,24 @@ export default class I18NModule extends Module {
         this.#secure = app.secure;
         return next(app);
     }
-    handle(request, next) {
+    async handle(request, next) {
         const requested = request.headers.try(PERSIST_HEADER);
-        if (requested === undefined)
-            return next(request);
+        if (requested === undefined) {
+            const locale = request.cookies.try(COOKIE_NAME);
+            if (locale === undefined)
+                return next(request);
+            // if has cookie, run route with i18n
+            return await new Promise((resolve, reject) => {
+                storage().run({ locale }, async () => {
+                    try {
+                        resolve(await next(request));
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+        }
         // only cookie-persistance is server-supported
         if (this.#persist !== "cookie")
             return new Response(null, {
@@ -101,22 +116,18 @@ export default class I18NModule extends Module {
             .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 ??
+        const cookie_locale = mode === "cookie"
+            ? request.cookies.try(COOKIE_NAME)
+            : undefined;
+        const locale = cookie_locale ??
             pick(client_locales, server_locales) ??
             this.#defaultLocale;
-        return next({
-            ...request,
-            context: {
-                ...request.context,
-                i18n: {
-                    currency: this.#currency,
-                    mode,
-                    locale,
-                    locales: server_locales,
-                },
-            },
-        });
+        return next(request.set("i18n", {
+            currency: this.#currency,
+            mode,
+            locale,
+            locales: server_locales,
+        }));
     }
 }
 //# sourceMappingURL=Module.js.map

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

@@ -0,0 +1,4 @@
+import type Formatter from "#i18n/Formatter";
+import type { Dict } from "@rcompat/type";
+export default function format(input: string, params: Dict, currency: string, formatter: Formatter): string;
+//# sourceMappingURL=format.d.ts.map

package/lib/private/i18n/format.js

@@ -0,0 +1,95 @@
+import is from "@rcompat/is";
+export default function format(input, params, currency, formatter) {
+    let template = input;
+    // save escaped braces
+    template = template.replace(/\{\{/g, "\uE000");
+    template = template.replace(/\}\}/g, "\uE001");
+    // Process normal parameters with nested brace support
+    const template_re = /\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+    template = template.replace(template_re, (_, body) => {
+        // name[:spec]
+        let name = body;
+        let spec;
+        const colon = body.indexOf(":");
+        if (colon >= 0) {
+            name = body.slice(0, colon);
+            spec = body.slice(colon + 1);
+        }
+        const value = params[name];
+        if (!spec)
+            return value == null ? "" : String(value);
+        // number selection: "n|one|other" or "n|zero|one|other"
+        const bar = spec.indexOf("|");
+        const head = (bar === -1 ? spec : spec.slice(0, bar)).toLowerCase();
+        const tail = bar === -1 ? "" : spec.slice(bar + 1);
+        // units u(...)/unit(...)
+        const m = /^(?:u|unit)\(([^)]+)\)$/.exec(head);
+        if (m)
+            return formatter.unit(Number(value ?? 0), m[1]);
+        switch (head) {
+            case "n":
+            case "number": {
+                if (tail) {
+                    const options = tail.split("|");
+                    const n = Number(value ?? 0);
+                    const formatted = formatter.number(n);
+                    const plural = () => {
+                        const category = Number.isFinite(n)
+                            ? formatter.pluralRules().select(n)
+                            : "other";
+                        if (options.length === 2) {
+                            const [one, other] = options;
+                            return category === "one" ? one : other;
+                        }
+                        if (options.length === 3) {
+                            const [zero, one, other] = options;
+                            return n === 0 ? zero : (category === "one" ? one : other);
+                        }
+                        if (options.length === 5) {
+                            const [zero, one, few, many, other] = options;
+                            if (n === 0)
+                                return zero;
+                            switch (category) {
+                                case "one": return one;
+                                case "few": return few;
+                                case "many": return many;
+                                default: return other;
+                            }
+                        }
+                        return formatted;
+                    };
+                    return plural().replace(new RegExp(`\\{${name}\\}`, "g"), formatted);
+                }
+                return formatter.number(Number(value ?? 0));
+            }
+            case "d":
+            case "date": {
+                const d = is.number(value)
+                    ? new Date(value)
+                    : is.date(value)
+                        ? value
+                        : new Date(NaN);
+                return formatter.date(d);
+            }
+            case "c":
+            case "currency":
+                return formatter.currency(currency, Number(value ?? 0));
+            case "o":
+            case "ordinal":
+                return formatter.ordinal(Number(value ?? 0));
+            case "a":
+            case "ago":
+                return formatter.relative(Number(value ?? 0));
+            case "l":
+            case "list":
+                return formatter.list(Array.isArray(value) ? value : []);
+            default:
+                return value == null ? "" : String(value);
+        }
+    });
+    // restore escaped braces
+    template = template.replace(/\uE000/g, "{");
+    template = template.replace(/\uE001/g, "}");
+    return template;
+}
+//# sourceMappingURL=format.js.map