@primate/core 0.3.4 → 0.4.1

package/lib/private/frontend/Module.js

@@ -1,21 +1,17 @@
 import fail from "#fail";
-import bundle from "#frontend/bundle-server";
 import inline from "#inline";
 import location from "#location";
 import Module from "#Module";
-import assert from "@rcompat/assert";
 import map from "@rcompat/async/map";
 import hash from "@rcompat/crypto/hash";
 import FileRef from "@rcompat/fs/FileRef";
 import APPLICATION_JSON from "@rcompat/http/mime/application/json";
 import Status from "@rcompat/http/Status";
-import pema from "pema";
-import array from "pema/array";
-import boolean from "pema/boolean";
-import string from "pema/string";
-const contexts = ["views", "components"];
-async function normalize(path) {
-    return `p_${await hash(path)}`;
+import p from "pema";
+async function normalize(path, frontend) {
+    const file = new FileRef(path);
+    const basename = path.slice(0, -file.fullExtension.length);
+    return `p_${await hash(`${basename}.${frontend}`)}`;
 }
 export default class FrontendModule extends Module {
     #options;
@@ -24,10 +20,11 @@ export default class FrontendModule extends Module {
     compile = {};
     css;
     conditions = [];
-    static schema = pema({
-        fileExtensions: array(string).optional(),
-        spa: boolean.default(true),
-        ssr: boolean.default(true),
+    #mode = "development";
+    static schema = p({
+        fileExtensions: p.array(p.string).optional(),
+        spa: p.boolean.default(true),
+        ssr: p.boolean.default(true),
     });
     static options = FrontendModule.schema.infer;
     static input = FrontendModule.schema.input;
@@ -45,12 +42,14 @@ export default class FrontendModule extends Module {
         return `root_${this.name}`;
     }
     get ssr() {
-        return this.#options.ssr;
+        return this.#options.ssr && (this.#mode !== "development" || !this.client);
     }
     get spa() {
         return this.#options.spa;
     }
     #load(name, props, app) {
+        if (!this.ssr)
+            return { view: null, name, props };
         const view = app.loadView(name);
         return { view, name, props };
     }
@@ -76,7 +75,7 @@ export default class FrontendModule extends Module {
         };
     }
     normalize(name) {
-        return normalize(name);
+        return normalize(name, this.name);
     }
     respond = (view, props = {}, options = {}) => async (app, { as_layout, layouts = [] } = {}, request) => {
         if (as_layout) {
@@ -96,15 +95,16 @@ export default class FrontendModule extends Module {
         };
         const $props = this.layouts
             ? {
-                views: await map(views, ({ name }) => normalize(name)),
+                views: await map(views, ({ name }) => this.normalize(name)),
                 props: views.map(c => c.props),
                 request: $request,
             }
             : { props, request: $request };
         const client = {
-            view: this.layouts ? "root" : await normalize(view),
+            view: this.layouts ? "root" : await this.normalize(view),
             spa: this.spa,
             ssr: this.ssr,
+            mode: app.mode,
             ...$props,
         };
         if (this.spa && request.headers.get("Accept") === APPLICATION_JSON) {
@@ -119,10 +119,14 @@ export default class FrontendModule extends Module {
                 status: options.status ?? Status.OK,
             });
         }
+        if (!this.ssr) {
+            const { head } = await this.#render({ view: null, props: {} }, client, app);
+            return app.view({ body: "<div id=\"app\"></div>", head, ...options });
+        }
         try {
             const server = this.layouts
                 ? {
-                    view: app.loadView(`${this.rootname}.js`),
+                    view: app.loadView(this.rootname),
                     props: {
                         views: views.map(c => c.view),
                         props: views.map(c => c.props),
@@ -149,14 +153,16 @@ export default class FrontendModule extends Module {
     publish(app) {
         if (this.compile.client) {
             const { compile, css, fileExtensions, name, root, conditions } = this;
+            const _normalize = this.normalize.bind(this);
             if (this.client) {
-                app.frontends.set(name, fileExtensions);
+                app.frontends.set(name, [...fileExtensions]);
                 conditions.forEach(condition => app.conditions.add(condition));
             }
-            app.build.plugin({
+            app.plugin("client", {
                 name,
                 setup(build) {
                     const resolveDir = app.root.path;
+                    const css_cache = new Map();
                     if (root !== undefined) {
                         const filter = new RegExp(`^${name}:root`);
                         build.onResolve({ filter }, ({ path }) => {
@@ -168,14 +174,12 @@ export default class FrontendModule extends Module {
                         });
                     }
                     if (css !== undefined) {
-                        build.onResolve({ filter: css.filter }, ({ path }) => {
-                            return { namespace: `${name}css`, path };
+                        build.onResolve({ filter: new RegExp(`^${name}:css:`) }, args => {
+                            return { path: args.path, namespace: `${name}-css` };
                         });
-                        build.onLoad({ filter: css.filter }, ({ path }) => {
-                            const contents = app.build.load(FileRef.webpath(path));
-                            return contents
-                                ? { contents, loader: "css", resolveDir: resolveDir }
-                                : null;
+                        build.onLoad({ filter: /.*/, namespace: `${name}-css` }, args => {
+                            const contents = css_cache.get(args.path);
+                            return contents ? { contents, loader: "css" } : null;
                         });
                     }
                     const views_filter = new RegExp(`^${name}:views`);
@@ -189,7 +193,7 @@ export default class FrontendModule extends Module {
                         let contents = "";
                         for (const view of views) {
                             const { path } = view.debase(views_base, "/");
-                            contents += `export { default as ${await normalize(path)} }
+                            contents += `export { default as ${await _normalize(path)} }
                 from "#view/${path}";\n`;
                         }
                         return { contents, resolveDir: app.root.path };
@@ -197,16 +201,16 @@ export default class FrontendModule extends Module {
                     const filter = new RegExp(`(${fileExtensions.map(e => e.replace(".", "\\.")).join("|")})$`);
                     build.onLoad({ filter }, async (args) => {
                         const file = new FileRef(args.path);
-                        // Compile file to JavaScript and potentially CSS
+                        // compile file to JavaScript and potentially CSS
                         const compiled = await compile.client(await file.text(), file, false);
                         let contents = compiled.js;
                         if (css
                             && compiled.css !== null
                             && compiled.css !== undefined
                             && compiled.css !== "") {
-                            const path = FileRef.webpath(`${args.path}css`);
-                            app.build.save(path, compiled.css);
-                            contents += `\nimport "${path}";`;
+                            const css_path = `${name}:css:${args.path}`;
+                            css_cache.set(css_path, compiled.css);
+                            contents += `\nimport "${css_path}";`;
                         }
                         return { contents };
                     });
@@ -215,35 +219,28 @@ export default class FrontendModule extends Module {
         }
     }
     init(app, next) {
+        this.#mode = app.mode;
+        return next(app);
+    }
+    prebuild(app) {
         this.fileExtensions.forEach(e => {
             app.bind(e, async (file, { context }) => {
-                assert(contexts.includes(context), `${this.name}: only components supported`);
+                if (context === "views" && !this.ssr)
+                    return "";
+                // production: just compile to JS, don't bundle yet
                 if (this.compile.server) {
-                    const code = await this.compile.server(await file.text(), file);
-                    const bundled = await bundle({
-                        code,
-                        source: file,
-                        root: app.root,
-                        extensions: this.fileExtensions,
-                        compile: async (s, f) => this.compile.server(s, f),
-                        bundle: app.config("bundle"),
-                        conditions: [...app.conditions],
-                    });
-                    return bundled;
+                    return await this.compile.server(await file.text(), file);
                 }
                 return await file.text();
             });
         });
-        return next(app);
     }
     async build(app, next) {
+        this.prebuild(app);
         // compile root server
         if (this.root !== undefined && this.compile.server !== undefined) {
-            const filename = `${this.rootname}.js`;
-            const root = await this.compile.server(this.root.create(app.depth(), app.i18n_active));
-            const path = app.runpath(location.server, filename);
-            await path.write(root);
-            app.addRoot(path);
+            const source = await this.compile.server(this.root.create(app.depth(), app.i18n_active));
+            app.addRoot(this.rootname, source);
         }
         this.publish(app);
         return next(app);

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

@@ -1,4 +1,4 @@
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 import type { Plugin } from "esbuild";
 type Publish = (app: BuildApp, extension: string) => Plugin;
 export { Publish as default };

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

@@ -4,7 +4,7 @@ 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 class I18NModule extends Module {
     #private;
     name: string;

package/lib/private/i18n/Module.js

@@ -70,7 +70,7 @@ export default class I18NModule extends Module {
                 headers: {
                     "Content-Length": String(0),
                 },
-                status: Status.NO_CONTENT
+                status: Status.NO_CONTENT,
             });
         // only accept configured locales
         if (!this.#configured(requested))
@@ -78,7 +78,7 @@ export default class I18NModule extends Module {
                 headers: {
                     "Content-Length": String(0),
                 },
-                status: Status.NO_CONTENT
+                status: Status.NO_CONTENT,
             });
         const header = cookie(COOKIE_NAME, requested, {
             secure: this.#secure,

package/lib/private/location.d.ts

@@ -1,20 +1,14 @@
 declare const _default: {
     readonly app_html: "app.html";
-    readonly build: "build";
     readonly client: "client";
-    readonly lib: "lib";
-    readonly components: "components";
     readonly config: "config";
     readonly error_html: "error.html";
-    readonly modules: "modules";
     readonly pages: "pages";
     readonly routes: "routes";
-    readonly server: "server";
     readonly static: "static";
     readonly stores: "stores";
     readonly locales: "locales";
     readonly views: "views";
-    readonly hooks: "hooks";
 };
 export default _default;
 //# sourceMappingURL=location.d.ts.map

package/lib/private/location.js

@@ -1,26 +1,16 @@
 export default {
     // default rendering template
     app_html: "app.html",
-    // build environment
-    build: "build",
     // client build
     client: "client",
-    // component library
-    lib: "lib",
-    // renderable components
-    components: "components",
     // config
     config: "config",
     // error rendering template
     error_html: "error.html",
-    // custom modules
-    modules: "modules",
     // HTML pages
     pages: "pages",
     // hierarchical routes
     routes: "routes",
-    // server build
-    server: "server",
     // static assets
     static: "static",
     // stores
@@ -29,7 +19,5 @@ export default {
     locales: "locales",
     // views
     views: "views",
-    // hooks
-    hooks: "hooks",
 };
 //# sourceMappingURL=location.js.map

package/lib/private/module/BuildHook.d.ts

@@ -1,4 +1,4 @@
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 import type Hook from "#module/Hook";
 type BuildHook = Hook<BuildApp>;
 export type { BuildHook as default };

package/lib/private/module/NextBuild.d.ts

@@ -1,4 +1,4 @@
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 import type Next from "#module/Next";
 type NextBuild = Next<BuildApp>;
 export type { NextBuild as default };

package/lib/private/module/NextServe.d.ts

@@ -1,5 +1,5 @@
 import type Next from "#module/Next";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 type NextServe = Next<ServeApp>;
 export type { NextServe as default };
 //# sourceMappingURL=NextServe.d.ts.map

package/lib/private/paths.d.ts

@@ -0,0 +1,5 @@
+import type FileRef from "@rcompat/fs/FileRef";
+import type Dict from "@rcompat/type/Dict";
+declare function resolve(root: FileRef, config_paths?: Dict<string[]>): Promise<any>;
+export default resolve;
+//# sourceMappingURL=paths.d.ts.map

package/lib/private/paths.js

@@ -0,0 +1,30 @@
+import fail from "#fail";
+import log from "#log";
+async function resolve(root, config_paths) {
+    const tsconfig_path = root.join("tsconfig.json");
+    if (await tsconfig_path.exists()) {
+        try {
+            let text = await tsconfig_path.text();
+            // strip JSONC features
+            text = text
+                .replace(/\/\*[\s\S]*?\*\//g, "")
+                .replace(/\/\/.*/g, "")
+                .replace(/,(\s*[}\]])/g, "$1");
+            const config = JSON.parse(text);
+            const ts_paths = config.compilerOptions?.paths ?? {};
+            if (config_paths !== undefined && Object.keys(ts_paths).length > 0) {
+                return fail("tsconfig.json exists with paths, remove config paths");
+            }
+            // merge with defaults (user paths override)
+            return { ...ts_paths };
+        }
+        catch {
+            log.warn("Failed to parse tsconfig.json, falling back to config");
+        }
+    }
+    if (config_paths !== undefined)
+        return config_paths;
+    return {};
+}
+export default resolve;
+//# sourceMappingURL=paths.js.map

package/lib/private/reducer.d.ts

@@ -1,9 +1,9 @@
 import type App from "#App";
-import type BuildApp from "#BuildApp";
+import type BuildApp from "#build/App";
 import type Module from "#Module";
 import type RequestFacade from "#request/RequestFacade";
 import type ResponseLike from "#response/ResponseLike";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 type HookInput = {
     build: BuildApp;
     handle: RequestFacade;

package/lib/private/request/route.d.ts

@@ -1,4 +1,4 @@
 import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 export default function (app: ServeApp, partial_request: RequestFacade): Promise<Response>;
 //# sourceMappingURL=route.d.ts.map

package/lib/private/request/route.js

@@ -1,16 +1,14 @@
 import log from "#log";
-import errorResponse from "#response/error";
-import jsonResponse from "#response/json";
+import response_error from "#response/error";
+import response_json from "#response/json";
 import respond from "#response/respond";
 import guard from "#route/guard";
 import Status from "@rcompat/http/Status";
 import ParseError from "pema/ParseError";
 async function reducer(hooks, request) {
     const [first, ...rest] = hooks;
-    if (rest.length === 0) {
+    if (rest.length === 0)
         return await first(request, _ => new Response());
-    }
-    ;
     return await first(request, _ => reducer(rest, _));
 }
 ;
@@ -30,7 +28,7 @@ export default async function (app, partial_request) {
     try {
         const route = await app.route(partial_request);
         if (route === undefined) {
-            return errorResponse()(app, {}, partial_request);
+            return response_error()(app, {}, partial_request);
         }
         const { errors, guards, handler, layouts } = route;
         errorRoute = errors[0];
@@ -45,7 +43,7 @@ export default async function (app, partial_request) {
     catch (error) {
         const request = partial_request;
         if (error instanceof ParseError) {
-            return jsonResponse(error.toJSON(), { status: Status.BAD_REQUEST })(app);
+            return response_json(error.toJSON(), { status: Status.BAD_REQUEST })(app);
         }
         log.error(error);
         // the +error.js page itself could fail
@@ -53,7 +51,7 @@ export default async function (app, partial_request) {
             return respond(await errorRoute(request))(app, {}, request);
         }
         catch {
-            return errorResponse()(app, {}, request);
+            return response_error()(app, {}, request);
         }
     }
 }

package/lib/private/response/ResponseFunction.d.ts

@@ -1,6 +1,6 @@
 import type View from "#frontend/View";
 import type RequestFacade from "#request/RequestFacade";
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 import type Dict from "@rcompat/type/Dict";
 import type MaybePromise from "@rcompat/type/MaybePromise";
 type ResponseFunction = (app: ServeApp, transfer: Dict, request: RequestFacade) => MaybePromise<View | null | Response | undefined>;

package/lib/private/response/binary.d.ts

@@ -1,4 +1,4 @@
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 import type StreamSource from "@rcompat/fs/StreamSource";
 /**
  * Stream a binary response.

package/lib/private/response/json.d.ts

@@ -4,6 +4,6 @@
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../ServeApp.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+declare const _default: (body: unknown, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
 export default _default;
 //# sourceMappingURL=json.d.ts.map

package/lib/private/response/sse.d.ts

@@ -10,6 +10,6 @@ type Body = {
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: Body, init?: ResponseInit) => (app: import("../ServeApp.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+declare const _default: (body: Body, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
 export default _default;
 //# sourceMappingURL=sse.d.ts.map

package/lib/private/response/text.d.ts

@@ -4,6 +4,6 @@
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: string, init?: ResponseInit) => (app: import("../ServeApp.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
+declare const _default: (body: string, init?: ResponseInit) => (app: import("../serve/App.js").default) => import("@rcompat/type/MaybePromise").default<Response>;
 export default _default;
 //# sourceMappingURL=text.d.ts.map

package/lib/private/response/view.d.ts

@@ -1,11 +1,8 @@
-import type ViewResponse from "#frontend/ViewResponse";
-/**
- * Render a view component using a frontend for the given filename extension
- * @param view path to view
- * @param props props for view
- * @param options rendering options
- * @return Response rendering function
- */
-declare const view: ViewResponse;
+import type ViewOptions from "#frontend/ViewOptions";
+import type Dict from "@rcompat/type/Dict";
+import type ResponseFunction from "./ResponseFunction.js";
+declare function view<Props>(component: (props: Props) => any, props: Props, options?: ViewOptions): ResponseFunction;
+declare function view(component: () => any, props?: Dict, options?: ViewOptions): ResponseFunction;
+declare function view(name: string, props?: Dict, options?: ViewOptions): ResponseFunction;
 export default view;
 //# sourceMappingURL=view.d.ts.map

package/lib/private/response/view.js

@@ -9,7 +9,6 @@ const backmap = {
     htmx: "htmx",
     marko: "marko",
     md: "markdown",
-    poly: "poly",
     solid: "solid",
     svelte: "svelte",
     voby: "voby",
@@ -24,7 +23,7 @@ function no_frontend(view) {
     const error = "No frontend for {0}";
     const fix = hasPkg ? ", did you configure {1}?" : "";
     const pkgname = hasPkg ? `@primate/${backmap[extension]}` : "";
-    throw fail(`${error}${fix}`, view, pkgname);
+    return fail(`${error}${fix}`, view, pkgname);
 }
 /**
  * Render a view component using a frontend for the given filename extension
@@ -33,11 +32,16 @@ function no_frontend(view) {
  * @param options rendering options
  * @return Response rendering function
  */
-const view = (function viewResponse(name, props, options) {
-    return (app, transfer, request) => extensions
-        .map(extension => app.frontends[new FileRef(name)[extension]])
-        .find(extension => extension !== undefined)?.(name, props, options)(app, transfer, request)
-        ?? no_frontend(name);
-});
+function view(name, props, options) {
+    const _name = name;
+    return async (app, transfer, request) => {
+        const found_view = extensions
+            .map(extension => app.frontends[new FileRef(_name)[extension]])
+            .find(extension => extension !== undefined)?.(_name, props, options)(app, transfer, request);
+        if (found_view !== undefined)
+            return found_view;
+        throw no_frontend(_name);
+    };
+}
 export default view;
 //# sourceMappingURL=view.js.map

package/lib/private/response.d.ts

@@ -1,4 +1,4 @@
-import type ServeApp from "#ServeApp";
+import type ServeApp from "#serve/App";
 import type MaybePromise from "@rcompat/type/MaybePromise";
 declare const _default: <T>(mime: string, mapper: (input: T) => BodyInit) => (body: T, init?: ResponseInit) => (app: ServeApp) => MaybePromise<Response>;
 export default _default;

package/lib/private/route/router.d.ts

@@ -1,6 +1,7 @@
 import type Verb from "#request/Verb";
 import type RouteHandler from "#route/Handler";
 import type RouteOptions from "#route/Options";
+export declare const routes: string[];
 declare class Router {
     #private;
     push(route: string): void;
@@ -8,11 +9,11 @@ declare class Router {
     get active(): string | undefined;
     add(verb: Verb, handler: RouteHandler, options?: RouteOptions): void;
     get(path: string): {
-        options?: {
+        head?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;
-        head?: {
+        options?: {
             handler: RouteHandler;
             options: RouteOptions;
         } | undefined;

package/lib/private/route/router.js

@@ -1,17 +1,18 @@
 import assert from "@rcompat/assert";
 import is from "@rcompat/assert/is";
 import maybe from "@rcompat/assert/maybe";
+const stack = [];
+export const routes = stack;
 class Router {
     #routes = {};
-    #stack = [];
     push(route) {
-        this.#stack.push(route);
+        stack.push(route);
     }
     pop() {
-        this.#stack.pop();
+        stack.pop();
     }
     get active() {
-        return this.#stack.at(-1);
+        return stack.at(-1);
     }
     add(verb, handler, options = {}) {
         assert(this.active !== undefined);