@decohere/forge 0.0.1-dev.11 → 0.0.1-dev.110

package/commonjs/src/packaging/dependency-pinner.service.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DependencyPinner", {
+    enumerable: true,
+    get: function() {
+        return DependencyPinner;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _io = require("@decohere/nexus/io");
+const _errors = require("../errors.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class DependencyPinner {
+    async pin(imported, shipped, projects, workspaceRoot) {
+        const scopes = [
+            ...shipped.map((project)=>({
+                    name: project.name,
+                    dir: project.projectRoot,
+                    pkg: project.pkg
+                })),
+            {
+                name: "the workspace root",
+                dir: workspaceRoot.dir,
+                pkg: workspaceRoot.pkg
+            }
+        ];
+        const declaredBy = new Map();
+        for (const scope of scopes){
+            for (const name of Object.keys(scope.pkg.dependencies ?? {})){
+                if (projects.has(name)) {
+                    continue; // a workspace library, copied from its build, never installed
+                }
+                declaredBy.set(name, [
+                    ...declaredBy.get(name) ?? [],
+                    scope
+                ]);
+            }
+        }
+        this.assertImportsAreShipped(imported, declaredBy, scopes);
+        const pinned = {};
+        for (const name of [
+            ...declaredBy.keys()
+        ].sort()){
+            pinned[name] = await this.installedVersion(name, declaredBy.get(name) ?? [], workspaceRoot.dir);
+        }
+        return pinned;
+    }
+    assertImportsAreShipped(imported, declaredBy, scopes) {
+        for (const name of [
+            ...imported.keys()
+        ].sort()){
+            if (declaredBy.has(name)) {
+                continue;
+            }
+            const importers = [
+                ...imported.get(name) ?? []
+            ].sort().join(", ");
+            const devOnly = scopes.find((scope)=>scope.pkg.devDependencies?.[name] != null);
+            if (devOnly != null) {
+                throw new _errors.ForgeError(`${name} is imported at run time by ${importers}, but it is only a devDependency ` + `(of ${devOnly.name}). Move it to "dependencies".`);
+            }
+            throw new _errors.ForgeError(`${name} is imported at run time by ${importers}, but is not in "dependencies" of the ` + "deployable, any library it uses, or the workspace root package.json. Add it there.");
+        }
+    }
+    async installedVersion(name, declarers, workspaceRootDir) {
+        const versions = new Map();
+        for (const scope of declarers){
+            const version = await findInstalledVersion(name, scope.dir) ?? await findInstalledVersion(name, workspaceRootDir);
+            if (version == null) {
+                throw new _errors.ForgeError(`${name} is declared by ${scope.name} but is not installed. ` + "Run the package manager install first.");
+            }
+            versions.set(scope.name, version);
+        }
+        const distinct = new Set(versions.values());
+        if (distinct.size > 1) {
+            const detail = [
+                ...versions
+            ].map(([owner, version])=>`${owner}: ${version}`).join(", ");
+            throw new _errors.ForgeError(`${name} is installed at different versions for the packages that declare it (${detail}). ` + "One packaged app can only ship one version; align them.");
+        }
+        const [version] = distinct;
+        if (version == null) {
+            throw new _errors.ForgeError(`${name} is not installed. Run the package manager install first.`);
+        }
+        return version;
+    }
+}
+DependencyPinner = _ts_decorate([
+    (0, _decorators.injectable)()
+], DependencyPinner);
+/** Looks for `node_modules/<name>` in `fromDir` and each folder above it, as Node does. */ async function findInstalledVersion(name, fromDir) {
+    let dir = _nodepath.default.resolve(fromDir);
+    for(;;){
+        const manifest = _nodepath.default.join(dir, "node_modules", name, "package.json");
+        if (await _io.io.fileExists(manifest)) {
+            const { version } = await _io.io.readJsonFile(manifest);
+            return version;
+        }
+        const parent = _nodepath.default.dirname(dir);
+        if (parent === dir) {
+            return undefined;
+        }
+        dir = parent;
+    }
+}

package/commonjs/src/packaging/deployable.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PACKAGE_DIR () {
+        return PACKAGE_DIR;
+    },
+    get deployable () {
+        return deployable;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _io = require("@decohere/nexus/io");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const PACKAGE_DIR = ".package";
+/**
+ * A deployable is a project with a Dockerfile: `docker.dockerfile` from `.decohere.js`,
+ * or `Dockerfile` in the project folder. `forge docker` and `forge package` share this
+ * rule so they always agree on which projects are deployables.
+ */ function dockerfileName(project) {
+    return project.dockerConfig?.dockerfile ?? "Dockerfile";
+}
+function dockerfilePath(project) {
+    return _nodepath.default.join(project.projectRoot, dockerfileName(project));
+}
+async function isDeployable(project) {
+    return await _io.io.fileExists(dockerfilePath(project));
+}
+const deployable = {
+    dockerfileName,
+    dockerfilePath,
+    isDeployable
+};

package/commonjs/src/packaging/import-graph.service.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ImportGraph", {
+    enumerable: true,
+    get: function() {
+        return ImportGraph;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _io = require("@decohere/nexus/io");
+const _scribe = require("@decohere/scribe");
+const _parseimports = require("parse-imports");
+const _const = require("../const.js");
+const _errors = require("../errors.js");
+const _releaseexports = require("./release-exports.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+const CODE_FILE = /\.(?:js|mjs|cjs)$/;
+class ImportGraph {
+    #logger = _scribe.scribe.logger(ImportGraph.name);
+    async walk(entry, projects) {
+        const reached = {
+            workspace: new Set([
+                entry.name
+            ]),
+            thirdParty: new Map()
+        };
+        const exportsByProject = new Map();
+        const seen = new Set();
+        const queue = [
+            {
+                file: _nodepath.default.join(entry.releaseDir, "es6", _releaseexports.releaseExports.toJs(entry.pkg.main ?? "src/index.ts")),
+                owner: entry
+            }
+        ];
+        while(queue.length > 0){
+            const { file, owner } = queue.pop();
+            if (seen.has(file)) {
+                continue;
+            }
+            seen.add(file);
+            for (const specifier of (await this.importsOf(file, owner))){
+                if (specifier.startsWith(".")) {
+                    queue.push({
+                        file: await this.resolveRelative(file, specifier, owner),
+                        owner
+                    });
+                } else if (!isBuiltin(specifier)) {
+                    this.follow(specifier, owner, projects, exportsByProject, reached, queue);
+                }
+            }
+        }
+        return reached;
+    }
+    follow(specifier, importer, projects, exportsByProject, reached, queue) {
+        const name = packageName(specifier);
+        const project = projects.get(name);
+        if (project == null) {
+            const owners = reached.thirdParty.get(name) ?? new Set();
+            owners.add(importer.name);
+            reached.thirdParty.set(name, owners);
+            return;
+        }
+        reached.workspace.add(name);
+        let exports1 = exportsByProject.get(name);
+        if (exports1 == null) {
+            exports1 = _releaseexports.releaseExports.build(project.pkg);
+            exportsByProject.set(name, exports1);
+        }
+        const subpath = specifier.slice(name.length);
+        const target = _releaseexports.releaseExports.resolve(exports1, subpath);
+        if (target == null) {
+            throw new _errors.ForgeError(`${importer.name} imports "${specifier}", but ${name} does not export "${subpath === "" ? "." : `.${subpath}`}".`);
+        }
+        queue.push({
+            file: _nodepath.default.join(project.releaseDir, target),
+            owner: project
+        });
+    }
+    async importsOf(file, owner) {
+        if (!await _io.io.fileExists(file)) {
+            throw new _errors.ForgeError(`${file} is imported by ${owner.name} but was not built. ` + "Run `forge build --configuration release` first.");
+        }
+        if (!CODE_FILE.test(file)) {
+            return [];
+        }
+        const code = await _io.io.readFile(file);
+        const specifiers = [];
+        try {
+            for (const entry of (await (0, _parseimports.parseImports)(code))){
+                if (entry.moduleSpecifier.value != null) {
+                    specifiers.push(entry.moduleSpecifier.value);
+                } else if (entry.isDynamicImport) {
+                    this.#logger.warn(`${file}: dynamic import of ${entry.moduleSpecifier.code} cannot be followed; ` + "whatever it loads is not packaged");
+                }
+            }
+        } catch (reason) {
+            throw new _errors.ForgeError(`Could not read the imports of ${file}: ${reason instanceof Error ? reason.message : String(reason)}`);
+        }
+        return specifiers;
+    }
+    /** Compiled output keeps explicit `.js` paths; tolerate extensionless and folder imports. */ async resolveRelative(importer, specifier, owner) {
+        const base = _nodepath.default.resolve(_nodepath.default.dirname(importer), specifier);
+        for (const candidate of [
+            base,
+            `${base}.js`,
+            _nodepath.default.join(base, "index.js")
+        ]){
+            if (await _io.io.fileExists(candidate)) {
+                return candidate;
+            }
+        }
+        throw new _errors.ForgeError(`${importer} (${owner.name}) imports "${specifier}", which was not built. ` + "Run `forge build --configuration release` first.");
+    }
+}
+ImportGraph = _ts_decorate([
+    (0, _decorators.injectable)()
+], ImportGraph);
+/** `@scope/pkg/deep/path` becomes `@scope/pkg`; `pkg/deep` becomes `pkg`. */ function packageName(specifier) {
+    const parts = specifier.split("/");
+    return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
+}
+function isBuiltin(specifier) {
+    return specifier.startsWith("node:") || _const.BUILT_IN_MODULES.includes(specifier) || _const.BUILT_IN_MODULES.includes(packageName(specifier));
+}

package/commonjs/src/packaging/release-exports.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "releaseExports", {
+    enumerable: true,
+    get: function() {
+        return releaseExports;
+    }
+});
+const ES6_PREFIX = "./es6/";
+/** Condition names that can point at runnable ESM, most specific first. `types` never does. */ const RUNTIME_CONDITIONS = [
+    "import",
+    "node",
+    "default"
+];
+/** `src/main.ts` becomes `src/main.js`, with any leading `./` dropped. */ function toJs(filePath) {
+    return filePath.replace(/^\.\//, "").replace(/\.ts$/, ".js").replace(/\.mts$/, ".mjs");
+}
+/**
+ * The `exports` a library needs once only its `es6/` output is shipped: the library's own
+ * map (or its `main`) with every path pointed at `./es6/...js`.
+ */ function build(pkg) {
+    const result = {};
+    for (const [subpath, target] of Object.entries(subpathMap(pkg.exports))){
+        const file = runtimeFile(target);
+        if (file != null) {
+            result[subpath] = file.startsWith(ES6_PREFIX) ? file : `${ES6_PREFIX}${toJs(file)}`;
+        }
+    }
+    if (Object.keys(result).length === 0) {
+        result["."] = `${ES6_PREFIX}${toJs(pkg.main ?? "src/index.ts")}`;
+    }
+    return result;
+}
+/** The file one subpath (`""` for the package root, `/testing`) points at, or undefined. */ function resolve(exports1, subpath) {
+    const key = subpath === "" ? "." : `.${subpath}`;
+    const exact = exports1[key];
+    if (exact != null) {
+        return exact;
+    }
+    for (const [pattern, target] of Object.entries(exports1)){
+        const star = pattern.indexOf("*");
+        if (star < 0) {
+            continue;
+        }
+        const prefix = pattern.slice(0, star);
+        const suffix = pattern.slice(star + 1);
+        if (key.startsWith(prefix) && key.endsWith(suffix) && key.length >= pattern.length - 1) {
+            return target.replaceAll("*", key.slice(prefix.length, key.length - suffix.length));
+        }
+    }
+    return undefined;
+}
+/** A bare path or a conditions object means "the root"; otherwise keys are subpaths. */ function subpathMap(exports1) {
+    if (exports1 == null) {
+        return {};
+    }
+    if (typeof exports1 === "string") {
+        return {
+            ".": exports1
+        };
+    }
+    const keys = Object.keys(exports1);
+    return keys.length > 0 && keys.every((key)=>key.startsWith(".")) ? exports1 : {
+        ".": exports1
+    };
+}
+function runtimeFile(target) {
+    if (typeof target === "string") {
+        return target;
+    }
+    if (target == null) {
+        return undefined;
+    }
+    for (const condition of RUNTIME_CONDITIONS){
+        const file = runtimeFile(target[condition]);
+        if (file != null) {
+            return file;
+        }
+    }
+    return undefined;
+}
+const releaseExports = {
+    build,
+    resolve,
+    toJs
+};

package/commonjs/src/packaging/ui-assets.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_UI_OUTPUT () {
+        return DEFAULT_UI_OUTPUT;
+    },
+    get DEFAULT_UI_TARGET () {
+        return DEFAULT_UI_TARGET;
+    },
+    get uiAssets () {
+        return uiAssets;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _io = require("@decohere/nexus/io");
+const _errors = require("../errors.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DEFAULT_UI_OUTPUT = "dist";
+const DEFAULT_UI_TARGET = "ui";
+/** Folders `forge package` writes itself; a UI cannot land on top of them. */ const RESERVED_TARGETS = new Set([
+    "es6",
+    "node_modules",
+    "config",
+    "package.json"
+]);
+/**
+ * What the deployable's `ui` declaration (`.decohere.js`) asks for, checked before anything
+ * is written: the UI project exists and has been built. Forge does not build it (see ADR 0007).
+ * Returns `undefined` when the deployable declares no UI.
+ */ async function resolve(deployable, projects) {
+    const ui = deployable.uiConfig;
+    if (ui == null) {
+        return undefined;
+    }
+    const to = _nodepath.default.normalize(ui.to ?? DEFAULT_UI_TARGET);
+    const output = ui.output ?? DEFAULT_UI_OUTPUT;
+    if (_nodepath.default.isAbsolute(to) || to.split(_nodepath.default.sep).includes("..") || to === ".") {
+        throw new _errors.ForgeError(`ui.to of ${deployable.name} must be a folder inside .package/, but is "${ui.to}".`);
+    }
+    if (RESERVED_TARGETS.has(to.split(_nodepath.default.sep)[0])) {
+        throw new _errors.ForgeError(`ui.to of ${deployable.name} is "${ui.to}", which forge package uses for something else.`);
+    }
+    const uiProject = projects.find((candidate)=>candidate.name === ui.project);
+    if (uiProject == null) {
+        throw new _errors.ForgeError(`${deployable.name} declares the UI project ${ui.project}, which is not a workspace project. ` + `Known projects: ${projects.map((p)=>p.name).join(", ")}`);
+    }
+    const root = _nodepath.default.resolve(uiProject.projectRoot);
+    const from = _nodepath.default.resolve(root, output);
+    if (!from.startsWith(root + _nodepath.default.sep)) {
+        throw new _errors.ForgeError(`ui.output of ${deployable.name} must stay inside ${ui.project}.`);
+    }
+    if (!await _io.io.directoryExists(from)) {
+        throw new _errors.ForgeError(`${deployable.name} declares the UI project ${ui.project}, but it has no build output at ${from}. ` + "Build the UI first (forge does not build it), or set ui.output if it builds somewhere else.");
+    }
+    return {
+        project: ui.project,
+        from,
+        to
+    };
+}
+const uiAssets = {
+    resolve
+};

package/commonjs/src/services/dependency-resolver.service.js

@@ -168,5 +168,3 @@ class DependencyResolver {
 DependencyResolver = _ts_decorate([
     (0, _decorators.injectable)()
 ], DependencyResolver);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/dependency-resolver.service.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project, Workspace } from \"@decohere/mesh\";\nimport { type FileEx, io } from \"@decohere/nexus/io\";\nimport { parseImports } from \"parse-imports\";\nimport { BUILT_IN_MODULES } from \"../const.js\";\nimport { ForgeError } from \"../errors.js\";\nimport type {\n\tDependencyWarning,\n\tDriftEntry,\n\tPackage,\n\tResolvedDependency,\n} from \"../types/dependency.types.js\";\n\nexport type ProjectDependencies = {\n\tproject: Project;\n\tupdatedPackage: PackageJson;\n\twarnings: DependencyWarning[];\n};\n\n@injectable()\nexport class DependencyResolver {\n\tpublic computeDrift(current: PackageJson, computed: PackageJson): DriftEntry | null {\n\t\tconst sortKeys = (obj: Record<string, string>) =>\n\t\t\tObject.fromEntries(Object.entries(obj).sort());\n\n\t\tconst currentDeps = sortKeys(current.dependencies ?? {});\n\t\tconst computedDeps = sortKeys(computed.dependencies ?? {});\n\t\tconst currentDevDeps = sortKeys(current.devDependencies ?? {});\n\t\tconst computedDevDeps = sortKeys(computed.devDependencies ?? {});\n\n\t\tconst hasDrift =\n\t\t\tJSON.stringify(currentDeps) !== JSON.stringify(computedDeps) ||\n\t\t\tJSON.stringify(currentDevDeps) !== JSON.stringify(computedDevDeps);\n\n\t\tif (!hasDrift) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn {\n\t\t\toriginal: { dependencies: currentDeps, devDependencies: currentDevDeps },\n\t\t\tupdated: { dependencies: computedDeps, devDependencies: computedDevDeps },\n\t\t};\n\t}\n\n\tpublic async getWorkspacePackages(\n\t\tworkspace: Workspace,\n\t\tprojects: readonly Project[],\n\t): Promise<Map<string, Package>> {\n\t\tconst packageJson = await workspace.getPackageJson().catch(() => {\n\t\t\tthrow new Error(\n\t\t\t\t`Root package.json not found at \"${workspace.packageJsonDirectory}/package.json\". ` +\n\t\t\t\t\t`Ensure the workspace root has a package.json with dependencies listed.`,\n\t\t\t);\n\t\t});\n\n\t\tconst internals = new Map(\n\t\t\tawait Promise.all(\n\t\t\t\tprojects.map(async (proj): Promise<[string, Package]> => {\n\t\t\t\t\tconst packageJson = await proj.getPackageJson();\n\t\t\t\t\treturn [\n\t\t\t\t\t\tpackageJson.name,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: packageJson.name,\n\t\t\t\t\t\t\tversion: packageJson.version,\n\t\t\t\t\t\t\tisInternal: true,\n\t\t\t\t\t\t},\n\t\t\t\t\t];\n\t\t\t\t}),\n\t\t\t),\n\t\t);\n\n\t\tconst packages = Object.entries(packageJson.dependencies)\n\t\t\t.filter(([key]) => !internals.has(key))\n\t\t\t.map<[string, Package]>(([key, val]) => [key, { name: key, version: val }]);\n\n\t\tconst devPackages = Object.entries(packageJson.devDependencies)\n\t\t\t.filter(([key]) => !internals.has(key))\n\t\t\t.map<[string, Package]>(([key, val]) => [key, { name: key, version: val, isDev: true }]);\n\n\t\treturn new Map([...packages, ...devPackages, ...internals]);\n\t}\n\n\tpublic async computeProjectDependencies(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<ProjectDependencies> {\n\t\tconst { dependencies, devDependencies, warnings } = await this.getDependencies(\n\t\t\tproject,\n\t\t\tworkspacePackages,\n\t\t);\n\n\t\tconst pkg = await project.getPackageJson();\n\t\tconst updatedPackage = pkg\n\t\t\t.withDependencies(dependencies)\n\t\t\t.withDevDependencies(devDependencies);\n\n\t\treturn { project, updatedPackage, warnings };\n\t}\n\n\tprivate async getDependencies(project: Project, workspacePackages: Map<string, Package>) {\n\t\tconst files = await project.getAllFiles();\n\t\tconst results = await Promise.all(files.map((file) => this.getFileImports(file)));\n\t\tconst imports = results.flatMap((r) => r.imports);\n\t\tconst warnings = results.flatMap((r) => r.warnings);\n\n\t\tconst allDependencies = [...new Set(imports)]\n\t\t\t.map((fileImport) => this.getDependencyFrom(fileImport, workspacePackages))\n\t\t\t.filter((dep) => dep != null);\n\n\t\tconst missing = allDependencies.filter(\n\t\t\t(dep): dep is ResolvedDependency & { missing: true } => dep.missing,\n\t\t);\n\n\t\tif (missing.length > 0) {\n\t\t\tconst names = missing.map((dep) => dep.name).join(\", \");\n\t\t\tthrow new ForgeError(`Missing packages in project \"${project.name}\": ${names}`);\n\t\t}\n\n\t\tconst resolved = allDependencies.filter(\n\t\t\t(dep): dep is ResolvedDependency & { missing: false } => !dep.missing,\n\t\t);\n\n\t\tconst dependencies = Object.fromEntries(\n\t\t\tresolved\n\t\t\t\t.filter((dep) => !dep.isDev)\n\t\t\t\t.map<[string, string]>((dep) => [dep.name, dep.version]),\n\t\t);\n\n\t\tconst devDependencies = Object.fromEntries(\n\t\t\tresolved\n\t\t\t\t.filter((dep) => dep.isDev)\n\t\t\t\t.map<[string, string]>((dep) => [dep.name, dep.version]),\n\t\t);\n\n\t\treturn { dependencies, devDependencies, warnings };\n\t}\n\n\tprivate getDependencyFrom(\n\t\timportName: string,\n\t\tworkspacePackages: Map<string, Package>,\n\t): ResolvedDependency | undefined {\n\t\tif (importName.startsWith(\".\") || importName.startsWith(\"node:\")) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst packageNameMatch = importName.match(/^(?:(@[^/]+\\/[^/]+)|([^/]+))/);\n\t\tconst packageName = packageNameMatch?.[0];\n\n\t\tif (packageName == null || BUILT_IN_MODULES.includes(packageName)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst packg = workspacePackages.get(packageName);\n\n\t\tif (packg == null) {\n\t\t\treturn {\n\t\t\t\tname: packageName,\n\t\t\t\tversion: undefined,\n\t\t\t\tinternal: undefined,\n\t\t\t\tmissing: true,\n\t\t\t\tisDev: false,\n\t\t\t};\n\t\t}\n\n\t\treturn {\n\t\t\tname: packageName,\n\t\t\tversion: packg.version ?? \"\",\n\t\t\tinternal: packg.isInternal ?? false,\n\t\t\tmissing: false,\n\t\t\tisDev: packg.isDev ?? false,\n\t\t};\n\t}\n\n\tprivate async getFileImports(\n\t\tfile: FileEx,\n\t): Promise<{ imports: string[]; warnings: DependencyWarning[] }> {\n\t\tconst contents = await io.readFile(file.fullPath);\n\t\tconst parsed = Array.from(await parseImports(contents));\n\n\t\tconst imports: string[] = [];\n\t\tconst warnings: DependencyWarning[] = [];\n\n\t\tfor (const impt of parsed) {\n\t\t\tif (impt.moduleSpecifier.value != null) {\n\t\t\t\timports.push(impt.moduleSpecifier.value);\n\t\t\t} else if (impt.isDynamicImport) {\n\t\t\t\tconst line = contents.substring(0, impt.startIndex).split(\"\\n\").length;\n\t\t\t\twarnings.push({\n\t\t\t\t\tfile: file.fullPath,\n\t\t\t\t\tline,\n\t\t\t\t\tmessage: `Dynamic import with non-literal specifier \\`${impt.moduleSpecifier.code}\\` cannot be statically resolved`,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn { imports, warnings };\n\t}\n}\n"],"names":["DependencyResolver","computeDrift","current","computed","sortKeys","obj","Object","fromEntries","entries","sort","currentDeps","dependencies","computedDeps","currentDevDeps","devDependencies","computedDevDeps","hasDrift","JSON","stringify","original","updated","getWorkspacePackages","workspace","projects","packageJson","getPackageJson","catch","Error","packageJsonDirectory","internals","Map","Promise","all","map","proj","name","version","isInternal","packages","filter","key","has","val","devPackages","isDev","computeProjectDependencies","project","workspacePackages","warnings","getDependencies","pkg","updatedPackage","withDependencies","withDevDependencies","files","getAllFiles","results","file","getFileImports","imports","flatMap","r","allDependencies","Set","fileImport","getDependencyFrom","dep","missing","length","names","join","ForgeError","resolved","importName","startsWith","packageNameMatch","match","packageName","BUILT_IN_MODULES","includes","packg","get","undefined","internal","contents","io","readFile","fullPath","parsed","Array","from","parseImports","impt","moduleSpecifier","value","push","isDynamicImport","line","substring","startIndex","split","message","code"],"mappings":"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"}

package/commonjs/src/services/file-writer.service.js

@@ -228,5 +228,3 @@ FileWriterService = _ts_decorate([
     _diagnostics.Trace,
     (0, _decorators.injectable)()
 ], FileWriterService);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/file-writer.service.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport { io } from \"@decohere/nexus/io\";\nimport \"../extensions/project.extensions.js\";\nimport type { BuildTarget } from \"../types/build-target.type.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\n\nconst DEFAULT_WRITE_CONCURRENCY = 16;\n\n@Trace\n@injectable()\nexport class FileWriterService {\n\t#artifactByPath = new Map<string, string>();\n\t#warmupSignature = \"\";\n\t#warmupPromise: Promise<void> | undefined;\n\t#initialized = false;\n\t#pendingWrites: TransformResponse[] = [];\n\t#activeWorkers = 0;\n\t#drainResolvers: Array<() => void> = [];\n\t#ensuredDirs = new Set<string>();\n\t#ensureDirPromises = new Map<string, Promise<void>>();\n\t#workerError: unknown;\n\n\tpublic async initialize(): Promise<void> {\n\t\tif (this.#initialized) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#initialized = true;\n\t}\n\n\tpublic async warmup(projects: Project[]): Promise<void> {\n\t\tconst outputDirs = this.getOutputDirs(projects);\n\t\tconst signature = outputDirs.join(\"|\");\n\t\tif (signature === this.#warmupSignature && this.#warmupPromise != null) {\n\t\t\treturn this.#warmupPromise;\n\t\t}\n\n\t\tthis.#warmupSignature = signature;\n\t\tthis.#ensuredDirs.clear();\n\t\tthis.#ensureDirPromises.clear();\n\t\tthis.#workerError = undefined;\n\t\tthis.#warmupPromise = this.loadExistingArtifacts(outputDirs);\n\t\treturn this.#warmupPromise;\n\t}\n\n\tpublic enqueueOutput(response: TransformResponse): void {\n\t\tif (this.#workerError != null) {\n\t\t\treturn;\n\t\t}\n\t\tif (response.outcome !== \"success\" || response.outputPath == null) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#pendingWrites.push(response);\n\t\tthis.startWorkers();\n\t}\n\n\tpublic enqueueOutputs(responses: TransformResponse[]): void {\n\t\tfor (const response of responses) {\n\t\t\tthis.enqueueOutput(response);\n\t\t}\n\t}\n\n\tpublic async flush(): Promise<void> {\n\t\tif (this.#warmupPromise != null) {\n\t\t\tawait this.#warmupPromise;\n\t\t}\n\t\tif (this.#pendingWrites.length === 0 && this.#activeWorkers === 0) {\n\t\t\treturn;\n\t\t}\n\t\tawait new Promise<void>((resolve) => {\n\t\t\tthis.#drainResolvers.push(resolve);\n\t\t});\n\t\tif (this.#workerError != null) {\n\t\t\tthrow this.#workerError;\n\t\t}\n\t}\n\n\tprivate getOutputDirs(projects: Project[]): string[] {\n\t\tconst dirs = new Set<string>();\n\t\tfor (const project of projects) {\n\t\t\tfor (const target of project.getForgeConfiguration().targets) {\n\t\t\t\tdirs.add(project.getOutDir(target as BuildTarget));\n\t\t\t}\n\t\t}\n\t\treturn [...dirs].sort();\n\t}\n\n\tprivate async loadExistingArtifacts(outputDirs: string[]): Promise<void> {\n\t\tthis.#artifactByPath.clear();\n\n\t\tconst files: string[] = [];\n\t\tfor (const dir of outputDirs) {\n\t\t\tfiles.push(...(await this.collectFiles(dir)));\n\t\t}\n\n\t\tawait this.withConcurrency(files, this.getWriteConcurrency(), async (filePath) => {\n\t\t\tconst content = await fs.readFile(filePath, \"utf8\");\n\t\t\tthis.#artifactByPath.set(filePath, content);\n\t\t});\n\t}\n\n\tprivate async collectFiles(rootDir: string): Promise<string[]> {\n\t\ttry {\n\t\t\tconst entries = await fs.readdir(rootDir, { withFileTypes: true });\n\t\t\tconst files: string[] = [];\n\t\t\tfor (const entry of entries) {\n\t\t\t\tconst fullPath = `${rootDir}/${entry.name}`;\n\t\t\t\tif (entry.isDirectory()) {\n\t\t\t\t\tfiles.push(...(await this.collectFiles(fullPath)));\n\t\t\t\t} else if (entry.isFile()) {\n\t\t\t\t\tfiles.push(fullPath);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn files;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\tprivate getWriteConcurrency(): number {\n\t\tconst requested = Number(process.env.FORGE_WRITE_CONCURRENCY);\n\t\tif (Number.isFinite(requested) && requested > 0) {\n\t\t\treturn Math.floor(requested);\n\t\t}\n\t\treturn DEFAULT_WRITE_CONCURRENCY;\n\t}\n\n\tprivate startWorkers(): void {\n\t\tif (this.#workerError != null) {\n\t\t\treturn;\n\t\t}\n\t\tconst maxWorkers = this.getWriteConcurrency();\n\t\twhile (this.#activeWorkers < maxWorkers && this.#pendingWrites.length > 0) {\n\t\t\tthis.#activeWorkers += 1;\n\t\t\tvoid this.runWorker().finally(() => {\n\t\t\t\tthis.#activeWorkers -= 1;\n\t\t\t\tif (this.#pendingWrites.length > 0) {\n\t\t\t\t\tthis.startWorkers();\n\t\t\t\t} else if (this.#activeWorkers === 0) {\n\t\t\t\t\tthis.resolveDrain();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate async runWorker(): Promise<void> {\n\t\twhile (true) {\n\t\t\tconst response = this.#pendingWrites.shift();\n\t\t\tif (response == null) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tif (this.#warmupPromise != null) {\n\t\t\t\t\tawait this.#warmupPromise;\n\t\t\t\t}\n\n\t\t\t\tconst outputPath = response.outputPath;\n\t\t\t\tif (outputPath == null) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst outputDir = response.outputDir;\n\t\t\t\tif (outputDir != null) {\n\t\t\t\t\tawait this.ensureDirectory(outputDir);\n\t\t\t\t}\n\n\t\t\t\tconst existing = this.#artifactByPath.get(outputPath);\n\t\t\t\tif (existing === response.code) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tawait io.writeFile(outputPath, response.code);\n\t\t\t\tthis.#artifactByPath.set(outputPath, response.code);\n\t\t\t} catch (error) {\n\t\t\t\tthis.#workerError = error;\n\t\t\t\tthis.#pendingWrites = [];\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate ensureDirectory(dir: string): Promise<void> {\n\t\tif (this.#ensuredDirs.has(dir)) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t\tconst existing = this.#ensureDirPromises.get(dir);\n\t\tif (existing != null) {\n\t\t\treturn existing;\n\t\t}\n\t\tconst mkdirPromise = fs.mkdir(dir, { recursive: true }).then(() => {\n\t\t\tthis.#ensuredDirs.add(dir);\n\t\t\tthis.#ensureDirPromises.delete(dir);\n\t\t});\n\t\tthis.#ensureDirPromises.set(dir, mkdirPromise);\n\t\treturn mkdirPromise;\n\t}\n\n\tprivate resolveDrain(): void {\n\t\tif (this.#pendingWrites.length > 0 || this.#activeWorkers > 0) {\n\t\t\treturn;\n\t\t}\n\t\tfor (const resolve of this.#drainResolvers) {\n\t\t\tresolve();\n\t\t}\n\t\tthis.#drainResolvers = [];\n\t}\n\n\tprivate async withConcurrency<T>(\n\t\titems: T[],\n\t\tconcurrency: number,\n\t\tworker: (item: T) => Promise<void>,\n\t): Promise<void> {\n\t\tlet cursor = 0;\n\t\tconst workerCount = Math.min(concurrency, items.length);\n\t\tconst workers = Array.from({ length: workerCount }, () =>\n\t\t\t(async () => {\n\t\t\t\twhile (true) {\n\t\t\t\t\tconst index = cursor;\n\t\t\t\t\tcursor += 1;\n\t\t\t\t\tif (index >= items.length) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tawait worker(items[index]);\n\t\t\t\t}\n\t\t\t})(),\n\t\t);\n\t\tawait Promise.all(workers);\n\t}\n}\n"],"names":["FileWriterService","DEFAULT_WRITE_CONCURRENCY","Map","Set","initialize","warmup","projects","outputDirs","getOutputDirs","signature","join","clear","undefined","loadExistingArtifacts","enqueueOutput","response","outcome","outputPath","push","startWorkers","enqueueOutputs","responses","flush","length","Promise","resolve","dirs","project","target","getForgeConfiguration","targets","add","getOutDir","sort","files","dir","collectFiles","withConcurrency","getWriteConcurrency","filePath","content","fs","readFile","set","rootDir","entries","readdir","withFileTypes","entry","fullPath","name","isDirectory","isFile","requested","Number","process","env","FORGE_WRITE_CONCURRENCY","isFinite","Math","floor","maxWorkers","runWorker","finally","resolveDrain","shift","outputDir","ensureDirectory","existing","get","code","io","writeFile","error","has","mkdirPromise","mkdir","recursive","then","delete","items","concurrency","worker","cursor","workerCount","min","workers","Array","from","index","all"],"mappings":"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"}