@primate/core 0.4.6 → 0.6.0

package/lib/private/errors.d.ts

@@ -0,0 +1,88 @@
+import type { FileRef } from "@rcompat/fs";
+import type ParseError from "pema/ParseError";
+declare function app_reserved_directory(directory: string): import("@rcompat/error").TemplateError;
+declare function app_duplicate_module(name: string): import("@rcompat/error").TemplateError;
+declare function build_missing_binary_addon(): import("@rcompat/error").TemplateError;
+declare function build_missing_route(route: string, file: FileRef): import("@rcompat/error").TemplateError;
+declare function build_multiple_db_drivers(drivers: string[]): import("@rcompat/error").TemplateError;
+declare function build_live_reload_failed(filename: string, cause: Error): import("@rcompat/error").TemplateError;
+declare function build_previous_build_exists(file: FileRef): import("@rcompat/error").TemplateError;
+declare function config_tsconfig_has_paths(): import("@rcompat/error").TemplateError;
+declare function config_file_missing(): import("@rcompat/error").TemplateError;
+declare function config_file_empty(file: FileRef): import("@rcompat/error").TemplateError;
+declare function config_file_error(file: FileRef, cause: Error): import("@rcompat/error").TemplateError;
+declare function config_missing(property: string): import("@rcompat/error").TemplateError;
+declare function frontend_missing(view: string, module?: string): import("@rcompat/error").TemplateError;
+declare function frontend_missing_app_js(): import("@rcompat/error").TemplateError;
+declare function request_unsupported_mime(path: string, mime: string): import("@rcompat/error").TemplateError;
+declare function request_unparsable_mime(path: string, mime: string, cause: Error): import("@rcompat/error").TemplateError;
+declare function request_unexpected_body(expected: string, actual: string): import("@rcompat/error").TemplateError;
+declare function request_bag_missing_key(bag: string, key: string): import("@rcompat/error").TemplateError;
+declare function response_invalid_body(body: string): import("@rcompat/error").TemplateError;
+declare function hook_route_functions_not_allowed(file: string): import("@rcompat/error").TemplateError;
+declare function hook_not_allowed(file: string): import("@rcompat/error").TemplateError;
+declare function hook_unused(file: string): import("@rcompat/error").TemplateError;
+declare function hook_reused_next(): import("@rcompat/error").TemplateError;
+declare function hook_no_return(): import("@rcompat/error").TemplateError;
+declare function hook_bad_return(): import("@rcompat/error").TemplateError;
+declare function session_missing_id(): import("@rcompat/error").TemplateError;
+declare function session_id_string(): import("@rcompat/error").TemplateError;
+declare function session_id_data(): import("@rcompat/error").TemplateError;
+declare function target_missing(target: string, targets: string[]): import("@rcompat/error").TemplateError;
+declare function target_duplicate(target: string): import("@rcompat/error").TemplateError;
+declare function route_missing_verb(route: string, verb: string): import("@rcompat/error").TemplateError;
+declare function route_invalid_special_file(route: string): import("@rcompat/error").TemplateError;
+declare function route_invalid_parameter(route: string, parameter: string): import("@rcompat/error").TemplateError;
+declare function route_invalid_characters(route: string, regexp: RegExp): import("@rcompat/error").TemplateError;
+declare function view_missing(view: string): import("@rcompat/error").TemplateError;
+declare function view_missing_default_export(view: string): import("@rcompat/error").TemplateError;
+declare function view_duplicate_extension(extension: string): import("@rcompat/error").TemplateError;
+declare function view_error(view: string, cause: Error): import("@rcompat/error").TemplateError;
+declare function env_invalid_schema(cause: ParseError): import("@rcompat/error").TemplateError;
+declare function env_missing_key(key: string): import("@rcompat/error").TemplateError;
+declare const errors: {
+    env_invalid_schema: typeof env_invalid_schema;
+    env_missing_key: typeof env_missing_key;
+    view_missing: typeof view_missing;
+    view_missing_default_export: typeof view_missing_default_export;
+    view_duplicate_extension: typeof view_duplicate_extension;
+    view_error: typeof view_error;
+    target_missing: typeof target_missing;
+    target_duplicate: typeof target_duplicate;
+    session_missing_id: typeof session_missing_id;
+    session_id_string: typeof session_id_string;
+    session_id_data: typeof session_id_data;
+    hook_route_functions_not_allowed: typeof hook_route_functions_not_allowed;
+    hook_not_allowed: typeof hook_not_allowed;
+    hook_unused: typeof hook_unused;
+    hook_reused_next: typeof hook_reused_next;
+    hook_no_return: typeof hook_no_return;
+    hook_bad_return: typeof hook_bad_return;
+    response_invalid_body: typeof response_invalid_body;
+    request_unsupported_mime: typeof request_unsupported_mime;
+    request_unparsable_mime: typeof request_unparsable_mime;
+    request_unexpected_body: typeof request_unexpected_body;
+    request_bag_missing_key: typeof request_bag_missing_key;
+    route_missing_verb: typeof route_missing_verb;
+    route_invalid_special_file: typeof route_invalid_special_file;
+    route_invalid_parameter: typeof route_invalid_parameter;
+    route_invalid_characters: typeof route_invalid_characters;
+    frontend_missing: typeof frontend_missing;
+    frontend_missing_app_js: typeof frontend_missing_app_js;
+    config_file_missing: typeof config_file_missing;
+    config_missing: typeof config_missing;
+    config_tsconfig_has_paths: typeof config_tsconfig_has_paths;
+    config_file_empty: typeof config_file_empty;
+    config_file_error: typeof config_file_error;
+    build_missing_binary_addon: typeof build_missing_binary_addon;
+    build_missing_route: typeof build_missing_route;
+    build_multiple_db_drivers: typeof build_multiple_db_drivers;
+    build_live_reload_failed: typeof build_live_reload_failed;
+    build_previous_build_exists: typeof build_previous_build_exists;
+    app_reserved_directory: typeof app_reserved_directory;
+    app_duplicate_module: typeof app_duplicate_module;
+};
+export type Code = keyof typeof errors;
+export declare const Code: { [K in Code]: K; };
+export default errors;
+//# sourceMappingURL=errors.d.ts.map

package/lib/private/errors.js

@@ -0,0 +1,211 @@
+import error from "@rcompat/error";
+const t = error.template;
+function app_reserved_directory(directory) {
+    return t `cannot build to ${directory}, reserved directory`;
+}
+function app_duplicate_module(name) {
+    return t `module ${name} loaded twice`;
+}
+const APP = error.coded({
+    app_reserved_directory,
+    app_duplicate_module,
+});
+function build_missing_binary_addon() {
+    return t `could not find matching binary addon`;
+}
+function build_missing_route(route, file) {
+    return t `cannot find route source for ${route} under ${file.path}`;
+}
+function build_multiple_db_drivers(drivers) {
+    const defaults = ["index.ts", "index.js", "default.ts", "default.js"];
+    return t `multiple database drivers ${drivers}, add one of ${defaults}`;
+}
+function build_live_reload_failed(filename, cause) {
+    return t `failed to live-reload ${filename}: ${cause}`;
+}
+function build_previous_build_exists(file) {
+    return t `${file.path} exists but does not contain a previous build`;
+}
+const BUILD = error.coded({
+    build_missing_binary_addon,
+    build_missing_route,
+    build_multiple_db_drivers,
+    build_live_reload_failed,
+    build_previous_build_exists,
+});
+function config_tsconfig_has_paths() {
+    return t `tsconfig.json exists with paths, remove config paths`;
+}
+function config_file_missing() {
+    return t `missing ${"config/app.ts"}`;
+}
+function config_file_empty(file) {
+    return t `${file.path}: empty config file`;
+}
+function config_file_error(file, cause) {
+    return t `error in config file ${file.path}: ${cause}`;
+}
+function config_missing(property) {
+    return t `${property} not configured`;
+}
+const CONFIG = error.coded({
+    config_file_missing,
+    config_missing,
+    config_tsconfig_has_paths,
+    config_file_empty,
+    config_file_error,
+});
+function frontend_missing(view, module) {
+    if (module === undefined)
+        return t `no frontend for ${view}`;
+    const pkg_name = `@primate/${module}`;
+    return t `no frontend for ${view}, did you configure ${pkg_name}?`;
+}
+function frontend_missing_app_js() {
+    return t `could not find ${"app.js"} in assets`;
+}
+const FRONTEND = error.coded({
+    frontend_missing,
+    frontend_missing_app_js,
+});
+function request_unsupported_mime(path, mime) {
+    return t `${path}: unsupported MIME type ${mime}`;
+}
+function request_unparsable_mime(path, mime, cause) {
+    return t `${path}: unparsable MIME type ${mime} (${cause})`;
+}
+function request_unexpected_body(expected, actual) {
+    return t `request body: expected ${expected}, got ${actual}`;
+}
+function request_bag_missing_key(bag, key) {
+    return t `${bag} has no key ${key}`;
+}
+const REQUEST = error.coded({
+    request_unsupported_mime,
+    request_unparsable_mime,
+    request_unexpected_body,
+    request_bag_missing_key,
+});
+function response_invalid_body(body) {
+    return t `invalid body ${body} returned from route`;
+}
+const RESPONSE = error.coded({
+    response_invalid_body,
+});
+function hook_route_functions_not_allowed(file) {
+    return t `${file}: route functions may not be used inside +hook files`;
+}
+function hook_not_allowed(file) {
+    return t `${file}: hook functions may only be used inside +hook files`;
+}
+function hook_unused(file) {
+    return t `${file}: did not register any hooks (call hook(...))`;
+}
+function hook_reused_next() {
+    return t `hook called next() more than once`;
+}
+const advice = "return next(request);";
+function hook_no_return() {
+    return t `hook called next() without returning; did you forget ${advice}?`;
+}
+function hook_bad_return() {
+    return t `hook must return a response-like value or ${advice}`;
+}
+const HOOK = error.coded({
+    hook_route_functions_not_allowed,
+    hook_not_allowed,
+    hook_unused,
+    hook_reused_next,
+    hook_no_return,
+    hook_bad_return,
+});
+function session_missing_id() {
+    return t `session store must have a session_id field`;
+}
+function session_id_string() {
+    return t `session store session_id must be a string type`;
+}
+function session_id_data() {
+    return t `"both ${"id"} and ${"data"} must be defined or undefined`;
+}
+const SESSION = error.coded({
+    session_missing_id,
+    session_id_string,
+    session_id_data,
+});
+function target_missing(target, targets) {
+    return t `no target ${target}, available targets ${targets}`;
+}
+function target_duplicate(target) {
+    return t `cannot add target ${target} twice`;
+}
+const TARGET = error.coded({
+    target_missing,
+    target_duplicate,
+});
+function route_missing_verb(route, verb) {
+    return t `${route} has no verb ${verb}`;
+}
+function route_invalid_special_file(route) {
+    return t `${route} is not a valid special file`;
+}
+function route_invalid_parameter(route, parameter) {
+    return t `${route} has an invalid parameter ${parameter}`;
+}
+function route_invalid_characters(route, regexp) {
+    return t `${route} may only contain any of ${regexp.source.slice(1, -1)}`;
+}
+const ROUTE = error.coded({
+    route_missing_verb,
+    route_invalid_special_file,
+    route_invalid_parameter,
+    route_invalid_characters,
+});
+function view_missing(view) {
+    return t `no view ${view}`;
+}
+function view_missing_default_export(view) {
+    return t `${view} must export a default component`;
+}
+function view_duplicate_extension(extension) {
+    return t `duplicate file extension ${extension}`;
+}
+function view_error(view, cause) {
+    return t `${view} error: ${cause}`;
+}
+const VIEW = error.coded({
+    view_missing,
+    view_missing_default_export,
+    view_duplicate_extension,
+    view_error,
+});
+function env_invalid_schema(cause) {
+    const issues = cause.issues
+        .map(i => `  ${i.path.replace(/^\//, "")}: ${i.message}`)
+        .join("\n");
+    return t `environment variables failed validation:\n${issues}`;
+}
+function env_missing_key(key) {
+    return t `environment variable ${key} is not defined`;
+}
+const ENV = error.coded({
+    env_invalid_schema,
+    env_missing_key,
+});
+const errors = {
+    ...APP,
+    ...BUILD,
+    ...CONFIG,
+    ...FRONTEND,
+    ...ROUTE,
+    ...REQUEST,
+    ...RESPONSE,
+    ...HOOK,
+    ...SESSION,
+    ...TARGET,
+    ...VIEW,
+    ...ENV,
+};
+export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export default errors;
+//# sourceMappingURL=errors.js.map

package/lib/private/frontend.d.ts

@@ -0,0 +1,72 @@
+import type App from "#App";
+import type BuildApp from "#build/App";
+import type Render from "#client/Render";
+import type ServerView from "#client/ServerView";
+import type ViewOptions from "#client/ViewOptions";
+import type Module from "#Module";
+import type RequestFacade from "#request/RequestFacade";
+import type ServeApp from "#serve/App";
+import type { FileRef } from "@rcompat/fs";
+import type { Dict, MaybePromise, Unpack } from "@rcompat/type";
+import type { ObjectType } from "pema";
+export type { Module };
+declare const base_schema: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly extensions: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
+    readonly spa: import("pema").DefaultType<import("pema").BooleanType, true>;
+    readonly ssr: import("pema").DefaultType<import("pema").BooleanType, true>;
+}>, {
+    extensions: string[] | undefined;
+    spa: boolean;
+    ssr: boolean;
+}>;
+type C = typeof base_schema.Complement;
+type Options<E extends C> = typeof base_schema.infer & E["infer"];
+type On<A, E extends C> = (app: A, options: Options<E>) => MaybePromise<void>;
+export interface Init<S = ServerView, E extends C = ObjectType<never>> {
+    name: string;
+    extensions: string[];
+    layouts: boolean;
+    client: boolean;
+    conditions?: 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;
+    };
+    transform?: (input: {
+        body: string;
+        head: string;
+        headers: Dict<string>;
+        app: ServeApp;
+        options: ViewOptions;
+        request: RequestFacade;
+    }) => MaybePromise<{
+        body: string;
+        head?: string;
+        headers?: Dict<string>;
+        partial?: boolean;
+    }>;
+    schema?: E;
+    onInit?: On<App, E>;
+    onBuild?: On<BuildApp, E>;
+    onServe?: On<ServeApp, E>;
+}
+export default function frontend_module<S = ServerView, E extends C = ObjectType<never>>(init: Init<S, E>): (input?: E extends ObjectType<never, never> ? {
+    extensions?: string[] | undefined;
+    spa?: boolean | undefined;
+    ssr?: boolean | undefined;
+} | undefined : Unpack<({
+    extensions?: string[] | undefined;
+    spa?: boolean | undefined;
+    ssr?: boolean | undefined;
+} | undefined) & E["input"]>) => Module;
+//# sourceMappingURL=frontend.d.ts.map

package/lib/private/frontend.js

@@ -0,0 +1,245 @@
+import E from "#errors";
+import inline from "#inline";
+import location from "#location";
+import hash from "@rcompat/crypto/hash";
+import fn from "@rcompat/fn";
+import fs from "@rcompat/fs";
+import { MIME, Status } from "@rcompat/http";
+import p from "pema";
+const base_schema = p({
+    extensions: p.array(p.string).optional(),
+    spa: p.boolean.default(true),
+    ssr: p.boolean.default(true),
+});
+export default function frontend_module(init) {
+    const _render = init.render ?? (async (view, props) => ({ body: await view(props) }));
+    const rootname = `root_${init.name}`;
+    const module_name = init.name;
+    const conditions = init.conditions ?? [];
+    const schema = base_schema.extend(init.schema ?? {});
+    async function normalize(path) {
+        const file = fs.ref(path);
+        const basename = path.slice(0, -file.fullExtension.length);
+        return `p_${await hash(`${basename}.${module_name}`)}`;
+    }
+    return (input) => {
+        const options = schema.parse(input);
+        const spa = options.spa;
+        const extensions = options.extensions ?? init.extensions;
+        let mode = "development";
+        function ssr() {
+            return options.ssr && (mode !== "development" || !init.client);
+        }
+        function load(name, props, app) {
+            if (!ssr())
+                return { view: null, name, props };
+            const view = app.loadView(name);
+            return { view, name, props };
+        }
+        async function render(server, client, app) {
+            const { body, head = "", headers = {} } = ssr()
+                ? await _render(server.view, server.props)
+                : { body: "", head: "" };
+            if (!init.client) {
+                if (app.mode === "development") {
+                    const asset = app.assets.find(a => a.src?.includes("app") && a.src.endsWith(".js"));
+                    if (asset === undefined)
+                        throw E.frontend_missing_app_js();
+                    const app_script = `<script type="module" src="${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 === undefined)
+                throw E.frontend_missing_app_js();
+            const app_script = `<script type="module" src="${app_asset.src}"></script>`;
+            const props = JSON.stringify({ frontend: init.name, ...client });
+            const hydrated = await inline(props, MIME.APPLICATION_JSON, "hydration");
+            const script_src = [hydrated.integrity];
+            return {
+                body,
+                head: head.concat(app_script, hydrated.head),
+                headers: app.headers({ "script-src": script_src }),
+            };
+        }
+        function respond(view, props = {}, options = {}) {
+            return async (app, { as_layout, layouts = [] } = {}, request) => {
+                if (as_layout)
+                    return 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(load(view, props, app));
+                const $request = request.toJSON();
+                const $props = init.layouts
+                    ? {
+                        views: await fn.async.map(views, ({ name }) => normalize(name)),
+                        props: views.map(c => c.props),
+                        request: $request,
+                    }
+                    : { props, request: $request };
+                const client = {
+                    view: init.layouts ? "root" : await normalize(view),
+                    spa: spa,
+                    ssr: ssr(),
+                    mode: app.mode,
+                    ...$props,
+                };
+                if (spa && request.headers.try("Accept") === MIME.APPLICATION_JSON) {
+                    const json_body = JSON.stringify(client);
+                    return new Response(json_body, {
+                        headers: {
+                            ...app.headers(),
+                            "Content-Type": MIME.APPLICATION_JSON,
+                            "Content-Length": String(app.body_length(json_body)),
+                            "Cache-Control": "no-store",
+                        },
+                        status: options.status ?? Status.OK,
+                    });
+                }
+                if (!ssr()) {
+                    const { head } = await render({ view: null, props: {} }, client, app);
+                    return app.view({ body: "<div id=\"app\"></div>", head, ...options });
+                }
+                try {
+                    const server = init.layouts
+                        ? {
+                            view: app.loadView(rootname),
+                            props: {
+                                views: views.map(c => c.view),
+                                props: views.map(c => c.props),
+                                request: $request,
+                            },
+                        }
+                        : {
+                            view: app.loadView(view),
+                            props,
+                            request: $request,
+                        };
+                    const base = await render(server, client, app);
+                    const { body, head = base.head, headers = base.headers, partial = options.partial, } = await init.transform?.({ ...base, app, options, request })
+                        ?? { ...base, partial: undefined };
+                    return app.view({ body, head, headers, partial, ...options });
+                }
+                catch (error) {
+                    throw E.view_error(`${location.views}/${view}`, error);
+                }
+            };
+        }
+        ;
+        return {
+            name: module_name,
+            setup({ onInit, onBuild, onServe }) {
+                onInit(async (app) => {
+                    await init.onInit?.(app, options);
+                    mode = app.mode;
+                });
+                onBuild(async (app) => {
+                    await init.onBuild?.(app, options);
+                    const build_ssr = options.ssr &&
+                        (app.mode !== "development" || !init.client);
+                    const compile_server = init.compile?.server;
+                    const compile_client = init.compile?.client;
+                    // prebuild
+                    extensions.forEach(e => {
+                        app.bind(e, async (file, { context }) => {
+                            if (context === "views" && !build_ssr)
+                                return "";
+                            // production: just compile to JS, don't bundle yet
+                            if (compile_server !== undefined) {
+                                return await compile_server(await file.text(), file);
+                            }
+                            return await file.text();
+                        });
+                    });
+                    // build
+                    if (init.root !== undefined && compile_server !== undefined) {
+                        const source = await compile_server(init.root.create(app.depth(), app.i18n_active), fs.ref(`root:${module_name}`));
+                        app.addRoot(rootname, source);
+                    }
+                    // publsh
+                    if (app.mode === "development") {
+                        app.frontends.set(module_name, [...extensions]);
+                    }
+                    if (compile_client !== undefined) {
+                        if (init.client) {
+                            app.frontends.set(module_name, [...extensions]);
+                            conditions.forEach(c => app.conditions.add(c));
+                        }
+                        app.plugin("client", {
+                            name: module_name,
+                            setup(build) {
+                                const resolveDir = app.root.path;
+                                const css_cache = new Map();
+                                if (init.root !== undefined) {
+                                    const root = init.root;
+                                    const filter = new RegExp(`^${module_name}:root`);
+                                    build.onResolve({ filter }, ({ path }) => {
+                                        return { namespace: `${module_name}`, path };
+                                    });
+                                    build.onLoad({ filter }, async () => {
+                                        const contents = (await compile_client(root.create(app.depth(), app.i18n_active), fs.ref("/tmp"), true)).js;
+                                        return contents.length > 0 ? {
+                                            contents,
+                                            loader: "js",
+                                            resolveDir,
+                                        } : null;
+                                    });
+                                }
+                                if (init.css !== undefined) {
+                                    build.onResolve({ filter: new RegExp(`^${module_name}:css:`) }, args => {
+                                        return { path: args.path, namespace: `${module_name}-css` };
+                                    });
+                                    build.onLoad({ filter: /.*/, namespace: `${module_name}-css` }, args => {
+                                        const contents = css_cache.get(args.path);
+                                        return contents ? { contents, loader: "css" } : null;
+                                    });
+                                }
+                                const views_filter = new RegExp(`^${module_name}:views`);
+                                const views_base = app.root.join(location.views);
+                                build.onResolve({ filter: views_filter }, ({ path }) => {
+                                    return { namespace: `${module_name}`, path };
+                                });
+                                build.onLoad({ filter: views_filter }, async () => {
+                                    const views = await views_base.files({
+                                        recursive: true,
+                                        filter: c => extensions.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(`(${extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
+                                build.onLoad({ filter }, async (args) => {
+                                    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;
+                                    if (init.css !== undefined
+                                        && compiled.css !== null
+                                        && compiled.css !== undefined
+                                        && compiled.css !== "") {
+                                        const css_path = `${module_name}:css:${args.path}`;
+                                        css_cache.set(css_path, compiled.css);
+                                        contents += `\nimport "${css_path}";`;
+                                    }
+                                    return { contents };
+                                });
+                            },
+                        });
+                    }
+                });
+                onServe(async (app) => {
+                    await init.onServe?.(app, options);
+                    extensions.forEach(extension => app.frontend(extension, respond));
+                });
+            },
+        };
+    };
+}
+//# sourceMappingURL=frontend.js.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