@decohere/forge 0.0.1-dev.5

package/commonjs/src/forge.module.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ForgeModule", {
+    enumerable: true,
+    get: function() {
+        return ForgeModule;
+    }
+});
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _index = /*#__PURE__*/ _interop_require_wildcard(require("./actions/index.js"));
+const _index1 = /*#__PURE__*/ _interop_require_wildcard(require("./commands/index.js"));
+const _dependencyresolverservice = require("./services/dependency-resolver.service.js");
+const _filewriterservice = require("./services/file-writer.service.js");
+const _swctranspiler = require("./services/swc-transpiler.js");
+const _typeemitter = require("./services/type-emitter.js");
+const _transformertype = require("./types/transformer.type.js");
+const _workspaceconfig = require("./workspace.config.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class ForgeModule extends _cli.ModuleManifest {
+    id = "forge";
+    command = _index1.ForgeCommand;
+    actions = {
+        clean: _index.Clean,
+        copy: _index.Copy,
+        build: _index.Build,
+        watch: _index.Watch,
+        publish: _index.Publish,
+        syncDependencies: _index.SyncDependencies,
+        syncLockFile: _index.SyncLockFile,
+        reportDependencies: _index.ReportDependencies,
+        version: _index.Version,
+        tag: _index.Tag,
+        commitFiles: _index.CommitFiles
+    };
+    commands = {
+        build: _index1.BuildCommand,
+        publish: _index1.PublishCommand,
+        dependencies: _index1.DependencyCommand,
+        version: _index1.VersionCommand,
+        tag: _index1.TagCommand
+    };
+    registerServices(builder) {
+        builder.registerSingleton(_transformertype.TransformerKey, _swctranspiler.SwcTranspiler);
+        builder.registerSingleton(_transformertype.TransformerKey, _typeemitter.TypeEmitter);
+        builder.registerSingleton(_dependencyresolverservice.DependencyResolver);
+        builder.registerSingleton(_filewriterservice.FileWriterService);
+    }
+    async createWorkspace(options) {
+        const { configurations: _, ...forgeDefaults } = _workspaceconfig.WorkspaceDefaults;
+        const userConfig = await _mesh.UserConfigFactory.getUserConfig(options.configFile);
+        // Only apply forge default configurations when user config doesn't provide any.
+        // This ensures user-defined configurations take priority while still providing
+        // sensible defaults (debug + release) when no config file is present.
+        const configurations = userConfig.configurations?.length ? undefined : _workspaceconfig.DefaultConfigurations;
+        return _mesh.WorkspaceFactory.create({
+            ...forgeDefaults,
+            ...configurations ? {
+                configurations
+            } : {},
+            configFile: options.configFile,
+            rootDir: options.rootDir ?? _workspaceconfig.WorkspaceDefaults.rootDir
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/index.js

@@ -0,0 +1,22 @@
+"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 ForgeError () {
+        return _errors.ForgeError;
+    },
+    get ForgeModule () {
+        return _forgemodule.ForgeModule;
+    }
+});
+const _errors = require("./errors.js");
+const _forgemodule = require("./forge.module.js");
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEZvcmdlRXJyb3IgfSBmcm9tIFwiLi9lcnJvcnMuanNcIjtcbmV4cG9ydCB7IEZvcmdlTW9kdWxlIH0gZnJvbSBcIi4vZm9yZ2UubW9kdWxlLmpzXCI7XG5leHBvcnQgdHlwZSB7IEZvcmdlQ29uZmlndXJhdGlvbiB9IGZyb20gXCIuL3R5cGVzL2NvbmZpZ3VyYXRpb24udHlwZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBXb3Jrc3BhY2VPcHRpb25zIH0gZnJvbSBcIi4vdHlwZXMvd29ya3NwYWNlLWNvbmZpZy50eXBlLmpzXCI7XG4iXSwibmFtZXMiOlsiRm9yZ2VFcnJvciIsIkZvcmdlTW9kdWxlIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztRQUFTQTtlQUFBQSxrQkFBVTs7UUFDVkM7ZUFBQUEsd0JBQVc7Ozt3QkFETzs2QkFDQyJ9

package/commonjs/src/mixins/caches-outputs.mixin.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CachesOutputs", {
+    enumerable: true,
+    get: function() {
+        return CachesOutputs;
+    }
+});
+const _io = require("@decohere/nexus/io");
+class CachesOutputs {
+    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */ get outputCache() {
+        const self = this;
+        if (self.__outputCache == null) {
+            self.__outputCache = new Map();
+        }
+        return self.__outputCache;
+    }
+    cacheOutputs(responses) {
+        for (const response of responses){
+            if (response.outcome !== "success") continue;
+            const existing = this.outputCache.get(response.file.fullPath) ?? [];
+            this.outputCache.set(response.file.fullPath, [
+                ...existing,
+                response
+            ]);
+        }
+    }
+    deleteCachedOutputs(filePath) {
+        const outputs = this.outputCache.get(filePath);
+        if (outputs == null) return;
+        for (const response of outputs){
+            if (response.outputPath != null) {
+                void _io.io.deleteFile(response.outputPath);
+            }
+        }
+        this.outputCache.delete(filePath);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/mixins/incremental-transform.mixin.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IncrementalTransform", {
+    enumerable: true,
+    get: function() {
+        return IncrementalTransform;
+    }
+});
+const _rxjs = require("rxjs");
+// WeakMap avoids the private-field-in-mixin problem: private class fields (#x)
+// are not accessible when methods are copied onto a different class prototype.
+const subjects = new WeakMap();
+function getSubject(instance) {
+    let subject = subjects.get(instance);
+    if (subject == null) {
+        subject = new _rxjs.Subject();
+        subjects.set(instance, subject);
+    }
+    return subject;
+}
+class IncrementalTransform {
+    get incrementalTransform$() {
+        return getSubject(this).asObservable();
+    }
+    watch(workspace) {
+        workspace.projectFileChanged$.subscribe((evt)=>{
+            void this.onIncrementalFileEvent(evt).then((responses)=>{
+                getSubject(this).next(responses);
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DependencyResolver", {
+    enumerable: true,
+    get: function() {
+        return DependencyResolver;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _io = require("@decohere/nexus/io");
+const _parseimports = require("parse-imports");
+const _const = require("../const.js");
+const _errors = require("../errors.js");
+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 DependencyResolver {
+    computeDrift(current, computed) {
+        const sortKeys = (obj)=>Object.fromEntries(Object.entries(obj).sort());
+        const currentDeps = sortKeys(current.dependencies ?? {});
+        const computedDeps = sortKeys(computed.dependencies ?? {});
+        const currentDevDeps = sortKeys(current.devDependencies ?? {});
+        const computedDevDeps = sortKeys(computed.devDependencies ?? {});
+        const hasDrift = JSON.stringify(currentDeps) !== JSON.stringify(computedDeps) || JSON.stringify(currentDevDeps) !== JSON.stringify(computedDevDeps);
+        if (!hasDrift) {
+            return null;
+        }
+        return {
+            original: {
+                dependencies: currentDeps,
+                devDependencies: currentDevDeps
+            },
+            updated: {
+                dependencies: computedDeps,
+                devDependencies: computedDevDeps
+            }
+        };
+    }
+    async getWorkspacePackages(workspace, projects) {
+        const packageJson = await workspace.getPackageJson().catch(()=>{
+            throw new Error(`Root package.json not found at "${workspace.packageJsonDirectory}/package.json". ` + `Ensure the workspace root has a package.json with dependencies listed.`);
+        });
+        const internals = new Map(await Promise.all(projects.map(async (proj)=>{
+            const packageJson = await proj.getPackageJson();
+            return [
+                packageJson.name,
+                {
+                    name: packageJson.name,
+                    version: packageJson.version,
+                    isInternal: true
+                }
+            ];
+        })));
+        const packages = Object.entries(packageJson.dependencies).filter(([key])=>!internals.has(key)).map(([key, val])=>[
+                key,
+                {
+                    name: key,
+                    version: val
+                }
+            ]);
+        const devPackages = Object.entries(packageJson.devDependencies).filter(([key])=>!internals.has(key)).map(([key, val])=>[
+                key,
+                {
+                    name: key,
+                    version: val,
+                    isDev: true
+                }
+            ]);
+        return new Map([
+            ...packages,
+            ...devPackages,
+            ...internals
+        ]);
+    }
+    async computeProjectDependencies(project, workspacePackages) {
+        const { dependencies, devDependencies, warnings } = await this.getDependencies(project, workspacePackages);
+        const pkg = await project.getPackageJson();
+        const updatedPackage = pkg.withDependencies(dependencies).withDevDependencies(devDependencies);
+        return {
+            project,
+            updatedPackage,
+            warnings
+        };
+    }
+    async getDependencies(project, workspacePackages) {
+        const files = await project.getAllFiles();
+        const results = await Promise.all(files.map((file)=>this.getFileImports(file)));
+        const imports = results.flatMap((r)=>r.imports);
+        const warnings = results.flatMap((r)=>r.warnings);
+        const allDependencies = [
+            ...new Set(imports)
+        ].map((fileImport)=>this.getDependencyFrom(fileImport, workspacePackages)).filter((dep)=>dep != null);
+        const missing = allDependencies.filter((dep)=>dep.missing);
+        if (missing.length > 0) {
+            const names = missing.map((dep)=>dep.name).join(", ");
+            throw new _errors.ForgeError(`Missing packages in project "${project.name}": ${names}`);
+        }
+        const resolved = allDependencies.filter((dep)=>!dep.missing);
+        const dependencies = Object.fromEntries(resolved.filter((dep)=>!dep.isDev).map((dep)=>[
+                dep.name,
+                dep.version
+            ]));
+        const devDependencies = Object.fromEntries(resolved.filter((dep)=>dep.isDev).map((dep)=>[
+                dep.name,
+                dep.version
+            ]));
+        return {
+            dependencies,
+            devDependencies,
+            warnings
+        };
+    }
+    getDependencyFrom(importName, workspacePackages) {
+        if (importName.startsWith(".") || importName.startsWith("node:")) {
+            return;
+        }
+        const packageNameMatch = importName.match(/^(?:(@[^/]+\/[^/]+)|([^/]+))/);
+        const packageName = packageNameMatch?.[0];
+        if (packageName == null || _const.BUILT_IN_MODULES.includes(packageName)) {
+            return;
+        }
+        const packg = workspacePackages.get(packageName);
+        if (packg == null) {
+            return {
+                name: packageName,
+                version: undefined,
+                internal: undefined,
+                missing: true,
+                isDev: false
+            };
+        }
+        return {
+            name: packageName,
+            version: packg.version ?? "",
+            internal: packg.isInternal ?? false,
+            missing: false,
+            isDev: packg.isDev ?? false
+        };
+    }
+    async getFileImports(file) {
+        const contents = await _io.io.readFile(file.fullPath);
+        const parsed = Array.from(await (0, _parseimports.parseImports)(contents));
+        const imports = [];
+        const warnings = [];
+        for (const impt of parsed){
+            if (impt.moduleSpecifier.value != null) {
+                imports.push(impt.moduleSpecifier.value);
+            } else if (impt.isDynamicImport) {
+                const line = contents.substring(0, impt.startIndex).split("\n").length;
+                warnings.push({
+                    file: file.fullPath,
+                    line,
+                    message: `Dynamic import with non-literal specifier \`${impt.moduleSpecifier.code}\` cannot be statically resolved`
+                });
+            }
+        }
+        return {
+            imports,
+            warnings
+        };
+    }
+}
+DependencyResolver = _ts_decorate([
+    (0, _decorators.injectable)()
+], DependencyResolver);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/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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"}