@primate/core 0.7.5 → 0.8.1

package/lib/private/build/App.d.ts

@@ -26,8 +26,6 @@ export default class BuildApp extends App {
     cleanup(): void;
     basename(file: FileRef, directory: FileRef): string;
     depth(): number;
-    get i18n_active(): boolean;
-    set i18n_active(active: boolean);
     get session_active(): boolean;
     set session_active(active: boolean);
     serve(): Promise<ServeApp>;

package/lib/private/build/App.js

@@ -8,7 +8,6 @@ export default class BuildApp extends App {
     #postbuild = [];
     #roots = {};
     #id = crypto.randomUUID().slice(0, 8);
-    #i18n_active = false;
     #session_active = false;
     #paths;
     #bindings = [
@@ -91,12 +90,6 @@ export default class BuildApp extends App {
     depth() {
         return this.get(s_layout_depth);
     }
-    get i18n_active() {
-        return this.#i18n_active;
-    }
-    set i18n_active(active) {
-        this.#i18n_active = active;
-    }
     get session_active() {
         return this.#session_active;
     }

package/lib/private/build/client/index.js

@@ -7,6 +7,7 @@ import plugin_routes from "#build/client/plugin/routes";
 import plugin_server_stamp from "#build/client/plugin/server-stamp";
 import plugin_view from "#build/client/plugin/view";
 import plugin_app_request from "#build/shared/plugin/app-request";
+import E from "#errors";
 import location from "#location";
 import { CodeError } from "@rcompat/error";
 import * as esbuild from "esbuild";
@@ -26,13 +27,6 @@ const write_bootstrap = async (app) => {
     `}
     import facade from "$:app";
 
-    ${app.i18n_active ? `
-    import i18n from "app:config:i18n";
-    const i18n_config = i18n[s_config];
-    ` : `
-    const i18n_config = undefined;
-    `}
-
     const app = await serve(import.meta.url, {
       assets,
       facade,
@@ -40,7 +34,6 @@ const write_bootstrap = async (app) => {
       views,
       pages,
       session: session_config,
-      i18n: i18n_config,
       mode: "${app.mode}",
       target: "${app.target.name}",
       log: "${app.log.level}"
@@ -50,6 +43,17 @@ const write_bootstrap = async (app) => {
   `;
     await app.path.build.join("serve.js").write(build_start_script);
 };
+function user_entrypoints(app) {
+    const configured = app.config("entrypoints") ?? {};
+    const reserved = ["app", "head", "body"];
+    const conflicts = Object.keys(configured).filter(name => reserved.includes(name));
+    if (conflicts.length)
+        throw E.build_reserved_entrypoints(conflicts);
+    return Object.fromEntries(Object.entries(configured).map(([name, file]) => [
+        name,
+        app.path.client.join(file).path,
+    ]));
+}
 export default async function build_client(app) {
     app.plugin("client", plugin_frontend(app));
     app.plugin("client", plugin_alias(app));
@@ -60,42 +64,41 @@ export default async function build_client(app) {
     app.plugin("client", plugin_routes(app));
     app.plugin("client", plugin_server_stamp(app));
     app.plugin("client", plugin_entrypoint(app));
-    const imports = await app.path.static.files({
-        recursive: true,
-        filter: file => /\.(?:js|ts|css)$/.test(file.path),
-    });
-    imports.forEach(file => {
-        const src = file.debase(app.path.static);
-        app.entrypoint(`import "./${location.static}${src}";`);
-    });
     app.entrypoint("import \"primate/client/app\";");
     const tsconfig = app.root.join("tsconfig.json");
     const conditions = app.conditions.values();
     const build_options = {
         plugins: app.plugins("client"),
         outdir: app.runpath(location.client).path,
-        entryPoints: ["app:client"],
+        entryPoints: {
+            app: "app:client",
+            ...user_entrypoints(app),
+        },
         conditions: ["style", "browser", "default", "module", ...conditions],
         resolveExtensions: [".ts", ".js", ...app.frontendExtensions],
         ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
         bundle: true,
         format: "esm",
         logLevel: "silent",
+        loader: app.config("loaders"),
     };
-    const NO_HR = app.config("livereload.exclude") ?? [];
+    if (app.mode === "development") {
+        const NO_HR = app.config("livereload.exclude") ?? [];
+        app.entrypoint(`
+    const NO_HR = ${JSON.stringify(NO_HR)};
+    new EventSource("/esbuild").addEventListener("change", () => {
+      if (!NO_HR.includes(location.pathname)) location.reload();
+    });
+  `);
+    }
     const mode_options = app.mode === "development"
         ? {
-            banner: {
-                js: `const NO_HR=${JSON.stringify(NO_HR)};
-          new EventSource("/esbuild").addEventListener("change",
-          () => !NO_HR.includes(location.pathname) && location.reload());`,
-            },
-            entryNames: "app",
+            entryNames: "[name]",
             minify: false,
             splitting: false,
         }
         : {
-            entryNames: "app-[hash]",
+            entryNames: "[name]-[hash]",
             minify: true,
             splitting: true,
         };
@@ -113,9 +116,8 @@ export default async function build_client(app) {
     }
     catch (cause) {
         const original = cause?.errors?.[0]?.detail;
-        if (CodeError.is(original)) {
+        if (CodeError.is(original))
             throw original;
-        }
         throw cause;
     }
     await write_bootstrap(app);

package/lib/private/build/client/plugin/frontend.js

@@ -6,7 +6,7 @@ export default function plugin_client_frontend(app) {
                 return { namespace: "frontends", path };
             });
             build.onLoad({ filter: /app:frontends/ }, async () => {
-                const contents = [...app.frontends.keys()].map(name => `export { default as ${name} } from "@primate/${name}";`).join("\n");
+                const contents = [...app.frontends.keys()].map(name => `export { app as ${name} } from "@primate/${name}";`).join("\n");
                 return { contents, resolveDir: app.root.path };
             });
         },

package/lib/private/build/client/plugin/routes.js

@@ -7,7 +7,7 @@ export default function plugin_client_routes(app) {
             build.onResolve({ filter: /.*/ }, async (args) => {
                 if (args.pluginData === "primate-client-route-inner")
                     return null;
-                if (intercept(args, app.path.views))
+                if (intercept(args, app.root))
                     return null;
                 const result = await build.resolve(args.path, {
                     resolveDir: args.resolveDir,

package/lib/private/build/hook.js

@@ -24,9 +24,6 @@ async function pre(app) {
     await stamp.write("export default 0;\n");
     const router = await $router(app.path.routes, app.extensions);
     app.set(s_layout_depth, router.depth("layout"));
-    const i18n_ts = app.path.config.join("i18n.ts");
-    const i18n_js = app.path.config.join("i18n.js");
-    app.i18n_active = await i18n_ts.exists() || await i18n_js.exists();
     const session_ts = app.path.config.join("session.ts");
     const session_js = app.path.config.join("session.js");
     app.session_active = await session_ts.exists() || await session_js.exists();

package/lib/private/build/server/index.js

@@ -7,26 +7,14 @@ import plugin_node_imports from "#build/server/plugin/node-imports";
 import plugin_requires from "#build/server/plugin/requires";
 import plugin_roots from "#build/server/plugin/roots";
 import plugin_route from "#build/server/plugin/route";
-import plugin_stores from "#build/server/plugin/stores";
+import plugin_route_client from "#build/server/plugin/route-client";
 import plugin_view from "#build/server/plugin/view";
 import plugin_views from "#build/server/plugin/views";
 import plugin_virtual_pages from "#build/server/plugin/virtual-pages";
 import plugin_virtual_routes from "#build/server/plugin/virtual-routes";
 import plugin_wasm from "#build/server/plugin/wasm";
 import plugin_app_request from "#build/shared/plugin/app-request";
-import plugin_route_client from "#build/server/plugin/route-client";
-import runtime from "@rcompat/runtime";
 import * as esbuild from "esbuild";
-const externals = {
-    node: ["node:*"],
-    bun: ["node:*", "bun:*"],
-    deno: ["node:*"],
-};
-const conditions = {
-    node: ["node"],
-    bun: ["bun", "node"],
-    deno: ["deno", "node"],
-};
 export default async function build_server(app) {
     app.plugin("server", plugin_node_imports(app));
     app.plugin("server", plugin_frontend(app));
@@ -40,13 +28,11 @@ export default async function build_server(app) {
     app.plugin("server", plugin_roots(app));
     app.plugin("server", plugin_views(app));
     app.plugin("server", plugin_assets(app));
-    app.plugin("server", plugin_stores(app));
     app.plugin("server", plugin_native_addons(app));
     app.plugin("server", plugin_requires(app));
     app.plugin("server", plugin_config(app));
     app.plugin("server", plugin_wasm(app));
     app.plugin("server", plugin_app_request(app));
-    const runtime_name = runtime.name;
     const tsconfig_json = app.root.join("tsconfig.json");
     const options = {
         entryPoints: [app.path.build.join("serve.js").path],
@@ -56,19 +42,20 @@ export default async function build_server(app) {
         platform: "node",
         format: "esm",
         packages: app.mode === "development" ? "external" : undefined,
-        external: [...externals[runtime_name]],
+        external: [...app.target.externals],
         loader: {
             ".json": "json",
         },
         banner: {
-            js: `import { createRequire as __createRequire } from "node:module";const require = __createRequire(import.meta.url);`,
+            js: `import { createRequire as __createRequire } from "node:module";
+      const require = __createRequire(import.meta.url);`,
         },
         nodePaths: [app.root.join("node_modules").path],
         resolveExtensions: app.extensions,
         absWorkingDir: app.root.path,
         ...await tsconfig_json.exists() ? { tsconfig: tsconfig_json.path } : {},
         conditions: [
-            ...conditions[runtime_name], // node | deno | bun
+            ...app.target.conditions, // node | deno | bun
             ...app.conditions, // set by modules
             ...app.config("conditions"), // set by user,
             "module", "import", "runtime", "default", // defaults

package/lib/private/build/server/plugin/native-addons.d.ts

@@ -1,4 +1,4 @@
 import type BuildApp from "#build/App";
 import type { Plugin } from "esbuild";
-export default function plugin_server_store(app: BuildApp): Plugin;
+export default function plugin_native_addons(app: BuildApp): Plugin;
 //# sourceMappingURL=native-addons.d.ts.map

package/lib/private/build/server/plugin/native-addons.js

@@ -2,7 +2,7 @@ import E from "#errors";
 import fs from "@rcompat/fs";
 import runtime from "@rcompat/runtime";
 const requirer = runtime.toRequire(import.meta.url);
-export default function plugin_server_store(app) {
+export default function plugin_native_addons(app) {
     return {
         name: "primate/server/native-addons",
         setup(build) {

package/lib/private/build/shared/intercept.d.ts

@@ -1,4 +1,4 @@
 import type { FileRef } from "@rcompat/fs";
 import type { OnResolveArgs } from "esbuild";
-export default function intercept(args: OnResolveArgs, views: FileRef): boolean;
+export default function intercept(args: OnResolveArgs, root: FileRef): boolean;
 //# sourceMappingURL=intercept.d.ts.map

package/lib/private/build/shared/intercept.js

@@ -17,8 +17,10 @@ function is_npm_package(path, resolve_dir) {
         return false;
     }
 }
-export default function intercept(args, views) {
-    if (!args.resolveDir.startsWith(views.path))
+export default function intercept(args, root) {
+    if (!args.resolveDir.startsWith(root.path))
+        return true;
+    if (args.resolveDir.includes("node_modules"))
         return true;
     if (is_bare(args.path))
         return true;

package/lib/private/client/create-form.d.ts

@@ -5,21 +5,23 @@ type FormErrors = {
     form: FieldErrors;
     fields: Dict<FieldErrors>;
 };
-type FormSnapshot = {
+type FormSnapshot<Result = unknown> = {
     id: FormId;
     submitting: boolean;
     submitted: boolean;
+    result: Result | null;
     errors: FormErrors;
 };
-export type FormView = FormSnapshot & {
+export type FormView<Result = unknown> = FormSnapshot<Result> & {
     submit: (event?: Event) => Promise<void>;
 };
-type FormSubscriber = (snapshot: FormSnapshot) => void;
+type FormSubscriber<Result = unknown> = (snapshot: FormSnapshot<Result>) => void;
 export type MethodMeta = {
     contentType?: string;
 };
-export type ClientMethod<Values extends Dict = Dict> = MethodMeta & ((args: {
+export type ClientMethod<Values extends Dict = Dict, Path extends Dict = Dict, Result = unknown> = MethodMeta & ((args: {
     body: Values;
+    path: Path;
 }) => Promise<Response>);
 export type FormInit = {
     id?: string;
@@ -28,15 +30,17 @@ export type FormInit = {
     headers?: Dict<string>;
     action?: (args: {
         body: unknown;
+        path?: Dict<string>;
     }) => Promise<Response>;
     contentType?: string;
+    path?: Dict<string>;
 };
-type FormController = {
-    subscribe(fn: FormSubscriber): () => void;
-    read(): FormSnapshot;
+type FormController<Result = unknown> = {
+    subscribe(fn: FormSubscriber<Result>): () => void;
+    read(): FormSnapshot<Result>;
     submit(event?: Event): Promise<void>;
     get id(): FormId;
 };
-export default function createForm(init: FormInit): FormController;
-export {};
+declare function createForm<Result = unknown>(init: FormInit): FormController<Result>;
+export default createForm;
 //# sourceMappingURL=create-form.d.ts.map

package/lib/private/client/create-form.js

@@ -37,12 +37,13 @@ function form_data_body(form_data) {
     }
     return new URLSearchParams(form_data);
 }
-export default function createForm(init) {
+function createForm(init) {
     const id = init.id ?? `form-${crypto.randomUUID()}`;
     let snapshot = {
         id,
         submitting: false,
         submitted: false,
+        result: null,
         errors: { form: [], fields: {} },
     };
     const subscribers = new Set();
@@ -100,12 +101,23 @@ export default function createForm(init) {
         setSubmitting(true);
         try {
             const response = await (is.defined(init.action)
-                ? init.action({ body: content_type_body(init.contentType, form_data) })
+                ? init.action({
+                    body: content_type_body(init.contentType, form_data),
+                    path: init.path,
+                })
                 : submit(url, form_data_body(form_data), method));
             if (response.ok) {
                 // on success: clear errors, let the app decide what to do next
                 // (redirect/reload)
-                snapshot = { ...snapshot, submitted: true, errors: { form: [], fields: {} } };
+                const result = response.status === 204
+                    ? null
+                    : await response.json();
+                snapshot = {
+                    ...snapshot,
+                    submitted: true,
+                    result,
+                    errors: { form: [], fields: {} },
+                };
                 publish();
                 return;
             }
@@ -115,7 +127,11 @@ export default function createForm(init) {
         }
         catch (error) {
             // network error
-            setErrors([{ type: "network_error", message: error.message, path: "" }]);
+            setErrors([{
+                    type: "network_error",
+                    message: error.message,
+                    path: "",
+                }]);
         }
         finally {
             setSubmitting(false);
@@ -138,4 +154,5 @@ export default function createForm(init) {
         },
     };
 }
+export default createForm;
 //# sourceMappingURL=create-form.js.map

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

@@ -1,10 +1,14 @@
 import type EnvSchema from "#app/EnvSchema";
 import AppFacade from "#app/Facade";
 import schema from "#config/schema";
+import type I18NConfig from "#i18n/Config";
 import type { ObjectType } from "pema";
-export default function config<P extends EnvSchema = EnvSchema>(input?: typeof schema.input & {
+type ConfigInput<P extends EnvSchema, I extends I18NConfig | undefined> = typeof schema.input & {
     env?: {
         schema?: ObjectType<P>;
     };
-}): AppFacade<P>;
+    i18n?: I;
+};
+export default function config<P extends EnvSchema = EnvSchema, const I extends I18NConfig | undefined = undefined>(input?: ConfigInput<P, I>): AppFacade<P, I>;
+export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,46 +1,50 @@
 import type DB from "#db/DB";
+import type I18NConfig from "#i18n/Config";
 import type Module from "#Module";
 import type { Dict } from "@rcompat/type";
 import type { ObjectType, Parsed } from "pema";
 declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
-    readonly conditions: import("pema").DefaultType<import("pema").ArrayType<import("pema").StringType>, string[]>;
+    readonly conditions: import("pema").DefaultType<import("pema").ArrayType<import("pema").StringType, undefined>, string[]>;
     readonly http: {
-        readonly csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType>>>;
-        readonly headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType>>;
-        readonly host: import("pema").DefaultType<import("pema").StringType, "localhost">;
-        readonly port: import("pema").DefaultType<import("pema").UintType<"u32">, 6161>;
-        readonly ssl: {
-            readonly cert: import("pema").OptionalType<import("pema").UnionType<[import("pema").IsType<import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
-            readonly key: import("pema").OptionalType<import("pema").UnionType<[import("pema").IsType<import("@rcompat/fs").FileRef>, import("pema").StringType]>>;
+        csp: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").ArrayType<import("pema").StringType, undefined>, undefined>>;
+        headers: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType, undefined>>;
+        host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+        port: import("pema").DefaultType<import("pema").UintType<"u32", undefined>, 6161>;
+        ssl: {
+            cert: import("pema").OptionalType<import("pema").StringType>;
+            key: import("pema").OptionalType<import("pema").StringType>;
         };
-        readonly static: {
-            readonly root: import("pema").DefaultType<import("pema").StringType, "/">;
+        static: {
+            root: import("pema").DefaultType<import("pema").StringType, "/">;
         };
     };
     readonly livereload: {
-        readonly exclude: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType>>;
-        readonly host: import("pema").OptionalType<import("pema").StringType>;
-        readonly port: import("pema").OptionalType<import("pema").UintType<"u32">>;
+        exclude: import("pema").OptionalType<import("pema").ArrayType<import("pema").StringType, undefined>>;
+        host: import("pema").OptionalType<import("pema").StringType>;
+        port: import("pema").OptionalType<import("pema").UintType<"u32", undefined>>;
     };
     readonly db: {
-        readonly migrations: import("pema").OptionalType<ObjectType<{
+        migrations: import("pema").OptionalType<ObjectType<{
             table: import("pema").StringType;
             db: import("pema").PureType<DB<unknown>, "PureType">;
-        }, {
+        }, undefined, {
             table: string;
             db: DB<unknown>;
         }>>;
     };
     readonly env: {
-        readonly schema: import("pema").OptionalType<import("pema").PureType<ObjectType<Dict<Parsed<unknown>>, {
+        schema: import("pema").OptionalType<import("pema").PureType<ObjectType<Dict<Parsed<unknown>>, undefined, {
             [x: string]: unknown;
         }>, "PureType">>;
     };
+    readonly i18n: import("pema").OptionalType<import("pema").PureType<I18NConfig, "PureType">>;
+    readonly loaders: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").LiteralType<"file", undefined>, undefined>>;
+    readonly entrypoints: import("pema").OptionalType<import("pema").RecordType<import("pema").StringType, import("pema").StringType, undefined>>;
     readonly modules: import("pema").DefaultType<import("pema").ArrayType<ObjectType<{
         name: import("pema").StringType;
         setup: import("pema").FunctionType;
-    }, Module>>, Module[]>;
-}>, {
+    }, undefined, Module>, undefined>, Module[]>;
+}>, undefined, {
     conditions: string[];
     http: {
         csp: Record<string, string[]> | undefined;
@@ -48,8 +52,8 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
         host: string;
         port: number;
         ssl: {
-            cert: string | import("@rcompat/fs").FileRef | undefined;
-            key: string | import("@rcompat/fs").FileRef | undefined;
+            cert: string | undefined;
+            key: string | undefined;
         };
         static: {
             root: string;
@@ -67,10 +71,13 @@ declare const _default: ObjectType<import("pema").NormalizeSchemaObject<{
         } | undefined;
     };
     env: {
-        schema: ObjectType<Dict<Parsed<unknown>>, {
+        schema: ObjectType<Dict<Parsed<unknown>>, undefined, {
             [x: string]: unknown;
         }> | undefined;
     };
+    i18n: I18NConfig | undefined;
+    loaders: Record<string, "file"> | undefined;
+    entrypoints: Record<string, string> | undefined;
     modules: Module[];
 }>;
 export default _default;

package/lib/private/config/schema.js

@@ -1,4 +1,3 @@
-import fs from "@rcompat/fs";
 import p from "pema";
 export default p({
     conditions: p.array(p.string).unique().default([]),
@@ -8,8 +7,8 @@ export default p({
         host: p.string.default("localhost"),
         port: p.uint.port().default(6161),
         ssl: {
-            cert: p.union(p.is(fs.isRef), p.string).optional(),
-            key: p.union(p.is(fs.isRef), p.string).optional(),
+            cert: p.string.optional(),
+            key: p.string.optional(),
         },
         static: {
             root: p.string.default("/"),
@@ -29,6 +28,9 @@ export default p({
     env: {
         schema: p.pure().optional(),
     },
+    i18n: p.pure().optional(),
+    loaders: p.dict(p.literal("file")).optional(),
+    entrypoints: p.dict(p.string).optional(),
     modules: p.array(p.object({
         name: p.string,
         setup: p.function,

package/lib/private/cookie.d.ts

@@ -1,10 +1,10 @@
 declare const Schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
-    readonly httpOnly: import("pema").DefaultType<import("pema").BooleanType, true>;
+    readonly httpOnly: import("pema").DefaultType<import("pema").BooleanType<undefined>, true>;
     readonly path: import("pema").DefaultType<import("pema").StringType, "/">;
-    readonly sameSite: import("pema").UnionType<[import("pema").LiteralType<"Lax">, import("pema").LiteralType<"None">, import("pema").LiteralType<"Strict">]>;
-    readonly secure: import("pema").BooleanType;
-    readonly maxAge: import("pema").OptionalType<import("pema").NumberType<"f64">>;
-}>, {
+    readonly sameSite: import("pema").UnionType<[import("pema").LiteralType<"Lax", undefined>, import("pema").LiteralType<"None", undefined>, import("pema").LiteralType<"Strict", undefined>], undefined>;
+    readonly secure: import("pema").BooleanType<undefined>;
+    readonly maxAge: import("pema").OptionalType<import("pema").NumberType<"f64", undefined>>;
+}>, undefined, {
     httpOnly: boolean;
     path: string;
     sameSite: "Lax" | "None" | "Strict";