@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/public/Config.js

@@ -0,0 +1,286 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _PublicConfig_config, _PublicConfig_pkg, _PublicConfig_pkgFilePath, _PublicConfig_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeConfigProxy = makeConfigProxy;
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@atlaspack/utils");
+const Environment_1 = __importDefault(require("./Environment"));
+const projectPath_1 = require("../projectPath");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const internalConfigToConfig = new utils_1.DefaultWeakMap(() => new WeakMap());
+/**
+ * Implements read tracking over an object.
+ *
+ * Calling this function with a non-trivial object like a class instance will fail to work.
+ *
+ * We track reads to fields that resolve to:
+ *
+ * - primitive values
+ * - arrays
+ *
+ * That is, reading a nested field `a.b.c` will make a single call to `onRead` with the path
+ * `['a', 'b', 'c']`.
+ *
+ * In case the value is null or an array, we will track the read as well.
+ *
+ * Iterating over `Object.keys(obj.field)` will register a read for the `['field']` path.
+ * Other reads work normally.
+ *
+ * @example
+ *
+ *     const usedPaths = new Set();
+ *     const onRead = (path) => {
+ *        usedPaths.add(path);
+ *     };
+ *
+ *     const config = makeConfigProxy(onRead, {a: {b: {c: 'd'}}})
+ *     console.log(config.a.b.c);
+ *     console.log(Array.from(usedPaths));
+ *     // We get a single read for the path
+ *     // ['a', 'b', 'c']
+ *
+ */
+function makeConfigProxy(onRead, config) {
+    const reportedPaths = new Set();
+    const reportPath = (path) => {
+        if (reportedPaths.has(path)) {
+            return;
+        }
+        reportedPaths.add(path);
+        onRead(path);
+    };
+    const makeProxy = (target, path) => {
+        // @ts-expect-error TS2345
+        return new Proxy(target, {
+            ownKeys(target) {
+                reportPath(path);
+                return Object.getOwnPropertyNames(target);
+            },
+            get(target, prop) {
+                // @ts-expect-error TS7053
+                const value = target[prop];
+                if (typeof value === 'object' &&
+                    value != null &&
+                    !Array.isArray(value)) {
+                    return makeProxy(value, [...path, prop]);
+                }
+                reportPath([...path, prop]);
+                return value;
+            },
+        });
+    };
+    // @ts-expect-error TS2322
+    return makeProxy(config, []);
+}
+class PublicConfig {
+    constructor(config, options) {
+        // @ts-expect-error TS2564
+        _PublicConfig_config.set(this, void 0);
+        _PublicConfig_pkg.set(this, void 0);
+        _PublicConfig_pkgFilePath.set(this, void 0);
+        // @ts-expect-error TS2564
+        _PublicConfig_options.set(this, void 0);
+        let existing = internalConfigToConfig.get(options).get(config);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _PublicConfig_config, config, "f");
+        __classPrivateFieldSet(this, _PublicConfig_options, options, "f");
+        internalConfigToConfig.get(options).set(config, this);
+        return this;
+    }
+    get env() {
+        return new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _PublicConfig_config, "f").env), __classPrivateFieldGet(this, _PublicConfig_options, "f"));
+    }
+    get searchPath() {
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, __classPrivateFieldGet(this, _PublicConfig_config, "f").searchPath);
+    }
+    get result() {
+        return __classPrivateFieldGet(this, _PublicConfig_config, "f").result;
+    }
+    get isSource() {
+        return __classPrivateFieldGet(this, _PublicConfig_config, "f").isSource;
+    }
+    setResult(result) {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").result = result;
+    }
+    setCacheKey(cacheKey) {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").cacheKey = cacheKey;
+    }
+    invalidateOnFileChange(filePath) {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnFileChange.add((0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, filePath));
+    }
+    invalidateOnConfigKeyChange(filePath, configKey) {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnConfigKeyChange.push({
+            filePath: (0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, filePath),
+            configKey,
+        });
+    }
+    addDevDependency(devDep) {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").devDeps.push({
+            ...devDep,
+            resolveFrom: (0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, devDep.resolveFrom),
+            additionalInvalidations: devDep.additionalInvalidations?.map((i) => ({
+                ...i,
+                resolveFrom: (0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, i.resolveFrom),
+            })),
+        });
+    }
+    invalidateOnFileCreate(invalidation) {
+        // @ts-expect-error TS2339
+        if (invalidation.glob != null) {
+            __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnFileCreate.push(invalidation);
+            // @ts-expect-error TS2339
+        }
+        else if (invalidation.filePath != null) {
+            __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnFileCreate.push({
+                filePath: (0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, 
+                // @ts-expect-error TS2339
+                invalidation.filePath),
+            });
+        }
+        else {
+            // @ts-expect-error TS2339
+            (0, assert_1.default)(invalidation.aboveFilePath != null);
+            __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnFileCreate.push({
+                // @ts-expect-error TS2339
+                fileName: invalidation.fileName,
+                aboveFilePath: (0, projectPath_1.toProjectPath)(__classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot, 
+                // @ts-expect-error TS2339
+                invalidation.aboveFilePath),
+            });
+        }
+    }
+    invalidateOnEnvChange(env) {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnEnvChange.add(env);
+    }
+    invalidateOnStartup() {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnStartup = true;
+    }
+    invalidateOnBuild() {
+        __classPrivateFieldGet(this, _PublicConfig_config, "f").invalidateOnBuild = true;
+    }
+    async getConfigFrom(searchPath, fileNames, options) {
+        // @ts-expect-error TS2339
+        let packageKey = options?.packageKey;
+        if (packageKey != null) {
+            let pkg = await this.getConfigFrom(searchPath, ['package.json'], {
+                exclude: true,
+            });
+            // @ts-expect-error TS18046
+            if (pkg && pkg.contents[packageKey]) {
+                // Invalidate only when the package key changes
+                this.invalidateOnConfigKeyChange(pkg.filePath, [packageKey]);
+                return {
+                    // @ts-expect-error TS18046
+                    contents: pkg.contents[packageKey],
+                    filePath: pkg.filePath,
+                };
+            }
+        }
+        // @ts-expect-error TS2339
+        const readTracking = options?.readTracking;
+        if (readTracking === true) {
+            for (let fileName of fileNames) {
+                const config = await this.getConfigFrom(searchPath, [fileName], {
+                    exclude: true,
+                });
+                if (config != null) {
+                    // @ts-expect-error TS2322
+                    return Promise.resolve({
+                        contents: makeConfigProxy((keyPath) => {
+                            this.invalidateOnConfigKeyChange(config.filePath, keyPath);
+                        }, config.contents),
+                        filePath: config.filePath,
+                    });
+                }
+            }
+            // fall through so that file above invalidations are registered
+        }
+        if (fileNames.length === 0) {
+            return null;
+        }
+        // Invalidate when any of the file names are created above the search path.
+        for (let fileName of fileNames) {
+            this.invalidateOnFileCreate({
+                fileName,
+                aboveFilePath: searchPath,
+            });
+        }
+        // @ts-expect-error TS2339
+        let parse = options && options.parse;
+        let configFilePath = await (0, utils_1.resolveConfig)(__classPrivateFieldGet(this, _PublicConfig_options, "f").inputFS, searchPath, fileNames, __classPrivateFieldGet(this, _PublicConfig_options, "f").projectRoot);
+        if (configFilePath == null) {
+            return null;
+        }
+        // @ts-expect-error TS2339
+        if (!options || !options.exclude) {
+            this.invalidateOnFileChange(configFilePath);
+        }
+        // If this is a JavaScript file, load it with the package manager.
+        let extname = path_1.default.extname(configFilePath);
+        if (extname === '.js' || extname === '.cjs' || extname === '.mjs') {
+            let specifier = (0, utils_1.relativePath)(path_1.default.dirname(searchPath), configFilePath);
+            // Add dev dependency so we reload the config and any dependencies in watch mode.
+            this.addDevDependency({
+                specifier,
+                resolveFrom: searchPath,
+            });
+            // Invalidate on startup in case the config is non-deterministic,
+            // e.g. uses unknown environment variables, reads from the filesystem, etc.
+            this.invalidateOnStartup();
+            let config = await __classPrivateFieldGet(this, _PublicConfig_options, "f").packageManager.require(specifier, searchPath);
+            if (Object.prototype.toString.call(config) === '[object Module]' &&
+                config.default != null) {
+                // Native ESM config. Try to use a default export, otherwise fall back to the whole namespace.
+                config = config.default;
+            }
+            return {
+                contents: config,
+                filePath: configFilePath,
+            };
+        }
+        let conf = await (0, utils_1.readConfig)(__classPrivateFieldGet(this, _PublicConfig_options, "f").inputFS, configFilePath, parse == null ? null : { parse });
+        if (conf == null) {
+            return null;
+        }
+        return {
+            contents: conf.config,
+            filePath: configFilePath,
+        };
+    }
+    getConfig(filePaths, options) {
+        return this.getConfigFrom(this.searchPath, filePaths, options);
+    }
+    async getPackage() {
+        if (__classPrivateFieldGet(this, _PublicConfig_pkg, "f")) {
+            return __classPrivateFieldGet(this, _PublicConfig_pkg, "f");
+        }
+        let pkgConfig = await this.getConfig(['package.json'], {
+            readTracking: true,
+        });
+        if (!pkgConfig) {
+            return null;
+        }
+        __classPrivateFieldSet(this, _PublicConfig_pkg, pkgConfig.contents, "f");
+        __classPrivateFieldSet(this, _PublicConfig_pkgFilePath, pkgConfig.filePath, "f");
+        return __classPrivateFieldGet(this, _PublicConfig_pkg, "f");
+    }
+}
+_PublicConfig_config = new WeakMap(), _PublicConfig_pkg = new WeakMap(), _PublicConfig_pkgFilePath = new WeakMap(), _PublicConfig_options = new WeakMap();
+exports.default = PublicConfig;

package/dist/public/Dependency.js

@@ -0,0 +1,138 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Dependency_dep, _Dependency_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyToInternalDependency = dependencyToInternalDependency;
+exports.getPublicDependency = getPublicDependency;
+const types_1 = require("../types");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const Environment_1 = __importDefault(require("./Environment"));
+const Target_1 = __importDefault(require("./Target"));
+const Symbols_1 = require("./Symbols");
+const types_2 = require("../types");
+const projectPath_1 = require("../projectPath");
+const utils_1 = require("../utils");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const SpecifierTypeNames = Object.keys(types_2.SpecifierType);
+const PriorityNames = Object.keys(types_2.Priority);
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const internalDependencyToDependency = new WeakMap();
+const _dependencyToInternalDependency = new WeakMap();
+function dependencyToInternalDependency(dependency) {
+    return (0, nullthrows_1.default)(_dependencyToInternalDependency.get(dependency));
+}
+function getPublicDependency(dep, options) {
+    let existing = internalDependencyToDependency.get(dep);
+    if (existing != null) {
+        return existing;
+    }
+    return new Dependency(dep, options);
+}
+class Dependency {
+    constructor(dep, options) {
+        _Dependency_dep.set(this, void 0);
+        _Dependency_options.set(this, void 0);
+        __classPrivateFieldSet(this, _Dependency_dep, dep, "f");
+        __classPrivateFieldSet(this, _Dependency_options, options, "f");
+        _dependencyToInternalDependency.set(this, dep);
+        internalDependencyToDependency.set(dep, this);
+        return this;
+    }
+    [(_Dependency_dep = new WeakMap(), _Dependency_options = new WeakMap(), inspect)]() {
+        return `Dependency(${String(this.sourcePath)} -> ${this.specifier})`;
+    }
+    get id() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").id;
+    }
+    get specifier() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").specifier;
+    }
+    get specifierType() {
+        // @ts-expect-error TS2322
+        return SpecifierTypeNames[__classPrivateFieldGet(this, _Dependency_dep, "f").specifierType];
+    }
+    get priority() {
+        // @ts-expect-error TS2322
+        return PriorityNames[__classPrivateFieldGet(this, _Dependency_dep, "f").priority];
+    }
+    get needsStableName() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").needsStableName;
+    }
+    get bundleBehavior() {
+        let bundleBehavior = __classPrivateFieldGet(this, _Dependency_dep, "f").bundleBehavior;
+        return bundleBehavior == null ? null : types_1.BundleBehaviorNames[bundleBehavior];
+    }
+    get isEntry() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").isEntry;
+    }
+    get isOptional() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").isOptional;
+    }
+    get loc() {
+        return (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _Dependency_options, "f").projectRoot, __classPrivateFieldGet(this, _Dependency_dep, "f").loc);
+    }
+    get env() {
+        return new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _Dependency_dep, "f").env), __classPrivateFieldGet(this, _Dependency_options, "f"));
+    }
+    get packageConditions() {
+        // Merge custom conditions with conditions stored as bitflags.
+        // Order is not important because exports conditions are resolved
+        // in the order they are declared in the package.json.
+        let conditions = __classPrivateFieldGet(this, _Dependency_dep, "f").customPackageConditions;
+        if (__classPrivateFieldGet(this, _Dependency_dep, "f").packageConditions) {
+            conditions = conditions ? [...conditions] : [];
+            for (let key in types_2.ExportsCondition) {
+                // @ts-expect-error TS7053
+                if (__classPrivateFieldGet(this, _Dependency_dep, "f").packageConditions & types_2.ExportsCondition[key]) {
+                    conditions.push(key);
+                }
+            }
+        }
+        return conditions;
+    }
+    get meta() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").meta;
+    }
+    get symbols() {
+        // @ts-expect-error TS2322
+        return new Symbols_1.MutableDependencySymbols(__classPrivateFieldGet(this, _Dependency_options, "f"), __classPrivateFieldGet(this, _Dependency_dep, "f"));
+    }
+    get target() {
+        let target = __classPrivateFieldGet(this, _Dependency_dep, "f").target;
+        return target ? new Target_1.default(target, __classPrivateFieldGet(this, _Dependency_options, "f")) : null;
+    }
+    get sourceAssetId() {
+        // TODO: does this need to be public?
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").sourceAssetId;
+    }
+    get sourcePath() {
+        // TODO: does this need to be public?
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _Dependency_options, "f").projectRoot, __classPrivateFieldGet(this, _Dependency_dep, "f").sourcePath);
+    }
+    get sourceAssetType() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").sourceAssetType;
+    }
+    get resolveFrom() {
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _Dependency_options, "f").projectRoot, __classPrivateFieldGet(this, _Dependency_dep, "f").resolveFrom ?? __classPrivateFieldGet(this, _Dependency_dep, "f").sourcePath);
+    }
+    get range() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").range;
+    }
+    get pipeline() {
+        return __classPrivateFieldGet(this, _Dependency_dep, "f").pipeline;
+    }
+}
+exports.default = Dependency;