@decohere/forge 0.0.1-dev.5

package/es6/src/extensions/project.extensions.js

@@ -0,0 +1,51 @@
+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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import path from "node:path";
+import { Project } from "@decohere/mesh";
+import { memoize } from "@decohere/nexus/caching";
+import { extension } from "@decohere/nexus/extensibility";
+import { io } from "@decohere/nexus/io";
+import { SWC_CONFIG } from "../const.js";
+import { SwcConfig } from "../types/swc-config.type.js";
+export class ProjectExtensions {
+    static getForgeConfiguration(project) {
+        return project.configuration;
+    }
+    static async getSwcConfig(project) {
+        const projectConfigPath = path.join(project.projectDirectory, SWC_CONFIG);
+        if (await io.fileExists(projectConfigPath)) {
+            return new SwcConfig(await io.readJsonFile(projectConfigPath));
+        }
+        const rootConfigPath = path.join(project.rootDir, SWC_CONFIG);
+        if (await io.fileExists(rootConfigPath)) {
+            return new SwcConfig(await io.readJsonFile(rootConfigPath));
+        }
+        return new SwcConfig();
+    }
+}
+_ts_decorate([
+    extension(Project),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Project === "undefined" ? Object : Project
+    ]),
+    _ts_metadata("design:returntype", typeof ForgeConfiguration === "undefined" ? Object : ForgeConfiguration)
+], ProjectExtensions, "getForgeConfiguration", null);
+_ts_decorate([
+    extension(Project),
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Project === "undefined" ? Object : Project
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ProjectExtensions, "getSwcConfig", null);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/factories/swc-config.factory.js

@@ -0,0 +1,83 @@
+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;
+}
+import path from "node:path";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { merge } from "@decohere/nexus/objects";
+import { ForgeError } from "../errors.js";
+const defaultOptions = {
+    jsc: {
+        parser: {
+            syntax: "typescript",
+            decorators: true
+        },
+        target: "esnext",
+        transform: {
+            decoratorMetadata: true
+        },
+        experimental: {
+            keepImportAttributes: true
+        }
+    },
+    module: {
+        resolveFully: true
+    },
+    sourceMaps: "inline"
+};
+export class SwcConfigFactory {
+    /**
+	 * Creates a base config for a project+target combination, without a filename.
+	 * Call once per (project, target) and then use createFileConfig() per file.
+	 */ createBaseConfig(buildTarget, configOptions) {
+        const { userConfig, tsConfig, aliasPaths } = configOptions;
+        const { compilerOptions } = tsConfig ?? {};
+        const paths = aliasPaths ? compilerOptions?.paths : undefined;
+        const baseUrl = SwcConfigFactory.getBaseUrl(tsConfig) ?? (paths != null ? path.resolve(".") : undefined);
+        const options = {
+            jsc: {
+                baseUrl,
+                paths
+            },
+            module: {
+                type: buildTarget
+            }
+        };
+        return merge.withOptions({
+            mergeArrays: false
+        }, defaultOptions, options, userConfig ?? {});
+    }
+    /** Stamps a per-file filename onto a pre-built base config. */ createFileConfig(file, baseConfig) {
+        const config = {
+            ...baseConfig,
+            filename: file.fullPath
+        };
+        this.validate(config);
+        return config;
+    }
+    /**
+	 * Validates SWC options against known causes of Rust/NAPI process crashes.
+	 * Throws a ForgeError with a descriptive message instead of letting the
+	 * NAPI layer abort the process.
+	 *
+	 * Known crash causes:
+	 * - `jsc.baseUrl` set to a relative path (SWC requires an absolute path)
+	 */ validate(options) {
+        const baseUrl = options.jsc?.baseUrl;
+        if (baseUrl != null && !path.isAbsolute(baseUrl)) {
+            throw new ForgeError(`SWC config: jsc.baseUrl must be an absolute path to avoid a process crash, got: "${baseUrl}". Use path.resolve() to convert it.`);
+        }
+    }
+    /** Resolves tsconfig baseUrl to an absolute path. Returns undefined if not set. */ static getBaseUrl(tsConfig) {
+        const baseUrl = tsConfig?.compilerOptions?.baseUrl;
+        if (baseUrl == null) return undefined;
+        return path.resolve(baseUrl);
+    }
+}
+SwcConfigFactory = _ts_decorate([
+    Trace
+], SwcConfigFactory);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/forge.module.js

@@ -0,0 +1,58 @@
+import { UserConfigFactory, WorkspaceFactory } from "@decohere/mesh";
+import { ModuleManifest } from "@decohere/nexus/cli";
+import * as Actions from "./actions/index.js";
+import * as Commands from "./commands/index.js";
+import { DependencyResolver } from "./services/dependency-resolver.service.js";
+import { FileWriterService } from "./services/file-writer.service.js";
+import { SwcTranspiler } from "./services/swc-transpiler.js";
+import { TypeEmitter } from "./services/type-emitter.js";
+import { TransformerKey } from "./types/transformer.type.js";
+import { DefaultConfigurations, WorkspaceDefaults } from "./workspace.config.js";
+export class ForgeModule extends ModuleManifest {
+    id = "forge";
+    command = Commands.ForgeCommand;
+    actions = {
+        clean: Actions.Clean,
+        copy: Actions.Copy,
+        build: Actions.Build,
+        watch: Actions.Watch,
+        publish: Actions.Publish,
+        syncDependencies: Actions.SyncDependencies,
+        syncLockFile: Actions.SyncLockFile,
+        reportDependencies: Actions.ReportDependencies,
+        version: Actions.Version,
+        tag: Actions.Tag,
+        commitFiles: Actions.CommitFiles
+    };
+    commands = {
+        build: Commands.BuildCommand,
+        publish: Commands.PublishCommand,
+        dependencies: Commands.DependencyCommand,
+        version: Commands.VersionCommand,
+        tag: Commands.TagCommand
+    };
+    registerServices(builder) {
+        builder.registerSingleton(TransformerKey, SwcTranspiler);
+        builder.registerSingleton(TransformerKey, TypeEmitter);
+        builder.registerSingleton(DependencyResolver);
+        builder.registerSingleton(FileWriterService);
+    }
+    async createWorkspace(options) {
+        const { configurations: _, ...forgeDefaults } = WorkspaceDefaults;
+        const userConfig = await 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 : DefaultConfigurations;
+        return WorkspaceFactory.create({
+            ...forgeDefaults,
+            ...configurations ? {
+                configurations
+            } : {},
+            configFile: options.configFile,
+            rootDir: options.rootDir ?? WorkspaceDefaults.rootDir
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2ZvcmdlLm1vZHVsZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVc2VyQ29uZmlnRmFjdG9yeSwgV29ya3NwYWNlRmFjdG9yeSB9IGZyb20gXCJAZGVjb2hlcmUvbWVzaFwiO1xuaW1wb3J0IHR5cGUgeyBXb3Jrc3BhY2VGYWN0b3J5T3B0aW9ucyB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBNb2R1bGVNYW5pZmVzdCB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgdHlwZSB7IENvbnRhaW5lckJ1aWxkZXIgfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2NvbXBvc2l0aW9uXCI7XG5pbXBvcnQgKiBhcyBBY3Rpb25zIGZyb20gXCIuL2FjdGlvbnMvaW5kZXguanNcIjtcbmltcG9ydCAqIGFzIENvbW1hbmRzIGZyb20gXCIuL2NvbW1hbmRzL2luZGV4LmpzXCI7XG5pbXBvcnQgeyBEZXBlbmRlbmN5UmVzb2x2ZXIgfSBmcm9tIFwiLi9zZXJ2aWNlcy9kZXBlbmRlbmN5LXJlc29sdmVyLnNlcnZpY2UuanNcIjtcbmltcG9ydCB7IEZpbGVXcml0ZXJTZXJ2aWNlIH0gZnJvbSBcIi4vc2VydmljZXMvZmlsZS13cml0ZXIuc2VydmljZS5qc1wiO1xuaW1wb3J0IHsgU3djVHJhbnNwaWxlciB9IGZyb20gXCIuL3NlcnZpY2VzL3N3Yy10cmFuc3BpbGVyLmpzXCI7XG5pbXBvcnQgeyBUeXBlRW1pdHRlciB9IGZyb20gXCIuL3NlcnZpY2VzL3R5cGUtZW1pdHRlci5qc1wiO1xuaW1wb3J0IHsgVHJhbnNmb3JtZXJLZXkgfSBmcm9tIFwiLi90eXBlcy90cmFuc2Zvcm1lci50eXBlLmpzXCI7XG5pbXBvcnQgeyBEZWZhdWx0Q29uZmlndXJhdGlvbnMsIFdvcmtzcGFjZURlZmF1bHRzIH0gZnJvbSBcIi4vd29ya3NwYWNlLmNvbmZpZy5qc1wiO1xuXG5leHBvcnQgY2xhc3MgRm9yZ2VNb2R1bGUgZXh0ZW5kcyBNb2R1bGVNYW5pZmVzdCB7XG5cdHB1YmxpYyByZWFkb25seSBpZCA9IFwiZm9yZ2VcIjtcblx0cHVibGljIHJlYWRvbmx5IGNvbW1hbmQgPSBDb21tYW5kcy5Gb3JnZUNvbW1hbmQ7XG5cdHB1YmxpYyByZWFkb25seSBhY3Rpb25zID0ge1xuXHRcdGNsZWFuOiBBY3Rpb25zLkNsZWFuLFxuXHRcdGNvcHk6IEFjdGlvbnMuQ29weSxcblx0XHRidWlsZDogQWN0aW9ucy5CdWlsZCxcblx0XHR3YXRjaDogQWN0aW9ucy5XYXRjaCxcblx0XHRwdWJsaXNoOiBBY3Rpb25zLlB1Ymxpc2gsXG5cdFx0c3luY0RlcGVuZGVuY2llczogQWN0aW9ucy5TeW5jRGVwZW5kZW5jaWVzLFxuXHRcdHN5bmNMb2NrRmlsZTogQWN0aW9ucy5TeW5jTG9ja0ZpbGUsXG5cdFx0cmVwb3J0RGVwZW5kZW5jaWVzOiBBY3Rpb25zLlJlcG9ydERlcGVuZGVuY2llcyxcblx0XHR2ZXJzaW9uOiBBY3Rpb25zLlZlcnNpb24sXG5cdFx0dGFnOiBBY3Rpb25zLlRhZyxcblx0XHRjb21taXRGaWxlczogQWN0aW9ucy5Db21taXRGaWxlcyxcblx0fTtcblx0cHVibGljIHJlYWRvbmx5IGNvbW1hbmRzID0ge1xuXHRcdGJ1aWxkOiBDb21tYW5kcy5CdWlsZENvbW1hbmQsXG5cdFx0cHVibGlzaDogQ29tbWFuZHMuUHVibGlzaENvbW1hbmQsXG5cdFx0ZGVwZW5kZW5jaWVzOiBDb21tYW5kcy5EZXBlbmRlbmN5Q29tbWFuZCxcblx0XHR2ZXJzaW9uOiBDb21tYW5kcy5WZXJzaW9uQ29tbWFuZCxcblx0XHR0YWc6IENvbW1hbmRzLlRhZ0NvbW1hbmQsXG5cdH07XG5cblx0cHVibGljIHJlZ2lzdGVyU2VydmljZXMoYnVpbGRlcjogQ29udGFpbmVyQnVpbGRlcikge1xuXHRcdGJ1aWxkZXIucmVnaXN0ZXJTaW5nbGV0b24oVHJhbnNmb3JtZXJLZXksIFN3Y1RyYW5zcGlsZXIpO1xuXHRcdGJ1aWxkZXIucmVnaXN0ZXJTaW5nbGV0b24oVHJhbnNmb3JtZXJLZXksIFR5cGVFbWl0dGVyKTtcblx0XHRidWlsZGVyLnJlZ2lzdGVyU2luZ2xldG9uKERlcGVuZGVuY3lSZXNvbHZlcik7XG5cdFx0YnVpbGRlci5yZWdpc3RlclNpbmdsZXRvbihGaWxlV3JpdGVyU2VydmljZSk7XG5cdH1cblxuXHRwdWJsaWMgb3ZlcnJpZGUgYXN5bmMgY3JlYXRlV29ya3NwYWNlKG9wdGlvbnM6IFdvcmtzcGFjZUZhY3RvcnlPcHRpb25zKSB7XG5cdFx0Y29uc3QgeyBjb25maWd1cmF0aW9uczogXywgLi4uZm9yZ2VEZWZhdWx0cyB9ID0gV29ya3NwYWNlRGVmYXVsdHM7XG5cdFx0Y29uc3QgdXNlckNvbmZpZyA9IGF3YWl0IFVzZXJDb25maWdGYWN0b3J5LmdldFVzZXJDb25maWcob3B0aW9ucy5jb25maWdGaWxlKTtcblx0XHQvLyBPbmx5IGFwcGx5IGZvcmdlIGRlZmF1bHQgY29uZmlndXJhdGlvbnMgd2hlbiB1c2VyIGNvbmZpZyBkb2Vzbid0IHByb3ZpZGUgYW55LlxuXHRcdC8vIFRoaXMgZW5zdXJlcyB1c2VyLWRlZmluZWQgY29uZmlndXJhdGlvbnMgdGFrZSBwcmlvcml0eSB3aGlsZSBzdGlsbCBwcm92aWRpbmdcblx0XHQvLyBzZW5zaWJsZSBkZWZhdWx0cyAoZGVidWcgKyByZWxlYXNlKSB3aGVuIG5vIGNvbmZpZyBmaWxlIGlzIHByZXNlbnQuXG5cdFx0Y29uc3QgY29uZmlndXJhdGlvbnMgPSB1c2VyQ29uZmlnLmNvbmZpZ3VyYXRpb25zPy5sZW5ndGhcblx0XHRcdD8gdW5kZWZpbmVkXG5cdFx0XHQ6IERlZmF1bHRDb25maWd1cmF0aW9ucztcblx0XHRyZXR1cm4gV29ya3NwYWNlRmFjdG9yeS5jcmVhdGUoe1xuXHRcdFx0Li4uZm9yZ2VEZWZhdWx0cyxcblx0XHRcdC4uLihjb25maWd1cmF0aW9ucyA/IHsgY29uZmlndXJhdGlvbnMgfSA6IHt9KSxcblx0XHRcdGNvbmZpZ0ZpbGU6IG9wdGlvbnMuY29uZmlnRmlsZSxcblx0XHRcdHJvb3REaXI6IG9wdGlvbnMucm9vdERpciA/PyBXb3Jrc3BhY2VEZWZhdWx0cy5yb290RGlyLFxuXHRcdH0pO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiVXNlckNvbmZpZ0ZhY3RvcnkiLCJXb3Jrc3BhY2VGYWN0b3J5IiwiTW9kdWxlTWFuaWZlc3QiLCJBY3Rpb25zIiwiQ29tbWFuZHMiLCJEZXBlbmRlbmN5UmVzb2x2ZXIiLCJGaWxlV3JpdGVyU2VydmljZSIsIlN3Y1RyYW5zcGlsZXIiLCJUeXBlRW1pdHRlciIsIlRyYW5zZm9ybWVyS2V5IiwiRGVmYXVsdENvbmZpZ3VyYXRpb25zIiwiV29ya3NwYWNlRGVmYXVsdHMiLCJGb3JnZU1vZHVsZSIsImlkIiwiY29tbWFuZCIsIkZvcmdlQ29tbWFuZCIsImFjdGlvbnMiLCJjbGVhbiIsIkNsZWFuIiwiY29weSIsIkNvcHkiLCJidWlsZCIsIkJ1aWxkIiwid2F0Y2giLCJXYXRjaCIsInB1Ymxpc2giLCJQdWJsaXNoIiwic3luY0RlcGVuZGVuY2llcyIsIlN5bmNEZXBlbmRlbmNpZXMiLCJzeW5jTG9ja0ZpbGUiLCJTeW5jTG9ja0ZpbGUiLCJyZXBvcnREZXBlbmRlbmNpZXMiLCJSZXBvcnREZXBlbmRlbmNpZXMiLCJ2ZXJzaW9uIiwiVmVyc2lvbiIsInRhZyIsIlRhZyIsImNvbW1pdEZpbGVzIiwiQ29tbWl0RmlsZXMiLCJjb21tYW5kcyIsIkJ1aWxkQ29tbWFuZCIsIlB1Ymxpc2hDb21tYW5kIiwiZGVwZW5kZW5jaWVzIiwiRGVwZW5kZW5jeUNvbW1hbmQiLCJWZXJzaW9uQ29tbWFuZCIsIlRhZ0NvbW1hbmQiLCJyZWdpc3RlclNlcnZpY2VzIiwiYnVpbGRlciIsInJlZ2lzdGVyU2luZ2xldG9uIiwiY3JlYXRlV29ya3NwYWNlIiwib3B0aW9ucyIsImNvbmZpZ3VyYXRpb25zIiwiXyIsImZvcmdlRGVmYXVsdHMiLCJ1c2VyQ29uZmlnIiwiZ2V0VXNlckNvbmZpZyIsImNvbmZpZ0ZpbGUiLCJsZW5ndGgiLCJ1bmRlZmluZWQiLCJjcmVhdGUiLCJyb290RGlyIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxpQkFBaUIsRUFBRUMsZ0JBQWdCLFFBQVEsaUJBQWlCO0FBRXJFLFNBQVNDLGNBQWMsUUFBUSxzQkFBc0I7QUFFckQsWUFBWUMsYUFBYSxxQkFBcUI7QUFDOUMsWUFBWUMsY0FBYyxzQkFBc0I7QUFDaEQsU0FBU0Msa0JBQWtCLFFBQVEsNENBQTRDO0FBQy9FLFNBQVNDLGlCQUFpQixRQUFRLG9DQUFvQztBQUN0RSxTQUFTQyxhQUFhLFFBQVEsK0JBQStCO0FBQzdELFNBQVNDLFdBQVcsUUFBUSw2QkFBNkI7QUFDekQsU0FBU0MsY0FBYyxRQUFRLDhCQUE4QjtBQUM3RCxTQUFTQyxxQkFBcUIsRUFBRUMsaUJBQWlCLFFBQVEsd0JBQXdCO0FBRWpGLE9BQU8sTUFBTUMsb0JBQW9CVjtJQUNoQlcsS0FBSyxRQUFRO0lBQ2JDLFVBQVVWLFNBQVNXLFlBQVksQ0FBQztJQUNoQ0MsVUFBVTtRQUN6QkMsT0FBT2QsUUFBUWUsS0FBSztRQUNwQkMsTUFBTWhCLFFBQVFpQixJQUFJO1FBQ2xCQyxPQUFPbEIsUUFBUW1CLEtBQUs7UUFDcEJDLE9BQU9wQixRQUFRcUIsS0FBSztRQUNwQkMsU0FBU3RCLFFBQVF1QixPQUFPO1FBQ3hCQyxrQkFBa0J4QixRQUFReUIsZ0JBQWdCO1FBQzFDQyxjQUFjMUIsUUFBUTJCLFlBQVk7UUFDbENDLG9CQUFvQjVCLFFBQVE2QixrQkFBa0I7UUFDOUNDLFNBQVM5QixRQUFRK0IsT0FBTztRQUN4QkMsS0FBS2hDLFFBQVFpQyxHQUFHO1FBQ2hCQyxhQUFhbEMsUUFBUW1DLFdBQVc7SUFDakMsRUFBRTtJQUNjQyxXQUFXO1FBQzFCbEIsT0FBT2pCLFNBQVNvQyxZQUFZO1FBQzVCZixTQUFTckIsU0FBU3FDLGNBQWM7UUFDaENDLGNBQWN0QyxTQUFTdUMsaUJBQWlCO1FBQ3hDVixTQUFTN0IsU0FBU3dDLGNBQWM7UUFDaENULEtBQUsvQixTQUFTeUMsVUFBVTtJQUN6QixFQUFFO0lBRUtDLGlCQUFpQkMsT0FBeUIsRUFBRTtRQUNsREEsUUFBUUMsaUJBQWlCLENBQUN2QyxnQkFBZ0JGO1FBQzFDd0MsUUFBUUMsaUJBQWlCLENBQUN2QyxnQkFBZ0JEO1FBQzFDdUMsUUFBUUMsaUJBQWlCLENBQUMzQztRQUMxQjBDLFFBQVFDLGlCQUFpQixDQUFDMUM7SUFDM0I7SUFFQSxNQUFzQjJDLGdCQUFnQkMsT0FBZ0MsRUFBRTtRQUN2RSxNQUFNLEVBQUVDLGdCQUFnQkMsQ0FBQyxFQUFFLEdBQUdDLGVBQWUsR0FBRzFDO1FBQ2hELE1BQU0yQyxhQUFhLE1BQU10RCxrQkFBa0J1RCxhQUFhLENBQUNMLFFBQVFNLFVBQVU7UUFDM0UsZ0ZBQWdGO1FBQ2hGLCtFQUErRTtRQUMvRSxzRUFBc0U7UUFDdEUsTUFBTUwsaUJBQWlCRyxXQUFXSCxjQUFjLEVBQUVNLFNBQy9DQyxZQUNBaEQ7UUFDSCxPQUFPVCxpQkFBaUIwRCxNQUFNLENBQUM7WUFDOUIsR0FBR04sYUFBYTtZQUNoQixHQUFJRixpQkFBaUI7Z0JBQUVBO1lBQWUsSUFBSSxDQUFDLENBQUM7WUFDNUNLLFlBQVlOLFFBQVFNLFVBQVU7WUFDOUJJLFNBQVNWLFFBQVFVLE9BQU8sSUFBSWpELGtCQUFrQmlELE9BQU87UUFDdEQ7SUFDRDtBQUNEIn0=

package/es6/src/index.js

@@ -0,0 +1,4 @@
+export { ForgeError } from "./errors.js";
+export { ForgeModule } from "./forge.module.js";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEZvcmdlRXJyb3IgfSBmcm9tIFwiLi9lcnJvcnMuanNcIjtcbmV4cG9ydCB7IEZvcmdlTW9kdWxlIH0gZnJvbSBcIi4vZm9yZ2UubW9kdWxlLmpzXCI7XG5leHBvcnQgdHlwZSB7IEZvcmdlQ29uZmlndXJhdGlvbiB9IGZyb20gXCIuL3R5cGVzL2NvbmZpZ3VyYXRpb24udHlwZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBXb3Jrc3BhY2VPcHRpb25zIH0gZnJvbSBcIi4vdHlwZXMvd29ya3NwYWNlLWNvbmZpZy50eXBlLmpzXCI7XG4iXSwibmFtZXMiOlsiRm9yZ2VFcnJvciIsIkZvcmdlTW9kdWxlIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxVQUFVLFFBQVEsY0FBYztBQUN6QyxTQUFTQyxXQUFXLFFBQVEsb0JBQW9CIn0=

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

@@ -0,0 +1,32 @@
+import { io } from "@decohere/nexus/io";
+export 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.deleteFile(response.outputPath);
+            }
+        }
+        this.outputCache.delete(filePath);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+import { Subject } from "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 Subject();
+        subjects.set(instance, subject);
+    }
+    return subject;
+}
+export 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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL21peGlucy9pbmNyZW1lbnRhbC10cmFuc2Zvcm0ubWl4aW4udHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBQcm9qZWN0RmlsZUV2ZW50LCBXb3Jrc3BhY2UgfSBmcm9tIFwiQGRlY29oZXJlL21lc2hcIjtcbmltcG9ydCB0eXBlIHsgT2JzZXJ2YWJsZSB9IGZyb20gXCJyeGpzXCI7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSBcInJ4anNcIjtcbmltcG9ydCB0eXBlIHsgVHJhbnNmb3JtUmVzcG9uc2UgfSBmcm9tIFwiLi4vdHlwZXMvdHJhbnNmb3JtLXJlc3BvbnNlLm1vZGVsLmpzXCI7XG5cbi8vIFdlYWtNYXAgYXZvaWRzIHRoZSBwcml2YXRlLWZpZWxkLWluLW1peGluIHByb2JsZW06IHByaXZhdGUgY2xhc3MgZmllbGRzICgjeClcbi8vIGFyZSBub3QgYWNjZXNzaWJsZSB3aGVuIG1ldGhvZHMgYXJlIGNvcGllZCBvbnRvIGEgZGlmZmVyZW50IGNsYXNzIHByb3RvdHlwZS5cbmNvbnN0IHN1YmplY3RzID0gbmV3IFdlYWtNYXA8b2JqZWN0LCBTdWJqZWN0PFRyYW5zZm9ybVJlc3BvbnNlW10+PigpO1xuXG5mdW5jdGlvbiBnZXRTdWJqZWN0KGluc3RhbmNlOiBvYmplY3QpOiBTdWJqZWN0PFRyYW5zZm9ybVJlc3BvbnNlW10+IHtcblx0bGV0IHN1YmplY3QgPSBzdWJqZWN0cy5nZXQoaW5zdGFuY2UpO1xuXHRpZiAoc3ViamVjdCA9PSBudWxsKSB7XG5cdFx0c3ViamVjdCA9IG5ldyBTdWJqZWN0PFRyYW5zZm9ybVJlc3BvbnNlW10+KCk7XG5cdFx0c3ViamVjdHMuc2V0KGluc3RhbmNlLCBzdWJqZWN0KTtcblx0fVxuXHRyZXR1cm4gc3ViamVjdDtcbn1cblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEluY3JlbWVudGFsVHJhbnNmb3JtIHtcblx0cHVibGljIGdldCBpbmNyZW1lbnRhbFRyYW5zZm9ybSQoKTogT2JzZXJ2YWJsZTxUcmFuc2Zvcm1SZXNwb25zZVtdPiB7XG5cdFx0cmV0dXJuIGdldFN1YmplY3QodGhpcykuYXNPYnNlcnZhYmxlKCk7XG5cdH1cblxuXHRwdWJsaWMgd2F0Y2god29ya3NwYWNlOiBXb3Jrc3BhY2UpOiB2b2lkIHtcblx0XHR3b3Jrc3BhY2UucHJvamVjdEZpbGVDaGFuZ2VkJC5zdWJzY3JpYmUoKGV2dCkgPT4ge1xuXHRcdFx0dm9pZCB0aGlzLm9uSW5jcmVtZW50YWxGaWxlRXZlbnQoZXZ0KS50aGVuKChyZXNwb25zZXMpID0+IHtcblx0XHRcdFx0Z2V0U3ViamVjdCh0aGlzKS5uZXh0KHJlc3BvbnNlcyk7XG5cdFx0XHR9KTtcblx0XHR9KTtcblx0fVxuXG5cdC8qKlxuXHQgKiBDYWxsZWQgZm9yIGV2ZXJ5IHdvcmtzcGFjZSBmaWxlIGNoYW5nZS4gSW1wbGVtZW50YXRpb25zIHNob3VsZCBpbnZhbGlkYXRlXG5cdCAqIGFueSBpbnRlcm5hbCBjYWNoZXMsIHBlcmZvcm0gdGhlIGluY3JlbWVudGFsIHRyYW5zZm9ybSwgYW5kIHJldHVybiB0aGUgcmVzdWx0cy5cblx0ICogUmV0dXJuIGFuIGVtcHR5IGFycmF5IGZvciBkZWxldGlvbnMgb3Igd2hlbiBubyBvdXRwdXQgaXMgcHJvZHVjZWQuXG5cdCAqL1xuXHRwcm90ZWN0ZWQgYWJzdHJhY3Qgb25JbmNyZW1lbnRhbEZpbGVFdmVudChcblx0XHRldnQ6IFByb2plY3RGaWxlRXZlbnQsXG5cdCk6IFByb21pc2U8VHJhbnNmb3JtUmVzcG9uc2VbXT47XG59XG4iXSwibmFtZXMiOlsiU3ViamVjdCIsInN1YmplY3RzIiwiV2Vha01hcCIsImdldFN1YmplY3QiLCJpbnN0YW5jZSIsInN1YmplY3QiLCJnZXQiLCJzZXQiLCJJbmNyZW1lbnRhbFRyYW5zZm9ybSIsImluY3JlbWVudGFsVHJhbnNmb3JtJCIsImFzT2JzZXJ2YWJsZSIsIndhdGNoIiwid29ya3NwYWNlIiwicHJvamVjdEZpbGVDaGFuZ2VkJCIsInN1YnNjcmliZSIsImV2dCIsIm9uSW5jcmVtZW50YWxGaWxlRXZlbnQiLCJ0aGVuIiwicmVzcG9uc2VzIiwibmV4dCJdLCJtYXBwaW5ncyI6IkFBRUEsU0FBU0EsT0FBTyxRQUFRLE9BQU87QUFHL0IsK0VBQStFO0FBQy9FLCtFQUErRTtBQUMvRSxNQUFNQyxXQUFXLElBQUlDO0FBRXJCLFNBQVNDLFdBQVdDLFFBQWdCO0lBQ25DLElBQUlDLFVBQVVKLFNBQVNLLEdBQUcsQ0FBQ0Y7SUFDM0IsSUFBSUMsV0FBVyxNQUFNO1FBQ3BCQSxVQUFVLElBQUlMO1FBQ2RDLFNBQVNNLEdBQUcsQ0FBQ0gsVUFBVUM7SUFDeEI7SUFDQSxPQUFPQTtBQUNSO0FBRUEsT0FBTyxNQUFlRztJQUNyQixJQUFXQyx3QkFBeUQ7UUFDbkUsT0FBT04sV0FBVyxJQUFJLEVBQUVPLFlBQVk7SUFDckM7SUFFT0MsTUFBTUMsU0FBb0IsRUFBUTtRQUN4Q0EsVUFBVUMsbUJBQW1CLENBQUNDLFNBQVMsQ0FBQyxDQUFDQztZQUN4QyxLQUFLLElBQUksQ0FBQ0Msc0JBQXNCLENBQUNELEtBQUtFLElBQUksQ0FBQyxDQUFDQztnQkFDM0NmLFdBQVcsSUFBSSxFQUFFZ0IsSUFBSSxDQUFDRDtZQUN2QjtRQUNEO0lBQ0Q7QUFVRCJ9

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

@@ -0,0 +1,162 @@
+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;
+}
+import { injectable } from "@decohere/crucible/decorators";
+import { io } from "@decohere/nexus/io";
+import { parseImports } from "parse-imports";
+import { BUILT_IN_MODULES } from "../const.js";
+import { ForgeError } from "../errors.js";
+export 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 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 || 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.readFile(file.fullPath);
+        const parsed = Array.from(await 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([
+    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":["injectable","io","parseImports","BUILT_IN_MODULES","ForgeError","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","resolved","importName","startsWith","packageNameMatch","match","packageName","includes","packg","get","undefined","internal","contents","readFile","fullPath","parsed","Array","from","impt","moduleSpecifier","value","push","isDynamicImport","line","substring","startIndex","split","message","code"],"mappings":"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"}