@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

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 '';
+}

package/dist/resolveOptions.js

@@ -0,0 +1,268 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = resolveOptions;
+const path_1 = __importDefault(require("path"));
+const rust_1 = require("@atlaspack/rust");
+const fs_1 = require("@atlaspack/fs");
+const cache_1 = require("@atlaspack/cache");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const package_manager_1 = require("@atlaspack/package-manager");
+const utils_1 = require("@atlaspack/utils");
+const loadDotEnv_1 = __importDefault(require("./loadDotEnv"));
+const projectPath_1 = require("./projectPath");
+const AtlaspackConfigRequest_1 = require("./requests/AtlaspackConfigRequest");
+const feature_flags_2 = require("@atlaspack/feature-flags");
+const constants_1 = require("./constants");
+// Default cache directory name
+const DEFAULT_CACHE_DIRNAME = '.parcel-cache';
+const LOCK_FILE_NAMES = ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml'];
+// Generate a unique instanceId, will change on every run of parcel
+function generateInstanceId(entries) {
+    return (0, rust_1.hashString)(`${entries.join(',')}-${Date.now()}-${Math.round(Math.random() * 100)}`);
+}
+// Compiles an array of globs to regex - used for lazy include/excludes
+function compileGlobs(globs) {
+    return globs.map((glob) => (0, utils_1.globToRegex)(glob));
+}
+function getDefaultFS() {
+    if ((0, feature_flags_1.getFeatureFlagValue)('vcsMode') !== 'OLD') {
+        return new fs_1.NodeVCSAwareFS({
+            gitRepoPath: null,
+            excludePatterns: [],
+            logEventDiff: () => { },
+        });
+    }
+    return new fs_1.NodeFS();
+}
+async function findGitRepositoryRoot(inputFS, projectRoot) {
+    let candidate = projectRoot;
+    while (candidate !== path_1.default.parse(candidate).root) {
+        const gitRepoPath = path_1.default.join(candidate, '.git');
+        if (await inputFS.exists(gitRepoPath)) {
+            return candidate;
+        }
+        candidate = path_1.default.dirname(candidate);
+    }
+    return null;
+}
+async function resolveOptions(initialOptions) {
+    const inputFS = initialOptions.inputFS || getDefaultFS();
+    const outputFS = initialOptions.outputFS || getDefaultFS();
+    let inputCwd = inputFS.cwd();
+    let outputCwd = outputFS.cwd();
+    let entries;
+    if (initialOptions.entries == null || initialOptions.entries === '') {
+        entries = [];
+    }
+    else if (Array.isArray(initialOptions.entries)) {
+        entries = initialOptions.entries.map((entry) => path_1.default.resolve(inputCwd, entry));
+    }
+    else {
+        entries = [path_1.default.resolve(inputCwd, initialOptions.entries)];
+    }
+    // When allowExplicitTargetEntries is enabled and no entries are provided,
+    // automatically derive entries from target sources
+    if ((0, feature_flags_1.getFeatureFlag)('allowExplicitTargetEntries') &&
+        initialOptions.targets &&
+        !Array.isArray(initialOptions.targets) &&
+        entries.length === 0) {
+        const targetSources = new Set();
+        for (const [, target] of Object.entries(initialOptions.targets)) {
+            if (target.source) {
+                const sources = Array.isArray(target.source)
+                    ? target.source
+                    : [target.source];
+                for (const source of sources) {
+                    targetSources.add(source);
+                }
+            }
+        }
+        entries = Array.from(targetSources);
+    }
+    let shouldMakeEntryReferFolder = false;
+    if (entries.length === 1 && !(0, utils_1.isGlob)(entries[0])) {
+        let [entry] = entries;
+        try {
+            shouldMakeEntryReferFolder = (await inputFS.stat(entry)).isDirectory();
+        }
+        catch {
+            // ignore failing stat call
+        }
+    }
+    let projectRoot;
+    if (initialOptions.projectRoot) {
+        // Use explicitly provided projectRoot
+        if (!path_1.default.isAbsolute(initialOptions.projectRoot)) {
+            throw new Error('Specified project root must be an absolute path');
+        }
+        projectRoot = initialOptions.projectRoot;
+    }
+    else {
+        // getRootDir treats the input as files, so getRootDir(["/home/user/myproject"]) returns "/home/user".
+        // Instead we need to make the the entry refer to some file inside the specified folders if entries refers to the directory.
+        let entryRoot = (0, utils_1.getRootDir)(shouldMakeEntryReferFolder ? [path_1.default.join(entries[0], 'index')] : entries);
+        let projectRootFile = (await (0, utils_1.resolveConfig)(inputFS, path_1.default.join(entryRoot, 'index'), [...LOCK_FILE_NAMES, '.git', '.hg'], path_1.default.parse(entryRoot).root)) || path_1.default.join(inputCwd, 'index'); // ? Should this just be rootDir
+        projectRoot = path_1.default.dirname(projectRootFile);
+    }
+    const gitRoot = await findGitRepositoryRoot(inputFS, projectRoot);
+    if (inputFS instanceof fs_1.NodeVCSAwareFS) {
+        inputFS.setGitRepoPath(gitRoot);
+    }
+    if (outputFS instanceof fs_1.NodeVCSAwareFS) {
+        outputFS.setGitRepoPath(gitRoot);
+    }
+    let packageManager = initialOptions.packageManager ||
+        new package_manager_1.NodePackageManager(inputFS, projectRoot);
+    let cacheDir = 
+    // If a cacheDir is provided, resolve it relative to cwd. Otherwise,
+    // use a default directory resolved relative to the project root.
+    initialOptions.cacheDir != null
+        ? path_1.default.resolve(outputCwd, initialOptions.cacheDir)
+        : path_1.default.resolve(projectRoot, DEFAULT_CACHE_DIRNAME);
+    // Make the root watch directory configurable. This is useful in some cases
+    // where symlinked dependencies outside the project root need to trigger HMR
+    // updates. Default to the project root if not provided.
+    let watchDir = initialOptions.watchDir != null
+        ? path_1.default.resolve(initialOptions.watchDir)
+        : projectRoot;
+    function createCache() {
+        if (initialOptions.cache) {
+            return initialOptions.cache;
+        }
+        const needsRustLmdbCache = (0, feature_flags_1.getFeatureFlag)('atlaspackV3');
+        if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            if (!needsRustLmdbCache && !(outputFS instanceof fs_1.NodeFS)) {
+                return new cache_1.FSCache(outputFS, cacheDir);
+            }
+        }
+        return new cache_1.LMDBLiteCache(cacheDir);
+    }
+    let cache = createCache();
+    let mode = initialOptions.mode ?? 'development';
+    let shouldOptimize = initialOptions?.defaultTargetOptions?.shouldOptimize ??
+        mode === 'production';
+    let publicUrl = initialOptions?.defaultTargetOptions?.publicUrl ?? '/';
+    let distDir = initialOptions?.defaultTargetOptions?.distDir != null
+        ? path_1.default.resolve(inputCwd, initialOptions?.defaultTargetOptions?.distDir)
+        : undefined;
+    let shouldBuildLazily = initialOptions.shouldBuildLazily ?? false;
+    let lazyIncludes = compileGlobs(initialOptions.lazyIncludes ?? []);
+    if (lazyIncludes.length > 0 && !shouldBuildLazily) {
+        throw new Error('Lazy includes can only be provided when lazy building is enabled');
+    }
+    let lazyExcludes = compileGlobs(initialOptions.lazyExcludes ?? []);
+    if (lazyExcludes.length > 0 && !shouldBuildLazily) {
+        throw new Error('Lazy excludes can only be provided when lazy building is enabled');
+    }
+    let shouldContentHash = initialOptions.shouldContentHash ?? initialOptions.mode === 'production';
+    if (shouldBuildLazily && shouldContentHash) {
+        throw new Error('Lazy bundling does not work with content hashing');
+    }
+    let env = {
+        ...(await (0, loadDotEnv_1.default)(initialOptions.env ?? {}, inputFS, path_1.default.join(projectRoot, 'index'), projectRoot)),
+        ...process.env,
+        ...initialOptions.env,
+    };
+    let port = determinePort(initialOptions.serveOptions, env.PORT);
+    return {
+        config: getRelativeConfigSpecifier(inputFS, projectRoot, initialOptions.config),
+        defaultConfig: getRelativeConfigSpecifier(inputFS, projectRoot, initialOptions.defaultConfig),
+        shouldPatchConsole: initialOptions.shouldPatchConsole ?? false,
+        env,
+        mode,
+        shouldAutoInstall: initialOptions.shouldAutoInstall ?? false,
+        hmrOptions: initialOptions.hmrOptions ?? null,
+        shouldBuildLazily,
+        lazyIncludes,
+        lazyExcludes,
+        unstableFileInvalidations: initialOptions.unstableFileInvalidations,
+        shouldBundleIncrementally: initialOptions.shouldBundleIncrementally ?? true,
+        shouldContentHash,
+        serveOptions: initialOptions.serveOptions
+            ? {
+                ...initialOptions.serveOptions,
+                distDir: distDir ?? path_1.default.join(outputCwd, 'dist'),
+                port,
+            }
+            : false,
+        shouldDisableCache: initialOptions.shouldDisableCache ?? false,
+        shouldProfile: initialOptions.shouldProfile ?? false,
+        shouldTrace: initialOptions.shouldTrace ?? false,
+        cacheDir,
+        watchDir,
+        watchBackend: initialOptions.watchBackend ?? 'watchman',
+        watchIgnore: initialOptions.watchIgnore,
+        entries: entries.map((e) => (0, projectPath_1.toProjectPath)(projectRoot, e)),
+        targets: initialOptions.targets,
+        logLevel: initialOptions.logLevel ?? 'info',
+        projectRoot,
+        inputFS,
+        outputFS,
+        cache,
+        packageManager,
+        additionalReporters: initialOptions.additionalReporters?.map(({ packageName, resolveFrom }) => ({
+            packageName,
+            resolveFrom: (0, projectPath_1.toProjectPath)(projectRoot, resolveFrom),
+        })) ?? [],
+        instanceId: generateInstanceId(entries),
+        detailedReport: initialOptions.detailedReport,
+        defaultTargetOptions: {
+            shouldOptimize,
+            shouldScopeHoist: initialOptions?.defaultTargetOptions?.shouldScopeHoist,
+            sourceMaps: initialOptions?.defaultTargetOptions?.sourceMaps ?? true,
+            publicUrl,
+            ...(distDir != null
+                ? { distDir: (0, projectPath_1.toProjectPath)(projectRoot, distDir) }
+                : {
+                /*::...null*/
+                }),
+            engines: initialOptions?.defaultTargetOptions?.engines,
+            outputFormat: initialOptions?.defaultTargetOptions?.outputFormat,
+            isLibrary: initialOptions?.defaultTargetOptions?.isLibrary,
+        },
+        // unused, feature-flags are set above this to allow this function to use
+        // feature-flags
+        featureFlags: { ...feature_flags_2.DEFAULT_FEATURE_FLAGS, ...initialOptions?.featureFlags },
+        parcelVersion: constants_1.ATLASPACK_VERSION,
+    };
+}
+function getRelativeConfigSpecifier(fs, projectRoot, specifier) {
+    if (specifier == null) {
+        return undefined;
+    }
+    else if (path_1.default.isAbsolute(specifier)) {
+        let resolveFrom = (0, AtlaspackConfigRequest_1.getResolveFrom)(fs, projectRoot);
+        let relative = (0, utils_1.relativePath)(path_1.default.dirname(resolveFrom), specifier);
+        // If the config is outside the project root, use an absolute path so that if the project root
+        // moves the path still works. Otherwise, use a relative path so that the cache is portable.
+        return relative.startsWith('..') ? specifier : relative;
+    }
+    else {
+        return specifier;
+    }
+}
+function determinePort(initialServerOptions, portInEnv, defaultPort = 1234) {
+    function parsePort(port) {
+        let parsedPort = Number(port);
+        // return undefined if port number defined in .env is not valid integer
+        if (!Number.isInteger(parsedPort)) {
+            return undefined;
+        }
+        return parsedPort;
+    }
+    if (!initialServerOptions) {
+        return typeof portInEnv !== 'undefined'
+            ? (parsePort(portInEnv) ?? defaultPort)
+            : defaultPort;
+    }
+    // if initialServerOptions.port is equal to defaultPort, then this means that port number is provided via PORT=~~~~ on cli. In this case, we should ignore port number defined in .env.
+    if (initialServerOptions.port !== defaultPort) {
+        return initialServerOptions.port;
+    }
+    return typeof portInEnv !== 'undefined'
+        ? (parsePort(portInEnv) ?? defaultPort)
+        : defaultPort;
+}

package/dist/rustWorkerThreadDylibHack.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRustWorkerThreadDylibHack = loadRustWorkerThreadDylibHack;
+/**
+ * This is a workaround for https://github.com/rust-lang/rust/issues/91979
+ * when running atlaspack with parcel bindings, it is possible that the parcel
+ * dylib will be loaded from a node worker thread, which causes a crash on exit.
+ *
+ * This is a workaround to ensure that the parcel dylib is loaded in the main
+ * thread, which fixes the crash.
+ */
+function loadRustWorkerThreadDylibHack() {
+    try {
+        require('@parcel/rust'); // eslint-disable-line
+    }
+    catch (err) {
+        /* ignore */
+    }
+}

package/dist/serializerCore.browser.js

@@ -0,0 +1,43 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeRaw = exports.serializeRaw = void 0;
+const buffer_1 = require("buffer");
+const msgpackr = __importStar(require("msgpackr"));
+let encoder = new msgpackr.Encoder({ structuredClone: true });
+let serializeRaw = (v) => buffer_1.Buffer.from(encoder.encode(v));
+exports.serializeRaw = serializeRaw;
+let deserializeRaw = (v) => encoder.decode(v);
+exports.deserializeRaw = deserializeRaw;

package/dist/summarizeRequest.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = summarizeRequest;
+const path_1 = __importDefault(require("path"));
+const NODE_MODULES = `${path_1.default.sep}node_modules${path_1.default.sep}`;
+const BUFFER_LIMIT = 5000000; // 5mb
+async function summarizeRequest(fs, req) {
+    let { content, size } = await summarizeDiskRequest(fs, req);
+    let isSource = isFilePathSource(fs, req.filePath);
+    return { content, size, isSource };
+}
+function isFilePathSource(fs, filePath) {
+    return !filePath.includes(NODE_MODULES);
+}
+async function summarizeDiskRequest(fs, req) {
+    let code = req.code;
+    let content;
+    let size;
+    if (code == null) {
+        // Get the filesize. If greater than BUFFER_LIMIT, use a stream to
+        // compute the hash. In the common case, it's faster to just read the entire
+        // file first and do the hash all at once without the overhead of streams.
+        size = (await fs.stat(req.filePath)).size;
+        if (size > BUFFER_LIMIT) {
+            content = fs.createReadStream(req.filePath);
+        }
+        else {
+            content = await fs.readFile(req.filePath);
+        }
+    }
+    else {
+        content = code;
+        size = Buffer.byteLength(code);
+    }
+    return { content, size };
+}

package/dist/types.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleBehaviorNames = exports.BundleBehavior = exports.ExportsCondition = exports.Priority = exports.SpecifierType = void 0;
+exports.SpecifierType = {
+    esm: 0,
+    commonjs: 1,
+    url: 2,
+    custom: 3,
+};
+exports.Priority = {
+    sync: 0,
+    parallel: 1,
+    lazy: 2,
+    conditional: 3,
+};
+// Must match package_json.rs in node-resolver-rs.
+exports.ExportsCondition = {
+    import: 1 << 0,
+    require: 1 << 1,
+    module: 1 << 2,
+    style: 1 << 12,
+    sass: 1 << 13,
+    less: 1 << 14,
+};
+exports.BundleBehavior = {
+    inline: 0,
+    isolated: 1,
+    inlineIsolated: 2,
+};
+// @ts-expect-error TS2322
+exports.BundleBehaviorNames = Object.keys(exports.BundleBehavior);