primate 0.13.1 → 0.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Expressive, minimal and extensible framework for JavaScript",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",

package/src/config.js

@@ -1,5 +1,6 @@
-import {File, Path} from "runtime-compat/fs";
+import crypto from "runtime-compat/crypto";
 import {is} from "runtime-compat/dyndef";
+import {File, Path} from "runtime-compat/fs";
 import cache from "./cache.js";
 import extend from "./extend.js";
 import defaults from "./primate.config.js";
@@ -45,11 +46,19 @@ const index = async env => {
   }
 };
 
+const hash = async (string, algorithm = "sha-384") => {
+  const encoder = new TextEncoder();
+  const bytes = await crypto.subtle.digest(algorithm, encoder.encode(string));
+  const algo = algorithm.replace("-", () => "");
+  return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
+};
+
 export default async (filename = "primate.config.js") => {
   is(filename).string();
   const root = await getRoot();
   const config = await getConfig(root, filename);
 
+  const resources = [];
   const env = {
     ...config,
     paths: qualify(root, config.paths),
@@ -61,7 +70,20 @@ export default async (filename = "primate.config.js") => {
     handlers: {...handlers},
     render: async ({body = "", head = ""} = {}) => {
       const html = await index(env);
-      return html.replace("%body%", () => body).replace("%head%", () => head);
+      const heads = resources.map(({src, code, type, inline, integrity}) => {
+        const tag = "script";
+        const pre = `<${tag} type="${type}" integrity="${integrity}"`;
+        const post = `</${tag}>`;
+        return inline ? `${pre}>${code}${post}` : `${pre} src="${src}">${post}`;
+      }).join("\n");
+      return html
+        .replace("%body%", () => body)
+        .replace("%head%", () => `${head}${heads}`);
+    },
+    publish: async ({src, code, type = "", inline = false}) => {
+      const integrity = await hash(code);
+      resources.push({src, code, type, inline, integrity});
+      return integrity;
     },
   };
   env.log.info(`${package_json.name} \x1b[34m${package_json.version}\x1b[0m`);
@@ -71,6 +93,6 @@ export default async (filename = "primate.config.js") => {
     .filter(module => module.load !== undefined)
     .map(module => module.load()(env)));
 
-  return cache("config", filename, () => ({...env,
+  return cache("config", filename, () => ({...env, resources,
     modules: modules.concat(loads)}));
 };

package/src/publish.js

@@ -0,0 +1,5 @@
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+
+export default async env =>
+  [...filter("publish", env.modules), _ => _].reduceRight((acc, handler) =>
+    input => handler(input, acc))(env);

package/src/run.js

@@ -1,14 +1,21 @@
 import config from "./config.js";
 import register from "./register.js";
 import compile from "./compile.js";
+import publish from "./publish.js";
 import bundle from "./bundle.js";
 import route from "./route.js";
 import serve from "./serve.js";
 
 export default async () => {
   const env = await config();
+  // register handlers
   await register(env);
+  // compile server-side code
   await compile(env);
+  // publish client-side code
+  await publish(env);
+  // bundle client-side code
   await bundle(env);
+  // serve
   serve({router: await route(env.paths.routes, env.handlers), ...env});
 };

package/src/serve.js

@@ -22,8 +22,19 @@ export default env => {
   const _respond = async request => {
     const csp = Object.keys(env.http.csp).reduce((policy_string, key) =>
       `${policy_string}${key} ${env.http.csp[key]};`, "");
+    const scripts = env.resources
+      .map(resource => `'${resource.integrity}'`).join(" ");
+    const _csp = scripts === "" ? csp : `${csp}script-src 'self' ${scripts};`;
+    // remove inline resources
+    for (let i = env.resources.length - 1; i >= 0; i--) {
+      const resource = env.resources[i];
+      if (resource.inline) {
+        env.resources.splice(i, 1);
+      }
+    }
+
     const headers = {
-      "Content-Security-Policy": csp,
+      "Content-Security-Policy": _csp,
       "Referrer-Policy": "same-origin",
     };
 
@@ -53,9 +64,24 @@ export default env => {
     },
   });
 
+  const publishedResource = request => {
+    const published = env.resources.find(resource =>
+      `/${resource.src}` === request.pathname);
+    if (published !== undefined) {
+      return new Response(published.code, {
+        status: statuses.OK,
+        headers: {
+          "Content-Type": mime(published.src),
+        },
+      });
+    }
+
+    return route(request);
+  };
+
   const _serve = async request => {
     const path = new Path(env.paths.public, request.pathname);
-    return await path.isFile ? resource(path.file) : route(request);
+    return await path.isFile ? resource(path.file) : publishedResource(request);
   };
 
   const handle = async request => {