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

package/dist/applyRuntimes.js

@@ -0,0 +1,384 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = applyRuntimes;
+const path_1 = __importDefault(require("path"));
+const assert_1 = __importDefault(require("assert"));
+const assert_2 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const AssetGraph_1 = require("./AssetGraph");
+const BundleGraph_1 = __importDefault(require("./public/BundleGraph"));
+const BundleGraph_2 = __importStar(require("./BundleGraph"));
+const Bundle_1 = require("./public/Bundle");
+const logger_1 = require("@atlaspack/logger");
+const rust_1 = require("@atlaspack/rust");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const Dependency_1 = require("./public/Dependency");
+const Environment_1 = require("./Environment");
+const AssetGraphRequest_1 = __importDefault(require("./requests/AssetGraphRequest"));
+const DevDepRequest_1 = require("./requests/DevDepRequest");
+const projectPath_1 = require("./projectPath");
+const profiler_1 = require("@atlaspack/profiler");
+const utils_1 = require("@atlaspack/utils");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+function nameRuntimeBundle(bundle, siblingBundle) {
+    // We don't run custom namers on runtime bundles as the runtime assumes that they are
+    // located at the same nesting level as their owning bundle. Custom naming could
+    // be added in future as long as the custom name is validated.
+    let { hashReference } = bundle;
+    let name = (0, nullthrows_1.default)(siblingBundle.name)
+        // Remove the existing hash from standard file patterns
+        // e.g. 'main.[hash].js' -> 'main.js' or 'main~[hash].js' -> 'main.js'
+        .replace(new RegExp(`[\\.~\\-_]?${siblingBundle.hashReference}`), '')
+        // Ensure the file ends with 'runtime.[hash].js'
+        .replace(`.${bundle.type}`, `.runtime.${hashReference}.${bundle.type}`);
+    bundle.name = name;
+    bundle.displayName = name.replace(hashReference, '[hash]');
+}
+/**
+ * The applyRuntimes function is responsible for generating all the runtimes
+ * (assets created during the build that don't actually exist on disk) and then
+ * linking them into the bundle graph.
+ *
+ * Introduction of manifest bundles: https://github.com/parcel-bundler/parcel/pull/8837
+ * Introduction of reverse topology: https://github.com/parcel-bundler/parcel/pull/8981
+ */
+async function applyRuntimes({ bundleGraph, config, options, pluginOptions, api, optionsRef, previousDevDeps, devDepRequests, configs, }) {
+    let runtimes = await config.getRuntimes();
+    /**
+     * Usually, the assets returned from a runtime will go in the same bundle. It is
+     * possible though, for a runtime to return an asset with a `parallel` priority,
+     * which allows it to be moved to a separate bundle. In practice, this is
+     * usually used to generate application manifest files.
+     *
+     * When adding a manifest bundle (a whole new separate bundle) during a runtime,
+     * it needs to be added to a bundle group which will be potentially referenced
+     * by another bundle group. To avoid trying to reference a manifest entry which
+     * hasn't been created yet, we process the bundles from the bottom up (topological
+     * order), so that children will always be available when parents try to reference
+     * them.
+     */
+    // @ts-expect-error TS2304
+    let bundles = [];
+    bundleGraph.traverseBundles({
+        // @ts-expect-error TS2304
+        exit(bundle) {
+            bundles.push(bundle);
+        },
+    });
+    let connectionMap = new utils_1.DefaultMap(() => []);
+    for (let bundle of bundles) {
+        for (let runtime of runtimes) {
+            let measurement;
+            try {
+                const namedBundle = Bundle_1.NamedBundle.get(bundle, bundleGraph, options);
+                measurement = profiler_1.tracer.createMeasurement(runtime.name, 'applyRuntime', namedBundle.displayName);
+                let applied = await runtime.plugin.apply({
+                    bundle: namedBundle,
+                    bundleGraph: new BundleGraph_1.default(bundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options),
+                    config: configs.get(runtime.name)?.result,
+                    options: pluginOptions,
+                    logger: new logger_1.PluginLogger({ origin: runtime.name }),
+                    tracer: new profiler_1.PluginTracer({
+                        origin: runtime.name,
+                        category: 'applyRuntime',
+                    }),
+                });
+                if (applied) {
+                    let runtimeAssets = Array.isArray(applied) ? applied : [applied];
+                    for (let { code, dependency, filePath, isEntry, env, runtimeAssetRequiringExecutionOnLoad, priority, symbolData, } of runtimeAssets) {
+                        let sourceName = path_1.default.join(path_1.default.dirname(filePath), `runtime-${(0, rust_1.hashString)(code)}.${bundle.type}`);
+                        let assetGroup = {
+                            code,
+                            runtimeAssetRequiringExecutionOnLoad,
+                            filePath: (0, projectPath_1.toProjectPath)(options.projectRoot, sourceName),
+                            env: (0, Environment_1.mergeEnvironments)(options.projectRoot, (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env), env),
+                            // Runtime assets should be considered source, as they should be
+                            // e.g. compiled to run in the target environment
+                            isSource: true,
+                            symbolData,
+                        };
+                        let connectionBundle = bundle;
+                        /**
+                         * If a runtime asset is marked with a priority of `parallel` this
+                         * means we need to create a new bundle for the asset and add it to
+                         * all the same bundle groups.
+                         */
+                        if (priority === 'parallel' && !bundle.needsStableName) {
+                            let bundleGroups = bundleGraph.getBundleGroupsContainingBundle(bundle);
+                            connectionBundle = (0, nullthrows_1.default)(bundleGraph.createBundle({
+                                type: bundle.type,
+                                needsStableName: false,
+                                env: bundle.env,
+                                target: bundle.target,
+                                uniqueKey: 'runtime-manifest:' + bundle.id,
+                                shouldContentHash: options.shouldContentHash,
+                            }));
+                            for (let bundleGroup of bundleGroups) {
+                                bundleGraph.addBundleToBundleGroup(connectionBundle, bundleGroup);
+                            }
+                            bundleGraph.createBundleReference(bundle, connectionBundle);
+                            // Ensure we name the bundle now as all other bundles have already
+                            // been named as this point.
+                            nameRuntimeBundle(connectionBundle, bundle);
+                        }
+                        // @ts-expect-error TS2345
+                        connectionMap.get(connectionBundle).push({
+                            bundle: connectionBundle,
+                            assetGroup,
+                            dependency,
+                            isEntry,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                throw new diagnostic_1.default({
+                    diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                        origin: runtime.name,
+                    }),
+                });
+            }
+            finally {
+                measurement && measurement.end();
+            }
+        }
+    }
+    /**
+     * When merging the connections in to the bundle graph, the topological
+     * order can create module not found errors in some situations, often when HMR
+     * is enabled. To fix this, we put the connections into DFS order.
+     *
+     * Note: While DFS order seems to be the most reliable order to process the
+     * connections, this is likely due to it being close to the order that the bundles were
+     * inserted into the graph. There is a known issue where runtime assets marked
+     * as `isEntry` can create scenarios where there is no correct load order that
+     * won't error, as the entry runtime assets are added to many bundles in a
+     * single bundle group but their dependencies are not.
+     *
+     * This issue is almost exclusive to HMR scenarios as the two HMR runtime
+     * plugins (@atlaspack/runtime-browser-hmr and @atlaspack/runtime-react-refresh)
+     * are the only known cases where a runtime asset is marked as `isEntry`.
+     */
+    let connections = [];
+    bundleGraph.traverseBundles({
+        // @ts-expect-error TS2304
+        enter(bundle) {
+            connections.push(...connectionMap.get(bundle));
+        },
+    });
+    // Add dev deps for runtime plugins AFTER running them, to account for lazy require().
+    for (let runtime of runtimes) {
+        let devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+            specifier: runtime.name,
+            resolveFrom: runtime.resolveFrom,
+        }, previousDevDeps, options);
+        devDepRequests.set(`${devDepRequest.specifier}:${(0, projectPath_1.fromProjectPathRelative)(devDepRequest.resolveFrom)}`, devDepRequest);
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+    // Create a new AssetGraph from the generated runtime assets which also runs
+    // transforms and resolves all dependencies.
+    let { assetGraph: runtimesAssetGraph, changedAssets } = await reconcileNewRuntimes(api, connections, optionsRef);
+    if ((0, feature_flags_1.getFeatureFlag)('skipRuntimeSymbolProp')) {
+        // Apply pre-computed symbol data from runtime assets to skip symbol propagation
+        applyRuntimeSymbolData(runtimesAssetGraph, connections);
+    }
+    // Convert the runtime AssetGraph into a BundleGraph, this includes assigning
+    // the assets their public ids
+    let runtimesBundleGraph = BundleGraph_2.default.fromAssetGraph(runtimesAssetGraph, options.mode === 'production', bundleGraph._publicIdByAssetId, bundleGraph._assetPublicIds);
+    // Merge the runtimes bundle graph into the main bundle graph.
+    bundleGraph.merge(runtimesBundleGraph);
+    // Add the public id mappings from the runtumes bundlegraph to the main bundle graph
+    for (let [assetId, publicId] of runtimesBundleGraph._publicIdByAssetId) {
+        bundleGraph._publicIdByAssetId.set(assetId, publicId);
+        bundleGraph._assetPublicIds.add(publicId);
+    }
+    // Connect each of the generated runtime assets to bundles in the main bundle
+    // graph. This is like a mini-bundling algorithm for runtime assets.
+    for (let { bundle, assetGroup, dependency, isEntry } of connections) {
+        let assetGroupNode = (0, AssetGraph_1.nodeFromAssetGroup)(assetGroup);
+        let assetGroupAssetNodeIds = runtimesAssetGraph.getNodeIdsConnectedFrom(runtimesAssetGraph.getNodeIdByContentKey(assetGroupNode.id));
+        (0, assert_2.default)(assetGroupAssetNodeIds.length === 1);
+        let runtimeNodeId = assetGroupAssetNodeIds[0];
+        let runtimeNode = (0, nullthrows_1.default)(runtimesAssetGraph.getNode(runtimeNodeId));
+        (0, assert_2.default)(runtimeNode.type === 'asset');
+        // Find the asset that the runtime asset should be connected from by resolving
+        // it's dependency.
+        let resolution = dependency &&
+            bundleGraph.getResolvedAsset((0, Dependency_1.dependencyToInternalDependency)(dependency), bundle);
+        // Walk all the dependencies of the runtime assets and check if they are
+        // already reachable from the bundle that the runtime asset is assigned to.
+        // If so, we add them to `duplicatedContentKeys` to be skipped when assigning
+        // assets to bundles.
+        let runtimesBundleGraphRuntimeNodeId = runtimesBundleGraph._graph.getNodeIdByContentKey(runtimeNode.id);
+        let duplicatedContentKeys = new Set();
+        runtimesBundleGraph._graph.traverse((nodeId, _, actions) => {
+            let node = (0, nullthrows_1.default)(runtimesBundleGraph._graph.getNode(nodeId));
+            if (node.type !== 'dependency') {
+                return;
+            }
+            let assets = runtimesBundleGraph._graph
+                .getNodeIdsConnectedFrom(nodeId)
+                .map((assetNodeId) => {
+                let assetNode = (0, nullthrows_1.default)(runtimesBundleGraph._graph.getNode(assetNodeId));
+                (0, assert_2.default)(assetNode.type === 'asset');
+                return assetNode.value;
+            });
+            for (let asset of assets) {
+                if (bundleGraph.isAssetReachableFromBundle(asset, bundle) ||
+                    resolution?.id === asset.id) {
+                    duplicatedContentKeys.add(asset.id);
+                    actions.skipChildren();
+                }
+            }
+        }, runtimesBundleGraphRuntimeNodeId);
+        let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+        let bundleGraphRuntimeNodeId = bundleGraph._graph.getNodeIdByContentKey(runtimeNode.id); // the node id is not constant between graphs
+        // Assign the runtime assets and all of it's depepdencies to the bundle unless
+        // we have detected it as already being reachable from this bundle via `duplicatedContentKeys`.
+        runtimesBundleGraph._graph.traverse((nodeId, _, actions) => {
+            let node = (0, nullthrows_1.default)(runtimesBundleGraph._graph.getNode(nodeId));
+            if (node.type === 'asset' || node.type === 'dependency') {
+                if (duplicatedContentKeys.has(node.id)) {
+                    actions.skipChildren();
+                    return;
+                }
+                const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id); // the node id is not constant between graphs
+                bundleGraph._graph.addEdge(bundleNodeId, bundleGraphNodeId, BundleGraph_2.bundleGraphEdgeTypes.contains);
+            }
+        }, runtimesBundleGraphRuntimeNodeId);
+        if (isEntry) {
+            bundleGraph._graph.addEdge(bundleNodeId, bundleGraphRuntimeNodeId);
+            bundle.entryAssetIds.unshift(runtimeNode.id);
+        }
+        if (dependency == null) {
+            // Verify this asset won't become an island
+            (0, assert_1.default)(bundleGraph._graph.getNodeIdsConnectedTo(bundleGraphRuntimeNodeId)
+                .length > 0, 'Runtime must have an inbound dependency or be an entry');
+        }
+        else {
+            let dependencyNodeId = bundleGraph._graph.getNodeIdByContentKey(dependency.id);
+            bundleGraph._graph.addEdge(dependencyNodeId, bundleGraphRuntimeNodeId);
+        }
+    }
+    return changedAssets;
+}
+/**
+ * Apply pre-computed symbol data from runtime assets to the asset graph
+ * to avoid running symbol propagation on runtime code we control.
+ */
+function applyRuntimeSymbolData(assetGraph, connections) {
+    for (let { assetGroup } of connections) {
+        let assetGroupNode = (0, AssetGraph_1.nodeFromAssetGroup)(assetGroup);
+        let assetGroupAssetNodeIds = assetGraph.getNodeIdsConnectedFrom(assetGraph.getNodeIdByContentKey(assetGroupNode.id));
+        if (assetGroupAssetNodeIds.length !== 1) {
+            continue;
+        }
+        let runtimeAssetNodeId = assetGroupAssetNodeIds[0];
+        let runtimeAssetNode = assetGraph.getNode(runtimeAssetNodeId);
+        if (!runtimeAssetNode || runtimeAssetNode.type !== 'asset') {
+            continue;
+        }
+        let symbolData = assetGroup.symbolData;
+        if (!symbolData) {
+            // We completely skip symbol propagation for runtime assets, so symbolData
+            // is required
+            throw new Error('Runtime asset is missing symbol data');
+        }
+        if (symbolData.symbols) {
+            // Convert from SymbolData format to internal Asset.symbols format
+            let internalSymbols = new Map();
+            for (let [symbol, data] of symbolData.symbols) {
+                internalSymbols.set(symbol, {
+                    local: data.local,
+                    loc: data.loc || null,
+                    meta: data.meta,
+                });
+            }
+            runtimeAssetNode.value.symbols = internalSymbols;
+        }
+        if (symbolData.dependencies && symbolData.dependencies.length > 0) {
+            let outgoingDeps = assetGraph
+                .getNodeIdsConnectedFrom(runtimeAssetNodeId)
+                .map((id) => assetGraph.getNode(id))
+                .filter((node) => node?.type === 'dependency')
+                .map((node) => node);
+            for (let depSymbolData of symbolData.dependencies) {
+                let matchingDep = outgoingDeps.find((depNode) => depNode.value.specifier === depSymbolData.specifier);
+                if (matchingDep) {
+                    if (depSymbolData.symbols) {
+                        let internalDepSymbols = new Map();
+                        for (let [symbol, data] of depSymbolData.symbols) {
+                            internalDepSymbols.set(symbol, {
+                                local: data.local,
+                                loc: data.loc || null,
+                                isWeak: data.isWeak,
+                                meta: data.meta,
+                            });
+                        }
+                        matchingDep.value.symbols = internalDepSymbols;
+                    }
+                    if (depSymbolData.usedSymbols) {
+                        matchingDep.usedSymbolsDown = new Set(depSymbolData.usedSymbols);
+                        // For runtime assets, usedSymbolsUp will be the same as usedSymbolsDown
+                        // since we know exactly what we're using
+                        let usedSymbolsUp = new Map();
+                        for (let symbol of depSymbolData.usedSymbols) {
+                            // Mark as resolved to external (null) since runtime deps are typically external
+                            usedSymbolsUp.set(symbol, null);
+                        }
+                        matchingDep.usedSymbolsUp = usedSymbolsUp;
+                    }
+                }
+            }
+        }
+    }
+}
+function reconcileNewRuntimes(api, connections, optionsRef) {
+    let assetGroups = connections.map((t) => t.assetGroup);
+    let request = (0, AssetGraphRequest_1.default)({
+        name: 'Runtimes',
+        assetGroups,
+        optionsRef,
+        skipSymbolProp: (0, feature_flags_1.getFeatureFlag)('skipRuntimeSymbolProp') ||
+            (0, feature_flags_1.getFeatureFlag)('rustSymbolTracker'),
+    });
+    // rebuild the graph
+    return api.runRequest(request, { force: true });
+}

package/dist/assetUtils.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssetIdFromOptions = createAssetIdFromOptions;
+exports.createAsset = createAsset;
+exports.generateFromAST = generateFromAST;
+exports.getInvalidationId = getInvalidationId;
+exports.getInvalidationHash = getInvalidationHash;
+const stream_1 = require("stream");
+const build_cache_1 = require("@atlaspack/build-cache");
+const logger_1 = require("@atlaspack/logger");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const loadAtlaspackPlugin_1 = __importDefault(require("./loadAtlaspackPlugin"));
+const Asset_1 = require("./public/Asset");
+const PluginOptions_1 = __importDefault(require("./public/PluginOptions"));
+const utils_1 = require("@atlaspack/utils");
+const utils_2 = require("./utils");
+const projectPath_1 = require("./projectPath");
+const rust_1 = require("@atlaspack/rust");
+const types_1 = require("./types");
+const profiler_1 = require("@atlaspack/profiler");
+const IdentifierRegistry_1 = require("./IdentifierRegistry");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+function createAssetIdFromOptions(options) {
+    const data = {
+        environmentId: (0, EnvironmentManager_1.toEnvironmentId)(options.env),
+        filePath: options.filePath,
+        code: options.code,
+        pipeline: options.pipeline,
+        query: options.query,
+        uniqueKey: options.uniqueKey,
+        fileType: options.type,
+    };
+    const id = (0, rust_1.createAssetId)(data);
+    IdentifierRegistry_1.identifierRegistry.addIdentifier('asset', id, data);
+    return id;
+}
+function createAsset(projectRoot, options) {
+    return {
+        id: options.id != null ? options.id : createAssetIdFromOptions(options),
+        committed: options.committed ?? false,
+        filePath: options.filePath,
+        query: options.query,
+        bundleBehavior: options.bundleBehavior
+            ? types_1.BundleBehavior[options.bundleBehavior]
+            : null,
+        isBundleSplittable: options.isBundleSplittable ?? true,
+        type: options.type,
+        contentKey: options.contentKey,
+        mapKey: options.mapKey,
+        astKey: options.astKey,
+        astGenerator: options.astGenerator,
+        dependencies: options.dependencies || new Map(),
+        isSource: options.isSource,
+        outputHash: options.outputHash,
+        pipeline: options.pipeline,
+        env: options.env,
+        meta: options.meta || {},
+        stats: options.stats,
+        symbols: options.symbols &&
+            new Map([...options.symbols].map(([k, v]) => [
+                k,
+                {
+                    local: v.local,
+                    meta: v.meta,
+                    loc: (0, utils_2.toInternalSourceLocation)(projectRoot, v.loc),
+                },
+            ])),
+        sideEffects: options.sideEffects ?? true,
+        uniqueKey: options.uniqueKey,
+        plugin: options.plugin,
+        configPath: options.configPath,
+        configKeyPath: options.configKeyPath,
+    };
+}
+const generateResults = new WeakMap();
+function generateFromAST(asset) {
+    let output = generateResults.get(asset.value);
+    if (output == null) {
+        output = _generateFromAST(asset);
+        generateResults.set(asset.value, output);
+    }
+    return output;
+}
+async function _generateFromAST(asset) {
+    let ast = await asset.getAST();
+    if (ast == null) {
+        throw new Error('Asset has no AST');
+    }
+    let pluginName = (0, nullthrows_1.default)(asset.value.plugin);
+    let { plugin } = await (0, loadAtlaspackPlugin_1.default)(pluginName, (0, projectPath_1.fromProjectPath)(asset.options.projectRoot, (0, nullthrows_1.default)(asset.value.configPath)), (0, nullthrows_1.default)(asset.value.configKeyPath), asset.options);
+    let generate = plugin.generate?.bind(plugin);
+    if (!generate) {
+        throw new Error(`${pluginName} does not have a generate method`);
+    }
+    let { content, map } = await generate({
+        asset: new Asset_1.Asset(asset),
+        ast,
+        options: new PluginOptions_1.default(asset.options),
+        logger: new logger_1.PluginLogger({ origin: pluginName }),
+        tracer: new profiler_1.PluginTracer({ origin: pluginName, category: 'asset-generate' }),
+    });
+    let mapBuffer = source_map_1.default.safeToBuffer(map);
+    // Store the results in the cache so we can avoid generating again next time
+    await Promise.all([
+        asset.options.cache.setStream((0, nullthrows_1.default)(asset.value.contentKey), (0, utils_1.blobToStream)(content)),
+        mapBuffer != null &&
+            asset.options.cache.setBlob((0, nullthrows_1.default)(asset.value.mapKey), mapBuffer),
+    ]);
+    return {
+        content: content instanceof stream_1.Readable
+            ? asset.options.cache.getStream((0, nullthrows_1.default)(asset.value.contentKey))
+            : content,
+        map,
+    };
+}
+function getInvalidationId(invalidation) {
+    switch (invalidation.type) {
+        case 'file':
+            return 'file:' + (0, projectPath_1.fromProjectPathRelative)(invalidation.filePath);
+        case 'env':
+            return 'env:' + invalidation.key;
+        case 'option':
+            return 'option:' + invalidation.key;
+        default:
+            // @ts-expect-error TS2339
+            throw new Error('Unknown invalidation type: ' + invalidation.type);
+    }
+}
+const hashCache = (0, build_cache_1.createBuildCache)();
+async function getInvalidationHash(invalidations, options) {
+    if (invalidations.length === 0) {
+        return '';
+    }
+    let sortedInvalidations = invalidations
+        .slice()
+        .sort((a, b) => (getInvalidationId(a) < getInvalidationId(b) ? -1 : 1));
+    let hashes = '';
+    for (let invalidation of sortedInvalidations) {
+        switch (invalidation.type) {
+            case 'file': {
+                // Only recompute the hash of this file if we haven't seen it already during this build.
+                let fileHash = hashCache.get(invalidation.filePath);
+                if (fileHash == null) {
+                    fileHash = (0, utils_1.hashFile)(options.inputFS, (0, projectPath_1.fromProjectPath)(options.projectRoot, invalidation.filePath));
+                    hashCache.set(invalidation.filePath, fileHash);
+                }
+                hashes += await fileHash;
+                break;
+            }
+            case 'env':
+                hashes +=
+                    invalidation.key + ':' + (options.env[invalidation.key] || '');
+                break;
+            case 'option':
+                hashes +=
+                    // @ts-expect-error TS7053
+                    invalidation.key + ':' + (0, utils_2.hashFromOption)(options[invalidation.key]);
+                break;
+            default:
+                // @ts-expect-error TS2339
+                throw new Error('Unknown invalidation type: ' + invalidation.type);
+        }
+    }
+    return (0, rust_1.hashString)(hashes);
+}

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtlaspackV3 = void 0;
+const rust_1 = require("@atlaspack/rust");
+const NapiWorkerPool_1 = require("./NapiWorkerPool");
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+class AtlaspackV3 {
+    constructor(atlaspack_napi, napiWorkerPool, isDefaultNapiWorkerPool) {
+        this._atlaspack_napi = atlaspack_napi;
+        this._napiWorkerPool = napiWorkerPool;
+        this._isDefaultNapiWorkerPool = isDefaultNapiWorkerPool;
+    }
+    static async create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }) {
+        // @ts-expect-error TS2339
+        options.logLevel = options.logLevel || 'error';
+        // @ts-expect-error TS2339
+        options.defaultTargetOptions = options.defaultTargetOptions || {};
+        // @ts-expect-error TS2339
+        options.defaultTargetOptions.engines =
+            // @ts-expect-error TS2339
+            options.defaultTargetOptions.engines || {};
+        let isDefaultNapiWorkerPool = false;
+        if (!napiWorkerPool) {
+            napiWorkerPool = new NapiWorkerPool_1.NapiWorkerPool();
+            isDefaultNapiWorkerPool = true;
+        }
+        // @ts-expect-error TS2488
+        const [internal, error] = await (0, rust_1.atlaspackNapiCreate)({
+            fs,
+            packageManager,
+            threads,
+            options,
+            napiWorkerPool,
+        }, lmdb);
+        if (error !== null) {
+            throw new diagnostic_1.default({
+                diagnostic: error,
+            });
+        }
+        return new AtlaspackV3(internal, napiWorkerPool, isDefaultNapiWorkerPool);
+    }
+    end() {
+        // If the worker pool was provided to us, don't shut it down, it's up to the provider.
+        if (this._isDefaultNapiWorkerPool) {
+            this._napiWorkerPool.shutdown();
+        }
+    }
+    buildAssetGraph(progressCallback) {
+        return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi, progressCallback);
+    }
+    buildBundleGraph(progressCallback) {
+        return (0, rust_1.atlaspackNapiBuildBundleGraph)(this._atlaspack_napi, progressCallback);
+    }
+    build(progressCallback) {
+        return (0, rust_1.atlaspackNapiBuild)(this._atlaspack_napi, progressCallback);
+    }
+    loadBundleGraph(bundleGraph) {
+        const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
+        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
+    }
+    updateBundleGraph(bundleGraph, changedAssetIds) {
+        const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+        return (0, rust_1.atlaspackNapiUpdateBundleGraph)(this._atlaspack_napi, nodesJson);
+    }
+    package(bundleId, options) {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId, options);
+    }
+    async respondToFsEvents(events) {
+        // @ts-expect-error TS2488
+        let [needsRebuild, error] = await (0, rust_1.atlaspackNapiRespondToFsEvents)(this._atlaspack_napi, events);
+        if (error) {
+            throw new Error(error);
+        }
+        return needsRebuild;
+    }
+    async completeCacheSession() {
+        return (await (0, rust_1.atlaspackNapiCompleteSession)(this._atlaspack_napi));
+    }
+}
+exports.AtlaspackV3 = AtlaspackV3;