@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/AssetGraph.js

@@ -0,0 +1,523 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeFromDep = nodeFromDep;
+exports.nodeFromAssetGroup = nodeFromAssetGroup;
+exports.nodeFromAsset = nodeFromAsset;
+exports.nodeFromEntrySpecifier = nodeFromEntrySpecifier;
+exports.nodeFromEntryFile = nodeFromEntryFile;
+const assert_1 = __importDefault(require("assert"));
+const rust_1 = require("@atlaspack/rust");
+const utils_1 = require("@atlaspack/utils");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const graph_1 = require("@atlaspack/graph");
+const Dependency_1 = require("./Dependency");
+const projectPath_1 = require("./projectPath");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+function nodeFromDep(dep) {
+    return {
+        id: dep.id,
+        type: 'dependency',
+        value: dep,
+        deferred: false,
+        excluded: false,
+        usedSymbolsDown: new Set(),
+        usedSymbolsUp: new Map(),
+        usedSymbolsDownDirty: true,
+        usedSymbolsUpDirtyDown: true,
+        usedSymbolsUpDirtyUp: true,
+    };
+}
+function nodeFromAssetGroup(assetGroup) {
+    return {
+        id: (0, rust_1.hashString)(
+        // @ts-expect-error TS2345
+        (0, projectPath_1.fromProjectPathRelative)(assetGroup.filePath) +
+            // @ts-expect-error TS2345
+            (0, EnvironmentManager_1.toEnvironmentId)(assetGroup.env) +
+            String(assetGroup.isSource) +
+            String(assetGroup.sideEffects) +
+            (assetGroup.code ?? '') +
+            ':' +
+            (assetGroup.pipeline ?? '') +
+            ':' +
+            (assetGroup.query ?? '')),
+        type: 'asset_group',
+        value: assetGroup,
+        usedSymbolsDownDirty: true,
+    };
+}
+function nodeFromAsset(asset) {
+    return {
+        id: asset.id,
+        type: 'asset',
+        value: asset,
+        usedSymbols: new Set(),
+        usedSymbolsDownDirty: true,
+        usedSymbolsUpDirty: true,
+    };
+}
+function nodeFromEntrySpecifier(entry) {
+    return {
+        id: 'entry_specifier:' + (0, projectPath_1.fromProjectPathRelative)(entry),
+        type: 'entry_specifier',
+        value: entry,
+    };
+}
+function nodeFromEntryFile(entry) {
+    return {
+        id: 'entry_file:' + (0, utils_1.hashObject)(entry),
+        type: 'entry_file',
+        value: entry,
+    };
+}
+// @ts-expect-error TS2417
+class AssetGraph extends graph_1.ContentGraph {
+    constructor(opts) {
+        this.safeToIncrementallyBundle = true;
+        if (opts) {
+            let { hash, ...rest } = opts;
+            // @ts-expect-error TS2345
+            super(rest);
+            this.hash = hash;
+        }
+        else {
+            super();
+            this.setRootNodeId(this.addNode({
+                id: '@@root',
+                type: 'root',
+                value: null,
+            }));
+        }
+        this.undeferredDependencies = new Set();
+        this.envCache = new Map();
+    }
+    static deserialize(opts) {
+        return new AssetGraph(opts);
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            hash: this.hash,
+        };
+    }
+    /**
+     * Determine if we can incrementally bundle, which will not require a full bundling pass
+     * but just update assets into the bundle graph output.
+     */
+    canIncrementallyBundle() {
+        return this.safeToIncrementallyBundle;
+    }
+    // Deduplicates Environments by making them referentially equal
+    normalizeEnvironment(input) {
+        if ((0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
+            return;
+        }
+        // @ts-expect-error TS2345
+        let { id, context } = (0, EnvironmentManager_1.fromEnvironmentId)(input.env);
+        let idAndContext = `${id}-${context}`;
+        let env = this.envCache.get(idAndContext);
+        if (env) {
+            input.env = (0, EnvironmentManager_1.toEnvironmentRef)(env);
+        }
+        else {
+            // @ts-expect-error TS2345
+            this.envCache.set(idAndContext, (0, EnvironmentManager_1.fromEnvironmentId)(input.env));
+        }
+    }
+    setRootConnections({ entries, assetGroups }) {
+        let nodes = [];
+        if (entries) {
+            for (let entry of entries) {
+                let node = nodeFromEntrySpecifier(entry);
+                nodes.push(node);
+            }
+        }
+        else if (assetGroups) {
+            for (const assetGroup of assetGroups) {
+                // Adding nodes individually ensures we do not encounter a range stack size exceeded error
+                // when there are >100000 asset groups
+                nodes.push(nodeFromAssetGroup(assetGroup));
+            }
+        }
+        this.replaceNodeIdsConnectedTo((0, nullthrows_1.default)(this.rootNodeId), nodes.map((node) => this.addNode(node)));
+    }
+    addNode(node) {
+        this.hash = null;
+        let existing = this.getNodeByContentKey(node.id);
+        if (existing != null) {
+            (0, assert_1.default)(existing.type === node.type);
+            existing.value = node.value;
+            let existingId = this.getNodeIdByContentKey(node.id);
+            this.updateNode(existingId, existing);
+            return existingId;
+        }
+        return super.addNodeByContentKey(node.id, node);
+    }
+    removeNode(nodeId) {
+        this.hash = null;
+        this.onNodeRemoved && this.onNodeRemoved(nodeId);
+        return super.removeNode(nodeId);
+    }
+    resolveEntry(entry, resolved, correspondingRequest) {
+        let entrySpecifierNodeId = this.getNodeIdByContentKey(nodeFromEntrySpecifier(entry).id);
+        let entrySpecifierNode = (0, nullthrows_1.default)(this.getNode(entrySpecifierNodeId));
+        (0, assert_1.default)(entrySpecifierNode.type === 'entry_specifier');
+        entrySpecifierNode.correspondingRequest = correspondingRequest;
+        this.replaceNodeIdsConnectedTo(entrySpecifierNodeId, resolved.map((file) => this.addNode(nodeFromEntryFile(file))));
+    }
+    resolveTargets(entry, targets, correspondingRequest) {
+        let depNodes = targets.map((target) => {
+            let node = nodeFromDep(
+            // The passed project path is ignored in this case, because there is no `loc`
+            (0, Dependency_1.createDependency)('', {
+                specifier: (0, projectPath_1.fromProjectPathRelative)(entry.filePath),
+                specifierType: 'url',
+                pipeline: target.pipeline,
+                target: target,
+                env: target.env,
+                isEntry: true,
+                needsStableName: true,
+                // @ts-expect-error TS2322
+                symbols: (0, EnvironmentManager_1.fromEnvironmentId)(target.env).isLibrary
+                    ? new Map([['*', { local: '*', isWeak: true, loc: null }]])
+                    : undefined,
+            }));
+            if ((0, EnvironmentManager_1.fromEnvironmentId)(node.value.env).isLibrary) {
+                // in library mode, all of the entry's symbols are "used"
+                node.usedSymbolsDown.add('*');
+                node.usedSymbolsUp.set('*', undefined);
+            }
+            return node;
+        });
+        let entryNodeId = this.getNodeIdByContentKey(nodeFromEntryFile(entry).id);
+        let entryNode = (0, nullthrows_1.default)(this.getNode(entryNodeId));
+        (0, assert_1.default)(entryNode.type === 'entry_file');
+        entryNode.correspondingRequest = correspondingRequest;
+        this.replaceNodeIdsConnectedTo(entryNodeId, depNodes.map((node) => this.addNode(node)));
+    }
+    resolveDependency(dependency, assetGroup, correspondingRequest) {
+        let depNodeId = this.getNodeIdByContentKey(dependency.id);
+        let depNode = (0, nullthrows_1.default)(this.getNode(depNodeId));
+        (0, assert_1.default)(depNode.type === 'dependency');
+        depNode.correspondingRequest = correspondingRequest;
+        if (!assetGroup) {
+            return;
+        }
+        let assetGroupNode = nodeFromAssetGroup(assetGroup);
+        let existing = this.getNodeByContentKey(assetGroupNode.id);
+        if (existing != null) {
+            (0, assert_1.default)(existing.type === 'asset_group');
+            assetGroupNode.value.canDefer =
+                assetGroupNode.value.canDefer && existing.value.canDefer;
+        }
+        let assetGroupNodeId = this.addNode(assetGroupNode);
+        this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(dependency.id), [
+            assetGroupNodeId,
+        ]);
+        this.replaceNodeIdsConnectedTo(depNodeId, [assetGroupNodeId]);
+    }
+    shouldVisitChild(nodeId, childNodeId) {
+        let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+        let childNode = (0, nullthrows_1.default)(this.getNode(childNodeId));
+        if (node.type !== 'dependency' ||
+            childNode.type !== 'asset_group' ||
+            childNode.deferred === false) {
+            return true;
+        }
+        // Node types are proved above
+        let dependencyNode = node;
+        let assetGroupNode = childNode;
+        let { sideEffects, canDefer = true } = assetGroupNode.value;
+        let dependency = dependencyNode.value;
+        let dependencyPreviouslyDeferred = dependencyNode.hasDeferred;
+        let assetGroupPreviouslyDeferred = assetGroupNode.deferred;
+        let defer = this.shouldDeferDependency(dependency, sideEffects, canDefer);
+        dependencyNode.hasDeferred = defer;
+        assetGroupNode.deferred = defer;
+        if (!dependencyPreviouslyDeferred && defer) {
+            this.markParentsWithHasDeferred(nodeId);
+        }
+        else if (assetGroupPreviouslyDeferred && !defer) {
+            this.unmarkParentsWithHasDeferred(childNodeId);
+        }
+        return !defer;
+    }
+    // Dependency: mark parent Asset <- AssetGroup with hasDeferred true
+    markParentsWithHasDeferred(nodeId) {
+        this.traverseAncestors(nodeId, (traversedNodeId, _, actions) => {
+            let traversedNode = (0, nullthrows_1.default)(this.getNode(traversedNodeId));
+            if (traversedNode.type === 'asset') {
+                traversedNode.hasDeferred = true;
+            }
+            else if (traversedNode.type === 'asset_group') {
+                traversedNode.hasDeferred = true;
+                actions.skipChildren();
+            }
+            else if (nodeId !== traversedNodeId) {
+                actions.skipChildren();
+            }
+        });
+    }
+    // AssetGroup: update hasDeferred of all parent Dependency <- Asset <- AssetGroup
+    unmarkParentsWithHasDeferred(nodeId) {
+        this.traverseAncestors(nodeId, (traversedNodeId, ctx, actions) => {
+            let traversedNode = (0, nullthrows_1.default)(this.getNode(traversedNodeId));
+            if (traversedNode.type === 'asset') {
+                let hasDeferred = this.getNodeIdsConnectedFrom(traversedNodeId).some((childNodeId) => {
+                    let childNode = (0, nullthrows_1.default)(this.getNode(childNodeId));
+                    // @ts-expect-error TS2339
+                    return childNode.hasDeferred == null
+                        ? false
+                        : // @ts-expect-error TS2339
+                            childNode.hasDeferred;
+                });
+                if (!hasDeferred) {
+                    delete traversedNode.hasDeferred;
+                }
+                return { hasDeferred };
+            }
+            else if (traversedNode.type === 'asset_group' &&
+                nodeId !== traversedNodeId) {
+                // @ts-expect-error TS2339
+                if (!ctx?.hasDeferred) {
+                    this.safeToIncrementallyBundle = false;
+                    delete traversedNode.hasDeferred;
+                }
+                actions.skipChildren();
+            }
+            else if (traversedNode.type === 'dependency') {
+                this.safeToIncrementallyBundle = false;
+                traversedNode.hasDeferred = false;
+            }
+            else if (nodeId !== traversedNodeId) {
+                actions.skipChildren();
+            }
+        });
+    }
+    // Defer transforming this dependency if it is marked as weak, there are no side effects,
+    // no re-exported symbols are used by ancestor dependencies and the re-exporting asset isn't
+    // using a wildcard and isn't an entry (in library mode).
+    // This helps with performance building large libraries like `lodash-es`, which re-exports
+    // a huge number of functions since we can avoid even transforming the files that aren't used.
+    shouldDeferDependency(dependency, sideEffects, canDefer) {
+        let dependencySymbols = dependency.symbols;
+        // Doing this separately keeps Flow happy further down
+        if (!dependencySymbols) {
+            return false;
+        }
+        let isDeferrable = [...dependencySymbols].every(([, { isWeak }]) => isWeak) &&
+            sideEffects === false &&
+            canDefer &&
+            !dependencySymbols.has('*');
+        if (!isDeferrable) {
+            return false;
+        }
+        let depNodeId = this.getNodeIdByContentKey(dependency.id);
+        let depNode = this.getNode(depNodeId);
+        (0, assert_1.default)(depNode);
+        let assets = this.getNodeIdsConnectedTo(depNodeId);
+        let symbols = new Map([...dependencySymbols].map(([key, val]) => [val.local, key]));
+        (0, assert_1.default)(assets.length === 1);
+        let firstAsset = (0, nullthrows_1.default)(this.getNode(assets[0]));
+        (0, assert_1.default)(firstAsset.type === 'asset');
+        let resolvedAsset = firstAsset.value;
+        // This doesn't change from here, so checking it now saves
+        // us some calls to `getIncomingDependency`
+        if (!resolvedAsset.symbols) {
+            return true;
+        }
+        let deps = this.getIncomingDependencies(resolvedAsset);
+        return deps.every((d) => {
+            // If this dependency has already been through this process, and we
+            // know it's not deferrable, then there's no need to re-check
+            if (this.undeferredDependencies.has(d)) {
+                return false;
+            }
+            let depIsDeferrable = d.symbols &&
+                !((0, EnvironmentManager_1.fromEnvironmentId)(d.env).isLibrary && d.isEntry) &&
+                !d.symbols.has('*') &&
+                ![...d.symbols.keys()].some((symbol) => {
+                    let assetSymbol = resolvedAsset.symbols?.get(symbol)?.local;
+                    return assetSymbol != null && symbols.has(assetSymbol);
+                });
+            if (!depIsDeferrable) {
+                // Mark this dep as not deferrable so it doesn't have to be re-checked
+                this.undeferredDependencies.add(d);
+                return false;
+            }
+        });
+    }
+    resolveAssetGroup(assetGroup, assets, correspondingRequest) {
+        this.normalizeEnvironment(assetGroup);
+        let assetGroupNode = nodeFromAssetGroup(assetGroup);
+        // @ts-expect-error TS2322
+        assetGroupNode = this.getNodeByContentKey(assetGroupNode.id);
+        if (!assetGroupNode) {
+            return;
+        }
+        (0, assert_1.default)(assetGroupNode.type === 'asset_group');
+        assetGroupNode.correspondingRequest = correspondingRequest;
+        let assetsByKey = new Map();
+        for (let asset of assets) {
+            if (asset.uniqueKey != null) {
+                assetsByKey.set(asset.uniqueKey, asset);
+            }
+        }
+        let dependentAssetKeys = new Set();
+        for (let asset of assets) {
+            for (let dep of asset.dependencies.values()) {
+                if (assetsByKey.has(dep.specifier)) {
+                    dependentAssetKeys.add(dep.specifier);
+                }
+            }
+        }
+        let assetObjects = [];
+        let assetNodeIds = [];
+        for (let asset of assets) {
+            this.normalizeEnvironment(asset);
+            let isDirect = !dependentAssetKeys.has(asset.uniqueKey);
+            let dependentAssets = [];
+            for (let dep of asset.dependencies.values()) {
+                let dependentAsset = assetsByKey.get(dep.specifier);
+                if (dependentAsset) {
+                    dependentAssets.push(dependentAsset);
+                    if (dependentAsset.id === asset.id) {
+                        // Don't orphan circular dependencies.
+                        isDirect = true;
+                    }
+                }
+            }
+            let id = this.addNode(nodeFromAsset(asset));
+            assetObjects.push({
+                assetNodeId: id,
+                dependentAssets,
+            });
+            if (isDirect) {
+                assetNodeIds.push(id);
+            }
+        }
+        this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(assetGroupNode.id), assetNodeIds);
+        for (let { assetNodeId, dependentAssets } of assetObjects) {
+            // replaceNodesConnectedTo has merged the value into the existing node, retrieve
+            // the actual current node.
+            let assetNode = (0, nullthrows_1.default)(this.getNode(assetNodeId));
+            (0, assert_1.default)(assetNode.type === 'asset');
+            this.resolveAsset(assetNode, dependentAssets);
+        }
+    }
+    resolveAsset(assetNode, dependentAssets) {
+        let depNodeIds = [];
+        let depNodesWithAssets = [];
+        for (let dep of assetNode.value.dependencies.values()) {
+            this.normalizeEnvironment(dep);
+            let depNode = nodeFromDep(dep);
+            let existing = this.getNodeByContentKey(depNode.id);
+            if (existing?.type === 'dependency' &&
+                existing.value.resolverMeta != null) {
+                depNode.value.meta = {
+                    ...depNode.value.meta,
+                    ...existing.value.resolverMeta,
+                };
+                if ((0, feature_flags_1.getFeatureFlag)('hmrImprovements')) {
+                    depNode.value.resolverMeta = existing.value.resolverMeta;
+                }
+            }
+            if ((0, feature_flags_1.getFeatureFlag)('hmrImprovements')) {
+                if (existing?.type === 'dependency' &&
+                    existing.value.resolverPriority != null) {
+                    depNode.value.priority = existing.value.resolverPriority;
+                    depNode.value.resolverPriority = existing.value.resolverPriority;
+                }
+            }
+            let dependentAsset = dependentAssets.find((a) => a.uniqueKey === dep.specifier);
+            if (dependentAsset) {
+                depNode.complete = true;
+                depNodesWithAssets.push([depNode, nodeFromAsset(dependentAsset)]);
+            }
+            depNode.value.sourceAssetType = assetNode.value.type;
+            depNodeIds.push(this.addNode(depNode));
+        }
+        assetNode.usedSymbolsUpDirty = true;
+        assetNode.usedSymbolsDownDirty = true;
+        this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(assetNode.id), depNodeIds);
+        for (let [depNode, dependentAssetNode] of depNodesWithAssets) {
+            let depAssetNodeId = this.addNode(dependentAssetNode);
+            this.replaceNodeIdsConnectedTo(this.getNodeIdByContentKey(depNode.id), [
+                depAssetNodeId,
+            ]);
+        }
+    }
+    getIncomingDependencies(asset) {
+        let nodeId = this.getNodeIdByContentKey(asset.id);
+        let assetGroupIds = this.getNodeIdsConnectedTo(nodeId);
+        let dependencies = [];
+        for (let i = 0; i < assetGroupIds.length; i++) {
+            let assetGroupId = assetGroupIds[i];
+            // Sometimes assets are connected directly to dependencies
+            // rather than through an asset group. This happens due to
+            // inline dependencies on assets via uniqueKey. See resolveAsset.
+            let node = this.getNode(assetGroupId);
+            if (node?.type === 'dependency') {
+                dependencies.push(node.value);
+                continue;
+            }
+            let assetIds = this.getNodeIdsConnectedTo(assetGroupId);
+            for (let j = 0; j < assetIds.length; j++) {
+                let node = this.getNode(assetIds[j]);
+                if (!node || node.type !== 'dependency') {
+                    continue;
+                }
+                dependencies.push(node.value);
+            }
+        }
+        return dependencies;
+    }
+    traverseAssets(visit, startNodeId) {
+        return this.filteredTraverse((nodeId) => {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            return node.type === 'asset' ? node.value : null;
+        }, visit, startNodeId);
+    }
+    getEntryAssetGroupNodes() {
+        let entryNodes = [];
+        this.traverse((nodeId, _, actions) => {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            if (node.type === 'asset_group') {
+                entryNodes.push(node);
+                actions.skipChildren();
+            }
+        });
+        return entryNodes;
+    }
+    getEntryAssets() {
+        let entries = [];
+        this.traverseAssets((asset, ctx, traversal) => {
+            entries.push(asset);
+            traversal.skipChildren();
+        });
+        return entries;
+    }
+    getHash() {
+        if (this.hash != null) {
+            return this.hash;
+        }
+        let hash = new rust_1.Hash();
+        // TODO: sort??
+        this.traverse((nodeId) => {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            if (node.type === 'asset') {
+                hash.writeString((0, nullthrows_1.default)(node.value.outputHash));
+            }
+            else if (node.type === 'dependency' && node.value.target) {
+                hash.writeString(JSON.stringify(node.value.target));
+            }
+        });
+        this.hash = hash.finish();
+        return this.hash;
+    }
+}
+exports.default = AssetGraph;