@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

package/dist/requests/AssetGraphRequestRust.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAssetGraphRequestRust = createAssetGraphRequestRust;
+exports.getAssetGraph = getAssetGraph;
+const assert_1 = __importDefault(require("assert"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const logger_1 = require("@atlaspack/logger");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const AssetGraph_1 = __importDefault(require("../AssetGraph"));
+const RequestTracker_1 = require("../RequestTracker");
+const SymbolPropagation_1 = require("../SymbolPropagation");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const Environment_1 = require("../Environment");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const assert_2 = __importDefault(require("assert"));
+function createAssetGraphRequestRust(rustAtlaspack) {
+    return (input) => ({
+        type: RequestTracker_1.requestTypes.asset_graph_request,
+        id: input.name,
+        run: async (input) => {
+            let options = input.options;
+            let { assetGraphPromise, commitPromise } = await rustAtlaspack.buildAssetGraph();
+            let [serializedAssetGraph, assetGraphError] = (await assetGraphPromise);
+            if (assetGraphError) {
+                throw new diagnostic_1.default({
+                    diagnostic: assetGraphError,
+                });
+            }
+            // Don't reuse a previous asset graph result if Rust didn't have one too
+            let prevResult = null;
+            if (serializedAssetGraph.hadPreviousGraph) {
+                prevResult =
+                    await input.api.getPreviousResult();
+            }
+            let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph, prevResult?.assetGraph));
+            let changedAssetsPropagation = new Set(changedAssets.keys());
+            let errors = (0, SymbolPropagation_1.propagateSymbols)({
+                options,
+                assetGraph,
+                changedAssetsPropagation,
+                assetGroupsWithRemovedParents: new Set(),
+                previousErrors: new Map(), //this.previousSymbolPropagationErrors,
+            });
+            if (errors.size > 0) {
+                // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+                // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+                throw new diagnostic_1.default({
+                    diagnostic: [...errors.values()][0],
+                });
+            }
+            await (0, dumpGraphToGraphViz_1.default)(assetGraph, 'AssetGraphV3');
+            let result = {
+                assetGraph,
+                assetRequests: [],
+                assetGroupsWithRemovedParents: new Set(),
+                changedAssets,
+                changedAssetsPropagation,
+                previousSymbolPropagationErrors: undefined,
+            };
+            let [_commitResult, commitError] = await commitPromise;
+            if (commitError) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: 'Error committing asset graph in Rust: ' + commitError.message,
+                    },
+                });
+            }
+            await input.api.storeResult(result);
+            input.api.invalidateOnBuild();
+            return result;
+        },
+        input,
+    });
+}
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+    let graph;
+    let reuseEdges = false;
+    if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+            _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+            nodes: prevAssetGraph.nodes,
+            rootNodeId: prevAssetGraph.rootNodeId,
+            adjacencyList: prevAssetGraph.adjacencyList,
+        });
+        reuseEdges = true;
+    }
+    else if (prevAssetGraph &&
+        (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)) {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+            _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+            nodes: prevAssetGraph.nodes,
+            initialCapacity: serializedGraph.edges.length,
+            // Accomodate the root node
+            initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+            rootNodeId: prevAssetGraph.rootNodeId,
+        });
+        graph.safeToIncrementallyBundle = false;
+    }
+    else {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: new Map(),
+            _nodeIdToContentKey: new Map(),
+            initialCapacity: serializedGraph.edges.length,
+            // Accomodate the root node
+            initialNodeCapacity: serializedGraph.nodes.length + 1,
+        });
+        let rootNodeId = graph.addNodeByContentKey('@@root', {
+            id: '@@root',
+            type: 'root',
+            value: null,
+        });
+        graph.setRootNodeId(rootNodeId);
+        graph.safeToIncrementallyBundle = false;
+    }
+    (0, assert_1.default)(graph, 'Asset graph not initialized');
+    (0, assert_1.default)(graph.rootNodeId != null, 'Asset graph has no root node');
+    // @ts-expect-error TS7031
+    function mapSymbols({ exported, ...symbol }) {
+        let jsSymbol = {
+            local: symbol.local ?? undefined,
+            loc: symbol.loc ?? undefined,
+            isWeak: symbol.isWeak,
+            meta: {
+                isEsm: symbol.isEsmExport,
+                isStaticBindingSafe: symbol.isStaticBindingSafe,
+            },
+        };
+        if (symbol.exported) {
+            // @ts-expect-error TS2339
+            jsSymbol.exported = symbol.exported;
+        }
+        return [exported, jsSymbol];
+    }
+    // See crates/atlaspack_core/src/types/environment.rs
+    let changedAssets = new Map();
+    let entry = 0;
+    let envs = new Map();
+    let getEnvId = (env) => {
+        let envKey = [
+            env.context,
+            env.engines.atlaspack,
+            env.engines.browsers,
+            env.engines.electron,
+            env.engines.node,
+            env.includeNodeModules,
+            env.isLibrary,
+            env.outputFormat,
+            env.shouldScopeHoist,
+            env.shouldOptimize,
+            env.sourceType,
+        ].join(':');
+        let envId = envs.get(envKey);
+        if (envId == null) {
+            envId = (0, Environment_1.getEnvironmentHash)(env);
+            envs.set(envKey, envId);
+        }
+        return envId;
+    };
+    function updateNode(newNode, isUpdateNode) {
+        if (isUpdateNode) {
+            let existingNode = graph.getNodeByContentKey(newNode.id);
+            (0, assert_2.default)(existingNode && existingNode.type === newNode.type);
+            Object.assign(existingNode, newNode);
+        }
+        else {
+            graph.addNodeByContentKey(newNode.id, newNode);
+        }
+    }
+    let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+    let nodesCount = serializedGraph.nodes.length + serializedGraph.updates.length;
+    for (let index = 0; index < nodesCount; index++) {
+        let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+        let node = isUpdateNode
+            ? serializedGraph.updates[index - nodeTypeSwitchoverIndex]
+            : serializedGraph.nodes[index];
+        node = JSON.parse(node);
+        if (node.type === 'entry') {
+            let id = 'entry:' + ++entry;
+            graph.addNodeByContentKey(id, {
+                id: id,
+                type: 'root',
+                value: null,
+            });
+        }
+        else if (node.type === 'asset') {
+            let asset = node.value;
+            let id = asset.id;
+            asset.committed = true;
+            asset.contentKey = id;
+            asset.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? // TODO: Rust can do this and avoid copying a significant amount of data over
+                    (0, Environment_1.getEnvironmentHash)(asset.env)
+                : getEnvId(asset.env);
+            asset.mapKey = `map:${asset.id}`;
+            asset.env = (0, EnvironmentManager_1.toEnvironmentRef)(asset.env);
+            // This is populated later when we map the edges between assets and dependencies
+            asset.dependencies = new Map();
+            // We need to add this property for source map handling, as some assets like runtimes
+            // are processed after the Rust transformation and take the v2 code path
+            asset.meta.isV3 = true;
+            if (asset.symbols != null) {
+                asset.symbols = new Map(asset.symbols.map(mapSymbols));
+            }
+            changedAssets.set(id, asset);
+            let assetNode = {
+                id,
+                type: 'asset',
+                usedSymbols: new Set(),
+                usedSymbolsDownDirty: true,
+                usedSymbolsUpDirty: true,
+                value: asset,
+            };
+            updateNode(assetNode, isUpdateNode);
+        }
+        else if (node.type === 'dependency') {
+            let { dependency, id } = node.value;
+            dependency.id = id;
+            dependency.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? // TODO: Rust can do this and avoid copying a significant amount of data over
+                    (0, Environment_1.getEnvironmentHash)(dependency.env)
+                : getEnvId(dependency.env);
+            dependency.env = (0, EnvironmentManager_1.toEnvironmentRef)(dependency.env);
+            if (dependency.symbols != null) {
+                dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
+            }
+            let usedSymbolsDown = new Set();
+            let usedSymbolsUp = new Map();
+            if (dependency.isEntry && dependency.isLibrary) {
+                usedSymbolsDown.add('*');
+                usedSymbolsUp.set('*', undefined);
+            }
+            let depNode = {
+                id,
+                type: 'dependency',
+                deferred: false,
+                excluded: false,
+                hasDeferred: node.has_deferred,
+                // @ts-expect-error TS2322
+                usedSymbolsDown,
+                usedSymbolsDownDirty: true,
+                usedSymbolsUp,
+                usedSymbolsUpDirtyDown: true,
+                usedSymbolsUpDirtyUp: true,
+                value: dependency,
+            };
+            updateNode(depNode, isUpdateNode);
+        }
+    }
+    if (!reuseEdges) {
+        for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+            let from = serializedGraph.edges[i];
+            let to = serializedGraph.edges[i + 1];
+            let fromNode = graph.getNode(from);
+            let toNode = graph.getNode(to);
+            if (fromNode?.type === 'dependency') {
+                (0, assert_1.default)(toNode?.type === 'asset');
+            }
+            if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+                fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+            }
+            graph.addEdge(from, to);
+        }
+    }
+    return {
+        assetGraph: graph,
+        changedAssets,
+    };
+}

package/dist/requests/AssetRequest.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAssetRequest;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const rust_1 = require("@atlaspack/rust");
+const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+const DevDepRequest_1 = require("./DevDepRequest");
+const ConfigRequest_1 = require("./ConfigRequest");
+const projectPath_1 = require("../projectPath");
+const ReporterRunner_1 = require("../ReporterRunner");
+const RequestTracker_1 = require("../RequestTracker");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+function createAssetRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.asset_request,
+        id: getId(input),
+        run,
+        input,
+    };
+}
+const type = 'asset_request';
+function getId(input) {
+    return (0, rust_1.hashString)(type +
+        (0, projectPath_1.fromProjectPathRelative)(input.filePath) +
+        (0, EnvironmentManager_1.toEnvironmentId)(input.env) +
+        String(input.isSource) +
+        String(input.sideEffects) +
+        (input.code ?? '') +
+        ':' +
+        (input.pipeline ?? '') +
+        ':' +
+        (input.query ?? ''));
+}
+// @ts-expect-error TS7031
+async function run({ input, api, farm, invalidateReason, options }) {
+    (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'transforming',
+        filePath: (0, projectPath_1.fromProjectPath)(options.projectRoot, input.filePath),
+    });
+    api.invalidateOnFileUpdate(input.filePath);
+    let start = Date.now();
+    let { optionsRef, ...rest } = input;
+    let { cachePath } = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let previousDevDepRequests = new Map(await Promise.all(api
+        .getSubRequests()
+        // @ts-expect-error TS7006
+        .filter((req) => req.requestType === RequestTracker_1.requestTypes.dev_dep_request)
+        // @ts-expect-error TS7006
+        .map(async (req) => [
+        req.id,
+        // @ts-expect-error TS2347
+        (0, nullthrows_1.default)(await api.getRequestResult(req.id)),
+    ])));
+    let request = {
+        ...rest,
+        invalidateReason,
+        devDeps: new Map([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => api.canSkipSubrequest(id))
+            .map(([, req]) => [
+            `${req.specifier}:${(0, projectPath_1.fromProjectPathRelative)(req.resolveFrom)}`,
+            req.hash,
+        ])),
+        invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => !api.canSkipSubrequest(id))
+            .flatMap(([, req]) => {
+            return [
+                {
+                    specifier: req.specifier,
+                    resolveFrom: req.resolveFrom,
+                },
+                // @ts-expect-error TS7006
+                ...(req.additionalInvalidations ?? []).map((i) => ({
+                    specifier: i.specifier,
+                    resolveFrom: i.resolveFrom,
+                })),
+            ];
+        })),
+    };
+    let { assets, configRequests, error, invalidations, devDepRequests } = (await farm.createHandle('runTransform', input.isSingleChangeRebuild)({
+        configCachePath: cachePath,
+        optionsRef,
+        request,
+    }));
+    let time = Date.now() - start;
+    if (assets) {
+        for (let asset of assets) {
+            asset.stats.time = time;
+        }
+    }
+    for (let filePath of invalidations.invalidateOnFileChange) {
+        api.invalidateOnFileUpdate(filePath);
+        api.invalidateOnFileDelete(filePath);
+    }
+    for (let invalidation of invalidations.invalidateOnFileCreate) {
+        api.invalidateOnFileCreate(invalidation);
+    }
+    for (let env of invalidations.invalidateOnEnvChange) {
+        api.invalidateOnEnvChange(env);
+    }
+    for (let option of invalidations.invalidateOnOptionChange) {
+        api.invalidateOnOptionChange(option);
+    }
+    if (invalidations.invalidateOnStartup) {
+        api.invalidateOnStartup();
+    }
+    if (invalidations.invalidateOnBuild) {
+        api.invalidateOnBuild();
+    }
+    for (let devDepRequest of devDepRequests) {
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+    for (let configRequest of configRequests) {
+        await (0, ConfigRequest_1.runConfigRequest)(api, configRequest);
+    }
+    if (error != null) {
+        throw new diagnostic_1.default({ diagnostic: error });
+    }
+    else {
+        return (0, nullthrows_1.default)(assets);
+    }
+}

package/dist/requests/AtlaspackBuildRequest.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAtlaspackBuildRequest;
+const BundleGraphRequest_1 = __importDefault(require("./BundleGraphRequest"));
+const WriteBundlesRequest_1 = __importDefault(require("./WriteBundlesRequest"));
+const utils_1 = require("../utils");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const BundleGraph_1 = require("../BundleGraph");
+const ReporterRunner_1 = require("../ReporterRunner");
+const BundleGraph_2 = __importDefault(require("../public/BundleGraph"));
+const Bundle_1 = require("../public/Bundle");
+const Asset_1 = require("../public/Asset");
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+function createAtlaspackBuildRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.atlaspack_build_request,
+        id: 'atlaspack_build_request',
+        run,
+        input,
+    };
+}
+async function run({ input, api, options, rustAtlaspack, }) {
+    let { optionsRef, requestedAssetIds, signal } = input;
+    let bundleGraphRequest = (0, BundleGraphRequest_1.default)({
+        optionsRef,
+        requestedAssetIds,
+        signal,
+    });
+    let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
+        force: Boolean(rustAtlaspack) ||
+            (options.shouldBuildLazily && requestedAssetIds.size > 0),
+    });
+    if ((0, feature_flags_1.getFeatureFlag)('nativePackager') &&
+        (0, feature_flags_1.getFeatureFlag)('nativePackagerSSRDev') &&
+        rustAtlaspack) {
+        let hasSupportedTarget = false;
+        bundleGraph.traverseBundles((bundle, ctx, actions) => {
+            if ((0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context === 'tesseract' &&
+                bundle.type === 'js') {
+                hasSupportedTarget = true;
+                actions.stop();
+            }
+        });
+        if (hasSupportedTarget) {
+            // In theory this could be a (somehow) null[] - but we know if we've gotten this far it probably isn't..
+            let nodes = bundleGraph._graph.nodes;
+            let rawEdges = [];
+            const gen = bundleGraph._graph.getAllEdges();
+            let next = gen.next();
+            while (!next.done) {
+                let edge = next.value;
+                rawEdges.push([edge.from, edge.to, edge.type]);
+                next = gen.next();
+            }
+            await rustAtlaspack.loadBundleGraph({ nodes, edges: rawEdges });
+        }
+    }
+    // @ts-expect-error TS2345
+    (0, dumpGraphToGraphViz_1.default)(bundleGraph._graph, 'BundleGraph', BundleGraph_1.bundleGraphEdgeTypes);
+    await (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'bundled',
+        bundleGraph: new BundleGraph_2.default(bundleGraph, 
+        // @ts-expect-error TS2304
+        (bundle, bundleGraph, options) => Bundle_1.NamedBundle.get(bundle, bundleGraph, options), options),
+        changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [
+            id,
+            (0, Asset_1.assetFromValue)(asset, options),
+        ])),
+    });
+    let packagingMeasurement = profiler_1.tracer.createMeasurement('packaging');
+    let writeBundlesRequest = (0, WriteBundlesRequest_1.default)({
+        bundleGraph,
+        optionsRef,
+    });
+    let { bundleInfo, scopeHoistingStats } = await api.runRequest(writeBundlesRequest);
+    packagingMeasurement && packagingMeasurement.end();
+    (0, utils_1.assertSignalNotAborted)(signal);
+    return {
+        bundleGraph,
+        bundleInfo,
+        changedAssets,
+        assetRequests,
+        scopeHoistingStats,
+    };
+}