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

package/dist/atlaspack-v3/worker/worker.js

@@ -0,0 +1,381 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _AtlaspackWorker_resolvers, _AtlaspackWorker_transformers, _AtlaspackWorker_fs, _AtlaspackWorker_packageManager, _AtlaspackWorker_options, _AtlaspackWorker_sideEffectDetector;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtlaspackWorker = void 0;
+/* eslint-disable import/first */
+const side_effect_detector_1 = require("./side-effect-detector");
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new side_effect_detector_1.SideEffectDetector();
+sideEffectDetector.install();
+const assert_1 = __importDefault(require("assert"));
+const napi = __importStar(require("@atlaspack/rust"));
+const fs_1 = require("@atlaspack/fs");
+const package_manager_1 = require("@atlaspack/package-manager");
+const worker_threads_1 = require("worker_threads");
+const module = __importStar(require("module"));
+const jsCallable_1 = require("../jsCallable");
+const compat_1 = require("./compat");
+const CONFIG = Symbol.for('parcel-plugin-config');
+class AtlaspackWorker {
+    constructor() {
+        _AtlaspackWorker_resolvers.set(this, void 0);
+        _AtlaspackWorker_transformers.set(this, void 0);
+        _AtlaspackWorker_fs.set(this, void 0);
+        _AtlaspackWorker_packageManager.set(this, void 0);
+        _AtlaspackWorker_options.set(this, void 0);
+        _AtlaspackWorker_sideEffectDetector.set(this, void 0);
+        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom, options }) => {
+            // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
+            let resolvedModule = await __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").require(specifier, resolveFrom, { shouldAutoInstall: false });
+            let instance = undefined;
+            // Check for CommonJS export (module.exports = new Plugin(...))
+            if (resolvedModule[CONFIG]) {
+                instance = resolvedModule[CONFIG];
+            }
+            else if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+                // ESM default export
+                instance = resolvedModule.default[CONFIG];
+            }
+            else if (resolvedModule.default &&
+                resolvedModule.default.default &&
+                resolvedModule.default.default[CONFIG]) {
+                // Double-wrapped default export
+                instance = resolvedModule.default.default[CONFIG];
+            }
+            else {
+                throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
+            }
+            if (__classPrivateFieldGet(this, _AtlaspackWorker_options, "f") == null) {
+                __classPrivateFieldSet(this, _AtlaspackWorker_options, {
+                    ...options,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager: __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f"),
+                    shouldAutoInstall: false,
+                }, "f");
+            }
+            // Set feature flags in the worker process
+            let featureFlagsModule = await __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").require('@atlaspack/feature-flags', __filename, { shouldAutoInstall: false });
+            featureFlagsModule.setFeatureFlags(options.featureFlags);
+            switch (kind) {
+                case 'resolver':
+                    __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").set(specifier, { resolver: instance });
+                    break;
+                case 'transformer': {
+                    return this.initializeTransformer(instance, specifier);
+                }
+            }
+        });
+        this.runResolverResolve = (0, jsCallable_1.jsCallable)(async ({ key, dependency: napiDependency, specifier, pipeline }) => {
+            const state = __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").get(key);
+            if (!state) {
+                throw new Error(`Resolver not found: ${key}`);
+            }
+            const env = new compat_1.Environment(napiDependency.env);
+            const dependency = new compat_1.Dependency(napiDependency, env);
+            const defaultOptions = {
+                logger: new compat_1.PluginLogger(),
+                tracer: new compat_1.PluginTracer(),
+                options: new compat_1.PluginOptions(this.options),
+            };
+            if (!('config' in state)) {
+                // @ts-expect-error TS2345
+                state.config = await state.resolver.loadConfig?.({
+                    config: new compat_1.PluginConfig({
+                        env: napiDependency.env,
+                        plugin: key,
+                        isSource: true,
+                        searchPath: 'index',
+                    }, this.options),
+                    ...defaultOptions,
+                });
+            }
+            // @ts-expect-error TS2345
+            const result = await state.resolver.resolve({
+                specifier,
+                dependency,
+                pipeline,
+                config: state.config,
+                ...defaultOptions,
+            });
+            if (!result) {
+                return {
+                    invalidations: [],
+                    resolution: { type: 'unresolved' },
+                };
+            }
+            if (result.isExcluded) {
+                return {
+                    invalidations: [],
+                    resolution: { type: 'excluded' },
+                };
+            }
+            return {
+                invalidations: [],
+                resolution: {
+                    type: 'resolved',
+                    filePath: result.filePath || '',
+                    canDefer: result.canDefer || false,
+                    sideEffects: result.sideEffects ?? true,
+                    code: result.code || undefined,
+                    meta: result.meta || undefined,
+                    pipeline: result.pipeline || undefined,
+                    priority: compat_1.dependencyPriorityMap.intoNullable(result.priority),
+                    query: result.query && result.query.toString(),
+                },
+            };
+        });
+        this.runTransformerTransform = (0, jsCallable_1.jsCallable)(async ({ key, asset: innerAsset }, contents, map) => {
+            const instance = __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").get(key);
+            if (!instance) {
+                throw new Error(`Transformer not found: ${key}`);
+            }
+            let { transformer, config, allowedEnv = new Set() } = instance;
+            let cacheBailouts = [];
+            const resolveFunc = (from, to) => {
+                let customRequire = module.createRequire(from);
+                let resolvedPath = customRequire.resolve(to);
+                // Tranformer not cacheable due to use of the resolve function
+                cacheBailouts.push(`resolve(${from}, ${to})`);
+                return Promise.resolve(resolvedPath);
+            };
+            const env = new compat_1.Environment(innerAsset.env);
+            let mutableAsset = new compat_1.MutableAsset(innerAsset, 
+            // @ts-expect-error TS2345
+            contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, this.options.projectRoot);
+            const pluginOptions = new compat_1.PluginOptions(this.options);
+            const defaultOptions = {
+                logger: new compat_1.PluginLogger(),
+                tracer: new compat_1.PluginTracer(),
+                options: pluginOptions,
+            };
+            if (transformer.loadConfig) {
+                if (config != null) {
+                    throw new Error(`Transformer (${key}) should not implement 'setup' and 'loadConfig'`);
+                }
+                // @ts-expect-error TS2345
+                config = await transformer.loadConfig({
+                    config: new compat_1.PluginConfig({
+                        plugin: key,
+                        isSource: innerAsset.isSource,
+                        searchPath: innerAsset.filePath,
+                        env,
+                    }, this.options),
+                    ...defaultOptions,
+                });
+                // Transformer uses the deprecated loadConfig API, so mark as not
+                // cachable
+                cacheBailouts.push(`Transformer.loadConfig`);
+            }
+            if (transformer.parse) {
+                const ast = await transformer.parse({
+                    // @ts-expect-error TS2322
+                    asset: mutableAsset,
+                    config,
+                    resolve: resolveFunc,
+                    ...defaultOptions,
+                });
+                if (ast) {
+                    mutableAsset.setAST(ast);
+                }
+                cacheBailouts.push(`Transformer.parse`);
+            }
+            const [result, sideEffects] = await __classPrivateFieldGet(this, _AtlaspackWorker_sideEffectDetector, "f").monitorSideEffects(key, () => transformer.transform({
+                // @ts-expect-error TS2322
+                asset: mutableAsset,
+                config,
+                resolve: resolveFunc,
+                ...defaultOptions,
+            }));
+            if (sideEffects.envUsage.didEnumerate) {
+                cacheBailouts.push(`Env access: enumeration of process.env`);
+            }
+            for (let variable of sideEffects.envUsage.vars) {
+                if (variable in allowedEnv) {
+                    continue;
+                }
+                cacheBailouts.push(`Env access: ${variable}`);
+            }
+            for (let { method, path } of sideEffects.fsUsage) {
+                cacheBailouts.push(`FS usage: ${method}(${path})`);
+            }
+            (0, assert_1.default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+            (0, assert_1.default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
+            if (transformer.generate) {
+                const ast = await mutableAsset.getAST();
+                if (ast) {
+                    const output = await transformer.generate({
+                        // @ts-expect-error TS2322
+                        asset: mutableAsset,
+                        ast,
+                        ...defaultOptions,
+                    });
+                    if (typeof output.content === 'string') {
+                        mutableAsset.setCode(output.content);
+                    }
+                    else if (output.content instanceof Buffer) {
+                        mutableAsset.setBuffer(output.content);
+                    }
+                    else {
+                        // @ts-expect-error TS2345
+                        mutableAsset.setStream(output.content);
+                    }
+                    if (output.map) {
+                        mutableAsset.setMap(output.map);
+                    }
+                }
+            }
+            let assetBuffer = await mutableAsset.getBuffer();
+            // If the asset has no code, we set the buffer to null, which we can
+            // detect in Rust, to avoid passing back an empty buffer, which we can't.
+            if (assetBuffer.length === 0) {
+                assetBuffer = null;
+            }
+            if (pluginOptions.used) {
+                // Plugin options accessed, so not cachable
+                cacheBailouts.push(`Plugin options accessed`);
+            }
+            return [
+                {
+                    id: mutableAsset.id,
+                    bundleBehavior: compat_1.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
+                    code: [],
+                    filePath: mutableAsset.filePath,
+                    isBundleSplittable: mutableAsset.isBundleSplittable,
+                    isSource: mutableAsset.isSource,
+                    meta: mutableAsset.meta,
+                    pipeline: mutableAsset.pipeline,
+                    // Query should be undefined if it's empty
+                    query: mutableAsset.query.toString() || undefined,
+                    sideEffects: mutableAsset.sideEffects,
+                    symbols: mutableAsset.symbols.intoNapi(),
+                    type: mutableAsset.type,
+                    uniqueKey: mutableAsset.uniqueKey,
+                },
+                assetBuffer,
+                // Only send back the map if it has changed
+                mutableAsset.isMapDirty
+                    ? // @ts-expect-error TS2533
+                        JSON.stringify((await mutableAsset.getMap()).toVLQ())
+                    : '',
+                // Limit to first 10 bailouts
+                cacheBailouts.slice(0, 10),
+            ];
+        });
+        __classPrivateFieldSet(this, _AtlaspackWorker_resolvers, new Map(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_transformers, new Map(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_fs, new fs_1.NodeFS(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_packageManager, new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), '/'), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_sideEffectDetector, sideEffectDetector, "f"); // Use the global detector that was installed before imports
+    }
+    clearState() {
+        __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").clear();
+        __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").clear();
+        __classPrivateFieldSet(this, _AtlaspackWorker_options, undefined, "f");
+    }
+    get options() {
+        if (__classPrivateFieldGet(this, _AtlaspackWorker_options, "f") == null) {
+            throw new Error('Plugin options have not been initialized');
+        }
+        return __classPrivateFieldGet(this, _AtlaspackWorker_options, "f");
+    }
+    async initializeTransformer(instance, specifier) {
+        let transformer = instance;
+        let setup, config, allowedEnv;
+        let packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), this.options.projectRoot);
+        if (transformer.setup) {
+            let setupResult = await transformer.setup({
+                logger: new compat_1.PluginLogger(),
+                options: new compat_1.PluginOptions({
+                    ...this.options,
+                    shouldAutoInstall: false,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager,
+                }),
+                config: new compat_1.PluginConfig({
+                    plugin: specifier,
+                    searchPath: 'index',
+                    // Consider project setup config as source
+                    isSource: true,
+                }, this.options),
+            });
+            config = setupResult?.config;
+            allowedEnv = Object.fromEntries(setupResult?.env?.map((env) => [env, process.env[env]]) || []);
+            // Always add the following env vars to the cache key
+            allowedEnv['NODE_ENV'] = process.env['NODE_ENV'];
+            setup = {
+                conditions: setupResult?.conditions,
+                config,
+                env: allowedEnv,
+            };
+        }
+        __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, {
+            transformer,
+            config,
+            packageManager,
+            allowedEnv,
+        });
+        return setup;
+    }
+}
+exports.AtlaspackWorker = AtlaspackWorker;
+_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap(), _AtlaspackWorker_options = new WeakMap(), _AtlaspackWorker_sideEffectDetector = new WeakMap();
+// Create napi worker and send it back to main thread
+const worker = new AtlaspackWorker();
+const napiWorker = napi.newNodejsWorker(worker);
+worker_threads_1.parentPort?.postMessage(napiWorker);
+worker_threads_1.parentPort?.setMaxListeners(worker_threads_1.parentPort.getMaxListeners() + 1);
+worker_threads_1.parentPort?.addListener('message', (message) => {
+    if (message === 'clearState') {
+        worker.clearState();
+        worker_threads_1.parentPort?.postMessage('stateCleared');
+    }
+});

package/dist/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR = exports.STARTUP = exports.OPTION_CHANGE = exports.ENV_CHANGE = exports.FILE_DELETE = exports.FILE_UPDATE = exports.FILE_CREATE = exports.INITIAL_BUILD = exports.VALID = exports.HASH_REF_REGEX = exports.HASH_REF_HASH_LEN = exports.HASH_REF_PREFIX = exports.ATLASPACK_VERSION = void 0;
+const package_json_1 = require("../package.json");
+exports.ATLASPACK_VERSION = package_json_1.version;
+exports.HASH_REF_PREFIX = 'HASH_REF_';
+exports.HASH_REF_HASH_LEN = 16;
+exports.HASH_REF_REGEX = new RegExp(`${exports.HASH_REF_PREFIX}\\w{${exports.HASH_REF_HASH_LEN}}`, 'g');
+exports.VALID = 0;
+exports.INITIAL_BUILD = 1 << 0;
+exports.FILE_CREATE = 1 << 1;
+exports.FILE_UPDATE = 1 << 2;
+exports.FILE_DELETE = 1 << 3;
+exports.ENV_CHANGE = 1 << 4;
+exports.OPTION_CHANGE = 1 << 5;
+exports.STARTUP = 1 << 6;
+exports.ERROR = 1 << 7;

package/dist/dumpGraphToGraphViz.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dumpGraphToGraphViz;
+const path_1 = __importDefault(require("path"));
+const graph_1 = require("@atlaspack/graph");
+const projectPath_1 = require("./projectPath");
+const types_1 = require("./types");
+const COLORS = {
+    root: 'gray',
+    asset: 'green',
+    dependency: 'orange',
+    transformer_request: 'cyan',
+    file: 'gray',
+    default: 'white',
+};
+const TYPE_COLORS = {
+    // bundle graph
+    bundle: 'blue',
+    contains: 'grey',
+    internal_async: 'orange',
+    references: 'red',
+    sibling: 'green',
+    // asset graph
+    // request graph
+    invalidated_by_create: 'green',
+    invalidated_by_create_above: 'orange',
+    invalidate_by_update: 'cyan',
+    invalidated_by_delete: 'red',
+};
+async function dumpGraphToGraphViz(graph, name, edgeTypes) {
+    if (process.env.ATLASPACK_BUILD_ENV === 'production' &&
+        !process.env.ATLASPACK_BUILD_REPL) {
+        return;
+    }
+    let mode = process.env.ATLASPACK_BUILD_REPL
+        ? // @ts-expect-error TS7017
+            globalThis.ATLASPACK_DUMP_GRAPHVIZ?.mode
+        : process.env.ATLASPACK_DUMP_GRAPHVIZ;
+    // @ts-expect-error TS2367
+    if (mode == null || mode == false) {
+        return;
+    }
+    let detailedSymbols = mode === 'symbols';
+    let GraphVizGraph = require('graphviz/lib/deps/graph').Graph;
+    let g = new GraphVizGraph(null, 'G');
+    g.type = 'digraph';
+    for (let [id, node] of graph.nodes.entries()) {
+        if (node == null)
+            continue;
+        let n = g.addNode(nodeId(id));
+        // @ts-expect-error TS7053
+        n.set('color', COLORS[node.type || 'default']);
+        n.set('shape', 'box');
+        n.set('style', 'filled');
+        let label;
+        if (typeof node === 'string') {
+            label = node;
+            // @ts-expect-error TS2339
+        }
+        else if (node.assets) {
+            // @ts-expect-error TS2339
+            label = `(${nodeId(id)}), (assetIds: ${[...node.assets]
+                .map((a) => {
+                let arr = a.filePath.split('/');
+                return arr[arr.length - 1];
+            })
+                // @ts-expect-error TS2339
+                .join(', ')}) (sourceBundles: ${[...node.sourceBundles].join(', ')}) (bb ${node.bundleBehavior ?? 'none'})`;
+            // @ts-expect-error TS2339
+        }
+        else if (node.type) {
+            // @ts-expect-error TS2339
+            label = `[${(0, graph_1.fromNodeId)(id)}] ${node.type || 'No Type'}: [${node.id}]: `;
+            // @ts-expect-error TS2339
+            if (node.type === 'dependency') {
+                // @ts-expect-error TS2339
+                label += node.value.specifier;
+                let parts = [];
+                // @ts-expect-error TS2339
+                if (node.value.priority !== types_1.Priority.sync) {
+                    parts.push(Object.entries(types_1.Priority).find(
+                    // @ts-expect-error TS2339
+                    ([, v]) => v === node.value.priority)?.[0]);
+                }
+                // @ts-expect-error TS2339
+                if (node.value.isOptional)
+                    parts.push('optional');
+                // @ts-expect-error TS2339
+                if (node.value.specifierType === types_1.SpecifierType.url)
+                    parts.push('url');
+                // @ts-expect-error TS2339
+                if (node.hasDeferred)
+                    parts.push('deferred');
+                // @ts-expect-error TS2339
+                if (node.deferred)
+                    parts.push('deferred');
+                // @ts-expect-error TS2339
+                if (node.excluded)
+                    parts.push('excluded');
+                if (parts.length)
+                    label += ' (' + parts.join(', ') + ')';
+                // @ts-expect-error TS2339
+                if (node.value.env)
+                    label += ` (${getEnvDescription(node.value.env)})`;
+                // @ts-expect-error TS2339
+                let depSymbols = node.value.symbols;
+                if (detailedSymbols) {
+                    if (depSymbols) {
+                        if (depSymbols.size) {
+                            label +=
+                                '\\nsymbols: ' +
+                                    [...depSymbols]
+                                        .map(([e, { local }]) => [e, local])
+                                        .join(';');
+                        }
+                        let weakSymbols = [...depSymbols]
+                            .filter(([, { isWeak }]) => isWeak)
+                            .map(([s]) => s);
+                        if (weakSymbols.length) {
+                            label += '\\nweakSymbols: ' + weakSymbols.join(',');
+                        }
+                        // @ts-expect-error TS2339
+                        if (node.usedSymbolsUp.size > 0) {
+                            label +=
+                                '\\nusedSymbolsUp: ' +
+                                    // @ts-expect-error TS2339
+                                    [...node.usedSymbolsUp]
+                                        .map(([s, sAsset]) => sAsset
+                                        ? `${s}(${sAsset.asset}.${sAsset.symbol ?? ''})`
+                                        : sAsset === null
+                                            ? `${s}(external)`
+                                            : `${s}(ambiguous)`)
+                                        .join(',');
+                        }
+                        // @ts-expect-error TS2339
+                        if (node.usedSymbolsDown.size > 0) {
+                            label +=
+                                // @ts-expect-error TS2339
+                                '\\nusedSymbolsDown: ' + [...node.usedSymbolsDown].join(',');
+                        }
+                        // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
+                        // if (node.usedSymbolsUpDirtyDown)
+                        //   label += '\\nusedSymbolsUpDirtyDown';
+                        // if (node.usedSymbolsUpDirtyUp) label += '\\nusedSymbolsUpDirtyUp';
+                    }
+                    else {
+                        label += '\\nsymbols: cleared';
+                    }
+                }
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'asset') {
+                label +=
+                    // @ts-expect-error TS2339
+                    path_1.default.basename((0, projectPath_1.fromProjectPathRelative)(node.value.filePath)) +
+                        '#' +
+                        // @ts-expect-error TS2339
+                        node.value.type;
+                if (detailedSymbols) {
+                    // @ts-expect-error TS2339
+                    if (!node.value.symbols) {
+                        label += '\\nsymbols: cleared';
+                        // @ts-expect-error TS2339
+                    }
+                    else if (node.value.symbols.size) {
+                        label +=
+                            '\\nsymbols: ' +
+                                // @ts-expect-error TS2339
+                                [...node.value.symbols]
+                                    .map(([e, { local }]) => [e, local])
+                                    .join(';');
+                    }
+                    // @ts-expect-error TS2339
+                    if (node.usedSymbols.size) {
+                        // @ts-expect-error TS2339
+                        label += '\\nusedSymbols: ' + [...node.usedSymbols].join(',');
+                    }
+                    // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
+                    // if (node.usedSymbolsUpDirty) label += '\\nusedSymbolsUpDirty';
+                }
+                else {
+                    label += '\\nsymbols: cleared';
+                }
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'asset_group') {
+                // @ts-expect-error TS2339
+                if (node.deferred)
+                    label += '(deferred)';
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'file') {
+                // @ts-expect-error TS2339
+                label += path_1.default.basename(node.id);
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'transformer_request') {
+                label +=
+                    // @ts-expect-error TS2339
+                    path_1.default.basename(node.value.filePath) +
+                        // @ts-expect-error TS2339
+                        ` (${getEnvDescription(node.value.env)})`;
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'bundle') {
+                let parts = [];
+                // @ts-expect-error TS2339
+                if (node.value.needsStableName)
+                    parts.push('stable name');
+                // @ts-expect-error TS2339
+                parts.push(node.value.name);
+                // @ts-expect-error TS2339
+                parts.push('bb:' + (node.value.bundleBehavior ?? 'null'));
+                // @ts-expect-error TS2339
+                if (node.value.isPlaceholder)
+                    parts.push('placeholder');
+                if (parts.length)
+                    label += ' (' + parts.join(', ') + ')';
+                // @ts-expect-error TS2339
+                if (node.value.env)
+                    label += ` (${getEnvDescription(node.value.env)})`;
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'request') {
+                // @ts-expect-error TS2339
+                label = node.requestType + ':' + node.id;
+            }
+        }
+        n.set('label', label);
+    }
+    let edgeNames;
+    if (edgeTypes) {
+        edgeNames = Object.fromEntries(Object.entries(edgeTypes).map(([k, v]) => [v, k]));
+    }
+    // @ts-expect-error TS2488
+    for (let edge of graph.getAllEdges()) {
+        let gEdge = g.addEdge(nodeId(edge.from), nodeId(edge.to));
+        let color = null;
+        if (edge.type != 1 && edgeNames) {
+            // @ts-expect-error TS7053
+            color = TYPE_COLORS[edgeNames[edge.type]];
+        }
+        if (color != null) {
+            gEdge.set('color', color);
+        }
+    }
+    if (process.env.ATLASPACK_BUILD_REPL) {
+        // @ts-expect-error TS7017
+        globalThis.ATLASPACK_DUMP_GRAPHVIZ?.(name, g.to_dot());
+    }
+    else {
+        const tempy = require('tempy');
+        let tmp = tempy.file({ name: `parcel-${name}.png` });
+        await g.output('png', tmp);
+        // eslint-disable-next-line no-console
+        console.log('Dumped', tmp);
+    }
+}
+// @ts-expect-error TS2552
+function nodeId(id) {
+    return `node${id}`;
+}
+function getEnvDescription(env) {
+    let description;
+    if (typeof env.engines.browsers === 'string') {
+        description = `${env.context}: ${env.engines.browsers}`;
+    }
+    else if (Array.isArray(env.engines.browsers)) {
+        description = `${env.context}: ${env.engines.browsers.join(', ')}`;
+    }
+    else if (env.engines.node) {
+        description = `node: ${env.engines.node}`;
+    }
+    else if (env.engines.electron) {
+        description = `electron: ${env.engines.electron}`;
+    }
+    return description ?? '';
+}