@primate/core 0.7.4 → 0.8.0

package/lib/private/i18n/{index/server.js → config.server.js}

@@ -1,11 +1,8 @@
-import DEFAULT_PERSIST_MODE from "#i18n/constant/DEFAULT_PERSIST_MODE";
 import format from "#i18n/format";
 import Formatter from "#i18n/Formatter";
 import resolve from "#i18n/resolve";
 import server_storage from "#i18n/storage";
-import sInternal from "#i18n/symbol/internal";
 import validate from "#i18n/validate";
-import sConfig from "#symbol/config";
 import is from "@rcompat/is";
 export default function i18n(config) {
     const catalogs = config.locales;
@@ -14,10 +11,9 @@ export default function i18n(config) {
     }
     const default_catalog = catalogs[config.defaultLocale];
     const currency = config.currency ?? "USD";
-    const persist = config.persist ?? DEFAULT_PERSIST_MODE;
+    const locales = Object.keys(catalogs);
     const get_locale = () => {
-        const storage = server_storage();
-        const store = storage.getStore();
+        const store = server_storage().getStore();
         return store?.locale ?? config.defaultLocale;
     };
     function t(...args) {
@@ -33,25 +29,37 @@ export default function i18n(config) {
         return translated;
     }
     const api = t;
-    api.locale = {
-        get: get_locale,
-        set: (_locale) => {
-            throw new Error("[i18n] locale.set is not supported on server.");
+    Object.defineProperties(api, {
+        defaultLocale: {
+            value: config.defaultLocale,
+            enumerable: true,
         },
-    };
-    Object.defineProperty(api, sInternal, {
-        value: {
-            restore: () => { },
-            init: () => { },
+        locales: {
+            value: locales,
+            enumerable: true,
+        },
+        catalogs: {
+            value: catalogs,
+            enumerable: true,
+        },
+        currency: {
+            value: currency,
+            enumerable: true,
+        },
+        locale: {
+            value: {
+                get: get_locale,
+                set: (_locale) => {
+                    throw new Error("[i18n] locale.set is not supported on server.");
+                },
+            },
+            enumerable: true,
+        },
+        restore: {
+            value: () => { },
+            enumerable: true,
         },
     });
-    Object.defineProperty(api, sConfig, {
-        get: () => ({ ...config, persist }),
-    });
-    api.subscribe = (run) => {
-        run(api);
-        return () => { };
-    };
     return api;
 }
-//# sourceMappingURL=server.js.map
+//# sourceMappingURL=config.server.js.map

package/lib/private/i18n/constant/COOKIE_NAME.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "primate-i18n";
+declare const _default = "primate-i18n";
 export default _default;
 //# sourceMappingURL=COOKIE_NAME.d.ts.map

package/lib/private/i18n/constant/DEFAULT_LOCALE.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "en-US";
+declare const _default = "en-US";
 export default _default;
 //# sourceMappingURL=DEFAULT_LOCALE.d.ts.map

package/lib/private/i18n/constant/DEFAULT_PERSIST_MODE.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "cookie";
+declare const _default = "cookie";
 export default _default;
 //# sourceMappingURL=DEFAULT_PERSIST_MODE.d.ts.map

package/lib/private/i18n/constant/PERSIST_HEADER.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "Primate-I18N-Locale";
+declare const _default = "Primate-I18N-Locale";
 export default _default;
 //# sourceMappingURL=PERSIST_HEADER.d.ts.map

package/lib/private/i18n/constant/PERSIST_METHOD.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "HEAD";
+declare const _default = "HEAD";
 export default _default;
 //# sourceMappingURL=PERSIST_METHOD.d.ts.map

package/lib/private/i18n/constant/PERSIST_STORAGE_KEY.d.ts

@@ -1,3 +1,3 @@
-declare const _default: "primate-i18n";
+declare const _default = "primate-i18n";
 export default _default;
 //# sourceMappingURL=PERSIST_STORAGE_KEY.d.ts.map

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

@@ -0,0 +1,42 @@
+import locale from "#i18n/locale";
+import type { Dict } from "@rcompat/type";
+export type { default as API } from "#i18n/API";
+export type { default as Catalogs } from "#i18n/Catalogs";
+export type { default as ContextData } from "#i18n/ContextData";
+export type RestoreRequest = {
+    cookies?: Dict<string | undefined>;
+};
+export type HeadlessTranslator = {
+    (...args: any[]): any;
+    defaultLocale: string;
+    locales: readonly string[];
+    catalogs: Dict;
+    currency: string;
+    locale: {
+        get(): string;
+        set(locale: any): void;
+    };
+    restore(request?: RestoreRequest): void;
+};
+export type LocaleOf<T extends HeadlessTranslator> = T extends {
+    locale: {
+        get(): infer Locale;
+    };
+} ? Locale : string;
+export type SetLocaleOf<T extends HeadlessTranslator> = T extends {
+    locale: {
+        set(locale: infer Locale): void;
+    };
+} ? Locale : never;
+export type BridgedTranslator<T extends HeadlessTranslator> = T & {
+    readonly locale: {
+        get(): LocaleOf<T>;
+        set(locale: SetLocaleOf<T>): void;
+    };
+    restore(request?: RestoreRequest): void;
+};
+declare const i18n: {
+    locale: typeof locale;
+};
+export default i18n;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/i18n/index.js

@@ -0,0 +1,6 @@
+import locale from "#i18n/locale";
+const i18n = {
+    locale,
+};
+export default i18n;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+import type create_i18n from "#i18n/config";
+type MissingI18N = ReturnType<typeof create_i18n>;
+export default function missing_i18n(): MissingI18N;
+export {};
+//# sourceMappingURL=missing.d.ts.map

package/lib/private/i18n/missing.js

@@ -0,0 +1,38 @@
+const message = "[i18n] is not configured. Add an `i18n` key to config/app.ts.";
+const fail = () => {
+    throw new Error(message);
+};
+export default function missing_i18n() {
+    const t = (() => fail());
+    Object.defineProperties(t, {
+        defaultLocale: {
+            get: fail,
+            enumerable: true,
+        },
+        locales: {
+            get: fail,
+            enumerable: true,
+        },
+        catalogs: {
+            get: fail,
+            enumerable: true,
+        },
+        locale: {
+            value: {
+                get: fail,
+                set: (_locale) => fail(),
+            },
+            enumerable: true,
+        },
+        currency: {
+            get: fail,
+            enumerable: true,
+        },
+        persist: {
+            get: fail,
+            enumerable: true,
+        },
+    });
+    return t;
+}
+//# sourceMappingURL=missing.js.map

package/lib/private/i18n/module.js

@@ -25,6 +25,15 @@ function pick(client, server) {
     }
     return undefined;
 }
+function no_content(headers = {}) {
+    return new Response(null, {
+        headers: {
+            ...headers,
+            "Content-Length": String(0),
+        },
+        status: http.Status.NO_CONTENT,
+    });
+}
 export default function i18n_module(config) {
     const default_locale = config.defaultLocale;
     const locales = Object.keys(config.locales);
@@ -40,58 +49,26 @@ export default function i18n_module(config) {
     }
     return create({
         name: "builtin/i18n",
-        setup({ onServe, onHandle, onRoute }) {
+        setup({ onServe, onHandle }) {
             onServe(app => {
                 secure = app.secure;
             });
-            onHandle(async (request, next) => {
+            onHandle((request, next) => {
                 const requested = request.headers.try(PERSIST_HEADER);
-                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 (persist !== "cookie")
-                    return new Response(null, {
-                        headers: {
-                            "Content-Length": String(0),
-                        },
-                        status: http.Status.NO_CONTENT,
-                    });
-                // only accept existing locales
-                if (!locales.includes(requested))
-                    return new Response(null, {
-                        headers: {
-                            "Content-Length": String(0),
-                        },
-                        status: http.Status.NO_CONTENT,
+                if (requested !== undefined) {
+                    if (persist !== "cookie")
+                        return no_content();
+                    if (!locales.includes(requested))
+                        return no_content();
+                    const header = cookie(COOKIE_NAME, requested, {
+                        secure,
+                        path: "/",
+                        sameSite: "Strict",
                     });
-                const header = cookie(COOKIE_NAME, requested, {
-                    secure,
-                    path: "/",
-                    sameSite: "Strict",
-                });
-                return new Response(null, {
-                    headers: {
+                    return no_content({
                         "Set-Cookie": header,
-                        "Content-Length": String(0),
-                    },
-                    status: http.Status.NO_CONTENT,
-                });
-            });
-            onRoute((request, next) => {
+                    });
+                }
                 const accept_language = request.headers.try("Accept-Language") ?? "";
                 const client_locales = accept_language
                     .split(",")
@@ -100,15 +77,22 @@ export default function i18n_module(config) {
                 const cookie_locale = persist === "cookie"
                     ? request.cookies.try(COOKIE_NAME)
                     : undefined;
-                const locale = cookie_locale ??
-                    pick(client_locales, locales) ??
-                    default_locale;
-                return next(request.set("i18n", {
+                const persisted_locale = cookie_locale !== undefined
+                    && locales.includes(cookie_locale)
+                    ? cookie_locale
+                    : undefined;
+                const locale = persisted_locale
+                    ?? pick(client_locales, locales)
+                    ?? default_locale;
+                const context = {
                     currency,
-                    mode: persist,
                     locale,
                     locales,
-                }));
+                    mode: persist,
+                };
+                return storage().run(context, () => {
+                    return next(request.set("i18n", context));
+                });
             });
         },
     });

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

@@ -1,13 +1,13 @@
 declare const _default: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
     readonly defaultLocale: import("pema").StringType;
-    readonly locales: import("pema").RecordType<import("pema").StringType, import("pema").UnknownType>;
+    readonly locales: import("pema").RecordType<import("pema").StringType, import("pema").UnknownType, undefined>;
     readonly currency: import("pema").DefaultType<import("pema").StringType, "USD">;
-    readonly persist: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"cookie">, import("pema").LiteralType<"localStorage">, import("pema").LiteralType<"sessionStorage">, import("pema").LiteralType<false>]>, false | "cookie" | "localStorage" | "sessionStorage">;
-}>, {
+    readonly persist: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"cookie", undefined>, import("pema").LiteralType<"localStorage", undefined>, import("pema").LiteralType<"sessionStorage", undefined>, import("pema").LiteralType<false, undefined>], undefined>, "cookie" | "localStorage" | "sessionStorage" | false>;
+}>, undefined, {
     defaultLocale: string;
     locales: Record<string, unknown>;
     currency: string;
-    persist: false | "cookie" | "localStorage" | "sessionStorage";
+    persist: "cookie" | "localStorage" | "sessionStorage" | false;
 }>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/lib/private/loader.d.ts

@@ -0,0 +1,5 @@
+import type Module from "#Module";
+type Loader = "file";
+export default function loader(extension: string, loader: Loader): Module;
+export {};
+//# sourceMappingURL=loader.d.ts.map

package/lib/private/loader.js

@@ -0,0 +1,28 @@
+import E from "#errors";
+import assert from "@rcompat/assert";
+import fs from "@rcompat/fs";
+export default function loader(extension, loader) {
+    assert.true(loader === "file", E.build_unrecognized_loader(loader));
+    const name = `loader-${extension}`;
+    const filter = new RegExp(`\\.${extension}$`);
+    const Loader = {
+        name,
+        setup({ onBuild }) {
+            onBuild(async (app) => {
+                app.plugin("client", {
+                    name: "static-loader",
+                    setup(build) {
+                        build.onLoad({ filter }, async (args) => {
+                            return {
+                                contents: await fs.bytes(args.path),
+                                loader: "file",
+                            };
+                        });
+                    },
+                });
+            });
+        },
+    };
+    return Loader;
+}
+//# sourceMappingURL=loader.js.map

package/lib/private/logger.d.ts

@@ -1,5 +1,5 @@
 import type { LogHook } from "#module/Setup";
-declare const Schema: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error">, import("pema").LiteralType<"warn">, import("pema").LiteralType<"info">, import("pema").LiteralType<"trace">]>, "info" | "error" | "trace" | "warn">;
+declare const Schema: import("pema").DefaultType<import("pema").UnionType<[import("pema").LiteralType<"error", undefined>, import("pema").LiteralType<"warn", undefined>, import("pema").LiteralType<"info", undefined>, import("pema").LiteralType<"trace", undefined>], undefined>, "error" | "info" | "trace" | "warn">;
 export { Schema };
 declare const levels: {
     readonly error: 0;

package/lib/private/request/RequestBag.d.ts

@@ -1,14 +1,13 @@
 import symbol from "@rcompat/symbol";
-import type { PartialDict } from "@rcompat/type";
-type Contents = PartialDict<string>;
-type Normalize = (key: string) => string;
-type Options = {
-    normalize?: Normalize;
+import type { Dict } from "@rcompat/type";
+type Normalize<T> = (key: keyof T & string) => string;
+type Options<T> = {
+    normalize?: Normalize<T>;
     raw?: string;
 };
-export default class RequestBag {
+export default class RequestBag<T extends Dict = Dict<string>> {
     #private;
-    [symbol.parse](): any;
+    [symbol.parse](): T;
     /**
      * Create a new RequestBag.
      *
@@ -16,7 +15,7 @@ export default class RequestBag {
      * @param name - Human-readable bag name used in error messages.
      * @param options - Optional `normalize` function and `raw` string.
      */
-    constructor(input: Contents, name: string, options?: Options);
+    constructor(input: T, name: string, options?: Options<T>);
     /**
      * The untouched, original source string for this bag. For example,
      * - `"?a=1&b=2"` for a query bag,
@@ -32,7 +31,7 @@ export default class RequestBag {
      * Iterate over `[key, value]` entries in the bag.
      * Keys are post-normalization; entries with `undefined` values are skipped.
      */
-    [Symbol.iterator](): IterableIterator<readonly [string, string]>;
+    [Symbol.iterator](): IterableIterator<[keyof T & string, T[keyof T & string]]>;
     /**
      * Get a value by key.
      *
@@ -40,21 +39,21 @@ export default class RequestBag {
      * @returns The defined value.
      * @throws If the key is absent or its value is `undefined`.
      */
-    get(key: string): string;
+    get<K extends keyof T & string>(key: K): T[K];
     /**
      * Try to get a value by key.
      *
      * @param key - Key to look up (pre-normalization).
      * @returns The value, or `undefined` if absent/undefined.
      */
-    try(key: string): string | undefined;
+    try<K extends keyof T & string>(key: K): T[K] | undefined;
     /**
      * Whether the bag contains a defined value for the key.
      *
      * @param key - Key to test (pre-normalization).
      * @returns `true` if present with a defined value; otherwise `false`.
      */
-    has(key: string): boolean;
+    has<K extends keyof T & string>(key: K): boolean;
     /** Returns {@link raw}. Useful in template strings. */
     toString(): string;
     /**
@@ -62,7 +61,7 @@ export default class RequestBag {
      *
      * @returns A shallow null-prototype clone of the bag's contents.
      */
-    toJSON(): any;
+    toJSON(): T;
 }
 export {};
 //# sourceMappingURL=RequestBag.d.ts.map

package/lib/private/request/RequestBag.js

@@ -28,8 +28,8 @@ export default class RequestBag {
         this.#raw = options?.raw ?? "";
         const contents = Object.create(null);
         for (const key of Object.keys(input)) {
-            // last-wins semantics if only case differs
-            contents[this.#normalize(key)] = input[key];
+            contents[this.#normalize(key)] =
+                input[key];
         }
         this.#contents = contents;
     }
@@ -58,8 +58,9 @@ export default class RequestBag {
     *[Symbol.iterator]() {
         for (const k of Object.keys(this.#contents)) {
             const v = this.#contents[k];
-            if (v !== undefined)
+            if (v !== undefined) {
                 yield [k, v];
+            }
         }
     }
     /**
@@ -100,7 +101,7 @@ export default class RequestBag {
     }
     /** Returns {@link raw}. Useful in template strings. */
     toString() {
-        return this.raw;
+        return this.#raw;
     }
     /**
      * JSON view of the normalized bag.

package/lib/private/request/RequestView.d.ts

@@ -1,10 +1,10 @@
-import type { Dict } from "@rcompat/type";
+import type { Dict, PartialDict } from "@rcompat/type";
 type RequestView = {
     context: Dict;
-    cookies: Dict<string>;
-    headers: Dict<string>;
-    path: Dict<string>;
-    query: Dict<string>;
+    cookies: PartialDict<string>;
+    headers: PartialDict<string>;
+    path: PartialDict<string>;
+    query: PartialDict<string>;
     url: URL;
 };
 export type { RequestView as default };

package/lib/private/request/RequestView.js

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

package/lib/private/response/view.d.ts

@@ -1,6 +1,7 @@
 import type ViewOptions from "#client/ViewOptions";
 import type ResponseFunction from "#response/ResponseFunction";
 import type { Dict } from "@rcompat/type";
+declare function view(component: abstract new (...args: any[]) => any, props?: Dict, options?: ViewOptions): ResponseFunction;
 declare function view<Props>(component: (props: Props) => any, props: Props, options?: ViewOptions): ResponseFunction;
 declare function view(component: () => any, props?: Dict, options?: ViewOptions): ResponseFunction;
 declare function view(name: string, props?: Dict, options?: ViewOptions): ResponseFunction;

package/lib/private/response/view.js

@@ -17,13 +17,6 @@ const backmap = {
     tsx: "react",
     jsx: "react",
 };
-/**
- * Render a view component using a frontend for the given filename extension
- * @param view path to view
- * @param props props for view
- * @param options rendering options
- * @return Response rendering function
- */
 function view(name, props, options) {
     const view_name = name;
     return async (app, transfer, request) => {

package/lib/private/route/Handler.d.ts

@@ -2,6 +2,6 @@ import type ResponseLike from "#response/ResponseLike";
 import type NarrowedRequest from "#route/NarrowedRequest";
 import type RouteOptions from "#route/Options";
 import type { MaybePromise } from "@rcompat/type";
-type RouteHandler<O extends RouteOptions = RouteOptions> = (request: NarrowedRequest<O>) => MaybePromise<ResponseLike>;
+type RouteHandler<O extends RouteOptions = RouteOptions, R extends ResponseLike = ResponseLike> = (request: NarrowedRequest<O>) => MaybePromise<R>;
 export { RouteHandler as default };
 //# sourceMappingURL=Handler.d.ts.map

package/lib/private/route/NarrowedRequest.d.ts

@@ -1,3 +1,4 @@
+import type RequestBag from "#request/RequestBag";
 import type RequestBody from "#request/RequestBody";
 import type RequestFacade from "#request/RequestFacade";
 import type RouteOptions from "#route/Options";
@@ -16,8 +17,12 @@ type NarrowedBody<O extends RouteOptions, B extends RequestBody> = O extends {
 } ? Omit<B, ContentTypeMethod[CT]> & {
     [K in ContentTypeMethod[CT]]: () => Promise<Unpack<T>>;
 } : B;
-type NarrowedRequest<O extends RouteOptions> = Omit<RequestFacade, "body"> & {
+type NarrowedPath<O extends RouteOptions> = O extends {
+    path: Parsed<infer T>;
+} ? RequestBag<Unpack<T>> : RequestBag;
+type NarrowedRequest<O extends RouteOptions> = Omit<RequestFacade, "body" | "path"> & {
     body: NarrowedBody<O, RequestBody>;
+    path: NarrowedPath<O>;
 };
 export type { NarrowedRequest as default };
 //# sourceMappingURL=NarrowedRequest.d.ts.map

package/lib/private/route/Options.d.ts

@@ -1,10 +1,11 @@
 import type http from "@rcompat/http";
-import type { Parsed } from "pema";
+import type { ObjectType, Parsed } from "pema";
 type MIME = Omit<typeof http.MIME, "resolve" | "extension">;
 type MIMEValue = MIME[keyof MIME];
 type RouteOptions = {
     contentType?: MIMEValue;
     body?: Parsed<unknown>;
+    path?: ObjectType;
 };
 export type { RouteOptions as default };
 //# sourceMappingURL=Options.d.ts.map

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

@@ -2,7 +2,6 @@ import type NextRoute from "#module/NextRoute";
 import type RequestFacade from "#request/RequestFacade";
 import type ResponseLike from "#response/ResponseLike";
 import type { MaybePromise } from "@rcompat/type";
-type HookFn = (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>;
+export type HookFn = (request: RequestFacade, next: NextRoute) => MaybePromise<ResponseLike>;
 export default function hook(fn: HookFn): HookFn;
-export {};
 //# sourceMappingURL=hook.d.ts.map

package/lib/private/route/router.d.ts

@@ -9,39 +9,39 @@ declare class Router {
     getHooks(path: string): RequestHook[];
     verifyHook(path: string): void;
     get(path: string): {
-        options?: {
+        connect?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        get?: {
+        delete?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        post?: {
+        get?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        put?: {
+        head?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        delete?: {
+        options?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        head?: {
+        patch?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        connect?: {
+        post?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        trace?: {
+        put?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        patch?: {
+        trace?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;