@primate/core 0.3.2 → 0.3.4

package/lib/private/BuildApp.d.ts

@@ -7,9 +7,11 @@ 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>;
+    frontends: Map<string, string[]>;
+    conditions: Set<string>;
     buildInit(): Promise<void>;
     get id(): string;
+    get frontendExtensions(): string[];
     get build(): Build;
     get server_build(): string[];
     addRoot(root: FileRef): void;

package/lib/private/BuildApp.js

@@ -8,6 +8,7 @@ import cache from "@rcompat/kv/cache";
 const s = Symbol("primate.Build");
 export default class BuildApp extends App {
     frontends = new Map();
+    conditions = new Set();
     #postbuild = [];
     #roots = [];
     #server_build = ["route"];
@@ -20,8 +21,12 @@ export default class BuildApp extends App {
     get id() {
         return this.#id;
     }
+    get frontendExtensions() {
+        return [...this.frontends.values()].flat();
+    }
     get build() {
-        const extensions = [...this.frontends.values()];
+        const extensions = this.frontendExtensions;
+        const conditions = this.conditions.values();
         return cache.get(s, () => new Build({
             ...(this.config("build")),
             outdir: this.runpath(location.client).path,
@@ -29,7 +34,7 @@ export default class BuildApp extends App {
                 contents: "",
                 resolveDir: this.root.path,
             },
-            conditions: ["style", "browser", "default", "module"],
+            conditions: ["style", "browser", "default", "module", ...conditions],
             resolveExtensions: [".ts", ".js", ...extensions],
             tsconfigRaw: {
                 compilerOptions: {

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

@@ -1,6 +1,7 @@
 import schema from "#config/schema";
 declare const _default: (config?: typeof schema.input) => {
     build: Record<string, unknown> | undefined;
+    bundle: string[];
     http: {
         csp: Record<string, string[]> | undefined;
         headers: Record<string, string> | undefined;

package/lib/private/config/schema.d.ts

@@ -2,6 +2,7 @@ import Module from "#Module";
 import FileRef from "@rcompat/fs/FileRef";
 declare const _default: import("pema").ObjectType<{
     build: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/unknown").UnknownType>>;
+    bundle: import("pema").DefaultType<import("pema/array").ArrayType<import("pema/string").StringType>, string[]>;
     http: import("pema").ObjectType<{
         csp: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/array").ArrayType<import("pema/string").StringType>>>;
         headers: import("pema").OptionalType<import("pema/record").RecordType<import("pema/string").StringType, import("pema/string").StringType>>;

package/lib/private/config/schema.js

@@ -1,6 +1,6 @@
 import Module from "#Module";
 import FileRef from "@rcompat/fs/FileRef";
-import pema from "pema";
+import p from "pema";
 import array from "pema/array";
 import boolean from "pema/boolean";
 import constructor from "pema/constructor";
@@ -9,8 +9,9 @@ import string from "pema/string";
 import uint from "pema/uint";
 import union from "pema/union";
 import unknown from "pema/unknown";
-export default pema({
+export default p({
     build: record(string, unknown).optional(),
+    bundle: p.array(p.string).default([]),
     http: {
         csp: record(string, array(string)).optional(),
         headers: record(string, string).optional(),

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

@@ -24,11 +24,12 @@ export default abstract class FrontendModule<S = ServerView> extends Module {
             css?: null | string;
             js: string;
         }>;
-        server?: (text: string) => MaybePromise<string>;
+        server?: (text: string, file?: FileRef) => MaybePromise<string>;
     };
     css?: {
         filter: RegExp;
     };
+    conditions: string[];
     static schema: import("pema").ObjectType<{
         fileExtensions: import("pema").OptionalType<import("pema/array").ArrayType<import("pema/string").StringType>>;
         spa: import("pema").DefaultType<import("pema/boolean").BooleanType, true>;

package/lib/private/frontend/Module.js

@@ -23,6 +23,7 @@ export default class FrontendModule extends Module {
     root;
     compile = {};
     css;
+    conditions = [];
     static schema = pema({
         fileExtensions: array(string).optional(),
         spa: boolean.default(true),
@@ -64,10 +65,10 @@ export default class FrontendModule extends Module {
         const app_asset = app.assets.find(asset => asset.src?.includes("app") && asset.src.endsWith(".js"));
         if (!app_asset)
             throw fail("Could not find app.js in assets");
-        const app_script = `<script type="module" src="${app_asset.src}" integrity="${app_asset.integrity}"></script>`;
+        const app_script = `<script type="module" src="${app_asset.src}"></script>`;
         const json_props = JSON.stringify({ frontend: this.name, ...client });
         const hydrated = await inline(json_props, APPLICATION_JSON, "hydration");
-        const script_src = [hydrated.integrity, `'${app_asset.integrity}'`];
+        const script_src = [hydrated.integrity];
         return {
             body,
             head: head.concat(app_script, hydrated.head),
@@ -138,7 +139,7 @@ export default class FrontendModule extends Module {
         }
         catch (error) {
             const path = `${location.views}/${view}`;
-            throw fail("error in view{0}\n{1}", path, error);
+            throw fail("error in view {0}\n{1}", path, error);
         }
     };
     serve(app, next) {
@@ -147,9 +148,10 @@ export default class FrontendModule extends Module {
     }
     publish(app) {
         if (this.compile.client) {
-            const { compile, css, fileExtensions, name, root } = this;
+            const { compile, css, fileExtensions, name, root, conditions } = this;
             if (this.client) {
-                fileExtensions.forEach(fe => app.frontends.set(name, fe));
+                app.frontends.set(name, fileExtensions);
+                conditions.forEach(condition => app.conditions.add(condition));
             }
             app.build.plugin({
                 name,
@@ -217,13 +219,15 @@ export default class FrontendModule extends Module {
             app.bind(e, async (file, { context }) => {
                 assert(contexts.includes(context), `${this.name}: only components supported`);
                 if (this.compile.server) {
-                    const code = await this.compile.server(await file.text());
+                    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) => this.compile.server(s),
+                        compile: async (s, f) => this.compile.server(s, f),
+                        bundle: app.config("bundle"),
+                        conditions: [...app.conditions],
                     });
                     return bundled;
                 }

package/lib/private/frontend/bundle-server.d.ts

@@ -5,7 +5,9 @@ type Init = {
     root: FileRef;
     extensions: string[];
     compile: (src: string, file?: FileRef) => Promise<string>;
+    bundle: string[];
+    conditions: string[];
 };
-export default function bundleServer(init: Init): Promise<string>;
+export default function bundle_server(init: Init): Promise<string>;
 export {};
 //# sourceMappingURL=bundle-server.d.ts.map

package/lib/private/frontend/bundle-server.js

@@ -1,7 +1,7 @@
 import FileRef from "@rcompat/fs/FileRef";
 import * as esbuild from "esbuild";
-export default async function bundleServer(init) {
-    const { code, source, root, extensions, compile } = init;
+export default async function bundle_server(init) {
+    const { code, source, root, extensions, compile, bundle } = init;
     const filter = new RegExp(`(${extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
     const plugin = {
         name: "primate/bundle/server",
@@ -18,7 +18,7 @@ export default async function bundleServer(init) {
                 const p = args.path;
                 const relative = p.startsWith("./") || p.startsWith("../");
                 const views = p.startsWith("#view/");
-                if (!relative && !views)
+                if (!relative && !views && !bundle.includes(p))
                     return { path: p, external: true };
                 return null;
             });
@@ -32,7 +32,7 @@ export default async function bundleServer(init) {
         platform: "node",
         format: "esm",
         target: "esnext",
-        conditions: ["node", "default", "apekit"],
+        conditions: ["node", "default", ...init.conditions],
         resolveExtensions: [".ts", ".js", ...extensions],
         plugins: [plugin],
         stdin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "The universal web framework",
   "homepage": "https://primate.run",
   "bugs": "https://github.com/primate-run/primate/issues",