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

package/dist/CommittedAsset.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const build_cache_1 = require("@atlaspack/build-cache");
+const utils_1 = require("@atlaspack/utils");
+const source_map_1 = __importDefault(require("@parcel/source-map"));
+const assetUtils_1 = require("./assetUtils");
+class CommittedAsset {
+    constructor(value, options) {
+        this.value = value;
+        this.key = this.value.contentKey;
+        this.options = options;
+    }
+    getContent() {
+        if (this.content == null) {
+            if (this.key != null) {
+                if (this.value.isLargeBlob) {
+                    return this.options.cache.getStream(this.key);
+                }
+                else {
+                    return this.options.cache.getBlob(this.key);
+                }
+            }
+            else if (this.value.astKey != null) {
+                return (0, utils_1.streamFromPromise)((0, assetUtils_1.generateFromAST)(this).then(({ content }) => {
+                    if (!(content instanceof stream_1.Readable)) {
+                        this.content = Promise.resolve(content);
+                    }
+                    return content;
+                }));
+            }
+            else {
+                throw new Error('Asset has no content');
+            }
+        }
+        return this.content;
+    }
+    async getCode() {
+        let content;
+        if (this.content == null && this.key != null) {
+            this.content = this.options.cache.getBlob(this.key);
+            content = await this.content;
+        }
+        else {
+            content = await this.getContent();
+        }
+        if (typeof content === 'string' || content instanceof Buffer) {
+            return content.toString();
+        }
+        else if (content != null) {
+            // @ts-expect-error TS2345
+            this.content = (0, utils_1.bufferStream)(content);
+            return (await this.content).toString();
+        }
+        return '';
+    }
+    async getBuffer() {
+        let content = await this.getContent();
+        if (content == null) {
+            return Buffer.alloc(0);
+        }
+        else if (typeof content === 'string' || content instanceof Buffer) {
+            return Buffer.from(content);
+        }
+        // @ts-expect-error TS2345
+        this.content = (0, utils_1.bufferStream)(content);
+        // @ts-expect-error TS2322
+        return this.content;
+    }
+    getStream() {
+        let content = this.getContent();
+        return content instanceof Promise
+            ? (0, utils_1.streamFromPromise)(content)
+            : (0, utils_1.blobToStream)(content);
+    }
+    getMapBuffer() {
+        let mapKey = this.value.mapKey;
+        if (mapKey != null && this.mapBuffer == null) {
+            this.mapBuffer = (async () => {
+                try {
+                    // Handle v3 assets that were processed by the native asset graph code (i.e. not runtime
+                    // or helper assets)
+                    if (this.options.featureFlags.atlaspackV3 &&
+                        this.value.meta.isV3 === true) {
+                        let buffer = await this.options.cache.getBuffer(mapKey);
+                        if (!buffer) {
+                            return buffer;
+                        }
+                        // We make the conversion from json to buffer here, since both js packagers lazily
+                        // instantiate a sourcemap from the map buffer. This ensures we do not have to modify
+                        // the packagers in any significant way. Additionally, storing the SourceMap objects
+                        // upfront in these packagers appears to make larger builds more prone to failing.
+                        let sourceMap = new source_map_1.default(this.options.projectRoot);
+                        sourceMap.addVLQMap(JSON.parse(buffer.toString()));
+                        return sourceMap.toBuffer();
+                    }
+                    return await this.options.cache.getBlob(mapKey);
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT' && this.value.astKey != null) {
+                        return (await (0, assetUtils_1.generateFromAST)(this)).map?.toBuffer();
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            })();
+        }
+        // @ts-expect-error TS2322
+        return this.mapBuffer ?? Promise.resolve();
+    }
+    getMap() {
+        if (this.map == null) {
+            this.map = (async () => {
+                let mapBuffer = await this.getMapBuffer();
+                if (mapBuffer) {
+                    // Get sourcemap from flatbuffer
+                    return new source_map_1.default(this.options.projectRoot, mapBuffer);
+                }
+            })();
+        }
+        return this.map;
+    }
+    getAST() {
+        if (this.value.astKey == null) {
+            return Promise.resolve(null);
+        }
+        if (this.ast == null) {
+            this.ast = this.options.cache
+                .getBlob(this.value.astKey)
+                .then((serializedAst) => (0, build_cache_1.deserializeRaw)(serializedAst));
+        }
+        return this.ast;
+    }
+    getDependencies() {
+        return Array.from(this.value.dependencies.values());
+    }
+}
+exports.default = CommittedAsset;

package/dist/Dependency.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencyId = createDependencyId;
+exports.createDependency = createDependency;
+exports.mergeDependencies = mergeDependencies;
+const rust_1 = require("@atlaspack/rust");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const projectPath_1 = require("./projectPath");
+const assert_1 = __importDefault(require("assert"));
+const IdentifierRegistry_1 = require("./IdentifierRegistry");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+function createDependencyId({ sourceAssetId, specifier, env, target, pipeline, specifierType, bundleBehavior, priority, packageConditions, }) {
+    (0, assert_1.default)(typeof specifierType === 'string');
+    (0, assert_1.default)(typeof priority === 'string' || priority == null);
+    const params = {
+        sourceAssetId,
+        specifier,
+        environmentId: (0, EnvironmentManager_1.toEnvironmentId)(env),
+        target: target != null
+            ? {
+                ...target,
+                env: (0, EnvironmentManager_1.fromEnvironmentId)(target.env),
+            }
+            : null,
+        pipeline,
+        specifierType: types_1.SpecifierType[specifierType],
+        bundleBehavior,
+        priority: priority ? types_1.Priority[priority] : types_1.Priority.sync,
+        packageConditions,
+    };
+    const id = (0, rust_1.createDependencyId)(params);
+    IdentifierRegistry_1.identifierRegistry.addIdentifier('dependency', id, params);
+    return id;
+}
+function createDependency(projectRoot, opts) {
+    let id = opts.id ||
+        createDependencyId({
+            bundleBehavior: opts.bundleBehavior,
+            env: opts.env,
+            packageConditions: opts.packageConditions,
+            pipeline: opts.pipeline,
+            priority: opts.priority,
+            sourceAssetId: opts.sourceAssetId,
+            specifier: opts.specifier,
+            specifierType: opts.specifierType,
+            target: opts.target,
+        });
+    let dep = {
+        id,
+        specifier: opts.specifier,
+        specifierType: types_1.SpecifierType[opts.specifierType],
+        priority: types_1.Priority[opts.priority ?? 'sync'],
+        needsStableName: opts.needsStableName ?? false,
+        bundleBehavior: opts.bundleBehavior
+            ? types_1.BundleBehavior[opts.bundleBehavior]
+            : null,
+        isEntry: opts.isEntry ?? false,
+        isOptional: opts.isOptional ?? false,
+        loc: (0, utils_1.toInternalSourceLocation)(projectRoot, opts.loc),
+        env: opts.env,
+        meta: opts.meta || {},
+        target: opts.target,
+        sourceAssetId: opts.sourceAssetId,
+        sourcePath: (0, projectPath_1.toProjectPath)(projectRoot, opts.sourcePath),
+        resolveFrom: (0, projectPath_1.toProjectPath)(projectRoot, opts.resolveFrom),
+        range: opts.range,
+        symbols: opts.symbols &&
+            new Map([...opts.symbols].map(([k, v]) => [
+                k,
+                {
+                    local: v.local,
+                    meta: v.meta,
+                    isWeak: v.isWeak,
+                    loc: (0, utils_1.toInternalSourceLocation)(projectRoot, v.loc),
+                },
+            ])),
+        pipeline: opts.pipeline,
+    };
+    if (opts.packageConditions) {
+        convertConditions(opts.packageConditions, dep);
+    }
+    return dep;
+}
+function mergeDependencies(a, b) {
+    let { meta, symbols, needsStableName, isEntry, isOptional, ...other } = b;
+    Object.assign(a, other);
+    Object.assign(a.meta, meta);
+    if (a.symbols && symbols) {
+        for (let [k, v] of symbols) {
+            a.symbols.set(k, v);
+        }
+    }
+    if (needsStableName)
+        a.needsStableName = true;
+    if (isEntry)
+        a.isEntry = true;
+    if (!isOptional)
+        a.isOptional = false;
+}
+function convertConditions(conditions, dep) {
+    // Store common package conditions as bit flags to reduce size.
+    // Custom conditions are stored as strings.
+    let packageConditions = 0;
+    let customConditions = [];
+    for (let condition of conditions) {
+        // @ts-expect-error TS7053
+        if (types_1.ExportsCondition[condition]) {
+            // @ts-expect-error TS7053
+            packageConditions |= types_1.ExportsCondition[condition];
+        }
+        else {
+            customConditions.push(condition);
+        }
+    }
+    if (packageConditions) {
+        dep.packageConditions = packageConditions;
+    }
+    if (customConditions.length) {
+        dep.customPackageConditions = customConditions;
+    }
+}

package/dist/Environment.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnvironment = createEnvironment;
+exports.mergeEnvironments = mergeEnvironments;
+exports.getEnvironmentHash = getEnvironmentHash;
+const rust_1 = require("@atlaspack/rust");
+const utils_1 = require("./utils");
+const Environment_1 = __importDefault(require("./public/Environment"));
+const Environment_2 = require("./public/Environment");
+const IdentifierRegistry_1 = require("./IdentifierRegistry");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+const DEFAULT_ENGINES = {
+    browsers: ['> 0.25%'],
+    node: '>= 8.0.0',
+};
+function createEnvironment({ context, engines, includeNodeModules, outputFormat, sourceType = 'module', shouldOptimize = false, isLibrary = false, shouldScopeHoist = false, sourceMap, unstableSingleFileOutput = false, loc, customEnv, } = {
+/*::...null*/
+}) {
+    if (context == null) {
+        if (engines?.node) {
+            context = 'node';
+        }
+        else if (engines?.browsers) {
+            context = 'browser';
+        }
+        else {
+            context = 'browser';
+        }
+    }
+    if (engines == null) {
+        switch (context) {
+            case 'node':
+            case 'electron-main':
+                engines = {
+                    node: DEFAULT_ENGINES.node,
+                };
+                break;
+            case 'browser':
+            case 'web-worker':
+            case 'service-worker':
+            case 'tesseract':
+            case 'electron-renderer':
+                engines = {
+                    // @ts-expect-error TS2322
+                    browsers: DEFAULT_ENGINES.browsers,
+                };
+                break;
+            default:
+                engines = {};
+        }
+    }
+    if (includeNodeModules == null) {
+        switch (context) {
+            case 'node':
+            case 'electron-main':
+            case 'electron-renderer':
+                includeNodeModules = false;
+                break;
+            case 'browser':
+            case 'web-worker':
+            case 'service-worker':
+            case 'tesseract':
+            default:
+                includeNodeModules = true;
+                break;
+        }
+    }
+    if (outputFormat == null) {
+        switch (context) {
+            case 'node':
+            case 'electron-main':
+            case 'electron-renderer':
+                outputFormat = 'commonjs';
+                break;
+            default:
+                outputFormat = 'global';
+                break;
+        }
+    }
+    let res = {
+        id: '',
+        context,
+        // @ts-expect-error TS2322
+        engines,
+        includeNodeModules,
+        outputFormat,
+        sourceType,
+        isLibrary,
+        shouldOptimize,
+        shouldScopeHoist,
+        sourceMap,
+        unstableSingleFileOutput,
+        loc,
+        customEnv,
+    };
+    res.id = getEnvironmentHash(res);
+    return (0, EnvironmentManager_1.toEnvironmentRef)(Object.freeze(res));
+}
+function mergeEnvironments(projectRoot, a, b) {
+    // If merging the same object, avoid copying.
+    if (a === b || !b) {
+        return (0, EnvironmentManager_1.toEnvironmentRef)(a);
+    }
+    if (b instanceof Environment_1.default) {
+        return (0, EnvironmentManager_1.toEnvironmentRef)((0, Environment_2.environmentToInternalEnvironment)(b));
+    }
+    return createEnvironment({
+        ...a,
+        ...b,
+        loc: b.loc ? (0, utils_1.toInternalSourceLocation)(projectRoot, b.loc) : a.loc,
+    });
+}
+function getEnvironmentHash(env) {
+    const data = {
+        context: env.context,
+        engines: env.engines,
+        includeNodeModules: env.includeNodeModules,
+        outputFormat: env.outputFormat,
+        sourceType: env.sourceType,
+        isLibrary: env.isLibrary,
+        shouldOptimize: env.shouldOptimize,
+        shouldScopeHoist: env.shouldScopeHoist,
+        sourceMap: env.sourceMap,
+        customEnv: env.customEnv,
+    };
+    const id = (0, rust_1.createEnvironmentId)(data);
+    IdentifierRegistry_1.identifierRegistry.addIdentifier('environment', id, data);
+    return id;
+}

package/dist/EnvironmentManager.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEnvironmentRef = toEnvironmentRef;
+exports.toEnvironmentId = toEnvironmentId;
+exports.fromEnvironmentId = fromEnvironmentId;
+exports.writeEnvironmentsToCache = writeEnvironmentsToCache;
+exports.loadEnvironmentsFromCache = loadEnvironmentsFromCache;
+const rust_1 = require("@atlaspack/rust");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = require("@atlaspack/logger");
+const constants_1 = require("./constants");
+const localEnvironmentCache = new Map();
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+function toEnvironmentRef(env) {
+    if (!(0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
+        return env;
+    }
+    const id = toEnvironmentId(env);
+    return id;
+}
+/**
+ * Convert environment to a string ID
+ */
+function toEnvironmentId(
+/**
+ * Redundant type during roll-out
+ */
+env) {
+    if (!(0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
+        return typeof env === 'string' ? env : env.id;
+    }
+    if (typeof env === 'string') {
+        return env;
+    }
+    (0, rust_1.addEnvironment)(env);
+    return env.id;
+}
+function fromEnvironmentId(id) {
+    if (!(0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
+        if (typeof id === 'string') {
+            throw new Error('This should never happen when environmentDeduplication feature-flag is off');
+        }
+        else {
+            return id;
+        }
+    }
+    if (typeof id !== 'string') {
+        return id;
+    }
+    const localEnv = localEnvironmentCache.get(id);
+    if (localEnv) {
+        return localEnv;
+    }
+    const env = Object.freeze((0, rust_1.getEnvironment)(id));
+    // @ts-expect-error TS2345
+    localEnvironmentCache.set(id, env);
+    // @ts-expect-error TS2322
+    return env;
+}
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function writeEnvironmentsToCache(cache) {
+    const environments = (0, rust_1.getAllEnvironments)();
+    const environmentIds = new Set();
+    // Store each environment individually
+    for (const env of environments) {
+        // @ts-expect-error TS18046
+        environmentIds.add(env.id);
+        // @ts-expect-error TS18046
+        const envKey = `Environment/${constants_1.ATLASPACK_VERSION}/${env.id}`;
+        await (0, logger_1.instrument)(`RequestTracker::writeToCache::cache.put(${envKey})`, async () => {
+            await cache.set(envKey, env);
+        });
+    }
+    // Store the list of environment IDs
+    await (0, logger_1.instrument)(`RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${constants_1.ATLASPACK_VERSION}`})`, async () => {
+        await cache.set(`EnvironmentManager/${constants_1.ATLASPACK_VERSION}`, Array.from(environmentIds));
+    });
+}
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function loadEnvironmentsFromCache(cache) {
+    const cachedEnvIds = await cache.get(`EnvironmentManager/${constants_1.ATLASPACK_VERSION}`);
+    if (cachedEnvIds == null) {
+        return;
+    }
+    const environments = [];
+    // @ts-expect-error TS2488
+    for (const envId of cachedEnvIds) {
+        const envKey = `Environment/${constants_1.ATLASPACK_VERSION}/${envId}`;
+        const cachedEnv = await cache.get(envKey);
+        if (cachedEnv != null) {
+            environments.push(cachedEnv);
+        }
+    }
+    if (environments.length > 0) {
+        (0, rust_1.setAllEnvironments)(environments);
+    }
+}

package/dist/IdentifierRegistry.js

@@ -0,0 +1,38 @@
+"use strict";
+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 _IdentifierRegistry_enabled, _IdentifierRegistry_createdDirectory;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifierRegistry = exports.IdentifierRegistry = void 0;
+const fs_1 = __importDefault(require("fs"));
+class IdentifierRegistry {
+    constructor(enabled) {
+        _IdentifierRegistry_enabled.set(this, void 0);
+        _IdentifierRegistry_createdDirectory.set(this, false);
+        __classPrivateFieldSet(this, _IdentifierRegistry_enabled, enabled, "f");
+    }
+    addIdentifier(type, identifier, data) {
+        if (__classPrivateFieldGet(this, _IdentifierRegistry_enabled, "f")) {
+            if (!__classPrivateFieldGet(this, _IdentifierRegistry_createdDirectory, "f")) {
+                fs_1.default.mkdirSync('./.atlaspack', { recursive: true });
+                __classPrivateFieldSet(this, _IdentifierRegistry_createdDirectory, true, "f");
+            }
+            fs_1.default.appendFile('./.atlaspack/atlaspack-identifiers.txt', `${type} ${identifier} ${JSON.stringify(data)}\n`, () => { });
+        }
+    }
+}
+exports.IdentifierRegistry = IdentifierRegistry;
+_IdentifierRegistry_enabled = new WeakMap(), _IdentifierRegistry_createdDirectory = new WeakMap();
+exports.identifierRegistry = new IdentifierRegistry(process.env.ATLASPACK_IDENTIFIER_DEBUG === 'true');

package/dist/InternalConfig.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = createConfig;
+const projectPath_1 = require("./projectPath");
+const Environment_1 = require("./Environment");
+const rust_1 = require("@atlaspack/rust");
+const IdentifierRegistry_1 = require("./IdentifierRegistry");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+function createConfig({ plugin, isSource, searchPath, env, result, invalidateOnFileChange, invalidateOnConfigKeyChange, invalidateOnFileCreate, invalidateOnEnvChange, invalidateOnOptionChange, devDeps, invalidateOnStartup, invalidateOnBuild, }) {
+    let environment = env ?? (0, Environment_1.createEnvironment)();
+    const configId = (0, rust_1.hashString)(plugin +
+        (0, projectPath_1.fromProjectPathRelative)(searchPath) +
+        (0, EnvironmentManager_1.toEnvironmentId)(environment) +
+        String(isSource));
+    IdentifierRegistry_1.identifierRegistry.addIdentifier('config_request', configId, {
+        plugin,
+        searchPath,
+        environmentId: (0, EnvironmentManager_1.toEnvironmentId)(environment),
+        isSource,
+    });
+    return {
+        id: configId,
+        isSource: isSource ?? false,
+        searchPath,
+        env: environment,
+        result: result ?? null,
+        cacheKey: null,
+        invalidateOnFileChange: invalidateOnFileChange ?? new Set(),
+        invalidateOnConfigKeyChange: invalidateOnConfigKeyChange ?? [],
+        invalidateOnFileCreate: invalidateOnFileCreate ?? [],
+        invalidateOnEnvChange: invalidateOnEnvChange ?? new Set(),
+        invalidateOnOptionChange: invalidateOnOptionChange ?? new Set(),
+        devDeps: devDeps ?? [],
+        invalidateOnStartup: invalidateOnStartup ?? false,
+        invalidateOnBuild: invalidateOnBuild ?? false,
+    };
+}