@primate/core 0.5.0 → 0.6.0

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

@@ -1,4 +1,5 @@
 import Flags from "#Flags";
-declare const _default: (input: typeof Flags.input) => Promise<true | undefined>;
+import type { FileRef } from "@rcompat/fs";
+declare const _default: (root: FileRef, input: typeof Flags.input) => Promise<true | undefined>;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/lib/private/build/index.js

@@ -1,39 +1,38 @@
+import { s_config } from "#app/Facade";
 import BuildApp from "#build/App";
 import bye from "#bye";
 import default_config from "#config/index";
-import fail from "#fail";
+import E from "#errors";
 import Flags from "#Flags";
 import log from "#log";
 import dict from "@rcompat/dict";
-import fs from "@rcompat/fs";
-import { s_config } from "#app/Facade";
 const no_config = (config) => config === undefined || dict.empty(config);
-const find_config = async (root) => {
+async function find_config(root) {
     const ts_config = root.join("config/app.ts");
     if (await ts_config.exists())
         return ts_config;
     const js_config = root.join("config/app.js");
     if (await js_config.exists())
         return js_config;
-};
-const get_config = async (root) => {
-    const config = await find_config(root);
-    if (config !== undefined) {
-        try {
-            const imported = (await config.import("default"))[s_config];
-            if (no_config(imported))
-                throw fail("empty config file at {0}", config);
-            return imported;
-        }
-        catch (error) {
-            throw fail("error in config file {0}", error);
-        }
+}
+;
+async function get_config(root) {
+    const config_file = await find_config(root);
+    if (config_file === undefined)
+        return default_config()[s_config];
+    try {
+        const imported = (await config_file.import("default"))[s_config];
+        if (no_config(imported))
+            throw E.config_file_empty(config_file);
+        return imported;
     }
-    return default_config();
-};
-export default async (input) => {
+    catch (error) {
+        throw E.config_file_error(config_file, error);
+    }
+}
+;
+export default async (root, input) => {
     try {
-        const root = await fs.project.root();
         const flags = Flags.parse(input);
         const config = await get_config(root);
         const app = await new BuildApp(root, config, flags).init();

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

@@ -1,6 +1,5 @@
 import plugin_assets from "#build/server/plugin/assets";
 import plugin_config from "#build/server/plugin/config";
-import plugin_db_default from "#build/server/plugin/db-default";
 import plugin_frontend from "#build/server/plugin/frontend";
 import plugin_live_reload from "#build/server/plugin/live-reload";
 import plugin_native_addons from "#build/server/plugin/native-addons";
@@ -8,14 +7,13 @@ 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_store from "#build/server/plugin/store";
-import plugin_store_wrap from "#build/server/plugin/store-wrap";
 import plugin_stores from "#build/server/plugin/stores";
 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 runtime from "@rcompat/runtime";
 import * as esbuild from "esbuild";
 const externals = {
@@ -32,9 +30,6 @@ export default async function build_server(app) {
     app.plugin("server", plugin_node_imports(app));
     app.plugin("server", plugin_frontend(app));
     app.plugin("server", plugin_view(app));
-    app.plugin("server", plugin_store(app));
-    app.plugin("server", plugin_store_wrap(app));
-    app.plugin("server", plugin_db_default(app));
     if (app.mode === "development")
         app.plugin("server", plugin_live_reload(app));
     app.plugin("server", plugin_virtual_pages(app));
@@ -48,6 +43,9 @@ export default async function build_server(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 = app.root.join("tsconfig.json");
     const options = {
         entryPoints: [app.path.build.join("serve.js").path],
         outfile: app.path.build.join("server.js").path,
@@ -55,7 +53,7 @@ export default async function build_server(app) {
         platform: "node",
         format: "esm",
         packages: app.mode === "development" ? "external" : undefined,
-        external: [...externals[runtime]],
+        external: [...externals[runtime_name]],
         loader: {
             ".json": "json",
         },
@@ -68,9 +66,9 @@ export default async function build_server(app) {
         nodePaths: [app.root.join("node_modules").path],
         resolveExtensions: app.extensions,
         absWorkingDir: app.root.path,
-        tsconfig: app.root.join("tsconfig.json").path,
+        ...await tsconfig.exists() ? { tsconfig: tsconfig.path } : {},
         conditions: [
-            ...conditions[runtime],
+            ...conditions[runtime_name],
             "module", "import", "runtime", "default",
             ...app.conditions
         ],

package/lib/private/build/server/plugin/app-request.d.ts

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

package/lib/private/build/server/plugin/app-request.js

@@ -0,0 +1,19 @@
+export default function plugin_server_request(app) {
+    return {
+        name: "primate/server/app/request",
+        setup(build) {
+            build.onResolve({ filter: /^app:request$/ }, ({ importer }) => {
+                const frontend = [...app.frontends.entries()]
+                    .find(([, exts]) => exts.some(ext => importer.endsWith(ext)));
+                return frontend !== undefined
+                    ? { namespace: "request", path: frontend[0] }
+                    : undefined;
+            });
+            build.onLoad({ filter: /.*/, namespace: "request" }, async ({ path }) => {
+                const contents = `export { default } from "@primate/${path}/request";`;
+                return { contents, resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=app-request.js.map

package/lib/private/build/server/plugin/assets.js

@@ -1,5 +1,5 @@
 import location from "#location";
-import MIME from "@rcompat/http/mime";
+import { MIME } from "@rcompat/http";
 function bytes2base64(bytes) {
     const chunk_size = 0x8000;
     let result = "";

package/lib/private/build/server/plugin/live-reload.js

@@ -1,4 +1,5 @@
-import fail from "#fail";
+import E from "#errors";
+import is from "@rcompat/is";
 export default function plugin_server_live_reload(app) {
     let build_n = 0;
     let serve_app;
@@ -7,27 +8,26 @@ export default function plugin_server_live_reload(app) {
         setup(build) {
             build.onEnd(async (result) => {
                 // don't do anything on errors
-                if (result.errors.length)
+                if (result.errors.length > 0)
                     return;
                 // we expect a single bundled file
-                const outFile = result.outputFiles?.[0];
-                if (!outFile)
+                const out_file = result.outputFiles?.[0];
+                if (is.undefined(out_file))
                     return;
                 const filename = `server.${build_n}.js`;
                 const s = app.path.build.join(filename);
-                await s.write(outFile.text);
+                await s.write(out_file.text);
                 try {
                     // stop old app
-                    if (serve_app !== undefined)
+                    if (is.defined(serve_app))
                         serve_app.stop();
                     serve_app = (await s.import()).default;
                     const stamp = app.runpath("client", "server-stamp.js");
                     await stamp.write(`export default ${build_n};\n`);
                     build_n++;
                 }
-                catch (err) {
-                    fail("[primate/server/live-reload] failed to import {0}", filename);
-                    console.error(err);
+                catch (error) {
+                    throw E.build_live_reload_failed(filename, error);
                 }
             });
         },

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

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import log from "#log";
 import fs from "@rcompat/fs";
 import { createRequire } from "node:module";
@@ -30,12 +30,9 @@ export default function plugin_server_store(app) {
                             const platform = process.platform;
                             const arch = process.arch;
                             let node_file = node_files.find(f => f.path.includes(`${platform}-${arch}`));
-                            if (!node_file) {
-                                node_file = node_files.find(f => f.path.includes(platform));
-                            }
-                            if (!node_file) {
-                                throw fail("could not find matching binary addon");
-                            }
+                            node_file ??= node_files.find(f => f.path.includes(platform));
+                            if (node_file === undefined)
+                                throw E.build_missing_binary_addon();
                             const addon_name = node_files[0].name;
                             const dest = app.path.build.join("native", addon_name);
                             await dest.directory.create();

package/lib/private/build/server/plugin/route.js

@@ -1,4 +1,4 @@
-import fail from "#fail";
+import E from "#errors";
 import wrap from "#route/wrap";
 import fs from "@rcompat/fs";
 const contents = "export default {};";
@@ -26,7 +26,7 @@ export default function plugin_server_route(app) {
                     }
                 }
                 if (!file || !extension) {
-                    throw fail(`cannot find route source for "${relative}" under ${path_routes.path}`);
+                    throw E.build_missing_route(relative, path_routes);
                 }
                 // normalise "routes/foo.ext" -> "foo" for router
                 const relative_from_routes = file.path.split("routes").pop();

package/lib/private/build/server/plugin/store.js

@@ -3,39 +3,17 @@ export default function plugin_server_store(app) {
     return {
         name: "primate/server/store",
         setup(build) {
-            build.onResolve({ filter: /^app:store\// }, args => {
-                const name = args.path.slice("app:store/".length).replace(/\.(js|ts)$/, "");
-                return { path: name, namespace: "primate-store-wrapper" };
-            });
-            build.onLoad({ filter: /.*/, namespace: "primate-store-wrapper" }, args => {
-                const name = args.path;
-                return {
-                    contents: `
-            import db from "app:db";
-            import wrap from "primate/orm/wrap";
-            import schema from "store:${name}";
-            export default wrap("${name}", schema, db);
-          `,
-                    loader: "js",
-                    resolveDir: app.path.stores.path,
-                };
-            });
-            build.onResolve({ filter: /^store:/ }, async (args) => {
-                const name = args.path.slice("store:".length);
-                for (const ext of app.extensions) {
-                    const file = fs.ref(`${app.path.stores.path}/${name}${ext}`);
-                    if (await file.exists()) {
-                        // special namespace to bypass auto-wrap
-                        return { path: file.path, namespace: "primate-store-raw" };
-                    }
-                }
-                return null;
-            });
-            build.onLoad({ filter: /.*/, namespace: "primate-store-raw" }, async (args) => {
+            build.onLoad({ filter: /.*/ }, async (args) => {
+                if (args.namespace !== "file")
+                    return null;
+                if (!/\.([tj]s)$/.test(args.path))
+                    return null;
                 const file = fs.ref(args.path);
-                const source = await file.text();
+                const stores_root = app.path.stores.path;
+                if (!file.path.startsWith(stores_root + "/"))
+                    return null;
                 return {
-                    contents: source,
+                    contents: await file.text(),
                     loader: args.path.endsWith(".ts") ? "ts" : "js",
                     resolveDir: file.directory.path,
                     watchFiles: [file.path],

package/lib/private/build/server/plugin/stores.js

@@ -8,14 +8,18 @@ export default function plugin_server_stores(app) {
                 return { path: "stores-virtual", namespace: "primate-stores" };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-stores" }, async () => {
-                const stores = await Promise.all((await base.files({ recursive: true, filter: /\.[jt]s$/ }))
-                    .map(async (path) => `${path}`.replace(base.toString(), _ => "")));
+                const files = await base.files({ recursive: true, filter: /\.[jt]s$/ });
                 const contents = `
-        const stores = {};
-        ${stores.map(path => path.slice(1, -".js".length)).map((bare, i) => `import * as store${i} from "${fs.webpath(`app:store/${bare}`)}";
-           stores["${fs.webpath(bare)}"] = store${i}.default;`).join("\n")}
-        export default stores;
-      `;
+    const stores = {};
+    ${files.map((file, i) => {
+                    const bare = fs.webpath(`${file}`
+                        .replace(base.toString(), "")
+                        .replace(/\.[jt]s$/, "").slice(1));
+                    return `import * as store${i} from "${file}";
+       stores["${bare}"] = store${i}.default;`;
+                }).join("\n")}
+    export default stores;
+  `;
                 return { contents, loader: "js", resolveDir: app.root.path };
             });
         },

package/lib/private/build/server/plugin/view.js

@@ -50,7 +50,7 @@ export default function plugin_server_view(app) {
             build.onLoad({ filter: /.*/, namespace: "primate-view-original" }, async (args) => {
                 const file = fs.ref(args.path);
                 const binder = app.binder(file);
-                if (!binder)
+                if (binder === undefined)
                     return null;
                 const contents = await binder(file, {
                     build: { id: app.id },

package/lib/private/build/shared/plugin/app-request.d.ts

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

package/lib/private/build/shared/plugin/app-request.js

@@ -0,0 +1,19 @@
+export default function plugin_shared_app_request(app) {
+    return {
+        name: "primate/shared/app/request",
+        setup(build) {
+            build.onResolve({ filter: /^app:/ }, ({ path, importer }) => {
+                const framework = path.slice(4);
+                const exts = app.frontends.get(framework);
+                return exts?.some(ext => importer.endsWith(ext))
+                    ? { namespace: "app-frontend", path: framework }
+                    : undefined;
+            });
+            build.onLoad({ filter: /.*/, namespace: "app-frontend" }, async ({ path }) => {
+                const contents = `export * from "@primate/${path}/app";`;
+                return { contents, resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=app-request.js.map

package/lib/private/client/Data.d.ts

@@ -1,8 +1,9 @@
-import type { Dict } from "@rcompat/type";
 import type Mode from "#Mode";
+import type RequestView from "#request/RequestView";
+import type { Dict } from "@rcompat/type";
 type ClientData<T extends Dict = Dict> = {
     view: string;
-    request: Dict;
+    request: RequestView;
     spa: boolean;
     ssr: boolean;
     mode: Mode;

package/lib/private/{frontend → client}/Render.d.ts

@@ -2,7 +2,7 @@ import type { Dict, MaybePromise } from "@rcompat/type";
 type Render<V = unknown> = (view: V, props: Dict) => MaybePromise<{
     body: string;
     head?: string;
-    headers?: Record<string, string>;
+    headers?: Dict<string>;
 }>;
 export type { Render as default };
 //# sourceMappingURL=Render.d.ts.map

package/lib/private/{frontend → client}/ViewResponse.d.ts

@@ -1,4 +1,4 @@
-import type ViewOptions from "#frontend/ViewOptions";
+import type ViewOptions from "#client/ViewOptions";
 import type ResponseFunction from "#response/ResponseFunction";
 import type { Dict } from "@rcompat/type";
 type View = (name: string, props?: Dict, options?: ViewOptions) => ResponseFunction;

package/lib/private/client/app.js

@@ -13,6 +13,5 @@ class ClientApp {
         }
     }
 }
-const app = new ClientApp();
-app.start();
+new ClientApp().start();
 //# sourceMappingURL=app.js.map

package/lib/private/client/boot.d.ts

@@ -0,0 +1,5 @@
+import type { Updater } from "#client/root";
+import type { Dict } from "@rcompat/type";
+declare const _default: <T extends Dict>(u: Updater<T>) => void;
+export default _default;
+//# sourceMappingURL=boot.d.ts.map

package/lib/private/client/boot.js

@@ -0,0 +1,64 @@
+import navigate from "#client/navigate";
+import root from "#client/root";
+import storage from "#client/storage";
+import submit from "#client/submit";
+import { MIME } from "@rcompat/http";
+export default (u) => {
+    root.set(u);
+    const { location, history } = globalThis;
+    if (document.contentType === "application/json") {
+        location.reload();
+        return;
+    }
+    globalThis.addEventListener("pageshow", event => {
+        if (event.persisted)
+            location.reload();
+    });
+    globalThis.addEventListener("load", _ => {
+        history.scrollRestoration = "manual";
+        if (location.hash !== "")
+            navigate.scroll_hash(location.hash);
+    });
+    globalThis.addEventListener("beforeunload", _ => {
+        history.scrollRestoration = "auto";
+    });
+    globalThis.addEventListener("popstate", () => {
+        const state = storage.peek() ?? { scrollTop: 0 };
+        const { pathname } = location;
+        let { scrollTop } = state;
+        if (state.stop) {
+            storage.back();
+            state.hash
+                ? navigate.scroll_hash(state.hash)
+                : globalThis.scrollTo(0, state.scrollTop);
+            return;
+        }
+        const back = state.pathname === pathname;
+        back ? storage.back() : (scrollTop = storage.forward().scrollTop);
+        navigate.goto(globalThis.location, false, () => globalThis.scrollTo(0, scrollTop ?? 0));
+    });
+    globalThis.addEventListener("click", event => {
+        const target = event.target.closest("a");
+        if (target?.tagName === "A" && target.href !== "") {
+            navigate.go(target.href, event);
+        }
+    });
+    globalThis.addEventListener("submit", async (event) => {
+        event.preventDefault();
+        const target = event.target;
+        const { enctype } = target;
+        const action = target.action ?? location.pathname;
+        const url = new URL(action);
+        const data = new FormData(target);
+        const form = enctype === MIME.MULTIPART_FORM_DATA
+            ? data
+            : new URLSearchParams(data);
+        try {
+            await submit(url.pathname, form, target.method);
+        }
+        catch (error) {
+            console.warn(error);
+        }
+    });
+};
+//# sourceMappingURL=boot.js.map

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

@@ -8,6 +8,7 @@ type FormErrors = {
 type FormSnapshot = {
     id: FormId;
     submitting: boolean;
+    submitted: boolean;
     errors: FormErrors;
 };
 export type FormView = FormSnapshot & {

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

@@ -1,4 +1,5 @@
 import extract_issues from "#client/extract-issues";
+import submit from "#client/submit";
 function decode_pointer_segment(segment) {
     // decode JSON Pointer: ~1 -> /, ~0 -> ~
     return segment.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -25,6 +26,7 @@ export default function createForm(init) {
     let snapshot = {
         id,
         submitting: false,
+        submitted: false,
         errors: { form: [], fields: {} },
     };
     const subscribers = new Set();
@@ -37,41 +39,42 @@ export default function createForm(init) {
         publish();
     }
     function setErrors(issues) {
-        const byField = {};
-        const formErrors = [];
+        const by_field = {};
+        const form_errors = [];
         for (const issue of issues) {
             const path = issue.path;
             // no path or empty string -> form-level error
-            if (!path) {
-                formErrors.push(issue.message);
+            if (path === undefined) {
+                form_errors.push(issue.message);
                 continue;
             }
             const key = pointer_to_fieldname(path);
             // if normalizes to empty (e.g. "/"), treat as form-level
-            if (!key) {
-                formErrors.push(issue.message);
+            if (key.length === 0) {
+                form_errors.push(issue.message);
                 continue;
             }
-            (byField[key] ??= []).push(issue.message);
+            (by_field[key] ??= []).push(issue.message);
         }
         snapshot = {
             ...snapshot,
+            submitted: false,
             errors: {
-                form: formErrors,
-                fields: byField,
+                form: form_errors,
+                fields: by_field,
             },
         };
         publish();
     }
-    async function submit(event) {
-        if (event) {
+    async function submit_form(event) {
+        if (event !== undefined) {
             event.preventDefault();
             event.stopPropagation();
         }
         const form_element = event?.currentTarget ??
             document.getElementById(id);
         // no form element
-        if (!form_element)
+        if (form_element === null)
             return;
         const method = init.method
             ?? form_element.method.toUpperCase()
@@ -80,15 +83,11 @@ export default function createForm(init) {
         const form_data = new FormData(form_element);
         setSubmitting(true);
         try {
-            const response = await fetch(url, {
-                method,
-                body: form_data,
-                headers: init.headers,
-            });
+            const response = await submit(url, form_data, method);
             if (response.ok) {
                 // on success: clear errors, let the app decide what to do next
                 // (redirect/reload)
-                snapshot = { ...snapshot, errors: { form: [], fields: {} } };
+                snapshot = { ...snapshot, submitted: true, errors: { form: [], fields: {} } };
                 publish();
                 return;
             }
@@ -98,7 +97,7 @@ export default function createForm(init) {
         }
         catch (error) {
             // network error
-            setErrors([{ message: error.message, path: "" }]);
+            setErrors([{ type: "network_error", message: error.message, path: "" }]);
         }
         finally {
             setSubmitting(false);
@@ -115,7 +114,7 @@ export default function createForm(init) {
     return {
         subscribe,
         read,
-        submit,
+        submit: submit_form,
         get id() {
             return snapshot.id;
         },

package/lib/private/client/extract-issues.js

@@ -2,6 +2,7 @@ export default function extractIssues(payload, defaultPath = "") {
     // scalar: { message, messages }
     if ("messages" in payload) {
         return payload.messages.map(m => ({
+            type: payload.type,
             message: m,
             // for forms, defaultPath is "", but Issue.path expects a JSONPointer
             // so we cast here; form-level errors are handled separately anyway
@@ -12,7 +13,7 @@ export default function extractIssues(payload, defaultPath = "") {
     const issues = [];
     for (const [path, bundle] of Object.entries(payload)) {
         for (const message of bundle.messages) {
-            issues.push({ message, path: path });
+            issues.push({ type: bundle.type, message, path: path });
         }
     }
     return issues;

package/lib/private/client/http.d.ts

@@ -0,0 +1,13 @@
+declare function refetch(input: string | URL, init?: RequestInit, max_hops?: number): Promise<{
+    requested: URL;
+    response: Response;
+}>;
+declare function is_json(response: Response): boolean;
+declare function submit(pathname: string, body: any, method: string): Promise<Response>;
+declare const http: {
+    refetch: typeof refetch;
+    is_json: typeof is_json;
+    submit: typeof submit;
+};
+export default http;
+//# sourceMappingURL=http.d.ts.map