@primate/core 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Primate core",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -21,9 +21,9 @@
     "@rcompat/build": "^0.4.0",
     "@rcompat/cli": "^0.5.1",
     "@rcompat/crypto": "^0.5.0",
-    "@rcompat/fs": "^0.4.1",
+    "@rcompat/fs": "^0.5.0",
     "@rcompat/function": "^0.4.0",
-    "@rcompat/http": "^0.5.2",
+    "@rcompat/http": "^0.5.3",
     "@rcompat/invariant": "^0.5.0",
     "@rcompat/object": "^0.5.0",
     "@rcompat/package": "^0.7.0",

package/src/build/app.js

@@ -29,38 +29,32 @@ export default async (root, config) => {
     modules: await module_loader(root, config.modules ?? []),
     fonts: [],
     // copy files to build folder, potentially transforming them
-    async stage(source, directory, filter) {
+    async stage(source, directory, apply_defines = false) {
       const { define = {} } = this.get("build", {});
+      const defines = Object.entries(define);
 
       if (!await source.exists()) {
         return;
       }
 
       const target_base = this.runpath(directory);
-      const defines = Object.entries(define);
-
-      // first, copy everything
-      await source.copy(target_base);
 
-      const location = this.get("location");
-      const client_location = join(location.client, location.static).path;
-      const mapper = text =>
-        defines.reduce((replaced, [key, substitution]) =>
-          replaced.replaceAll(key, substitution), text);
-
-      // then, copy and transform whitelisted paths using mapper
-      await Promise.all((await source.collect(filter)).map(async abs_path => {
-        const rel_path = join(directory, abs_path.debase(source));
-        if (directory.path === client_location && rel_path.path.endsWith(".css")) {
-          const contents = await abs_path.text();
-          const font_regex = /@font-face\s*\{.+?url\("(.+?\.woff2)"\).+?\}/gus;
-          this.fonts.push(...[...contents.matchAll(font_regex)].map(match => match[1]));
-        }
-        const target = await target_base.join(rel_path.debase(directory));
-        await target.directory.create();
+      if (!apply_defines || defines.length === 0) {
+        // copy everything
+        await source.copy(target_base);
+      } else {
+        // copy files individually, transform them using a defines mapper
+        const mapper = text =>
+          defines.reduce((replaced, [key, substitution]) =>
+            replaced.replaceAll(key, substitution), text);
 
-        defines.length > 0 && await target.write(mapper(await abs_path.text()));
-      }));
+        await Promise.all((await source.collect()).map(async abs_path => {
+          const rel_path = join(directory, abs_path.debase(source));
+          const target = await target_base.join(rel_path.debase(directory));
+          await target.directory.create();
+          await target.write(mapper(await abs_path.text()));
+        }));
+      }
     },
     async compile(component) {
       const { server, client, components } = this.get("location");

package/src/build/hook/build.js

@@ -11,8 +11,7 @@ import manifest from "@rcompat/package/manifest";
 import root from "@rcompat/package/root";
 import copy_includes from "./copy_includes.js";
 import $router from "./router.js";
-
-const html = /^.*.html$/u;
+import webpath from "@rcompat/fs/webpath";
 
 const pre = async (app, mode, target) => {
   let target$ = target;
@@ -54,12 +53,12 @@ const write_directories = async (build_directory, app) => {
   for (const name of app.server_build) {
     const d = app.runpath(name);
     const e = await Promise.all((await collect(d, js_re, { recursive: true }))
-      .map(async file => `${file}`.replace(d, _ => "")));
+      .map(async path => `${path}`.replace(d, _ => "")));
     const files_js = `
     const ${name} = [];
-    ${e.map((file , i) =>
-    `import * as ${name}${i} from "../${name}${file}";
-    ${name}.push(["${file.slice(1, -".js".length)}", ${name}${i}]);`,
+    ${e.map((path, i) =>
+    `import * as ${name}${i} from "${webpath(`../${name}${path}`)}";
+    ${name}.push(["${webpath(path.slice(1, -".js".length))}", ${name}${i}]);`,
   ).join("\n")}
     export default ${name};`;
     await build_directory.join(`${name}.js`).write(files_js);
@@ -70,16 +69,16 @@ const write_components = async (build_directory, app) => {
   const location = app.get("location");
   const d2 = app.runpath(location.server, location.components);
   const e = await Promise.all((await collect(d2, js_re, { recursive: true }))
-    .map(async file => `${file}`.replace(d2, _ => "")));
+    .map(async path => `${path}`.replace(d2, _ => "")));
   const components_js = `
 const components = [];
 ${e.map((component, i) =>
-    `import * as component${i} from "../server/components${component}";
-components.push(["${component.slice(1, -".js".length)}", component${i}]);`,
+    `import * as component${i} from "${webpath(`../server/components${component}`)}";
+components.push(["${webpath(component.slice(1, -".js".length))}", component${i}]);`,
   ).join("\n")}
 
 ${app.roots.map((root, i) => `
-import * as root${i} from "${root}";
+import * as root${i} from "${webpath(`../server/${root.name}`)}";
 components.push(["${root.name}", root${i}]);
 `).join("\n")}
 
@@ -114,8 +113,14 @@ const post = async (app, mode, target) => {
   const location = app.get("location");
   const defaults = join(import.meta.dirname, "../defaults");
 
-  await Promise.all(["routes", "types", "components"].map(directory =>
-    app.stage(app.path[directory], location[directory])));
+  // stage routes
+  await app.stage(app.path.routes, location.routes);
+
+  // stage types
+  await app.stage(app.path.types, location.types);
+
+  // stage components, transforming defines
+  await app.stage(app.path.components, location.components, true);
 
   const directory = app.runpath(location.routes);
   for (const path of await directory.collect()) {
@@ -123,9 +128,9 @@ const post = async (app, mode, target) => {
       ?.(directory, path.debase(`${directory}/`));
   }
   // copy framework pages
-  await app.stage(defaults, location.pages, html);
+  await app.stage(defaults, location.pages);
   // overwrite transformed pages to build
-  await app.stage(app.path.pages, location.pages, html);
+  await app.stage(app.path.pages, location.pages);
 
   // copy static files to build/server/static
   await app.stage(app.path.static, join(location.server, location.static));

package/src/build/targets/web.js

@@ -1,4 +1,5 @@
 import collect from "@rcompat/fs/collect";
+import webpath from "@rcompat/fs/webpath";
 
 const html = /^.*.html$/u;
 
@@ -20,9 +21,9 @@ export default async app => {
   });
   const d = app.runpath(location.pages);
   const pages = await Promise.all((await collect(d, html, { recursive: true }))
-    .map(async file => `${file}`.replace(`${d}/`, _ => "")));
+    .map(async file => `${file.debase(d)}`.slice(1)));
   const pages_str = pages.map(page =>
-    `"${page}": await join(import.meta.url, "../${location.pages}/${page}").text(),`).join("\n");
+    `"${page}": await join(import.meta.url, "${webpath(`../${location.pages}/${page}`)}").text(),`).join("\n");
 
   const assets_scripts = `
   import file from "@rcompat/fs/file";
@@ -80,11 +81,11 @@ export default async app => {
     },
     async asset(pathname) {
       const root_asset = buildroot.join(\`client/\${pathname}\`);
-      if (await await root_asset.isFile) {
+      if (await await root_asset.isFile()) {
         return serve_asset(root_asset);
       }
       const static_asset = buildroot.join(\`client/static/\${pathname}\`);
-      if (await static_asset.isFile) {
+      if (await static_asset.isFile()) {
         return serve_asset(static_asset);
       }
     },