@mosetta/build 0.0.9 → 0.0.10

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mosetta/build
 
+## 0.0.10
+
+### Patch Changes
+
+- 95b93d5: The build's node host is an entry of the build: `@mosetta/build/node` gives the real file system,
+  the framework's files resolved from the installed build, and `buildDirectory(root, …)` — the build
+  of a palette that lies on disk with its dependencies installed, by the build installed for it. The
+  CLI builds with it, and so does a platform's build container: a palette is built by the framework
+  version its lock names. `systemjs`, whose files the build mixes into a page, is a dependency of the
+  build now, not of the CLI.
+  - @mosetta/router@0.0.10
+  - @mosetta/runtime@0.0.10
+  - @mosetta/server@0.0.10
+  - @mosetta/server-action@0.0.10
+  - @mosetta/tar@0.0.10
+
 ## 0.0.9
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosetta/build",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "license": "MIT",
   "description": "The core of the tile forge: builds a tile palette — its tile side artifacts, their dependency closure, the tile host descriptor. Environment-agnostic — the file system and the bundling engine are supplied from outside.",
   "type": "module",
@@ -11,7 +11,8 @@
     "./packagesResolver": "./src/packagesResolver.mjs",
     "./scanner": "./src/scanner.mjs",
     "./archive": "./src/archive.mjs",
-    "./release": "./src/release.mjs"
+    "./release": "./src/release.mjs",
+    "./node": "./src/node.mjs"
   },
   "dependencies": {
     "@pnpm/dependency-path": "^1000.0.9",
@@ -24,12 +25,13 @@
     "react-dom": "*",
     "resolve.exports": "^2.0.3",
     "scheduler": "*",
+    "systemjs": "^6.15.1",
     "yaml": "^2.9.0",
-    "@mosetta/runtime": "0.0.9",
-    "@mosetta/server-action": "0.0.9",
-    "@mosetta/router": "0.0.9",
-    "@mosetta/tar": "0.0.9",
-    "@mosetta/server": "0.0.9"
+    "@mosetta/router": "0.0.10",
+    "@mosetta/runtime": "0.0.10",
+    "@mosetta/server": "0.0.10",
+    "@mosetta/tar": "0.0.10",
+    "@mosetta/server-action": "0.0.10"
   },
   "publishConfig": {
     "access": "public"

package/src/node.mjs

@@ -0,0 +1,113 @@
+// THE NODE HOST of the build: what a host running in node gives the build — the real file system
+// (read only), the framework's files resolved from this installation, and the build of a palette
+// that lies on disk with its dependencies installed. Shared by the CLI and the platform's build
+// container; anything that runs node builds the same way.
+//
+// Nothing here fetches anything: the dependencies are installed by whoever calls (a developer's
+// pnpm, CI, a build container), the build only reads them.
+//
+// The one entry of the package that is node's: the port's node implementation, an entry of its
+// own (`@mosetta/build/node`) that the build's core never imports.
+/* eslint-disable no-restricted-imports -- the node HOST: the file port and resolution, for node */
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { build, INERT_BUILD_CONFIG } from './build.mjs';
+import { FileSystem } from './fileSystem.mjs';
+import { FRAMEWORK_RESOLUTIONS, PackagesResolver, packageDirOf } from './packagesResolver.mjs';
+import { BUILD_CONFIG_FILE, scanCatalog } from './scanner.mjs';
+/* eslint-enable no-restricted-imports */
+
+/**
+ * Node implementation of the file port: the real FS, read-only.
+ *
+ * Packages are resolved by `PackagesResolver` from the scanner catalog, identically in all
+ * environments — not here.
+ */
+export class NodeFileSystem extends FileSystem {
+  readFile(file, encoding = null) {
+    return encoding ? fs.readFileSync(file, encoding) : fs.readFileSync(file);
+  }
+
+  exists(file) {
+    return fs.existsSync(file);
+  }
+
+  readDir(dir) {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
+  }
+
+  isDirectory(dir) {
+    try {
+      return fs.statSync(dir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  realPath(file) {
+    return fs.realpathSync(file);
+  }
+
+  mtimeMs(file) {
+    try {
+      return fs.statSync(file).mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+}
+
+const buildRequire = createRequire(import.meta.url);
+
+/** a framework file (`systemjs/dist/system.js`, `@mosetta/runtime/bootstrap`) as this installation of the build resolves it */
+export function frameworkFileOf(specifier) {
+  return buildRequire.resolve(specifier);
+}
+
+/** `catalog.framework`: the files of FRAMEWORK_RESOLUTIONS from this installation of the build */
+export function frameworkResolutions() {
+  const framework = {};
+  for (const spec of FRAMEWORK_RESOLUTIONS) framework[spec] = frameworkFileOf(spec);
+  return framework;
+}
+
+/**
+ * The directory generated sides' imports (the default ssr) resolve from: this installation of the
+ * build, where @mosetta/router, @mosetta/server and react are declared.
+ */
+export function frameworkDirOf(fileSystem = new NodeFileSystem()) {
+  return packageDirOf(fileSystem, frameworkFileOf('@mosetta/build'));
+}
+
+/**
+ * The build of the palette at `root` — on disk, its dependencies installed — with THIS build: the
+ * one installed for the palette, so a palette is built by the framework version its lock names.
+ * `engine` — the host's bundling engine; `evaluate` — the host's way to run a module the build
+ * bundled (settings schemas); `released` — ids the target already holds, not built again. A palette
+ * with build hooks (mosetta.build.mjs) needs its `buildConfig` made executable by the host; without
+ * one the build is refused rather than made without its hooks.
+ */
+export async function buildDirectory(root, { mode = 'production', engine, log = () => {}, evaluate = null, released = null, buildConfig = null } = {}) {
+  const fileSystem = new NodeFileSystem();
+  if (!buildConfig && fileSystem.exists(path.join(root, BUILD_CONFIG_FILE))) {
+    throw new Error(`the tile palette uses ${BUILD_CONFIG_FILE} (build hooks), but no executable hooks were passed`);
+  }
+  const frameworkDir = frameworkDirOf(fileSystem);
+  const resolver = new PackagesResolver({
+    fileSystem,
+    catalog: { ...scanCatalog({ fileSystem, root, frameworkDir, includeDev: mode !== 'production', log }), framework: frameworkResolutions() },
+  });
+  return build(root, {
+    mode,
+    log,
+    fileSystem,
+    resolver,
+    engine,
+    frameworkDir,
+    buildConfig: buildConfig ?? INERT_BUILD_CONFIG,
+    ...(evaluate ? { evaluate } : {}),
+    ...(released ? { released } : {}),
+  });
+}

package/src/nodeApi.mjs

@@ -1,4 +1,4 @@
-/* eslint-disable no-restricted-imports -- the ONLY place in the package where `node:*` is allowed */
+/* eslint-disable no-restricted-imports -- the ONLY place in the build's core where `node:*` is allowed (node.mjs is the node host, not the core) */
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { builtinModules } from 'node:module';