@atlaspack/core 2.24.1 → 2.24.2

package/dist/public/Symbols.js

@@ -0,0 +1,248 @@
+"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 _AssetSymbols_value, _AssetSymbols_options, _MutableAssetSymbols_value, _MutableAssetSymbols_options, _MutableDependencySymbols_value, _MutableDependencySymbols_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableDependencySymbols = exports.MutableAssetSymbols = exports.AssetSymbols = void 0;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const utils_1 = require("../utils");
+const EMPTY_ITERABLE = {
+    [Symbol.iterator]() {
+        return EMPTY_ITERATOR;
+    },
+};
+const EMPTY_ITERATOR = {
+    next() {
+        return { done: true };
+    },
+};
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+let valueToSymbols = new WeakMap();
+class AssetSymbols {
+    constructor(options, asset) {
+        /*::
+        @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
+        */
+        // @ts-expect-error TS2564
+        _AssetSymbols_value.set(this, void 0);
+        // @ts-expect-error TS2564
+        _AssetSymbols_options.set(this, void 0);
+        let existing = valueToSymbols.get(asset);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _AssetSymbols_value, asset, "f");
+        __classPrivateFieldSet(this, _AssetSymbols_options, options, "f");
+        valueToSymbols.set(asset, this);
+        return this;
+    }
+    hasExportSymbol(exportSymbol) {
+        return Boolean(__classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols?.has(exportSymbol));
+    }
+    hasLocalSymbol(local) {
+        if (__classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols == null) {
+            return false;
+        }
+        for (let s of __classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols.values()) {
+            if (local === s.local)
+                return true;
+        }
+        return false;
+    }
+    get(exportSymbol) {
+        return fromInternalAssetSymbol(__classPrivateFieldGet(this, _AssetSymbols_options, "f").projectRoot, __classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols?.get(exportSymbol));
+    }
+    get isCleared() {
+        return __classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols == null;
+    }
+    exportSymbols() {
+        return __classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols?.keys() ?? [];
+    }
+    // @ts-expect-error TS2416
+    [(_AssetSymbols_value = new WeakMap(), _AssetSymbols_options = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols
+            ? __classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols[Symbol.iterator]()
+            : EMPTY_ITERATOR;
+    }
+    [inspect]() {
+        return `AssetSymbols(${__classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols
+            ? [...__classPrivateFieldGet(this, _AssetSymbols_value, "f").symbols]
+                .map(([s, { local }]) => `${s}:${local}`)
+                .join(', ')
+            : null})`;
+    }
+}
+exports.AssetSymbols = AssetSymbols;
+let valueToMutableAssetSymbols = new WeakMap();
+class MutableAssetSymbols {
+    constructor(options, asset) {
+        /*::
+        @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
+        */
+        // @ts-expect-error TS2564
+        _MutableAssetSymbols_value.set(this, void 0);
+        // @ts-expect-error TS2564
+        _MutableAssetSymbols_options.set(this, void 0);
+        let existing = valueToMutableAssetSymbols.get(asset);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _MutableAssetSymbols_value, asset, "f");
+        __classPrivateFieldSet(this, _MutableAssetSymbols_options, options, "f");
+        return this;
+    }
+    // immutable
+    hasExportSymbol(exportSymbol) {
+        return Boolean(__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols?.has(exportSymbol));
+    }
+    hasLocalSymbol(local) {
+        if (__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols == null) {
+            return false;
+        }
+        for (let s of __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols.values()) {
+            if (local === s.local)
+                return true;
+        }
+        return false;
+    }
+    get(exportSymbol) {
+        return fromInternalAssetSymbol(__classPrivateFieldGet(this, _MutableAssetSymbols_options, "f").projectRoot, __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols?.get(exportSymbol));
+    }
+    get isCleared() {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols == null;
+    }
+    exportSymbols() {
+        // @ts-expect-error TS2322
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols.keys();
+    }
+    // @ts-expect-error TS2416
+    [(_MutableAssetSymbols_value = new WeakMap(), _MutableAssetSymbols_options = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols
+            ? __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols[Symbol.iterator]()
+            : EMPTY_ITERATOR;
+    }
+    [inspect]() {
+        return `MutableAssetSymbols(${__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols
+            ? [...__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols]
+                .map(([s, { local }]) => `${s}:${local}`)
+                .join(', ')
+            : null})`;
+    }
+    // mutating
+    ensure() {
+        if (__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols == null) {
+            __classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols = new Map();
+        }
+    }
+    set(exportSymbol, local, loc, meta) {
+        (0, nullthrows_1.default)(__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols).set(exportSymbol, {
+            local,
+            loc: (0, utils_1.toInternalSourceLocation)(__classPrivateFieldGet(this, _MutableAssetSymbols_options, "f").projectRoot, loc),
+            meta,
+        });
+    }
+    delete(exportSymbol) {
+        (0, nullthrows_1.default)(__classPrivateFieldGet(this, _MutableAssetSymbols_value, "f").symbols).delete(exportSymbol);
+    }
+}
+exports.MutableAssetSymbols = MutableAssetSymbols;
+let valueToMutableDependencySymbols = new WeakMap();
+class MutableDependencySymbols {
+    constructor(options, dep) {
+        /*::
+        @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|}]> { return ({}: any); }
+        */
+        // @ts-expect-error TS2564
+        _MutableDependencySymbols_value.set(this, void 0);
+        // @ts-expect-error TS2564
+        _MutableDependencySymbols_options.set(this, void 0);
+        let existing = valueToMutableDependencySymbols.get(dep);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _MutableDependencySymbols_value, dep, "f");
+        __classPrivateFieldSet(this, _MutableDependencySymbols_options, options, "f");
+        return this;
+    }
+    // immutable:
+    hasExportSymbol(exportSymbol) {
+        return Boolean(__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols?.has(exportSymbol));
+    }
+    hasLocalSymbol(local) {
+        if (__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols) {
+            for (let s of __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols.values()) {
+                if (local === s.local)
+                    return true;
+            }
+        }
+        return false;
+    }
+    get(exportSymbol) {
+        return fromInternalDependencySymbol(__classPrivateFieldGet(this, _MutableDependencySymbols_options, "f").projectRoot, (0, nullthrows_1.default)(__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols).get(exportSymbol));
+    }
+    get isCleared() {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols == null;
+    }
+    exportSymbols() {
+        // @ts-expect-error TS2322
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols ? __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols.keys() : EMPTY_ITERABLE;
+    }
+    // @ts-expect-error TS2416
+    [(_MutableDependencySymbols_value = new WeakMap(), _MutableDependencySymbols_options = new WeakMap(), Symbol.iterator)]() {
+        return __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols
+            ? __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols[Symbol.iterator]()
+            : EMPTY_ITERATOR;
+    }
+    [inspect]() {
+        return `MutableDependencySymbols(${__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols
+            ? [...__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols]
+                .map(([s, { local, isWeak }]) => `${s}:${local}${isWeak ? '?' : ''}`)
+                .join(', ')
+            : null})`;
+    }
+    // mutating:
+    ensure() {
+        if (__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols == null) {
+            __classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols = new Map();
+        }
+    }
+    set(exportSymbol, local, loc, isWeak) {
+        let symbols = (0, nullthrows_1.default)(__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols);
+        symbols.set(exportSymbol, {
+            local,
+            loc: (0, utils_1.toInternalSourceLocation)(__classPrivateFieldGet(this, _MutableDependencySymbols_options, "f").projectRoot, loc),
+            isWeak: (symbols.get(exportSymbol)?.isWeak ?? true) && (isWeak ?? false),
+        });
+    }
+    delete(exportSymbol) {
+        (0, nullthrows_1.default)(__classPrivateFieldGet(this, _MutableDependencySymbols_value, "f").symbols).delete(exportSymbol);
+    }
+}
+exports.MutableDependencySymbols = MutableDependencySymbols;
+function fromInternalAssetSymbol(projectRoot, value) {
+    return (value && {
+        local: value.local,
+        meta: value.meta,
+        loc: (0, utils_1.fromInternalSourceLocation)(projectRoot, value.loc),
+    });
+}
+function fromInternalDependencySymbol(projectRoot, value) {
+    return (value && {
+        local: value.local,
+        meta: value.meta,
+        isWeak: value.isWeak,
+        loc: (0, utils_1.fromInternalSourceLocation)(projectRoot, value.loc),
+    });
+}

package/dist/public/Target.js

@@ -0,0 +1,69 @@
+"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 _Target_target, _Target_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetToInternalTarget = targetToInternalTarget;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const Environment_1 = __importDefault(require("./Environment"));
+const projectPath_1 = require("../projectPath");
+const utils_1 = require("../utils");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+const internalTargetToTarget = new WeakMap();
+const _targetToInternalTarget = new WeakMap();
+function targetToInternalTarget(target) {
+    return (0, nullthrows_1.default)(_targetToInternalTarget.get(target));
+}
+class Target {
+    constructor(target, options) {
+        // @ts-expect-error TS2564
+        _Target_target.set(this, void 0);
+        // @ts-expect-error TS2564
+        _Target_options.set(this, void 0);
+        let existing = internalTargetToTarget.get(target);
+        if (existing != null) {
+            return existing;
+        }
+        __classPrivateFieldSet(this, _Target_target, target, "f");
+        __classPrivateFieldSet(this, _Target_options, options, "f");
+        _targetToInternalTarget.set(this, target);
+        internalTargetToTarget.set(target, this);
+        return this;
+    }
+    get distEntry() {
+        return __classPrivateFieldGet(this, _Target_target, "f").distEntry;
+    }
+    get distDir() {
+        return (0, projectPath_1.fromProjectPath)(__classPrivateFieldGet(this, _Target_options, "f").projectRoot, __classPrivateFieldGet(this, _Target_target, "f").distDir);
+    }
+    get env() {
+        return new Environment_1.default((0, EnvironmentManager_1.fromEnvironmentId)(__classPrivateFieldGet(this, _Target_target, "f").env), __classPrivateFieldGet(this, _Target_options, "f"));
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _Target_target, "f").name;
+    }
+    get publicUrl() {
+        return __classPrivateFieldGet(this, _Target_target, "f").publicUrl;
+    }
+    get loc() {
+        return (0, utils_1.fromInternalSourceLocation)(__classPrivateFieldGet(this, _Target_options, "f").projectRoot, __classPrivateFieldGet(this, _Target_target, "f").loc);
+    }
+    [(_Target_target = new WeakMap(), _Target_options = new WeakMap(), inspect)]() {
+        // @ts-expect-error TS7053
+        return `Target(${this.name} - ${this.env[inspect]()})`;
+    }
+}
+exports.default = Target;

package/dist/registerCoreWithSerializer.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCoreWithSerializer = registerCoreWithSerializer;
+const build_cache_1 = require("@atlaspack/build-cache");
+const graph_1 = require("@atlaspack/graph");
+const package_json_1 = __importDefault(require("../package.json"));
+const AtlaspackConfig_1 = require("./AtlaspackConfig");
+const AssetGraph_1 = __importDefault(require("./AssetGraph"));
+const BundleGraph_1 = __importDefault(require("./BundleGraph"));
+const Config_1 = __importDefault(require("./public/Config"));
+const RequestTracker_1 = require("./RequestTracker");
+// /flow-to-ts helpers
+// @ts-expect-error TS7034
+let coreRegistered;
+function registerCoreWithSerializer() {
+    // @ts-expect-error TS7005
+    if (coreRegistered) {
+        return;
+    }
+    const packageVersion = package_json_1.default.version;
+    if (typeof packageVersion !== 'string') {
+        throw new Error('Expected package version to be a string');
+    }
+    for (let [name, ctor] of Object.entries({
+        AssetGraph: AssetGraph_1.default,
+        Config: Config_1.default,
+        BundleGraph: BundleGraph_1.default,
+        Graph: graph_1.Graph,
+        AtlaspackConfig: AtlaspackConfig_1.AtlaspackConfig,
+        RequestGraph: RequestTracker_1.RequestGraph,
+    })) {
+        (0, build_cache_1.registerSerializableClass)(packageVersion + ':' + name, ctor);
+    }
+    coreRegistered = true;
+}