@primate/core 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@primate/core",
+  "version": "0.1.0",
+  "description": "Primate core",
+  "homepage": "https://primatejs.com",
+  "bugs": "https://github.com/primatejs/primate/issues",
+  "license": "MIT",
+  "files": [
+    "src/**/*.js",
+    "!src/**/*.spec.js",
+    "src/build/defaults/*.html"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primatejs/primate",
+    "directory": "packages/core"
+  },
+  "dependencies": {
+    "@rcompat/array": "^0.3.0",
+    "@rcompat/async": "^0.3.0",
+    "@rcompat/build": "^0.4.0",
+    "@rcompat/cli": "^0.5.1",
+    "@rcompat/crypto": "^0.5.0",
+    "@rcompat/fs": "^0.4.0",
+    "@rcompat/function": "^0.4.0",
+    "@rcompat/http": "^0.5.1",
+    "@rcompat/invariant": "^0.5.0",
+    "@rcompat/object": "^0.5.0",
+    "@rcompat/package": "^0.7.0",
+    "@rcompat/platform": "^0.3.0",
+    "@rcompat/stdio": "^0.4.0",
+    "@rcompat/sync": "^0.3.0"
+  },
+  "type": "module",
+  "imports": {
+    "#*": {
+      "@primate/lt": "./src/private/*.js",
+      "default": "./src/private/*.js"
+    },
+    "#error/*": {
+      "@primate/lt": "./src/private/error/*.js",
+      "default": "./src/private/error/*.js"
+    }
+  },
+  "exports": {
+    "./serve": "./src/serve/index.js",
+    "./build": "./src/build/index.js",
+    "./error": "./src/error/index.js",
+    "./log": "./src/log/index.js",
+    "./dispatch": "./src/dispatch/index.js",
+    "./handler/*": "./src/serve/handler/*.js"
+  }
+}

package/src/build/app.js

@@ -0,0 +1,105 @@
+import join from "@rcompat/fs/join";
+import get from "@rcompat/object/get";
+import valmap from "@rcompat/object/valmap";
+import module_loader from "./module_loader.js";
+import { web } from "./targets/exports.js";
+
+export default async (root, config) => {
+  const path = valmap(config.location, value => root.join(value));
+  const error = await path.routes.join("+error.js");
+
+  return {
+    postbuild: [],
+    bindings: {},
+    roots: [],
+    targets: { web: { target: web } },
+    importmaps: {},
+    assets: [],
+    path,
+    root,
+    // pseudostatic thus arrowbound
+    get: (config_key, fallback) => get(config, config_key) ?? fallback,
+    set: (key, value) => {
+      config[key] = value;
+    },
+    error: {
+      default: await error.exists() ? await error.import("default") : undefined,
+    },
+    extensions: {},
+    modules: await module_loader(root, config.modules ?? []),
+    fonts: [],
+    // copy files to build folder, potentially transforming them
+    async stage(source, directory, filter) {
+      const { define = {} } = this.get("build", {});
+
+      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();
+
+        defines.length > 0 && await target.write(mapper(await abs_path.text()));
+      }));
+    },
+    async compile(component) {
+      const { server, client, components } = this.get("location");
+
+      const compile = this.extensions[component.fullExtension]
+        ?? this.extensions[component.extension];
+      if (compile === undefined) {
+        const source = this.path.build.join(components);
+        const debased = `${component.path}`.replace(source, "");
+
+        const server_target = this.runpath(server, components, debased);
+        await server_target.directory.create();
+        await component.copy(server_target);
+
+        const client_target = this.runpath(client, components, debased);
+        await client_target.directory.create();
+        await component.copy(client_target);
+      } else {
+        // compile server components
+        await compile.server(component, this);
+
+        // compile client components
+        await compile.client(component, this);
+      }
+    },
+    register(extension, compile) {
+      this.extensions[extension] = compile;
+    },
+    runpath(...directories) {
+      return this.path.build.join(...directories);
+    },
+    target(name, handler) {
+      this.targets[name] = handler;
+    },
+    bind(extension, handler) {
+      this.bindings[extension] = handler;
+    },
+    done(fn) {
+      this.postbuild.push(fn);
+    },
+  };
+};

package/src/build/defaults/app.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Primate app</title>
+    <meta charset="utf-8" />
+    %head%
+  </head>
+  <body>%body%</body>
+</html>

package/src/build/defaults/error.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Error page</title>
+    <meta charset="utf-8" />
+    %head%
+  </head>
+  <body>
+    <h1>Error page</h1>
+    <p>
+      %body%
+    </p>
+  </body>
+</html>

package/src/build/hook/build.js

@@ -0,0 +1,179 @@
+import config_filename from "#config-filename";
+import log from "@primate/core/log";
+import cascade from "@rcompat/async/cascade";
+import Build from "@rcompat/build";
+import dim from "@rcompat/cli/color/dim";
+import collect from "@rcompat/fs/collect";
+import join from "@rcompat/fs/join";
+import exclude from "@rcompat/object/exclude";
+import stringify from "@rcompat/object/stringify";
+import manifest from "@rcompat/package/manifest";
+import copy_includes from "./copy_includes.js";
+import $router from "./router.js";
+
+const html = /^.*.html$/u;
+
+const pre = async (app, mode, target) => {
+  let target$ = target;
+  if (app.targets[target$] === undefined) {
+    throw new Error(`target ${dim(target)} does not exist`);
+  }
+  if (app.targets[target$].forward) {
+    target$ = app.targets[target$].forward;
+  }
+  app.build_target = target$;
+  log.system(`starting ${dim(target$)} build in ${dim(mode)} mode`);
+
+  app.build = new Build({
+    ...exclude(app.get("build"), ["includes", "index"]),
+    outdir: app.runpath(app.get("location.client")).path,
+    stdin: {
+      resolveDir: app.root.path,
+    },
+  }, mode);
+
+  app.server_build = ["routes", "types"];
+
+  // remove build directory in case exists
+  await app.path.build.remove();
+  await app.path.build.create();
+
+  await Promise.all(["server", "client", "pages", "components"]
+    .map(directory => app.runpath(directory).create()));
+
+  const router = await $router(app.path.routes);
+  const layout = { depth: router.depth("layout") };
+  app.set("layout", layout);
+
+  return { ...app, layout };
+};
+
+const js_re = /^.*.js$/u;
+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, _ => "")));
+    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}]);`,
+  ).join("\n")}
+    export default ${name};`;
+    await build_directory.join(`${name}.js`).write(files_js);
+  }
+};
+
+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, _ => "")));
+  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}]);`,
+  ).join("\n")}
+
+${app.roots.map((root, i) => `
+import * as root${i} from "${root}";
+components.push(["${root.name}", root${i}]);
+`).join("\n")}
+
+export default components;`;
+  await build_directory.join("components.js").write(components_js);
+};
+
+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 config from "./${config_filename}";
+const files = {};
+${app.server_build.map(name =>
+    `import ${name} from "./${build_number}/${name}.js";
+     files.${name} = ${name};`,
+  ).join("\n")}
+import components from "./${build_number}/components.js";
+import * as target from "./target.js";
+
+await serve(file(import.meta.url).directory, {
+  ...target,
+  config,
+  files,
+  components,
+  mode: "${mode}",
+});`;
+  await app.path.build.join("serve.js").write(build_start_script);
+};
+
+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])));
+
+  const directory = app.runpath(location.routes);
+  for (const path of await directory.collect()) {
+    await app.bindings[path.extension]
+      ?.(directory, path.debase(`${directory}/`));
+  }
+  // copy framework pages
+  await app.stage(defaults, location.pages, html);
+  // overwrite transformed pages to build
+  await app.stage(app.path.pages, location.pages, html);
+
+  // copy static files to build/server/static
+  await app.stage(app.path.static, join(location.server, location.static));
+
+  // copy static files to build/client/static
+  await app.stage(app.path.static, join(location.client, location.static));
+
+  // publish JavaScript and CSS files
+  const imports = await collect(app.path.static, /\.(?:css)$/u);
+  await Promise.all(imports.map(async file => {
+    const src = file.debase(app.path.static);
+    app.build.export(`import "./${location.static}${src}";`);
+  }));
+
+  // copy additional subdirectories to build/server
+  await copy_includes(app, location.server);
+
+  const components = await app.runpath(location.components).collect();
+
+  // from the build directory, compile to server and client
+  await Promise.all(components.map(component => app.compile(component)));
+
+  // start the build
+  await app.build.start();
+
+  // a target needs to create an `assets.js` that exports assets
+  await app.targets[app.build_target].target(app);
+
+  const build_number = crypto.randomUUID().slice(0, 8);
+  const build_directory = app.path.build.join(build_number);
+  // TODO: remove after rcompat automatically creates directories
+  await build_directory.create();
+
+  await write_components(build_directory, app);
+  await write_directories(build_directory, app);
+  await write_bootstrap(build_number, app, mode);
+
+  // copy config file
+  await app.root.join(config_filename).copy(app.path.build.join(config_filename));
+
+  const manifest_data = await manifest();
+  // create package.json
+  const package_json = "package.json";
+  await app.path.build.join(package_json).write(stringify(manifest_data));
+
+  log.system(`build written to ${dim(app.path.build)}`);
+
+  app.postbuild.forEach(fn => fn());
+};
+
+export default async (app, mode = "development", target = "web") =>
+  post(await (await cascade(app.modules.build))(await pre(app, mode, target)), mode, target);

package/src/build/hook/copy_includes.js

@@ -0,0 +1,20 @@
+import join from "@rcompat/fs/join";
+
+export default async (app, type, post = () => undefined) => {
+  const includes = app.get("build.includes");
+  const reserved = Object.values(app.get("location"));
+
+  if (Array.isArray(includes)) {
+    await Promise.all(includes
+      .filter(include => !reserved.includes(include))
+      .filter(include => /^[^/]*$/u.test(include))
+      .map(async include => {
+        const path = app.root.join(include);
+        if (await path.exists()) {
+          const target = join(type, include);
+          await app.stage(path, target);
+          await post(target);
+        }
+      }));
+  }
+};

package/src/build/hook/exports.js

@@ -0,0 +1,2 @@
+export { default as init } from "./init.js";
+export { default as build } from "./build.js";

package/src/build/hook/init.js

@@ -0,0 +1,3 @@
+import cascade from "@rcompat/async/cascade";
+
+export default async app => (await cascade(app.modules.init))(app);

package/src/build/hook/router.js

@@ -0,0 +1,32 @@
+import double_route from "#error/double-route";
+import optional_route from "#error/optional-route";
+import rest_route from "#error/rest-route";
+import Router from "@rcompat/fs/router";
+
+const error_entries = Object.entries({
+  DoubleRoute: double_route,
+  OptionalRoute: optional_route,
+  RestRoute: rest_route,
+});
+
+export default async directory => {
+
+  try {
+    return await Router.load({
+        directory,
+        specials: {
+          guard: { recursive: true },
+          error: { recursive: false },
+          layout: { recursive: true },
+        },
+        predicate(route, request) {
+          return route.default[request.method.toLowerCase()] !== undefined;
+        },
+      });
+  } catch (error) {
+    error_entries.forEach(([key, value]) =>
+      error instanceof Router.Error[key] && value(error.route));
+    // rethrow original error
+    throw error;
+  }
+};

package/src/build/index.js

@@ -0,0 +1,41 @@
+import bye from "#bye";
+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 app from "./app.js";
+import { build, init } from "./hook/exports.js";
+
+const get_config = async project_root => {
+  const local_config = project_root.join(config_filename);
+  return await local_config.exists()
+    ? tryreturn(async _ => {
+      const imported = await local_config.import("default");
+
+      empty(imported) && empty_config_file(local_config);
+
+      return imported;
+    }).orelse(({ message }) =>
+      error_in_config_file(message, `${platform} ${local_config}`))
+    : config;
+};
+
+export default async (mode, target) => tryreturn(async _ => {
+  const package_root = await root();
+  const app_config = override(config, await get_config(package_root));
+  const $app = await app(package_root, app_config);
+  await build(await init($app), mode, target);
+  return true;
+}).orelse(error => {
+  if (error.level === "error") {
+    bye();
+    return;
+  }
+  throw error;
+});

package/src/build/module_loader.js

@@ -0,0 +1,30 @@
+import config_filename from "#config-filename";
+import double_module from "#error/double-module";
+import module_no_name from "#error/module-no-name";
+import modules_array from "#error/modules-array";
+import * as hooks from "./hook/exports.js";
+
+const doubled = set => set.find((part, i, array) =>
+  array.filter((_, j) => i !== j).includes(part));
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+const load = (modules = []) => modules.map(module =>
+  [module, load(module.load?.() ?? [])]).flat();
+
+export default async (root, modules) => {
+  !Array.isArray(modules) && modules_array("modules");
+
+  modules.some(({ name }, n) => name === undefined && module_no_name(n));
+
+  const names = modules.map(({ name }) => name);
+  new Set(names).size !== modules.length && double_module(
+    doubled(names), root.join(config_filename));
+
+  // collect modules
+  const loaded = load(modules).flat(2);
+
+  return {
+    names: loaded.map(module => module.name),
+    ...Object.fromEntries([...Object.keys(hooks), "context"]
+      .map(hook => [hook, filter(hook, loaded)])),
+  };
+};

package/src/build/targets/exports.js

@@ -0,0 +1 @@
+export { default as web } from "./web.js";

package/src/build/targets/web.js

@@ -0,0 +1,81 @@
+import collect from "@rcompat/fs/collect";
+
+const html = /^.*.html$/u;
+
+export default async app => {
+  const location = app.get("location");
+  const http = app.get("http");
+  const client = app.runpath(location.client);
+  const re = /app..*(?:js|css)$/u;
+  const $imports = (await client.collect(re, { recursive: false })).map((file, i) => {
+    const type = file.extension === ".css" ? "style" : "js";
+    const src = `${http.static.root}${file.debase(client).name}`;
+    const path = `./${file.debase(`${app.path.build}/`)}`;
+    return {
+      src,
+      path,
+      code: `await file(asset${i}).text()`,
+      type,
+    };
+  });
+  const d = app.runpath(location.pages);
+  const pages = await Promise.all((await collect(d, html, { recursive: true }))
+    .map(async file => `${file}`.replace(`${d}/`, _ => "")));
+  const pages_str = pages.map(page =>
+    `"${page}": await file("./${location.pages}/${page}").text(),`).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";
+
+  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)))}\`;
+  };
+
+  ${$imports.map(({ path }, i) =>
+    `const asset${i} = await join(import.meta.dirname, "${path}").text();`)
+    .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(),
+  };
+  // importmap
+  assets.push({
+    inline: true,
+    code: stringify({ imports }),
+    type: "importmap",
+    integrity: await hash(stringify({ imports })),
+  });
+
+  const pages = {
+    ${pages_str}
+  };
+
+  const loader = {
+    page(name) {
+      return pages[name] ?? pages["${app.get("pages.app")}"];
+    },
+    asset(pathname) {
+      return assets.find(asset => asset.src === pathname);
+    },
+  };
+  const target = "web";
+
+  export { assets, loader, target };
+`;
+  await app.path.build.join("target.js").write(assets_scripts);
+
+};

package/src/dispatch/index.js

@@ -0,0 +1 @@
+export { default } from "#dispatch";

package/src/log/index.js

@@ -0,0 +1 @@
+export { default } from "#log";

package/src/private/bye.js

@@ -0,0 +1,5 @@
+import print from "@rcompat/cli/print";
+import dim from "@rcompat/cli/color/dim";
+import yellow from "@rcompat/cli/color/yellow";
+
+export default () => print(dim(yellow("~~ bye\n")));

package/src/private/config-filename.js

@@ -0,0 +1 @@
+export default "primate.config.js";

package/src/private/config.js

@@ -0,0 +1,48 @@
+export default {
+  base: "/",
+  modules: [],
+  pages: {
+    app: "app.html",
+    error: "error.html",
+  },
+  log: {
+    level: "warn",
+    trace: false,
+  },
+  http: {
+    host: "localhost",
+    port: 6161,
+    csp: {},
+    static: {
+      root: "/",
+    },
+  },
+  request: {
+    body: {
+      parse: true,
+    },
+  },
+  location: {
+    // renderable components
+    components: "components",
+    // HTML pages
+    pages: "pages",
+    // hierarchical routes
+    routes: "routes",
+    // static assets
+    static: "static",
+    // runtime types
+    types: "types",
+    // build environment
+    build: "build",
+    // client build
+    client: "client",
+    // server build
+    server: "server",
+  },
+  build: {
+    name: "app",
+    includes: [],
+    excludes: [],
+  },
+};