@primate/core 0.1.9 → 0.2.0

package/lib/private/hook/build.js

@@ -0,0 +1,245 @@
+import AppError from "#AppError";
+import location from "#location";
+import log from "#log";
+import reducer from "#reducer";
+import $router from "#request/router";
+import s_layout_depth from "#symbol/layout-depth";
+import FileRef from "@rcompat/fs/FileRef";
+import json from "@rcompat/package/json";
+import dedent from "@rcompat/string/dedent";
+const dirname = import.meta.dirname;
+const pre = async (app) => {
+    // remove build directory in case exists
+    await app.path.build.remove();
+    await app.path.build.create();
+    await Promise.all(["server", "client", "components"]
+        .map(directory => app.runpath(directory).create()));
+    // this has to occur before post, so that layout depth is available for
+    // compiling root components
+    // bindings should have been registered during `init`
+    const router = await $router(app.path.routes, app.extensions);
+    app.set(s_layout_depth, router.depth("layout"));
+    const i18n_config_path = app.path.config.join("i18n.ts");
+    const i18n_config_js_path = app.path.config.join("i18n.js");
+    // minimal effort: check if i18n.ts exists (heavier effort during serve)
+    const has_i18n_config = await i18n_config_path.exists()
+        || await i18n_config_js_path.exists();
+    app.i18n_active = has_i18n_config;
+    return app;
+};
+async function indexDatabase(base) {
+    const export_from = "export { default } from";
+    const default_database = `${export_from} "#stage/config/database/index.js";`;
+    // app/config/database does not exist
+    if (!await base.exists())
+        return default_database;
+    const databases = await base.list();
+    const n = databases.length;
+    // none in app/config/database -> fallback
+    if (n === 0)
+        return default_database;
+    // index database file found, will be overwritten in next step
+    if (databases.some(d => d.base === "index"))
+        return "";
+    const names = databases.map(d => d.name);
+    // app/config/database/default.ts -> use
+    const ts = names.includes("default.ts");
+    if (ts)
+        return `${export_from} "#stage/config/database/default.ts";`;
+    // app/config/database/default.js -> use
+    const js = names.includes("default.js");
+    if (js)
+        return `${export_from} "#stage/config/database/default.js";`;
+    // one in app/config/database -> default
+    if (n === 1)
+        return `${export_from} "#stage/config/database/${names[0]}";`;
+    throw new AppError("Multiple database drivers; add index or default.(ts|js). Found: {0}", names.join(", "));
+}
+const js_re = /^.*.js$/;
+const write_directories = async (build_directory, app) => {
+    for (const name of app.server_build) {
+        const d = app.runpath(`${name}s`);
+        const e = await Promise.all((await FileRef.collect(d, file => js_re.test(file.path)))
+            .map(async (path) => `${path}`.replace(d.toString(), _ => "")));
+        const files_js = `
+    const ${name} = [];
+    ${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `const ${name}${i} = (await import("${FileRef.webpath(`#${name}/${bare}`)}")).default;
+    ${name}.push(["${FileRef.webpath(bare)}", ${name}${i}]);`).join("\n")}
+    export default ${name};`;
+        await build_directory.join(`${name}s.js`).write(files_js);
+    }
+};
+const write_stores = async (build_directory, app) => {
+    const d2 = app.runpath(location.stores);
+    const e = await Promise.all((await FileRef.collect(d2, file => js_re.test(file.path)))
+        .map(async (path) => `${path}`.replace(d2.toString(), _ => "")));
+    const stores_js = `
+const store = [];
+${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as store${i} from "${FileRef.webpath(`#store/${bare}`)}";
+store.push(["${FileRef.webpath(bare)}", store${i}]);`).join("\n")}
+
+export default store;`;
+    await build_directory.join("stores.js").write(stores_js);
+};
+const write_components = async (build_directory, app) => {
+    const d2 = app.runpath(location.components);
+    const e = await Promise.all((await FileRef.collect(d2, file => js_re.test(file.path)))
+        .map(async (path) => `${path}`.replace(d2.toString(), _ => "")));
+    const components_js = `
+const component = [];
+${e.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as component${i} from "${FileRef.webpath(`#component/${bare}`)}";
+component.push(["${FileRef.webpath(bare)}", component${i}]);`).join("\n")}
+
+${app.roots.map((root, i) => `
+import * as root${i} from "${FileRef.webpath(`../server/${root.name}`)}";
+component.push(["${root.name.slice(0, -".js".length)}", root${i}]);
+`).join("\n")}
+
+export default component;`;
+    await build_directory.join("components.js").write(components_js);
+};
+const write_bootstrap = async (app, mode, i18n_active) => {
+    const build_start_script = `
+import serve from "primate/serve";
+const files = {};
+${app.server_build.map(name => `${name}s`).map(name => `import ${name} from "./${app.id}/${name}.js";
+     files.${name} = ${name};`).join("\n")}
+import components from "./${app.id}/components.js";
+import stores from "./${app.id}/stores.js";
+import target from "./target.js";
+import session from "#session";
+import config from "#config";
+import s_config from "primate/symbol/config";
+
+${i18n_active ? `
+import t from "#i18n";
+const i18n_config = t[s_config];
+` : `
+const i18n_config = undefined;
+`}
+
+const app = await serve(import.meta.url, {
+  ...target,
+  config,
+  files,
+  components,
+  stores,
+  mode: "${mode}",
+  session_config: session[s_config],
+  i18n_config,
+});
+
+export default app;
+`;
+    await app.path.build.join("serve.js").write(build_start_script);
+};
+const post = async (app) => {
+    const defaults = FileRef.join(import.meta.url, "../../defaults");
+    await app.stage(app.path.routes, "routes", file => dedent `
+    export * from "#stage/route${file}";
+  `);
+    await app.stage(app.path.stores, "stores", file => dedent `
+    import database from "#database";
+    import store from "#stage/store${file}";
+    import wrap from "primate/database/wrap";
+
+    export default await wrap("${file.base}", store, database);
+  `);
+    const configs = FileRef.join(dirname, "../../private/config/config");
+    const database_base = app.path.config.join("database");
+    await app.stage(configs, "config", async (file) => {
+        if (file.path === "/database/index.js")
+            return indexDatabase(database_base);
+        return `export { default } from "#stage/config${file}";`;
+    });
+    await app.stage(app.path.modules, "modules", file => `export { default } from "#stage/module${file}";`);
+    // stage locales
+    await app.stage(app.path.locales, "locales", file => `export { default } from "#stage/locale${file}";`);
+    // stage app config after locales so #locale imports can be resolved
+    await app.stage(app.path.config, "config", file => `export { default } from "#stage/config${file}";`);
+    // stage components
+    await app.stage(app.path.components, "components", file => `
+    import * as component from "#stage/component${file}";
+
+    export * from "#stage/component${file}";
+    export default component?.default;
+  `);
+    // copy framework pages
+    await defaults.copy(app.runpath(location.server, location.pages));
+    // copy pages to build
+    if (await app.path.pages.exists()) {
+        await app.path.pages.copy(app.runpath(location.server, location.pages));
+    }
+    if (await app.path.static.exists()) {
+        // copy static files to build/static
+        await app.path.static.copy(app.runpath(location.static));
+    }
+    // publish JavaScript and CSS files
+    const imports = await FileRef.collect(app.path.static, file => /\.(?:js|ts|css)$/.test(file.path));
+    await Promise.all(imports.map(async (file) => {
+        const src = file.debase(app.path.static);
+        app.build.export(`import "./${location.static}${src}";`);
+    }));
+    app.build.export("export { default } from \"primate/client/app\";");
+    app.build.plugin({
+        name: "@primate/core/frontend",
+        setup(build) {
+            build.onResolve({ filter: /#frontends/ }, ({ path }) => {
+                return { namespace: "frontends", path };
+            });
+            build.onLoad({ filter: /#frontends/ }, async () => {
+                const contents = [...app.frontends.keys()].map(name => `export { default as ${name} } from "@primate/${name}";`).join("\n");
+                return { contents, resolveDir: app.root.path };
+            });
+        },
+    });
+    app.build.plugin({
+        name: "@primate/core/alias",
+        setup(build) {
+            build.onResolve({ filter: /#static/ }, args => {
+                const path = args.path.slice(1);
+                return { path: app.root.join(path).path };
+            });
+        },
+    });
+    // start the build
+    await app.build.start();
+    // a target needs to create an `assets.js` that exports assets
+    await app.target.run();
+    const build_directory = app.path.build.join(app.id);
+    // TODO: remove after rcompat automatically creates directories
+    await build_directory.create();
+    await write_components(build_directory, app);
+    await write_stores(build_directory, app);
+    await write_directories(build_directory, app);
+    await write_bootstrap(app, app.mode, app.i18n_active);
+    const manifest_data = {
+        ...await (await json()).json(),
+        imports: {
+            "#config": "./config/app.js",
+            "#config/*": "./config/*.js",
+            "#database": "./config/database/index.js",
+            "#database/*": "./config/database/*.js",
+            "#session": "./config/session.js",
+            "#i18n": "./config/i18n.js",
+            "#component/*": "./components/*.js",
+            "#locale/*": "./locales/*.js",
+            "#module/*": "./modules/*.js",
+            "#route/*": "./routes/*.js",
+            "#stage/component/*": "./stage/components/*.js",
+            "#stage/locale/*": "./stage/locales/*.js",
+            "#stage/config/*": "./stage/config/*.js",
+            "#stage/module/*": "./stage/modules/*.js",
+            "#stage/route/*": "./stage/routes/*.js",
+            "#stage/store/*": "./stage/stores/*.js",
+            "#store/*": "./stores/*.js",
+        },
+    };
+    // create package.json
+    await app.path.build.join("package.json").writeJSON(manifest_data);
+    log.system("build written to {0}", app.path.build);
+    app.cleanup();
+    return app;
+};
+export default async (app) => post(await reducer(app.modules, await pre(app), "build"));
+//# sourceMappingURL=build.js.map

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

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

package/lib/private/hook/serve.js

@@ -0,0 +1,13 @@
+import log from "#log";
+import reducer from "#reducer";
+function pre(app) {
+    log.system("in startup");
+    return app;
+}
+;
+async function post(app) {
+    await app.start();
+    return app;
+}
+export default async (app) => post(await reducer(app.modules, pre(app), "serve"));
+//# sourceMappingURL=serve.js.map

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

@@ -0,0 +1,21 @@
+import type Catalogs from "#i18n/Catalogs";
+import type sInternal from "#i18n/symbol/internal";
+type LocaleTags<C extends Catalogs> = keyof C & string;
+type API<C extends Catalogs> = {
+    onChange(fn: (locale: LocaleTags<C>) => void): () => void;
+    subscribe(run: (value: API<C>) => void): () => void;
+    locale: {
+        get(): LocaleTags<C>;
+        set(locale: LocaleTags<C>): void;
+    };
+    readonly loading: boolean;
+    [sInternal]: {
+        init(locale: LocaleTags<C>): void;
+        wait(): Promise<void>;
+        depend(fn: () => void): () => void;
+        readonly version: number;
+        restore: () => void;
+    };
+};
+export type { API as default };
+//# sourceMappingURL=API.d.ts.map

package/lib/private/i18n/API.js

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

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

@@ -0,0 +1,4 @@
+import type Dict from "@rcompat/type/Dict";
+type Catalog = Dict<string>;
+export type { Catalog as default };
+//# sourceMappingURL=Catalog.d.ts.map

package/lib/private/i18n/Catalog.js

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

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

@@ -0,0 +1,4 @@
+import type Catalog from "#i18n/Catalog";
+type Catalogs<Locale extends string = string> = Record<Locale, Catalog>;
+export type { Catalogs as default };
+//# sourceMappingURL=Catalogs.d.ts.map

package/lib/private/i18n/Catalogs.js

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

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

@@ -0,0 +1,10 @@
+import type Catalogs from "#i18n/Catalogs";
+import type PersistMode from "#i18n/PersistMode";
+type Config<C extends Catalogs = Catalogs> = {
+    defaultLocale: keyof C & string;
+    locales: C;
+    currency?: string;
+    persist?: PersistMode;
+};
+export type { Config as default };
+//# sourceMappingURL=Config.d.ts.map

package/lib/private/i18n/Config.js

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

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

@@ -0,0 +1,6 @@
+type ContextData = {
+    locale: string;
+    currency?: string;
+};
+export type { ContextData as default };
+//# sourceMappingURL=ContextData.d.ts.map

package/lib/private/i18n/ContextData.js

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

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

@@ -0,0 +1,18 @@
+export default class Formatter {
+    #private;
+    constructor(locale: string);
+    get locale(): string;
+    set locale(locale: string);
+    number(number: number): string;
+    date(date: Date): string;
+    currency(currency: string, amount: number): string;
+    ordinal(number: number): string;
+    relative(milliseconds: number, options?: {
+        numeric?: "always" | "auto";
+        style?: "long" | "short" | "narrow";
+    }): string;
+    list(items: string[]): string;
+    unit(value: number, u: string): string;
+    pluralRules(): Intl.PluralRules;
+}
+//# sourceMappingURL=Formatter.d.ts.map

package/lib/private/i18n/Formatter.js

@@ -0,0 +1,108 @@
+import fail from "#fail";
+import ordinals from "#i18n/ordinals";
+import toIntlUnit from "#i18n/toIntlUnit";
+import is from "@rcompat/assert/is";
+export default class Formatter {
+    #locale;
+    constructor(locale) {
+        is(locale).string();
+        this.#locale = locale;
+    }
+    get locale() {
+        return this.#locale;
+    }
+    set locale(locale) {
+        is(locale).string();
+        this.#locale = locale;
+    }
+    number(number) {
+        try {
+            return new Intl.NumberFormat(this.#locale).format(number);
+        }
+        catch {
+            return String(number);
+        }
+    }
+    date(date) {
+        try {
+            return new Intl.DateTimeFormat(this.#locale).format(date);
+        }
+        catch {
+            return date.toString();
+        }
+    }
+    currency(currency, amount) {
+        const options = { style: "currency", currency };
+        try {
+            return new Intl.NumberFormat(this.#locale, options).format(amount);
+        }
+        catch {
+            return String(amount);
+        }
+    }
+    ordinal(number) {
+        try {
+            const n = Math.trunc(number);
+            const rules = new Intl.PluralRules(this.#locale, { type: "ordinal" });
+            const category = rules.select(n);
+            const language = this.#locale.split("-")[0];
+            if (!(language in ordinals))
+                return String(n);
+            const strategy = ordinals[language];
+            const position = strategy.position;
+            const pattern = strategy[category] || strategy.other;
+            return position === "prefix" ? `${pattern}${n}` : `${n}${pattern}`;
+        }
+        catch {
+            return String(Math.trunc(number));
+        }
+    }
+    relative(milliseconds, options) {
+        const defaults = { numeric: "auto", style: "long", ...options };
+        try {
+            const rtf = new Intl.RelativeTimeFormat(this.#locale, defaults);
+            const s = Math.round(milliseconds / 1000);
+            const abs = Math.abs(s);
+            if (abs >= 31536000)
+                return rtf.format(Math.trunc(s / 31536000), "year");
+            if (abs >= 2592000)
+                return rtf.format(Math.trunc(s / 2592000), "month");
+            if (abs >= 604800)
+                return rtf.format(Math.trunc(s / 604800), "week");
+            if (abs >= 86400)
+                return rtf.format(Math.trunc(s / 86400), "day");
+            if (abs >= 3600)
+                return rtf.format(Math.trunc(s / 3600), "hour");
+            if (abs >= 60)
+                return rtf.format(Math.trunc(s / 60), "minute");
+            return rtf.format(s, "second");
+        }
+        catch {
+            return `${milliseconds}ms`;
+        }
+    }
+    list(items) {
+        try {
+            return new Intl.ListFormat(this.#locale).format(items);
+        }
+        catch {
+            return items.join(", ");
+        }
+    }
+    unit(value, u) {
+        const unit = toIntlUnit(u);
+        if (unit === undefined)
+            throw fail("unit {0} not supported", u);
+        const options = { style: "unit", unit };
+        try {
+            return new Intl.NumberFormat(this.#locale, options).format(value);
+        }
+        catch {
+            return `${value} ${u}`;
+        }
+    }
+    pluralRules() {
+        return new Intl.PluralRules(this.#locale);
+    }
+}
+//# sourceMappingURL=Formatter.js.map

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

@@ -0,0 +1,16 @@
+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 "#ServeApp";
+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

@@ -0,0 +1,109 @@
+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, { status: Status.NO_CONTENT });
+        // only accept configured locales
+        if (!this.#configured(requested))
+            return new Response(null, { status: Status.NO_CONTENT });
+        const header = cookie(COOKIE_NAME, requested, {
+            secure: this.#secure,
+            path: "/",
+            sameSite: "Strict",
+        });
+        return new Response(null, {
+            headers: { "set-cookie": header },
+            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/PersistMode.d.ts

@@ -0,0 +1,3 @@
+type PersistMode = "cookie" | "localStorage" | "sessionStorage" | false;
+export type { PersistMode as default };
+//# sourceMappingURL=PersistMode.d.ts.map

package/lib/private/i18n/PersistMode.js

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

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

@@ -0,0 +1,4 @@
+type Normalize<S extends string> = Lowercase<S extends `${infer A}|${string}` ? A : S>;
+type TypeOf<T extends string> = Normalize<T> extends "n" | "number" ? number : Normalize<T> extends "d" | "date" ? Date | number : Normalize<T> extends "c" | "currency" ? number : Normalize<T> extends "o" | "ordinal" ? number : Normalize<T> extends "a" | "ago" ? number : Normalize<T> extends "l" | "list" ? string[] : Normalize<T> extends `u(${string})` | `unit(${string})` ? number : string;
+export type { TypeOf as default };
+//# sourceMappingURL=TypeOf.d.ts.map

package/lib/private/i18n/TypeOf.js

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

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

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

package/lib/private/i18n/constant/COOKIE_NAME.js

@@ -0,0 +1,2 @@
+export default "primate-i18n";
+//# sourceMappingURL=COOKIE_NAME.js.map

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

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

package/lib/private/i18n/constant/DEFAULT_LOCALE.js

@@ -0,0 +1,2 @@
+export default "en-US";
+//# sourceMappingURL=DEFAULT_LOCALE.js.map

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

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

package/lib/private/i18n/constant/DEFAULT_PERSIST_MODE.js

@@ -0,0 +1,2 @@
+export default "cookie";
+//# sourceMappingURL=DEFAULT_PERSIST_MODE.js.map

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

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

package/lib/private/i18n/constant/PERSIST_HEADER.js

@@ -0,0 +1,2 @@
+export default "Primate-I18N-Locale";
+//# sourceMappingURL=PERSIST_HEADER.js.map

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

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

package/lib/private/i18n/constant/PERSIST_METHOD.js

@@ -0,0 +1,2 @@
+export default "HEAD";
+//# sourceMappingURL=PERSIST_METHOD.js.map

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

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