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

package/dist/requests/WriteBundlesRequest.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createWriteBundlesRequest;
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const RequestTracker_1 = require("../RequestTracker");
+const types_1 = require("../types");
+const ReporterRunner_1 = require("../ReporterRunner");
+const constants_1 = require("../constants");
+const projectPath_1 = require("../projectPath");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const rust_1 = require("@atlaspack/rust");
+const PackageRequest_1 = require("./PackageRequest");
+const WriteBundleRequest_1 = __importDefault(require("./WriteBundleRequest"));
+const utils_1 = require("@atlaspack/utils");
+/** Length of the hash suffix in output filenames (e.g. .runtime.13dc01ac.js). */
+const NAME_HASH_DISPLAY_LEN = 8;
+/** Use at most NAME_HASH_DISPLAY_LEN chars for the name hash so filenames stay short. */
+function nameHashForFilename(hash) {
+    return hash.length <= NAME_HASH_DISPLAY_LEN
+        ? hash
+        : hash.slice(-NAME_HASH_DISPLAY_LEN);
+}
+function reportPackagingProgress(completeBundles, totalBundles) {
+    if (!(0, feature_flags_1.getFeatureFlag)('cliProgressReportingImprovements')) {
+        return;
+    }
+    (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'packagingAndOptimizing',
+        totalBundles,
+        completeBundles,
+    });
+}
+/**
+ * Packages, optimizes, and writes all bundles to the dist directory.
+ */
+function createWriteBundlesRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.write_bundles_request,
+        id: 'write_bundles:' + input.bundleGraph.getBundleGraphHash(),
+        run,
+        input,
+    };
+}
+async function run({ input, api, farm, options, }) {
+    let { bundleGraph, optionsRef } = input;
+    let { ref, dispose } = await farm.createSharedReference(bundleGraph);
+    api.invalidateOnOptionChange('shouldContentHash');
+    let res = new Map();
+    let bundleInfoMap = {};
+    let writeEarlyPromises = {};
+    let hashRefToNameHash = new Map();
+    // Include inline bundles so that non-inline bundles referenced from inline bundles are written to
+    // separate files. This ensures that source maps are written and work.
+    const allBundles = bundleGraph.getBundles({
+        includeInline: (0, feature_flags_1.getFeatureFlag)('inlineBundlesSourceMapFixes'),
+    });
+    const bundles = allBundles
+        .filter((bundle) => bundle.bundleBehavior !== types_1.BundleBehavior.inline &&
+        bundle.bundleBehavior !== types_1.BundleBehavior.inlineIsolated)
+        .filter((bundle) => {
+        // Do not package and write placeholder bundles to disk. We just
+        // need to update the name so other bundles can reference it.
+        if (bundle.isPlaceholder) {
+            const nameHash = nameHashForFilename(bundle.id);
+            hashRefToNameHash.set(bundle.hashReference, nameHash);
+            let name = (0, nullthrows_1.default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, nameHash);
+            res.set(bundle.id, {
+                filePath: (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name),
+                bundleId: bundle.id,
+                type: bundle.type, // FIXME: this is wrong if the packager changes the type...
+                stats: {
+                    time: 0,
+                    size: 0,
+                },
+            });
+            return false;
+        }
+        return true;
+    });
+    let cachedBundles = new Set(bundles.filter((b) => api.canSkipSubrequest(bundleGraph.getHash(b))));
+    // Package on the main thread if there is only one bundle to package.
+    // This avoids the cost of serializing the bundle graph for single file change builds.
+    let useMainThread = bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
+    try {
+        let completeBundles = cachedBundles.size;
+        reportPackagingProgress(completeBundles, bundles.length);
+        await Promise.all(bundles.map(async (bundle) => {
+            let request = (0, PackageRequest_1.createPackageRequest)({
+                bundle,
+                bundleGraph,
+                bundleGraphReference: ref,
+                optionsRef,
+                useMainThread,
+            });
+            let info = await api.runRequest(request);
+            if (!cachedBundles.has(bundle)) {
+                completeBundles++;
+                reportPackagingProgress(completeBundles, bundles.length);
+            }
+            if (!useMainThread) {
+                // Force a refresh of the cache to avoid a race condition
+                // between threaded reads and writes that can result in an LMDB cache miss:
+                //   1. The main thread has read some value from cache, necessitating a read transaction.
+                //   2. Concurrently, Thread A finishes a packaging request.
+                //   3. Subsequently, the main thread is tasked with this request, but fails because the read transaction is stale.
+                // This only occurs if the reading thread has a transaction that was created before the writing thread committed,
+                // and the transaction is still live when the reading thread attempts to get the written value.
+                // See https://github.com/parcel-bundler/parcel/issues/9121
+                options.cache.refresh();
+            }
+            bundleInfoMap[bundle.id] = info;
+            if (!info.hashReferences.length) {
+                hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash ? info.hash : bundle.id));
+                let writeBundleRequest = (0, WriteBundleRequest_1.default)({
+                    bundle,
+                    info,
+                    hashRefToNameHash,
+                    bundleGraph,
+                });
+                let promise = api.runRequest(writeBundleRequest);
+                // If the promise rejects before we await it (below), we don't want to crash the build.
+                promise.catch(() => { });
+                writeEarlyPromises[bundle.id] = promise;
+            }
+        }));
+        assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
+        await Promise.all(bundles.map((bundle) => {
+            let promise = writeEarlyPromises[bundle.id] ??
+                api.runRequest((0, WriteBundleRequest_1.default)({
+                    bundle,
+                    info: bundleInfoMap[bundle.id],
+                    hashRefToNameHash,
+                    bundleGraph,
+                }));
+            return promise.then((r) => res.set(bundle.id, r));
+        }));
+        let result = { bundleInfo: res };
+        if (utils_1.debugTools['scope-hoisting-stats']) {
+            // Aggregate scope hoisting stats from all bundles
+            let aggregatedScopeHoistingStats = {
+                totalAssets: 0,
+                wrappedAssets: 0,
+            };
+            for (let bundle of bundles) {
+                let bundleInfo = bundleInfoMap[bundle.id];
+                if (bundleInfo?.scopeHoistingStats) {
+                    aggregatedScopeHoistingStats.totalAssets +=
+                        bundleInfo.scopeHoistingStats.totalAssets;
+                    aggregatedScopeHoistingStats.wrappedAssets +=
+                        bundleInfo.scopeHoistingStats.wrappedAssets;
+                }
+            }
+            result.scopeHoistingStats = aggregatedScopeHoistingStats;
+        }
+        api.storeResult(result);
+        return result;
+    }
+    finally {
+        await dispose();
+    }
+}
+function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options) {
+    for (let bundle of bundles) {
+        if (hashRefToNameHash.get(bundle.hashReference) != null) {
+            continue;
+        }
+        hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash
+            ? (0, rust_1.hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
+                .map((bundleId) => bundleInfoMap[bundleId].hash)
+                .join(':'))
+            : bundle.id));
+    }
+}
+function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {
+    included.add(bundleId);
+    for (let hashRef of bundleInfoMap[bundleId]?.hashReferences ?? []) {
+        let referencedId = getIdFromHashRef(hashRef);
+        if (!included.has(referencedId)) {
+            getBundlesIncludedInHash(referencedId, bundleInfoMap, included);
+        }
+    }
+    return included;
+}
+function getIdFromHashRef(hashRef) {
+    return hashRef.slice(constants_1.HASH_REF_PREFIX.length);
+}

package/dist/requests/asset-graph-diff.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+// @ts-expect-error missing types
+const default_1 = __importDefault(require("rfdc/default"));
+const jest_diff_1 = require("jest-diff");
+const projectPath_1 = require("../projectPath");
+function filterNode(node) {
+    let clone = (0, default_1.default)(node);
+    // Clean up anything you don't want to see in the diff
+    // delete clone.id;
+    delete clone.value.id;
+    delete clone.value.meta.id;
+    delete clone.value.sourceAssetId;
+    delete clone.value.env.id;
+    delete clone.value.isEsm;
+    delete clone.value.shouldWrap;
+    delete clone.value.contentKey;
+    delete clone.value.placeholder;
+    delete clone.value.code;
+    delete clone.value.hasCjsExports;
+    delete clone.value.staticExports;
+    delete clone.value.isConstantModule;
+    delete clone.value.hasNodeReplacements;
+    delete clone.value.stats;
+    delete clone.value.astKey;
+    delete clone.value.astGenerator;
+    delete clone.value.dependencies;
+    return clone;
+}
+// @ts-expect-error missing return type
+function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
+    if (obj instanceof Map) {
+        const copy = {};
+        Array.from(obj.entries()).forEach(([k, v]) => {
+            if (v != null) {
+                copy[k] = compactDeep(v, ignoredPatterns, `${currentPath}.${k}`);
+            }
+        });
+        return copy;
+    }
+    else if (Array.isArray(obj)) {
+        // @ts-expect-error implicit any
+        return obj.map((v) => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
+    }
+    else if (typeof obj === 'object') {
+        const copy = {};
+        Object.entries(obj ?? {}).forEach(([key, value]) => {
+            const path = `${currentPath}.${key}`;
+            if (ignoredPatterns.some((pattern) => path.includes(pattern))) {
+                return;
+            }
+            // Equivalent false == null
+            if (key === 'isWeak' && value === false) {
+                return;
+            }
+            if (value != null) {
+                copy[key] = compactDeep(value, ignoredPatterns, path);
+            }
+        });
+        return copy;
+    }
+    else if (obj != null) {
+        return obj;
+    }
+}
+function assetGraphDiff(jsAssetGraph, rustAssetGraph, projectRoot) {
+    const getNodes = (graph) => {
+        let nodes = {};
+        // @ts-expect-error implicit any
+        graph.traverse((nodeId) => {
+            let node = graph.getNode(nodeId) ?? null;
+            if (!node)
+                return;
+            if (node.type === 'dependency') {
+                let sourcePath = node.value.sourcePath
+                    ? (0, projectPath_1.toProjectPath)(projectRoot, node.value.sourcePath)
+                    : (0, projectPath_1.toProjectPath)(projectRoot, 'entry');
+                nodes[`dep:${sourcePath}:${node.value.specifier}`] = filterNode(node);
+            }
+            else if (node.type === 'asset') {
+                nodes[`asset:${(0, projectPath_1.toProjectPath)(projectRoot, node.value.filePath)}`] =
+                    filterNode(node);
+            }
+        });
+        return nodes;
+    };
+    const jsNodes = getNodes(jsAssetGraph);
+    const rustNodes = getNodes(rustAssetGraph);
+    const all = new Set([...Object.keys(jsNodes), ...Object.keys(rustNodes)]);
+    const missing = [];
+    const extra = [];
+    for (const key of all.keys()) {
+        if (process.env.NATIVE_COMPARE !== 'true') {
+            continue;
+        }
+        let jsNode = jsNodes[key];
+        let rustNode = rustNodes[key];
+        if (!rustNode) {
+            missing.push(key);
+            continue;
+        }
+        if (!jsNode) {
+            extra.push(key);
+            continue;
+        }
+        console.log(key);
+        const ignoredPatterns = [
+            // ignored because we don't copy the environment ID back from rust
+            // in the target value
+            '$.value.target.env.id',
+            // ignore asset.mapKey because we don't do persistence on rust yet
+            '$.value.mapKey',
+            // ignore this because it's just the output hash. We don't need to compute
+            // this yet
+            '$.value.outputHash',
+            // ignore correspondingRequest from all nodes
+            '$.correspondingRequest',
+        ];
+        console.log((0, jest_diff_1.diff)(compactDeep(jsNode, ignoredPatterns), compactDeep(rustNode, ignoredPatterns)));
+    }
+    console.log('Missing', missing);
+    console.log('Extra', extra);
+}
+module.exports = assetGraphDiff;

package/dist/requests/asset-graph-dot.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetGraphToDot = assetGraphToDot;
+exports.getDebugAssetGraphDotPath = getDebugAssetGraphDotPath;
+exports.getDebugAssetGraphDotOptions = getDebugAssetGraphDotOptions;
+const path_1 = __importDefault(require("path"));
+/** @description Renders AssetGraph into GraphViz Dot format */
+function assetGraphToDot(assetGraph, { sort = false, style = true } = {}) {
+    const edges = [];
+    const nodeStyles = {};
+    assetGraph.traverse((nodeId) => {
+        let node = assetGraph.getNode(nodeId) ?? null;
+        if (!node)
+            return;
+        const fromIds = assetGraph.getNodeIdsConnectedTo(nodeId);
+        for (const fromId of fromIds) {
+            let fromNode = assetGraph.getNode(fromId) ?? null;
+            if (!fromNode)
+                throw new Error('No Node');
+            const edgeStyle = getEdgeStyle(node);
+            const nodeStyle = getNodeStyle(node);
+            let entry = `"${getNodeName(fromNode)}" -> "${getNodeName(node)}"`;
+            if (edgeStyle) {
+                entry += ` [${edgeStyle}]`;
+            }
+            if (nodeStyle) {
+                nodeStyles[getNodeName(node)] = nodeStyle;
+            }
+            edges.push(entry);
+        }
+    });
+    const nodeStylesList = Object.entries(nodeStyles);
+    if (sort) {
+        edges.sort();
+        nodeStylesList.sort();
+    }
+    let digraph = `digraph {\n\tnode [shape=rectangle]\n`;
+    if (style) {
+        digraph += nodeStylesList
+            .map(([node, style]) => `\t"${node}" [${style}]\n`)
+            .join('');
+    }
+    digraph += edges.map((v) => `\t${v}\n`).join('');
+    digraph += `}\n`;
+    return digraph;
+}
+function getDebugAssetGraphDotPath() {
+    let debugAssetGraphDot = process.env.DEBUG_ASSET_GRAPH_DOT;
+    if (debugAssetGraphDot === undefined || debugAssetGraphDot === '') {
+        return null;
+    }
+    if (!path_1.default.isAbsolute(debugAssetGraphDot)) {
+        debugAssetGraphDot = path_1.default.join(process.cwd(), debugAssetGraphDot);
+    }
+    return debugAssetGraphDot;
+}
+function getDebugAssetGraphDotOptions() {
+    const options = {};
+    let style = process.env.DEBUG_ASSET_GRAPH_DOT_STYLE;
+    if (style !== undefined) {
+        options.style = style === 'true';
+    }
+    let sort = process.env.DEBUG_ASSET_GRAPH_DOT_SORT;
+    if (sort !== undefined) {
+        options.sort = sort === 'true';
+    }
+    return options;
+}
+function fromCwd(input) {
+    return path_1.default.relative(process.cwd(), input);
+}
+function getNodeName(node) {
+    if (node.type === 'asset_group') {
+        // @ts-expect-error TS2345
+        return [`asset_group`, node.id, fromCwd(node.value.filePath)].join('\\n');
+    }
+    else if (node.type === 'asset') {
+        return [`asset`, node.id, fromCwd(node.value.filePath)].join('\\n');
+    }
+    else if (node.type === 'dependency') {
+        return [`dependency`, node.id, node.value.specifier].join('\\n');
+    }
+    else if (node.type === 'entry_specifier') {
+        return [`entry_specifier`, node.value].join('\\n');
+    }
+    else if (node.type === 'entry_file') {
+        return [`entry_file`, fromCwd(node.value.filePath)].join('\\n');
+    }
+    return 'ROOT';
+}
+function getEdgeStyle(node) {
+    if (node.type === 'asset_group') {
+        return ``;
+    }
+    else if (node.type === 'asset') {
+        return ``;
+    }
+    else if (node.type === 'dependency') {
+        if (node.value.priority === 2) {
+            return `style="dashed"`;
+        }
+    }
+    else if (node.type === 'entry_specifier') {
+        return ``;
+    }
+    else if (node.type === 'entry_file') {
+        return ``;
+    }
+    return '';
+}
+function getNodeStyle(node) {
+    if (node.type === 'asset_group') {
+        return `fillcolor="#E8F5E9", style="filled"`;
+    }
+    else if (node.type === 'asset') {
+        return `fillcolor="#DCEDC8", style="filled"`;
+    }
+    else if (node.type === 'dependency') {
+        return `fillcolor="#BBDEFB", style="filled"`;
+    }
+    else if (node.type === 'entry_specifier') {
+        return `fillcolor="#FFF9C4", style="filled"`;
+    }
+    else if (node.type === 'entry_file') {
+        return `fillcolor="#FFE0B2", style="filled"`;
+    }
+    return '';
+}