@primate/core 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Primate core",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -21,13 +21,13 @@
     "@rcompat/build": "^0.4.0",
     "@rcompat/cli": "^0.5.1",
     "@rcompat/crypto": "^0.5.0",
-    "@rcompat/fs": "^0.5.0",
+    "@rcompat/fs": "^0.5.1",
     "@rcompat/function": "^0.4.0",
     "@rcompat/http": "^0.5.3",
     "@rcompat/invariant": "^0.5.0",
     "@rcompat/object": "^0.5.0",
     "@rcompat/package": "^0.7.0",
-    "@rcompat/platform": "^0.3.0",
+    "@rcompat/runtime": "^0.1.0",
     "@rcompat/stdio": "^0.5.0",
     "@rcompat/sync": "^0.3.0"
   },

package/src/build/hook/build.js

@@ -38,7 +38,7 @@ const pre = async (app, mode, target) => {
   await app.path.build.remove();
   await app.path.build.create();
 
-  await Promise.all(["server", "client", "pages", "components"]
+  await Promise.all(["server", "client", "components"]
     .map(directory => app.runpath(directory).create()));
 
   const router = await $router(app.path.routes);
@@ -50,14 +50,15 @@ const pre = async (app, mode, target) => {
 
 const js_re = /^.*.js$/u;
 const write_directories = async (build_directory, app) => {
+  const location = app.get("location");
   for (const name of app.server_build) {
-    const d = app.runpath(name);
+    const d = app.runpath(location.server, name);
     const e = await Promise.all((await collect(d, js_re, { recursive: true }))
       .map(async path => `${path}`.replace(d, _ => "")));
     const files_js = `
     const ${name} = [];
     ${e.map((path, i) =>
-    `import * as ${name}${i} from "${webpath(`../${name}${path}`)}";
+    `import * as ${name}${i} from "${webpath(`../server/${name}${path}`)}";
     ${name}.push(["${webpath(path.slice(1, -".js".length))}", ${name}${i}]);`,
   ).join("\n")}
     export default ${name};`;
@@ -88,8 +89,7 @@ export default components;`;
 
 const write_bootstrap = async (build_number, app, mode) => {
   const build_start_script = `
-import file from "@rcompat/fs/file";
-import serve from "@primate/core/serve";
+import serve from "primate/serve";
 import config from "./${config_filename}";
 const files = {};
 ${app.server_build.map(name =>
@@ -97,9 +97,9 @@ ${app.server_build.map(name =>
      files.${name} = ${name};`,
   ).join("\n")}
 import components from "./${build_number}/components.js";
-import * as target from "./target.js";
+import target from "./target.js";
 
-await serve(file(import.meta.url).directory, {
+await serve(import.meta.url, {
   ...target,
   config,
   files,
@@ -114,10 +114,10 @@ const post = async (app, mode, target) => {
   const defaults = join(import.meta.dirname, "../defaults");
 
   // stage routes
-  await app.stage(app.path.routes, location.routes);
+  await app.stage(app.path.routes, join(location.server, location.routes));
 
   // stage types
-  await app.stage(app.path.types, location.types);
+  await app.stage(app.path.types, join(location.server, location.types));
 
   // stage components, transforming defines
   await app.stage(app.path.components, location.components, true);
@@ -128,9 +128,9 @@ const post = async (app, mode, target) => {
       ?.(directory, path.debase(`${directory}/`));
   }
   // copy framework pages
-  await app.stage(defaults, location.pages);
+  await app.stage(defaults, join(location.server, location.pages));
   // overwrite transformed pages to build
-  await app.stage(app.path.pages, location.pages);
+  await app.stage(app.path.pages, join(location.server, location.pages));
 
   // copy static files to build/server/static
   await app.stage(app.path.static, join(location.server, location.static));

package/src/build/index.js

@@ -3,12 +3,11 @@ import config from "#config";
 import config_filename from "#config-filename";
 import empty_config_file from "#error/empty-config-file";
 import error_in_config_file from "#error/error-in-config-file";
-import log from "@primate/core/log";
 import tryreturn from "@rcompat/async/tryreturn";
 import empty from "@rcompat/object/empty";
 import override from "@rcompat/object/override";
 import root from "@rcompat/package/root";
-import platform from "@rcompat/platform";
+import runtime from "@rcompat/runtime";
 import app from "./app.js";
 import { build, init } from "./hook/exports.js";
 
@@ -16,7 +15,7 @@ const empty_config = config => config === undefined || empty(config);
 
 const get_config = async project_root => {
   const local_config = project_root.join(config_filename);
-  const exists = await local_config.exists()
+  const exists = await local_config.exists();
   if (exists) {
     try {
       const imported = await local_config.import("default");
@@ -26,7 +25,7 @@ const get_config = async project_root => {
       return imported;
     } catch (error) {
       if (error.level === undefined) {
-        error_in_config_file(error.message, `${platform} ${local_config}`);
+        error_in_config_file(error.message, `${runtime} ${local_config}`);
       } else {
         throw error;
       }

package/src/build/targets/web.js

@@ -1,4 +1,5 @@
 import collect from "@rcompat/fs/collect";
+import join from "@rcompat/fs/join";
 import webpath from "@rcompat/fs/webpath";
 
 const html = /^.*.html$/u;
@@ -15,84 +16,55 @@ export default async app => {
     return {
       src,
       path,
-      code: `await file(asset${i}).text()`,
+      code: `await load_text(asset${i})`,
       type,
     };
   });
-  const d = app.runpath(location.pages);
+  const d = app.runpath(location.server, location.pages);
   const pages = await Promise.all((await collect(d, html, { recursive: true }))
     .map(async file => `${file.debase(d)}`.slice(1)));
   const pages_str = pages.map(page =>
-    `"${page}": await join(import.meta.url, "${webpath(`../${location.pages}/${page}`)}").text(),`).join("\n");
+    `"${page}": await load_text(import.meta.url,
+    "${webpath(`../${location.server}/${location.pages}/${page}`)}"),`).join("\n");
 
   const assets_scripts = `
-  import file from "@rcompat/fs/file";
-  import join from "@rcompat/fs/join";
-  import stringify from "@rcompat/object/stringify";
-  import crypto from "@rcompat/crypto";
-  import { OK } from "@rcompat/http/status";
-  import { resolve } from "@rcompat/http/mime";
-
-  const encoder = new TextEncoder();
-  const hash = async (data, algorithm = "sha-384") => {
-    const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
-    const prefix = algorithm.replace("-", _ => "");
-    return \`\${prefix}-\${btoa(String.fromCharCode(...new Uint8Array(bytes)))}\`;
-  };
+  import loader from "primate/loader";
+  import load_text from "primate/load-text";
 
   ${$imports.map(({ path }, i) =>
-    `const asset${i} = await join(import.meta.dirname, "${path}").text();`)
+    `const asset${i} = await load_text(import.meta.dirname, "${path}");`)
     .join("\n  ")}
   const assets = [${$imports.map(($import, i) => `{
   src: "${$import.src}",
   code: asset${i},
   type: "${$import.type}",
   inline: false,
-  integrity: await hash(asset${i}),
   }`).join(",\n  ")}];
 
   const imports = {
-   app: join("${http.static.root}", "${$imports.find($import =>
-  $import.src.includes("app") && $import.src.endsWith(".js")).src}").webpath(),
+     app: "${join(http.static.root, $imports.find($import =>
+    $import.src.includes("app") && $import.src.endsWith(".js")).src).webpath()}"
   };
   // importmap
   assets.push({
     inline: true,
-    code: stringify({ imports }),
+    code: { imports },
     type: "importmap",
-    integrity: await hash(stringify({ imports })),
   });
 
   const pages = {
     ${pages_str}
   };
-  const buildroot = file(import.meta.url).join("..");
 
-  const serve_asset = asset => new Response(asset.stream(), {
-    status: OK,
-    headers: {
-      "Content-Type": resolve(asset.name),
-    },
-  });
-
-  const loader = {
-    page(name) {
-      return pages[name] ?? pages["${app.get("pages.app")}"];
-    },
-    async asset(pathname) {
-      const root_asset = buildroot.join(\`client/\${pathname}\`);
-      if (await await root_asset.isFile()) {
-        return serve_asset(root_asset);
-      }
-      const static_asset = buildroot.join(\`client/static/\${pathname}\`);
-      if (await static_asset.isFile()) {
-        return serve_asset(static_asset);
-      }
-    },
+  export default {
+    assets,
+    loader: loader({
+      pages,
+      rootfile: import.meta.url,
+      pages_app: "${app.get("pages.app")}"
+    }),
+    target: "web",
   };
-  const target = "web";
-
-  export { assets, loader, target };
 `;
   await app.path.build.join("target.js").write(assets_scripts);
 

package/src/serve/app.js

@@ -1,11 +1,13 @@
 import double_extension from "#error/double-extension";
 import crypto from "@rcompat/crypto";
+import file from "@rcompat/fs/file";
 import join from "@rcompat/fs/join";
 import { html } from "@rcompat/http/mime";
 import { OK } from "@rcompat/http/status";
 import is from "@rcompat/invariant/is";
 import empty from "@rcompat/object/empty";
 import get from "@rcompat/object/get";
+import stringify from "@rcompat/object/stringify";
 import valmap from "@rcompat/object/valmap";
 import module_loader from "./module_loader.js";
 import to_sorted from "./to_sorted.js";
@@ -21,8 +23,6 @@ const to_csp = (config_csp, assets, csp) => config_csp
   .map(([key, directives]) => `${key} ${directives.join(" ")}`)
   .join(";");
 
-const encoder = new TextEncoder();
-
 const attribute = attributes => empty(attributes)
   ? ""
   : " ".concat(Object.entries(attributes)
@@ -61,8 +61,26 @@ const render_head = (assets, fonts, head) =>
       tags.font({ href, type: "font/woff2" }),
     ).join("\n"));
 
-export default async (root, { config, assets, files, components, loader, target, mode }) => {
-  const { http } = config;
+const encoder = new TextEncoder();
+const hash = async (data, algorithm = "sha-384") => {
+  const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
+  const prefix = algorithm.replace("-", _ => "");
+  return`${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
+};
+
+export default async (rootfile, build) => {
+  const root = file(rootfile).directory;
+  const { config, files, components, loader, target, mode } = build;
+  const assets = await Promise.all(build.assets.map(async asset => {
+    const code = asset.type === "importmap" ? stringify(asset.code) : asset.code;
+    return {
+      ...asset,
+      code,
+      integrity: await hash(code),
+    };
+  }));
+
+  const { http } = build.config;
   const secure = http?.ssl !== undefined;
   const path = valmap(config.location, value => root.join(value));
 
@@ -174,11 +192,7 @@ export default async (root, { config, assets, files, components, loader, target,
       this.handlers[extension] !== undefined && double_extension(extension);
       this.handlers[extension] = handle;
     },
-    async hash(data, algorithm = "sha-384") {
-      const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
-      const prefix = algorithm.replace("-", _ => "");
-      return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
-    },
+    hash,
     // noop
     target(name, handler) {},
     build_target: target,