@primate/core 0.4.6 → 0.6.0

package/lib/private/build/server/plugin/{hot-reload.js → live-reload.js}

@@ -1,36 +1,36 @@
-import fail from "#fail";
-export default function plugin_server_hot_reload(app) {
+import E from "#errors";
+import is from "@rcompat/is";
+export default function plugin_server_live_reload(app) {
     let build_n = 0;
     let serve_app;
     return {
-        name: "primate/server/hot-reload",
+        name: "primate/server/live-reload",
         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/hot-reload] failed to import {0}", filename);
-                    console.error(err);
+                catch (error) {
+                    throw E.build_live_reload_failed(filename, error);
                 }
             });
         },
     };
 }
-//# sourceMappingURL=hot-reload.js.map
+//# sourceMappingURL=live-reload.js.map

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

@@ -1,6 +1,6 @@
-import fail from "#fail";
+import E from "#errors";
 import log from "#log";
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 import { createRequire } from "node:module";
 const requirer = createRequire(import.meta.url);
 export default function plugin_server_store(app) {
@@ -17,23 +17,22 @@ export default function plugin_server_store(app) {
                         const module_path = requirer.resolve(args.path, {
                             paths: [args.resolveDir],
                         });
-                        const module_dir = new FileRef(module_path).directory;
+                        const module_dir = fs.ref(module_path).directory;
                         // built-ins have no .node and would otherwise cause global search
                         if (module_dir.path === ".")
                             return null;
                         // check if this module has .node files
-                        const node_files = await module_dir
-                            .collect(f => f.path.endsWith(".node"));
+                        const node_files = await module_dir.files({
+                            recursive: true,
+                            filter: info => info.path.endsWith(".node"),
+                        });
                         if (node_files.length > 0) {
                             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/node-imports.js

@@ -1,6 +1,6 @@
-import pkg from "@rcompat/fs/project/package";
+import fs from "@rcompat/fs";
 import { createRequire } from "node:module";
-const core_pkg = await pkg(import.meta.url);
+const core_pkg = await fs.project.package(import.meta.dirname);
 const core_root = core_pkg.directory.path;
 const requirer = createRequire(import.meta.url);
 export default function plugin_server_node_imports(_app) {

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

@@ -1,6 +1,6 @@
-import fail from "#fail";
+import E from "#errors";
 import wrap from "#route/wrap";
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 const contents = "export default {};";
 export default function plugin_server_route(app) {
     const path_routes = app.path.routes;
@@ -18,7 +18,7 @@ export default function plugin_server_route(app) {
                 let file;
                 let extension;
                 for (const e of extensions) {
-                    const candidate = new FileRef(base.path + e);
+                    const candidate = fs.ref(base.path + e);
                     if (await candidate.exists()) {
                         file = candidate;
                         extension = e;
@@ -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

@@ -1,41 +1,19 @@
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 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 database from "app:database";
-            import wrap from "primate/database/wrap";
-            import schema from "store:${name}";
-            export default wrap("${name}", schema, database);
-          `,
-                    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 = new FileRef(`${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) => {
-                const file = new FileRef(args.path);
-                const source = await file.text();
+            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 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

@@ -1,5 +1,4 @@
-import FileRef from "@rcompat/fs/FileRef";
-const jts_re = /\.[jt]s$/;
+import fs from "@rcompat/fs";
 export default function plugin_server_stores(app) {
     const base = app.path.stores;
     return {
@@ -9,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.collect(file => jts_re.test(file.path)))
-                    .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 "${FileRef.webpath(`app:store/${bare}`)}";
-           stores["${FileRef.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

@@ -1,4 +1,4 @@
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 export default function plugin_server_view(app) {
     return {
         name: "primate/server/view",
@@ -19,7 +19,7 @@ export default function plugin_server_view(app) {
                 // couldn't resolve, don't interfere
                 if (result.errors.length > 0 || !result.path)
                     return null;
-                const resolved = new FileRef(result.path);
+                const resolved = fs.ref(result.path);
                 // must live under app.path.views (e.g. app/views/...)
                 const views_root = app.path.views.path;
                 if (!resolved.path.startsWith(views_root + "/"))
@@ -40,7 +40,7 @@ export default function plugin_server_view(app) {
             build.onResolve({ filter: /^view:/ }, async (args) => {
                 const name = args.path.slice("view:".length);
                 for (const ext of app.extensions) {
-                    const file = new FileRef(`${app.path.views.path}/${name}${ext}`);
+                    const file = app.path.views.join(`${name}${ext}`);
                     if (await file.exists()) {
                         return { path: file.path, namespace: "primate-view-original" };
                     }
@@ -48,9 +48,9 @@ export default function plugin_server_view(app) {
                 return null;
             });
             build.onLoad({ filter: /.*/, namespace: "primate-view-original" }, async (args) => {
-                const file = new FileRef(args.path);
+                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/server/plugin/views.js

@@ -1,4 +1,4 @@
-import FileRef from "@rcompat/fs/FileRef";
+import fs from "@rcompat/fs";
 export default function plugin_server_views(app) {
     return {
         name: "primate/server/views",
@@ -7,15 +7,15 @@ export default function plugin_server_views(app) {
                 return { path: "views-virtual", namespace: "primate-views" };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-views" }, async () => {
-                const files = await app.path.views.collect();
+                const files = await app.path.views.files({ recursive: true });
                 const roots = Object.keys(app.roots);
                 const contents = `
         const view = [];
         ${files.map((file, i) => {
                     const path = app.basename(file, app.path.views);
                     return `
-            import * as view${i} from "${FileRef.webpath(`view:${path}`)}";
-            view.push(["${FileRef.webpath(path)}", view${i}]);`;
+            import * as view${i} from "${fs.webpath(`view:${path}`)}";
+            view.push(["${fs.webpath(path)}", view${i}]);`;
                 }).join("\n")}
 
         ${roots.map((filename, i) => `

package/lib/private/build/server/plugin/virtual-pages.js

@@ -1,6 +1,5 @@
-import pkg from "@rcompat/fs/project/package";
-const core_pkg = await pkg(import.meta.url);
-const core_root = core_pkg.directory;
+import fs from "@rcompat/fs";
+const core_pkg = await fs.project.root(import.meta.dirname);
 export default function plugin_server_virtual_pages(app) {
     return {
         name: "primate/server/virtual/pages",
@@ -9,15 +8,16 @@ export default function plugin_server_virtual_pages(app) {
                 return { path: "pages-virtual", namespace: "primate-pages" };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-pages" }, async () => {
-                const html = /^.*\.html$/ui;
-                const is_html = (file) => html.test(file.path);
-                const defaults = core_root.join("lib", "private", "defaults");
+                const filter = /^.*\.html$/ui;
+                const defaults = core_pkg.join("lib", "private", "defaults");
                 const pages = {};
-                for (const file of await defaults.collect(is_html))
+                for (const file of await defaults.files({ filter })) {
                     pages[file.name] = file;
+                }
                 if (await app.path.pages.exists()) {
-                    for (const file of await app.path.pages.collect(is_html))
+                    for (const file of await app.path.pages.files({ filter })) {
                         pages[file.name] = file;
+                    }
                 }
                 const entries = await Promise.all(Object.entries(pages).map(async ([name, file]) => {
                     const text = await file.text();

package/lib/private/build/server/plugin/virtual-routes.js

@@ -11,18 +11,10 @@ export default function plugin_server_virtual_routes(app) {
                 return { path: "routes-virtual", namespace: "primate-routes" };
             });
             build.onLoad({ filter: /.*/, namespace: "primate-routes" }, async () => {
-                const route_files = await routes_path.collect(is_route_file);
-                const watchDirs = new Set();
-                const findDirs = async (dir) => {
-                    watchDirs.add(dir.path);
-                    const entries = await dir.list();
-                    for (const entry of entries) {
-                        if (await entry.isDirectory()) {
-                            await findDirs(entry);
-                        }
-                    }
-                };
-                await findDirs(app.path.routes);
+                const route_files = await routes_path.files({
+                    filter: is_route_file,
+                    recursive: true,
+                });
                 const contents = `
           const route = [];
           ${route_files.map((file, i) => {
@@ -32,11 +24,14 @@ export default function plugin_server_virtual_routes(app) {
                 }).join("\n")}
           export default route;
         `;
+                const watchDirs = (await app.path.routes.dirs({
+                    recursive: true,
+                })).map(f => f.toString());
                 return {
                     contents,
                     loader: "js",
                     resolveDir: app.root.path,
-                    watchDirs: [...watchDirs],
+                    watchDirs,
                     watchFiles: route_files.map(f => f.path),
                 };
             });

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

@@ -22,9 +22,8 @@ export default function plugin_server_wasm(app) {
                 const wasm_file = app.runpath("wasm", args.path + ".wasm");
                 return {
                     contents: `
-            import FileRef from "primate/fs/FileRef";
-            const file = new FileRef("${wasm_file.path}");
-            export default await file.bytes();
+            import fs from "@rcompat/fs";
+            export default await fs.ref("${wasm_file.path}").bytes();
           `,
                     loader: "js",
                     resolveDir: app.root.path,

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/bye.js

@@ -1,5 +1,4 @@
-import dim from "@rcompat/cli/color/dim";
-import yellow from "@rcompat/cli/color/yellow";
+import color from "@rcompat/cli/color";
 import print from "@rcompat/cli/print";
-export default () => print(dim(yellow("~~ bye\n")));
+export default () => print(color.dim(color.yellow("~~ bye\n")));
 //# sourceMappingURL=bye.js.map

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

@@ -1,8 +1,9 @@
-import type Dict from "@rcompat/type/Dict";
 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/client/Render.d.ts

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

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

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type ServerData<V> = {
     view: V;
     props: Dict;

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

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

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

@@ -1,6 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
-import type JSONPointer from "@rcompat/type/JSONPointer";
-import type JSONValue from "@rcompat/type/JSONValue";
+import type { Dict, JSONPointer, JSONValue } from "@rcompat/type";
 type ValidateInit<T> = {
     headers?: Dict<string>;
     initial: T;

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

@@ -1,4 +1,4 @@
-import type Issue from "pema/Issue";
+import type { Issue } from "pema";
 type ValidationError = {
     issues?: ReadonlyArray<Issue>;
 } & Error;

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

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type View = {
     view: unknown;
     name: string;

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

@@ -1,4 +1,4 @@
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 export default interface ViewOptions extends ResponseInit {
     csp?: {
         script_src?: string[];

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

@@ -1,6 +1,6 @@
-import type ViewOptions from "#frontend/ViewOptions";
+import type ViewOptions from "#client/ViewOptions";
 import type ResponseFunction from "#response/ResponseFunction";
-import type Dict from "@rcompat/type/Dict";
+import type { Dict } from "@rcompat/type";
 type View = (name: string, props?: Dict, options?: ViewOptions) => ResponseFunction;
 export { View as default };
 //# sourceMappingURL=ViewResponse.d.ts.map

package/lib/private/client/app.js

@@ -1,6 +1,7 @@
 // @ts-expect-error esbuild vfs
 import stamp from "server:stamp";
-(() => stamp)();
+// @ts-expect-error esbuild vfs
+(0, () => stamp)();
 // @ts-expect-error esbuild vfs
 import * as frontends from "app:frontends";
 class ClientApp {
@@ -12,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

@@ -0,0 +1,32 @@
+import type { Dict } from "@rcompat/type";
+type FormId = string;
+type FieldErrors = readonly string[];
+type FormErrors = {
+    form: FieldErrors;
+    fields: Dict<FieldErrors>;
+};
+type FormSnapshot = {
+    id: FormId;
+    submitting: boolean;
+    submitted: boolean;
+    errors: FormErrors;
+};
+export type FormView = FormSnapshot & {
+    submit: (event?: Event) => Promise<void>;
+};
+type FormSubscriber = (snapshot: FormSnapshot) => void;
+export type FormInit = {
+    id?: string;
+    method?: "POST" | "PUT" | "PATCH" | "DELETE";
+    url?: string;
+    headers?: Dict<string>;
+};
+type FormController = {
+    subscribe(fn: FormSubscriber): () => void;
+    read(): FormSnapshot;
+    submit(event?: Event): Promise<void>;
+    get id(): FormId;
+};
+export default function createForm(init: FormInit): FormController;
+export {};
+//# sourceMappingURL=create-form.d.ts.map