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

package/dist/resolveOptions.js

@@ -0,0 +1,267 @@
+"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') || (0, feature_flags_1.getFeatureFlag)('nativePackager');
+        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,
+        nativeProfiler: initialOptions.nativeProfiler,
+        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);

package/dist/utils.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildAbortError = void 0;
+exports.getBundleGroupId = getBundleGroupId;
+exports.assertSignalNotAborted = assertSignalNotAborted;
+exports.getPublicId = getPublicId;
+exports.optionsProxy = optionsProxy;
+exports.hashFromOption = hashFromOption;
+exports.invalidateOnFileCreateToInternal = invalidateOnFileCreateToInternal;
+exports.createInvalidations = createInvalidations;
+exports.fromInternalSourceLocation = fromInternalSourceLocation;
+exports.toInternalSourceLocation = toInternalSourceLocation;
+exports.toInternalSymbols = toInternalSymbols;
+const assert_1 = __importDefault(require("assert"));
+const base_x_1 = __importDefault(require("base-x"));
+const utils_1 = require("@atlaspack/utils");
+const projectPath_1 = require("./projectPath");
+// /flow-to-ts helpers
+const base62 = (0, base_x_1.default)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+function getBundleGroupId(bundleGroup) {
+    return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
+}
+function assertSignalNotAborted(signal) {
+    if (signal && signal.aborted) {
+        throw new BuildAbortError();
+    }
+}
+class BuildAbortError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BuildAbortError';
+    }
+}
+exports.BuildAbortError = BuildAbortError;
+function getPublicId(id, alreadyExists) {
+    let encoded = base62.encode(Buffer.from(id, 'hex'));
+    for (let end = 5; end <= encoded.length; end++) {
+        let candidate = encoded.slice(0, end);
+        if (!alreadyExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error('Original id was not unique');
+}
+// These options don't affect compilation and should cause invalidations
+const ignoreOptions = new Set([
+    'env', // handled by separate invalidateOnEnvChange
+    'inputFS',
+    'outputFS',
+    'workerFarm',
+    'packageManager',
+    'detailedReport',
+    'shouldDisableCache',
+    'cacheDir',
+    'shouldAutoInstall',
+    'logLevel',
+    'shouldProfile',
+    'shouldTrace',
+    'shouldPatchConsole',
+    'projectRoot',
+    'additionalReporters',
+]);
+function optionsProxy(options, invalidateOnOptionChange, addDevDependency) {
+    let packageManager = addDevDependency
+        ? proxyPackageManager(options.projectRoot, options.packageManager, addDevDependency)
+        : options.packageManager;
+    return new Proxy(options, {
+        get(target, prop) {
+            if (prop === 'packageManager') {
+                return packageManager;
+            }
+            if (!ignoreOptions.has(prop)) {
+                invalidateOnOptionChange(prop);
+            }
+            // @ts-expect-error TS7053
+            return target[prop];
+        },
+    });
+}
+function proxyPackageManager(projectRoot, packageManager, addDevDependency) {
+    let require = (id, from, opts) => {
+        addDevDependency({
+            specifier: id,
+            resolveFrom: (0, projectPath_1.toProjectPath)(projectRoot, from),
+            range: opts?.range,
+        });
+        return packageManager.require(id, from, opts);
+    };
+    return new Proxy(packageManager, {
+        get(target, prop) {
+            if (prop === 'require') {
+                return require;
+            }
+            // @ts-expect-error TS7053
+            return target[prop];
+        },
+    });
+}
+function hashFromOption(value) {
+    if (typeof value === 'object' && value != null) {
+        // @ts-expect-error TS2345
+        return (0, utils_1.hashObject)(value);
+    }
+    return String(value);
+}
+function invalidateOnFileCreateToInternal(projectRoot, invalidation) {
+    // @ts-expect-error TS2339
+    if (invalidation.glob != null) {
+        // @ts-expect-error TS2339
+        return { glob: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.glob) };
+        // @ts-expect-error TS2339
+    }
+    else if (invalidation.filePath != null) {
+        return {
+            // @ts-expect-error TS2339
+            filePath: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.filePath),
+        };
+    }
+    else {
+        (0, assert_1.default)(
+        // @ts-expect-error TS2339
+        invalidation.aboveFilePath != null && invalidation.fileName != null);
+        return {
+            // @ts-expect-error TS2339
+            fileName: invalidation.fileName,
+            // @ts-expect-error TS2339
+            aboveFilePath: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.aboveFilePath),
+        };
+    }
+}
+function createInvalidations() {
+    return {
+        invalidateOnBuild: false,
+        invalidateOnStartup: false,
+        invalidateOnOptionChange: new Set(),
+        invalidateOnEnvChange: new Set(),
+        invalidateOnFileChange: new Set(),
+        invalidateOnFileCreate: [],
+    };
+}
+function fromInternalSourceLocation(projectRoot, loc) {
+    if (!loc)
+        return loc;
+    return {
+        filePath: (0, projectPath_1.fromProjectPath)(projectRoot, loc.filePath),
+        start: loc.start,
+        end: loc.end,
+    };
+}
+function toInternalSourceLocation(projectRoot, loc) {
+    if (!loc)
+        return loc;
+    return {
+        filePath: (0, projectPath_1.toProjectPath)(projectRoot, loc.filePath),
+        start: loc.start,
+        end: loc.end,
+    };
+}
+function toInternalSymbols(projectRoot, symbols) {
+    if (!symbols)
+        return symbols;
+    return new Map([...symbols].map(([k, { loc, ...v }]) => [
+        k,
+        {
+            ...v,
+            loc: toInternalSourceLocation(projectRoot, loc),
+        },
+    ]));
+}