@primate/core 0.3.4 → 0.4.1

package/lib/private/App.d.ts

@@ -1,5 +1,5 @@
-import type Binder from "#Binder";
 import type Config from "#config/Config";
+import type Flags from "#Flags";
 import type Mode from "#Mode";
 import type Module from "#Module";
 import TargetManager from "#target/Manager";
@@ -7,55 +7,41 @@ import type FileRef from "@rcompat/fs/FileRef";
 import get from "@rcompat/record/get";
 export default class App {
     #private;
-    constructor(root: FileRef, config: Config, mode: Mode);
-    init(target: string): Promise<App>;
+    constructor(root: FileRef, config: Config, flags: typeof Flags.infer);
+    init(): Promise<App>;
     get location(): {
         app_html: "app.html";
-        build: "build";
         client: "client";
-        lib: "lib";
-        components: "components";
         config: "config";
         error_html: "error.html";
-        modules: "modules";
         pages: "pages";
         routes: "routes";
-        server: "server";
         static: "static";
         stores: "stores";
         locales: "locales";
         views: "views";
-        hooks: "hooks";
     };
     get target(): TargetManager;
     get root(): FileRef;
     get path(): {
         readonly app_html: FileRef;
-        readonly build: FileRef;
         readonly client: FileRef;
-        readonly lib: FileRef;
-        readonly components: FileRef;
         readonly config: FileRef;
         readonly error_html: FileRef;
-        readonly modules: FileRef;
         readonly pages: FileRef;
         readonly routes: FileRef;
-        readonly server: FileRef;
         readonly static: FileRef;
         readonly stores: FileRef;
         readonly locales: FileRef;
         readonly views: FileRef;
-        readonly hooks: FileRef;
+    } & {
+        build: 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>>;
     runpath(...directories: string[]): FileRef;
-    bind(extension: string, binder: Binder): void;
 }
 //# sourceMappingURL=App.d.ts.map

package/lib/private/App.js

@@ -2,49 +2,8 @@ import fail from "#fail";
 import location from "#location";
 import reducer from "#reducer";
 import TargetManager from "#target/Manager";
-import assert from "@rcompat/assert";
-import transform from "@rcompat/build/sync/transform";
 import entries from "@rcompat/record/entries";
 import get from "@rcompat/record/get";
-const ts_options = {
-    loader: "ts",
-    tsconfigRaw: {
-        compilerOptions: {
-            experimentalDecorators: true,
-        },
-    },
-};
-const compile = (code) => transform(code, ts_options).code;
-const toContextString = (array) => array
-    .map(member => member.endsWith("s") ? member.slice(0, -1) : member)
-    .join(", ");
-const BIND_CONTEXTS = [
-    "config",
-    "routes",
-    "components",
-    "views",
-    "stores",
-    "locales",
-    "modules",
-];
-function generate_bindings(_app) {
-    return {
-        ".js": (file, { context }) => {
-            const error = `js: only ${toContextString(BIND_CONTEXTS)} are supported`;
-            assert(BIND_CONTEXTS.includes(context), error);
-            return file.text();
-        },
-        ".json": (file) => {
-            // just copy the JSON for now
-            return file.text();
-        },
-        ".ts": async (file, { context }) => {
-            const error = `ts: only ${toContextString(BIND_CONTEXTS)} are supported`;
-            assert(BIND_CONTEXTS.includes(context), error);
-            return compile(await file.text());
-        },
-    };
-}
 const doubled = (set) => set.find((part, i, array) => array.filter((_, j) => i !== j).includes(part)) ?? "";
 export default class App {
     #path;
@@ -53,24 +12,30 @@ export default class App {
     #modules;
     #kv = new Map();
     #mode;
-    #bindings;
     #target;
-    constructor(root, config, mode) {
+    #target_name;
+    constructor(root, config, flags) {
+        if (Object.values(location).includes(flags.dir)) {
+            throw fail("cannot build to {0} - reserved directory", flags.dir);
+        }
         this.#root = root;
         this.#config = config;
         this.#modules = config.modules?.flat(10) ?? [];
-        this.#path = entries(location).valmap(([, path]) => root.join(path)).get();
-        this.#mode = mode;
+        this.#path = entries({
+            ...location,
+            build: flags.dir,
+        }).valmap(([, path]) => root.join(path)).get();
+        this.#mode = flags.mode;
         this.#target = new TargetManager(this);
-        this.#bindings = Object.entries(generate_bindings(this));
+        this.#target_name = flags.target;
     }
-    async init(target) {
+    async init() {
         const names = this.#modules.map(({ name }) => name);
         if (new Set(names).size !== this.#modules.length) {
             throw fail("module {0} loaded twice", doubled(names));
         }
         const app = await reducer(this.#modules, this, "init");
-        this.#target.set(target);
+        this.#target.set(this.#target_name);
         return app;
     }
     get location() {
@@ -91,25 +56,6 @@ export default class App {
     get modules() {
         return [...this.#modules];
     }
-    get extensions() {
-        return this.#bindings.map(([extension]) => extension);
-    }
-    binder(file) {
-        return this.#bindings
-            .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);
     }
@@ -122,13 +68,5 @@ export default class App {
     runpath(...directories) {
         return this.#path.build.join(...directories);
     }
-    // this is technically not necessary for serving, but it has to be used by
-    // the init hook, which is shared between the build and serve app
-    bind(extension, binder) {
-        if (this.extensions.includes(extension)) {
-            throw new Error(`${extension} already bound`);
-        }
-        this.#bindings.push([extension, binder]);
-    }
 }
 //# sourceMappingURL=App.js.map

package/lib/private/Binder.d.ts

@@ -1,12 +1,10 @@
-import type BindingContext from "#BindingContext";
 import type FileRef from "@rcompat/fs/FileRef";
 import type MaybePromise from "@rcompat/type/MaybePromise";
 type Options = {
     build: {
         id: string;
-        stage: FileRef;
     };
-    context: BindingContext;
+    context: string;
 };
 type Binder = (file: FileRef, options: Options) => MaybePromise<string>;
 export type { Binder as default };

package/lib/private/Flags.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("pema").ObjectType<{
+    mode: import("pema/union").UnionType<[import("pema").LiteralType<"production">, import("pema").LiteralType<"development">, import("pema").LiteralType<"testing">]>;
+    target: import("pema").DefaultType<import("pema/string").StringType, "web">;
+    dir: import("pema").DefaultType<import("pema/string").StringType, "build">;
+}>;
+export default _default;
+//# sourceMappingURL=Flags.d.ts.map

package/lib/private/Flags.js

@@ -0,0 +1,7 @@
+import p from "pema";
+export default p({
+    mode: p.union("production", "development", "testing"),
+    target: p.string.default("web"),
+    dir: p.string.default("build"),
+});
+//# sourceMappingURL=Flags.js.map

package/lib/private/Module.d.ts

@@ -1,12 +1,12 @@
 import type App from "#App";
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 import type Next from "#module/Next";
 import type NextBuild from "#module/NextBuild";
 import type NextHandle from "#module/NextHandle";
 import type NextRoute from "#module/NextRoute";
 import type NextServe from "#module/NextServe";
 import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 export default abstract class Module {
     abstract get name(): string;
     init<T extends App>(app: T, next: Next<T>): import("@rcompat/type/MaybePromise").default<T>;

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

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

package/lib/private/backend/TAG.js

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

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

@@ -0,0 +1,34 @@
+import App from "#App";
+import type Binder from "#Binder";
+import type FileRef from "@rcompat/fs/FileRef";
+import type Dict from "@rcompat/type/Dict";
+import type { Plugin } from "esbuild";
+type PluginType = "server" | "client";
+export default class BuildApp extends App {
+    #private;
+    frontends: Map<string, string[]>;
+    conditions: Set<string>;
+    buildInit(): Promise<void>;
+    get extensions(): string[];
+    get id(): string;
+    get paths(): Dict<string[]>;
+    get frontendExtensions(): string[];
+    addRoot(name: string, source: string): void;
+    get roots(): Dict<string>;
+    plugin(type: PluginType, plugin: Plugin): void;
+    plugins(type: PluginType): Plugin[];
+    entrypoint(code: string): void;
+    get entrypoints(): string;
+    binder(file: FileRef): Binder | undefined;
+    bind(extension: string, binder: Binder): void;
+    done(fn: () => void): void;
+    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);
+}
+export {};
+//# sourceMappingURL=App.d.ts.map

package/lib/private/build/App.js

@@ -0,0 +1,103 @@
+import App from "#App";
+import build from "#build/hook";
+import log from "#log";
+import resolve_paths from "#paths";
+import s_layout_depth from "#symbol/layout-depth";
+export default class BuildApp extends App {
+    frontends = new Map();
+    conditions = new Set();
+    #postbuild = [];
+    #roots = {};
+    #id = crypto.randomUUID().slice(0, 8);
+    #i18n_active = false;
+    #session_active = false;
+    #paths;
+    #bindings = [
+        [".js", file => file.text()],
+        [".ts", file => file.text()],
+    ];
+    #plugins = [];
+    #entrypoint_imports = [];
+    async buildInit() {
+        log.system("starting {0} build in {1} mode", this.target.name, this.mode);
+        this.#paths = await resolve_paths(this.root, this.config("paths"));
+        await build(this);
+    }
+    get extensions() {
+        const builtin = [".ts", ".js", ".json"];
+        return [...builtin, ...this.#bindings.map(([extension]) => extension)];
+    }
+    get id() {
+        return this.#id;
+    }
+    get paths() {
+        return this.#paths;
+    }
+    get frontendExtensions() {
+        return [...this.frontends.values()].flat();
+    }
+    addRoot(name, source) {
+        this.#roots[name] = source;
+    }
+    get roots() {
+        return this.#roots;
+    }
+    plugin(type, plugin) {
+        this.#plugins.push({ type, plugin });
+    }
+    plugins(type) {
+        return this.#plugins
+            .filter(plugin => plugin.type === type)
+            .map(plugin => plugin.plugin);
+    }
+    entrypoint(code) {
+        this.#entrypoint_imports.push(code);
+    }
+    get entrypoints() {
+        return this.#entrypoint_imports.join("\n");
+    }
+    binder(file) {
+        return this.#bindings
+            .toSorted(([a], [b]) => a.length > b.length ? -1 : 1)
+            .find(([extension]) => file.path.endsWith(extension))?.[1];
+    }
+    bind(extension, binder) {
+        if (this.extensions.includes(extension)) {
+            throw new Error(`${extension} already bound`);
+        }
+        this.#bindings.push([extension, binder]);
+    }
+    done(fn) {
+        this.#postbuild.push(fn);
+    }
+    cleanup() {
+        this.#postbuild.forEach(fn => fn());
+    }
+    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);
+    }
+    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;
+    }
+    set session_active(active) {
+        this.#session_active = active;
+    }
+}
+//# sourceMappingURL=App.js.map

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

@@ -0,0 +1,3 @@
+import type BuildApp from "#build/App";
+export default function build_client(app: BuildApp): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,95 @@
+import plugin_alias from "#build/client/plugin/alias";
+import plugin_entrypoint from "#build/client/plugin/entrypoint";
+import plugin_frontend from "#build/client/plugin/frontend";
+import plugin_server_stamp from "#build/client/plugin/server-stamp";
+import reload from "#build/client/reload";
+import location from "#location";
+import * as esbuild from "esbuild";
+const write_bootstrap = async (app, mode) => {
+    const build_start_script = `
+    import serve from "primate/serve";
+    import views from "app:views";
+    import routes from "app:routes";
+    import pages from "app:pages";
+    import assets from "app:assets";
+    import s_config from "primate/symbol/config";
+    ${app.session_active ? `
+    import session from "app:config:session";
+    const session_config = session[s_config];
+    ` : `
+    const session_config = undefined;
+    `}
+    import config from "app:config";
+
+    ${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,
+      config,
+      routes,
+      views,
+      pages,
+      mode: "${mode}",
+      session_config,
+      i18n_config,
+      target: "${app.target.name}",
+    });
+
+    export default app;
+  `;
+    await app.path.build.join("serve.js").write(build_start_script);
+};
+export default async function build_client(app) {
+    app.plugin("client", plugin_frontend(app));
+    app.plugin("client", plugin_alias(app));
+    app.plugin("client", plugin_server_stamp(app));
+    app.plugin("client", plugin_entrypoint(app));
+    const imports = await app.path.static.collect(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 conditions = app.conditions.values();
+    const build_options = {
+        plugins: app.plugins("client"),
+        outdir: app.runpath(location.client).path,
+        entryPoints: ["app:client"],
+        conditions: ["style", "browser", "default", "module", ...conditions],
+        resolveExtensions: [".ts", ".js", ...app.frontendExtensions],
+        tsconfig: app.root.join("tsconfig.json").path,
+        bundle: true,
+        format: "esm",
+    };
+    const mode_options = app.mode === "development"
+        ? {
+            banner: {
+                js: `new EventSource("${reload.path}").addEventListener("change",
+      () => globalThis.location.reload());`,
+            },
+            entryNames: "app",
+            minify: false,
+            splitting: false,
+        }
+        : {
+            entryNames: "app-[hash]",
+            minify: true,
+            splitting: true,
+        };
+    const options = { ...build_options, ...mode_options };
+    if (app.mode === "development") {
+        const context = await esbuild.context(options);
+        await context.watch();
+        await context.serve({ host: reload.host, port: reload.port });
+    }
+    else {
+        await esbuild.build(options);
+    }
+    await write_bootstrap(app, app.mode);
+}
+//# sourceMappingURL=index.js.map

package/lib/private/build/client/plugin/alias.d.ts

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

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

@@ -0,0 +1,12 @@
+export default function plugin_client_alias(app) {
+    return {
+        name: "primate/client/alias",
+        setup(build) {
+            build.onResolve({ filter: /app:static/ }, args => {
+                const path = args.path.slice("app:static/".length);
+                return { path: app.root.join(path).path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=alias.js.map

package/lib/private/build/client/plugin/entrypoint.d.ts

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

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

@@ -0,0 +1,15 @@
+export default function plugin_client_entrypoint(app) {
+    return {
+        name: "primate/client/entrypoint",
+        setup(build) {
+            build.onResolve({ filter: /^app:client$/ }, () => {
+                return { path: "client-entrypoint", namespace: "primate-client" };
+            });
+            build.onLoad({ filter: /.*/, namespace: "primate-client" }, async () => {
+                const contents = app.entrypoints;
+                return { contents, loader: "js", resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=entrypoint.js.map

package/lib/private/build/client/plugin/frontend.d.ts

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

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

@@ -0,0 +1,15 @@
+export default function plugin_client_frontend(app) {
+    return {
+        name: "primate/client/frontend",
+        setup(build) {
+            build.onResolve({ filter: /app:frontends/ }, ({ path }) => {
+                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");
+                return { contents, resolveDir: app.root.path };
+            });
+        },
+    };
+}
+//# sourceMappingURL=frontend.js.map

package/lib/private/build/client/plugin/server-stamp.d.ts

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

package/lib/private/build/client/plugin/server-stamp.js

@@ -0,0 +1,14 @@
+export default function plugin_client_server_stamp(app) {
+    return {
+        name: "primate/client/server-stamp",
+        setup(build) {
+            build.onResolve({ filter: /^server:stamp$/ }, () => {
+                return {
+                    path: app.runpath("client", "server-stamp.js").path,
+                    sideEffects: true,
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=server-stamp.js.map

package/lib/private/build/client/reload.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    path: string;
+    host: string;
+    port: number;
+};
+export default _default;
+//# sourceMappingURL=reload.d.ts.map

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

@@ -0,0 +1,6 @@
+export default {
+    path: "/esbuild",
+    host: "localhost",
+    port: 6262,
+};
+//# sourceMappingURL=reload.js.map

package/lib/private/{hook/build.d.ts → build/hook.d.ts}

@@ -1,4 +1,4 @@
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 declare const _default: (app: BuildApp) => Promise<BuildApp>;
 export default _default;
-//# sourceMappingURL=build.d.ts.map
+//# sourceMappingURL=hook.d.ts.map

package/lib/private/build/hook.js

@@ -0,0 +1,49 @@
+import build_client from "#build/client/index";
+import build_server from "#build/server/index";
+import fail from "#fail";
+import location from "#location";
+import log from "#log";
+import reducer from "#reducer";
+import $router from "#request/router";
+import s_layout_depth from "#symbol/layout-depth";
+import pkg from "@rcompat/fs/project/package";
+const core_pkg = await pkg(import.meta.url);
+const { version } = await core_pkg.json();
+async function pre(app) {
+    const dot_primate = app.path.build.join(".primate");
+    if (await app.path.build.exists() && !await dot_primate.exists()) {
+        const message = "{0} exists but does not contain a previous build";
+        throw fail(message, app.path.build.path);
+    }
+    // remove build directory if exists
+    await app.path.build.remove();
+    await app.path.build.create();
+    // touch a .primate file to indicate this is a Primate build directory
+    await dot_primate.write(version);
+    await app.runpath(location.client).create();
+    const stamp = app.runpath("client", "server-stamp.js");
+    await stamp.write("export default 0;\n");
+    // this has to occur before post, so that layout depth is available for
+    // compiling root views
+    // bindings should have been registered during `init`
+    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();
+    return app;
+}
+;
+async function post(app) {
+    await build_client(app);
+    await build_server(app);
+    log.system("build written to {0}", app.path.build);
+    app.cleanup();
+    return app;
+}
+;
+export default async (app) => post(await reducer(app.modules, await pre(app), "build"));
+//# sourceMappingURL=hook.js.map

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

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