@primate/core 0.2.3 → 0.3.0

package/lib/private/App.d.ts

@@ -13,6 +13,7 @@ export default class App {
         app_html: "app.html";
         build: "build";
         client: "client";
+        lib: "lib";
         components: "components";
         config: "config";
         error_html: "error.html";
@@ -23,6 +24,8 @@ export default class App {
         static: "static";
         stores: "stores";
         locales: "locales";
+        views: "views";
+        hooks: "hooks";
     };
     get target(): TargetManager;
     get root(): FileRef;
@@ -30,6 +33,7 @@ export default class App {
         readonly app_html: FileRef;
         readonly build: FileRef;
         readonly client: FileRef;
+        readonly lib: FileRef;
         readonly components: FileRef;
         readonly config: FileRef;
         readonly error_html: FileRef;
@@ -40,11 +44,14 @@ export default class App {
         readonly static: FileRef;
         readonly stores: FileRef;
         readonly locales: FileRef;
+        readonly views: FileRef;
+        readonly hooks: FileRef;
     };
     get mode(): Mode;
     get modules(): Module[];
     get extensions(): string[];
     binder(file: FileRef): Binder | undefined;
+    basename(file: FileRef, directory: FileRef): string;
     get<T>(key: symbol): T;
     set(key: symbol, value: unknown): void;
     config<P extends string>(path: P): ReturnType<typeof get<Config, P>>;

package/lib/private/App.js

@@ -1,7 +1,6 @@
 import fail from "#fail";
 import location from "#location";
 import reducer from "#reducer";
-import wrap from "#route/wrap";
 import TargetManager from "#target/Manager";
 import assert from "@rcompat/assert";
 import transform from "@rcompat/build/sync/transform";
@@ -23,30 +22,26 @@ const BIND_CONTEXTS = [
     "config",
     "routes",
     "components",
+    "views",
     "stores",
     "locales",
     "modules",
 ];
 function generate_bindings(_app) {
     return {
-        ".js": async (file, { build, context }) => {
+        ".js": (file, { context }) => {
             const error = `js: only ${toContextString(BIND_CONTEXTS)} are supported`;
             assert(BIND_CONTEXTS.includes(context), error);
-            const code = context === "routes"
-                ? wrap(await file.text(), file, build)
-                : await file.text();
-            await file.append(".js").write(code);
+            return file.text();
         },
-        ".json": () => {
+        ".json": (file) => {
             // just copy the JSON for now
+            return file.text();
         },
-        ".ts": async (file, { build, context }) => {
+        ".ts": async (file, { context }) => {
             const error = `ts: only ${toContextString(BIND_CONTEXTS)} are supported`;
             assert(BIND_CONTEXTS.includes(context), error);
-            const code = context === "routes"
-                ? wrap(compile(await file.text()), file, build)
-                : compile(await file.text());
-            await file.append(".js").write(code);
+            return compile(await file.text());
         },
     };
 }
@@ -104,6 +99,17 @@ export default class App {
             .toSorted(([a], [b]) => a.length > b.length ? -1 : 1)
             .find(([extension]) => file.path.endsWith(extension))?.[1];
     }
+    basename(file, directory) {
+        const relative = file.debase(directory);
+        const extensions = this.extensions
+            .toSorted((a, b) => a.length > b.length ? -1 : 1);
+        for (const extension of extensions) {
+            if (relative.path.endsWith(extension)) {
+                return relative.path.slice(1, -extension.length);
+            }
+        }
+        return relative.bare().path.slice(1);
+    }
     get(key) {
         return this.#kv.get(key);
     }

package/lib/private/Binder.d.ts

@@ -8,6 +8,6 @@ type Options = {
     };
     context: BindingContext;
 };
-type Binder = (file: FileRef, options: Options) => MaybePromise<void>;
+type Binder = (file: FileRef, options: Options) => MaybePromise<string>;
 export type { Binder as default };
 //# sourceMappingURL=Binder.d.ts.map

package/lib/private/BindingContext.d.ts

@@ -1,3 +1,3 @@
-type BindingContext = "components" | "config" | "locales" | "modules" | "routes" | "stores";
+type BindingContext = "components" | "views" | "config" | "locales" | "modules" | "routes" | "stores" | "hooks";
 export type { BindingContext as default };
 //# sourceMappingURL=BindingContext.d.ts.map

package/lib/private/BuildApp.d.ts

@@ -3,6 +3,8 @@ import type BindingContext from "#BindingContext";
 import Build from "@rcompat/build";
 import type FileRef from "@rcompat/fs/FileRef";
 import type MaybePromise from "@rcompat/type/MaybePromise";
+type Loader = (source: string, file: FileRef) => MaybePromise<string>;
+type Resolver = (basename: string, file: FileRef) => string;
 export default class BuildApp extends App {
     #private;
     frontends: Map<string, string>;
@@ -15,9 +17,13 @@ export default class BuildApp extends App {
     done(fn: () => void): void;
     cleanup(): void;
     export(code: string): void;
-    stage(directory: FileRef, context: BindingContext, importer: (file: FileRef) => MaybePromise<string>): Promise<void>;
+    compile(directory: FileRef, context: BindingContext, options?: {
+        loader?: Loader;
+        resolver?: Resolver;
+    }): Promise<void>;
     depth(): number;
     get i18n_active(): boolean;
     set i18n_active(active: boolean);
 }
+export {};
 //# sourceMappingURL=BuildApp.d.ts.map

package/lib/private/BuildApp.js

@@ -29,11 +29,15 @@ export default class BuildApp extends App {
                 contents: "",
                 resolveDir: this.root.path,
             },
+            conditions: ["style", "browser", "default", "module"],
             resolveExtensions: [".ts", ".js", ...extensions],
             tsconfigRaw: {
                 compilerOptions: {
                     baseUrl: "${configDir}",
                     paths: {
+                        "#view/*": [
+                            "views/*", ...extensions.map(e => `views/*${e}`),
+                        ],
                         "#component/*": [
                             "components/*", ...extensions.map(e => `components/*${e}`),
                         ],
@@ -72,41 +76,41 @@ export default class BuildApp extends App {
     export(code) {
         this.build.export(code);
     }
-    async stage(directory, context, importer) {
-        if (!await directory.exists()) {
+    async compile(directory, context, options = {}) {
+        if (!await directory.exists())
             return;
+        const files = await directory.collect(({ path }) => this.extensions.some(e => path.endsWith(e)) && !path.endsWith(".d.ts"));
+        for (const file of files) {
+            await this.#compileFile(file, context, directory, options);
         }
-        if (!await this.runpath("stage").exists()) {
-            await this.runpath("stage").create();
-        }
-        const base = this.runpath("stage", context);
-        if (!await base.exists()) {
-            await base.create();
+    }
+    async #compileFile(file, context, directory, options) {
+        const binder = this.binder(file);
+        if (binder === undefined) {
+            log.info("no binder found for {0}", file.path);
+            return;
         }
-        const build_directory = this.runpath(directory.name);
-        await build_directory.create();
-        for (const file of await directory.collect(({ path }) => /^.*$/.test(path))) {
-            const debased = file.debase(directory);
-            const target = base.join(debased);
-            if (!await target.directory.exists()) {
-                await target.directory.create({ recursive: true });
-            }
-            const binder = this.binder(file);
-            if (binder === undefined) {
-                log.info("no binder found for {0}", file.path);
-                continue;
-            }
-            // copy to build/stage/${directory}
-            await file.copy(target);
-            await binder(target, {
-                build: { id: this.id, stage: this.runpath("stage") },
-                context,
-            });
-            // actual
-            const runtime_file = build_directory.join(debased.bare(".js"));
-            await runtime_file.directory.create();
-            runtime_file.write(await importer(debased));
+        // call the binder to compile
+        const compiled = await binder(file, {
+            build: { id: this.id, stage: this.runpath("stage") },
+            context,
+        });
+        if (!compiled) {
+            log.info("binder returned empty output for {0}", file.path);
+            return;
         }
+        // apply loader if provided
+        const transformed = options.loader
+            ? await options.loader(compiled, file)
+            : compiled;
+        const basename = this.basename(file, directory);
+        const resolved = options.resolver
+            ? options.resolver(basename, file)
+            : basename;
+        const target = this.runpath(context, `${resolved}.js`);
+        // write to final location
+        await target.directory.create({ recursive: true });
+        await target.write(transformed);
     }
     depth() {
         return this.get(s_layout_depth);

package/lib/private/Loader.d.ts

@@ -10,7 +10,7 @@ export default class Loader {
     constructor(init: Init);
     get static_root(): string;
     page(name?: string): string;
-    asset(file: FileRef): Response;
+    asset(file: FileRef): Promise<Response>;
     serve(pathname: string): Promise<Response | undefined>;
 }
 export {};

package/lib/private/Loader.js

@@ -21,10 +21,11 @@ export default class Loader {
         }
         return this.#pages[name];
     }
-    asset(file) {
+    async asset(file) {
         return new Response(file.stream(), {
             headers: {
                 "Content-Type": resolve(file.name),
+                "Content-Length": String(await file.byteLength()),
             },
             status: Status.OK,
         });
@@ -32,13 +33,13 @@ export default class Loader {
     async serve(pathname) {
         const client_file = this.#root.join(`client/${pathname}`);
         if (await client_file.isFile()) {
-            return this.asset(client_file);
+            return await this.asset(client_file);
         }
         if (pathname.startsWith(this.static_root)) {
             const assetname = pathname.slice(this.static_root.length);
             const static_file = this.#root.join(`static/${assetname}`);
             if (await static_file.isFile()) {
-                return this.asset(static_file);
+                return await this.asset(static_file);
             }
         }
     }

package/lib/private/ServeApp.d.ts

@@ -1,6 +1,6 @@
 import App from "#App";
 import type Asset from "#asset/Asset";
-import type ServerComponent from "#frontend/ServerComponent";
+import type ServerView from "#frontend/ServerView";
 import type ViewOptions from "#frontend/ViewOptions";
 import type ViewResponse from "#frontend/ViewResponse";
 import type I18NConfig from "#i18n/Config";
@@ -41,12 +41,13 @@ export default class ServeApp extends App {
     };
     get stores(): Dict;
     get i18n(): I18NConfig | undefined;
-    component<T = ServerComponent>(name: string): T;
+    loadView<T = ServerView>(name: string): T;
     headers(csp?: {}): {
         "Content-Security-Policy"?: string | undefined;
     };
     render(content: Omit<FullViewOptions, keyof ResponseInit>): string;
     page(page?: string): string;
+    body_length(body: BodyInit | null): number;
     respond(body: BodyInit | null, init?: ResponseInit): Response;
     view(options: FullViewOptions): Response;
     media(content_type: string, response?: ResponseInit): ResponseInit;

package/lib/private/ServeApp.js

@@ -20,6 +20,7 @@ import TEXT_HTML from "@rcompat/http/mime/text/html";
 import serve from "@rcompat/http/serve";
 import Status from "@rcompat/http/Status";
 import entries from "@rcompat/record/entries";
+import utf8ByteLength from "@rcompat/string/utf8-bytelength";
 import pema from "pema";
 import record from "pema/record";
 import string from "pema/string";
@@ -44,17 +45,17 @@ const render_head = (assets, head) => {
     const fonts = assets.filter(asset => asset.src?.endsWith(".woff2"));
     const rest = assets.filter(asset => !asset.src?.endsWith(".woff2")
         && asset.type !== "js");
-    return rest.toSorted(({ type }) => -1 * Number(type === "importmap"))
+    return fonts.map(font => tags.font({ href: font.src, type: "font/woff2" })).join("\n").concat("\n", rest
         .map(({ code, inline, integrity, src, type }) => type === "style"
         ? tags.style({ code, href: src, inline })
-        : tags.script({ code, inline, integrity, src, type })).join("\n").concat("\n", head ?? "").concat("\n", fonts.map(font => tags.font({ href: font.src, type: "font/woff2" })).join("\n"));
+        : tags.script({ code, inline, integrity, src, type })).join("\n")).concat("\n", head ?? "");
 };
 const s_http = Symbol("s_http");
 ;
 export default class ServeApp extends App {
     #init;
     #server;
-    #components;
+    #views;
     #csp = {};
     #assets = [];
     #stores;
@@ -65,7 +66,7 @@ export default class ServeApp extends App {
     constructor(rootfile, init) {
         super(new FileRef(rootfile).directory, init.config, init.mode);
         this.#init = init;
-        this.#components = Object.fromEntries(init.components ?? []);
+        this.#views = Object.fromEntries(init.views ?? []);
         this.#stores = Object.fromEntries((init.stores?.map(([k, s]) => [k, s.default])) ?? []);
         const http = this.#init.config.http;
         this.#i18n_config = init.i18n_config;
@@ -130,13 +131,14 @@ export default class ServeApp extends App {
     get i18n() {
         return this.#i18n_config;
     }
-    component(name) {
-        const base = name.slice(0, name.lastIndexOf((".")));
-        const component = this.#components[base];
-        if (component === undefined) {
-            throw fail("missing component {0}", `${location.components}/${name}`);
+    loadView(name) {
+        const f = new FileRef(name);
+        const base = f.path.slice(0, -f.fullExtension.length);
+        const view = this.#views[base];
+        if (view === undefined) {
+            throw fail("missing view component {0}", `${location.views}/${name}`);
         }
-        return (component.default ?? component);
+        return (view.default ?? view);
     }
     ;
     headers(csp = {}) {
@@ -165,14 +167,20 @@ export default class ServeApp extends App {
     page(page) {
         return this.loader().page(page);
     }
+    body_length(body) {
+        return typeof body === "string" ? utf8ByteLength(body) : 0;
+    }
     respond(body, init) {
         const { headers, status } = pema({
             headers: record(string, string),
             status: uint.values(Status).default(Status.OK),
         }).parse(init);
+        const body_length = this.body_length(body);
         return new Response(body, {
             headers: {
-                "Content-Type": TEXT_HTML, ...this.headers(), ...headers,
+                "Content-Type": TEXT_HTML,
+                ...this.headers(),
+                ...body_length ? { ...headers, "Content-Length": String(body_length) } : headers,
             }, status: status,
         });
     }
@@ -218,9 +226,7 @@ export default class ServeApp extends App {
     ;
     async start() {
         this.#assets = await Promise.all(this.#init.assets.map(async (asset) => {
-            const code = asset.type === "importmap"
-                ? JSON.stringify(asset.code, null, 2)
-                : asset.code;
+            const code = asset.code;
             return {
                 ...asset,
                 code,
@@ -239,7 +245,13 @@ export default class ServeApp extends App {
             }
             catch (error) {
                 log.error(error);
-                return new Response(null, { status: Status.INTERNAL_SERVER_ERROR });
+                return new Response(null, {
+                    headers: {
+                        "Content-Length": String(0),
+                        "Cache-Control": "no-cache",
+                    },
+                    status: Status.INTERNAL_SERVER_ERROR,
+                });
             }
         }, this.get(s_http));
         log.system("started {0}", this.url);

package/lib/private/ServeInit.d.ts

@@ -15,7 +15,7 @@ type BuildFiles = {
 };
 type ServeInit = {
     assets: Asset[];
-    components?: [string, Import][];
+    views?: [string, Import][];
     stores?: [string, Import][];
     config: Config;
     files: BuildFiles;

package/lib/private/backend/TAG.d.ts

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

package/lib/private/backend/TAG.js

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

package/lib/private/builtin/DevModule.js

@@ -15,9 +15,7 @@ export default class DevModule extends Module {
     #reload_url;
     constructor(app) {
         super();
-        const assets = app.assets
-            .filter(asset => asset.type !== "importmap")
-            .map(asset => asset.src);
+        const assets = app.assets.map(asset => asset.src);
         const http = app.config("http");
         this.#paths = ([reload_path]).concat(assets);
         this.#reload_url = `http://${http.host}:${reload_defaults.port}`;

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

@@ -1,6 +1,6 @@
 import type Dict from "@rcompat/type/Dict";
 type ClientData<T extends Dict = Dict> = {
-    component: string;
+    view: string;
     request: Dict;
     spa: boolean;
     ssr: boolean;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=app.d.ts.map

package/lib/private/client/{App.js → app.js}

@@ -1,6 +1,6 @@
 // @ts-expect-error esbuild vfs
 import * as frontends from "#frontends";
-export default class ClientApp {
+class ClientApp {
     start() {
         const hydration = document.getElementById("hydration")?.textContent;
         if (hydration !== undefined) {
@@ -9,4 +9,6 @@ export default class ClientApp {
         }
     }
 }
-//# sourceMappingURL=App.js.map
+const app = new ClientApp();
+app.start();
+//# sourceMappingURL=app.js.map

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

@@ -138,6 +138,10 @@ const go = async (href, updater, event) => {
     // external redirect
 };
 export default (updater) => {
+    if (document.contentType === "application/json") {
+        location.reload();
+        return;
+    }
     globalThis.addEventListener("pageshow", event => {
         if (event.persisted) {
             globalThis.location.reload();

package/lib/private/database/Query.d.ts

@@ -1,14 +1,14 @@
+import type Schema from "#database/Schema";
 import type StoreSchema from "pema/StoreSchema";
-import type DataRecord from "#database/DataRecord";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};
 type Filter<T, P extends keyof T> = X<Pick<T, Extract<P, keyof T>>>;
-export default class Query<T extends StoreSchema, P extends keyof DataRecord<T> = keyof DataRecord<T>> {
+export default class Query<T extends StoreSchema, P extends keyof Schema<T> = keyof Schema<T>> {
     #private;
     constructor(schema: T);
     select<K extends P>(...projection: K[]): Query<T, K>;
-    run(): Promise<Filter<DataRecord<T>, P>>;
+    run(): Promise<Filter<Schema<T>, P>>;
 }
 export {};
 //# sourceMappingURL=Query.d.ts.map

package/lib/private/database/QueryBuilder.d.ts

@@ -1,11 +1,11 @@
-import type DataRecord from "#database/DataRecord";
+import type Schema from "#database/Schema";
 import type InferStoreOut from "pema/InferStoreOut";
 import type StoreSchema from "pema/StoreSchema";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};
 type Filter<T, P extends keyof T> = X<Pick<T, Extract<P, keyof T>>>;
-export default abstract class QueryBuilder<T extends StoreSchema, P extends keyof DataRecord<T> = keyof DataRecord<T>> {
+export default abstract class QueryBuilder<T extends StoreSchema, P extends keyof Schema<T> = keyof Schema<T>> {
     abstract where(criteria: any): QueryBuilder<T>;
     abstract select<K extends P>(...fields: K[]): QueryBuilder<T, K>;
     abstract run(): Promise<Filter<InferStoreOut<T>, P>>;

package/lib/private/database/{DataRecord.d.ts → Schema.d.ts}

@@ -3,6 +3,6 @@ import type StoreSchema from "pema/StoreSchema";
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};
-type DataRecord<T extends StoreSchema> = X<InferStoreOut<T>>;
-export type { DataRecord as default };
-//# sourceMappingURL=DataRecord.d.ts.map
+type Schema<T extends StoreSchema> = X<InferStoreOut<T>>;
+export type { Schema as default };
+//# sourceMappingURL=Schema.d.ts.map

package/lib/private/database/Schema.js

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

package/lib/private/database/Store.d.ts

@@ -1,6 +1,6 @@
 import type Changes from "#database/Changes";
 import type Database from "#database/Database";
-import type DataRecord from "#database/DataRecord";
+import type Schema from "#database/Schema";
 import wrap from "#database/symbol/wrap";
 import type Types from "#database/Types";
 import type Dict from "@rcompat/type/Dict";
@@ -48,7 +48,7 @@ type Config = {
 export default class DatabaseStore<S extends StoreSchema> implements Serializable {
     #private;
     [wrap]: (name: string, database: Database) => this;
-    readonly R: DataRecord<S>;
+    readonly Schema: Schema<S>;
     constructor(schema: S, config?: Config);
     static new<S extends StoreSchema>(schema: S, config?: Config): DatabaseStore<S>;
     get schema(): {
@@ -82,14 +82,14 @@ export default class DatabaseStore<S extends StoreSchema> implements Serializabl
      * @throws If no record with the given id exists.
      * @returns The record for the given id.
      */
-    get(id: Id): Promise<DataRecord<S>>;
+    get(id: Id): Promise<Schema<S>>;
     /**
      * Try to get a record by id.
      *
      * @param id Record id.
      * @returns The record if found, otherwise `undefined`.
      */
-    try(id: Id): Promise<DataRecord<S> | undefined>;
+    try(id: Id): Promise<Schema<S> | undefined>;
     /**
      * Insert a single record.
      *
@@ -100,7 +100,7 @@ export default class DatabaseStore<S extends StoreSchema> implements Serializabl
      * @throws If a record with the same id already exists or validation fails.
      * @returns The inserted record with id.
      */
-    insert(record: Insertable<S>): Promise<DataRecord<S>>;
+    insert(record: Insertable<S>): Promise<Schema<S>>;
     /**
      * Update a single record.
      *
@@ -148,17 +148,17 @@ export default class DatabaseStore<S extends StoreSchema> implements Serializabl
      * @param options Query options.
      * @returns Matching records, possibly projected/limited/sorted.
      */
-    find(criteria: Criteria<S>): Promise<Filter<DataRecord<S>>[]>;
+    find(criteria: Criteria<S>): Promise<Filter<Schema<S>>[]>;
     find(criteria: Criteria<S>, options: {
         limit?: number;
         select?: undefined;
-        sort?: Sort<DataRecord<S>>;
-    }): Promise<Filter<DataRecord<S>>[]>;
-    find<F extends Select<DataRecord<S>>>(criteria: Criteria<S>, options?: {
+        sort?: Sort<Schema<S>>;
+    }): Promise<Filter<Schema<S>>[]>;
+    find<F extends Select<Schema<S>>>(criteria: Criteria<S>, options?: {
         limit?: number;
         select?: F;
-        sort?: Sort<DataRecord<S>>;
-    }): Promise<Filter<DataRecord<S>, F>[]>;
+        sort?: Sort<Schema<S>>;
+    }): Promise<Filter<Schema<S>, F>[]>;
     toJSON(): {
         type: "object";
         properties: Dict<import("pema/StoreType").Serialized>;

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

@@ -1,7 +1,7 @@
 import type App from "#App";
 import type BuildApp from "#BuildApp";
 import type Render from "#frontend/Render";
-import type ServerComponent from "#frontend/ServerComponent";
+import type ServerView from "#frontend/ServerView";
 import type ViewResponse from "#frontend/ViewResponse";
 import Module from "#Module";
 import type Next from "#module/Next";
@@ -10,7 +10,7 @@ import type NextServe from "#module/NextServe";
 import type ServeApp from "#ServeApp";
 import FileRef from "@rcompat/fs/FileRef";
 import type MaybePromise from "@rcompat/type/MaybePromise";
-export default abstract class FrontendModule<S = ServerComponent> extends Module {
+export default abstract class FrontendModule<S = ServerView> extends Module {
     #private;
     abstract client: boolean;
     abstract layouts: boolean;