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

package/dist/requests/ConfigRequest.js

@@ -0,0 +1,246 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPluginConfig = loadPluginConfig;
+exports.loadPluginSetup = loadPluginSetup;
+exports.getValueAtPath = getValueAtPath;
+exports.getConfigKeyContentHash = getConfigKeyContentHash;
+exports.runConfigRequest = runConfigRequest;
+exports.getConfigHash = getConfigHash;
+exports.getConfigRequests = getConfigRequests;
+const utils_1 = require("@atlaspack/utils");
+const build_cache_1 = require("@atlaspack/build-cache");
+const logger_1 = require("@atlaspack/logger");
+const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const Config_1 = __importDefault(require("../public/Config"));
+const utils_2 = require("../utils");
+const assetUtils_1 = require("../assetUtils");
+const rust_1 = require("@atlaspack/rust");
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+const projectPath_1 = require("../projectPath");
+async function loadPluginConfig(loadedPlugin, config, options) {
+    let loadConfig = loadedPlugin.plugin.loadConfig;
+    if (!loadConfig) {
+        return;
+    }
+    try {
+        config.result = await loadConfig({
+            config: new Config_1.default(config, options),
+            options: new PluginOptions_1.default((0, utils_2.optionsProxy)(options, (option) => {
+                config.invalidateOnOptionChange.add(option);
+            })),
+            logger: new logger_1.PluginLogger({ origin: loadedPlugin.name }),
+            tracer: new profiler_1.PluginTracer({
+                origin: loadedPlugin.name,
+                category: 'loadConfig',
+            }),
+        });
+    }
+    catch (e) {
+        throw new diagnostic_1.default({
+            diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                origin: loadedPlugin.name,
+            }),
+        });
+    }
+}
+async function loadPluginSetup(pluginName, setup, config, options) {
+    try {
+        let result = await setup({
+            config: new Config_1.default(config, options),
+            options: new PluginOptions_1.default((0, utils_2.optionsProxy)(options, (option) => {
+                config.invalidateOnOptionChange.add(option);
+            })),
+            logger: new logger_1.PluginLogger({ origin: pluginName }),
+            tracer: new profiler_1.PluginTracer({
+                origin: pluginName,
+                category: 'setup',
+            }),
+        });
+        config.result = result.config;
+    }
+    catch (e) {
+        throw new diagnostic_1.default({
+            diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                origin: pluginName,
+            }),
+        });
+    }
+}
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+function getValueAtPath(obj, key) {
+    let current = obj;
+    for (let part of key) {
+        if (current == null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+const configKeyCache = (0, build_cache_1.createBuildCache)();
+async function getConfigKeyContentHash(filePath, configKey, options) {
+    let cacheKey = `${(0, projectPath_1.fromProjectPathRelative)(filePath)}:${JSON.stringify(configKey)}`;
+    let cachedValue = configKeyCache.get(cacheKey);
+    if (cachedValue) {
+        // @ts-expect-error TS2322
+        return cachedValue;
+    }
+    const conf = await (0, utils_1.readConfig)(options.inputFS, (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath));
+    const value = getValueAtPath(conf?.config, configKey);
+    if (conf == null || value == null) {
+        // This can occur when a config key has been removed entirely during `respondToFSEvents`
+        return '';
+    }
+    const contentHash = typeof value === 'object'
+        ? (0, utils_1.hashObject)(value)
+        : (0, rust_1.hashString)(JSON.stringify(value));
+    configKeyCache.set(cacheKey, contentHash);
+    return contentHash;
+}
+async function runConfigRequest(api, configRequest) {
+    let { invalidateOnFileChange, invalidateOnConfigKeyChange, invalidateOnFileCreate, invalidateOnEnvChange, invalidateOnOptionChange, invalidateOnStartup, invalidateOnBuild, } = configRequest;
+    // If there are no invalidations, then no need to create a node.
+    if (invalidateOnFileChange.size === 0 &&
+        invalidateOnConfigKeyChange.length === 0 &&
+        invalidateOnFileCreate.length === 0 &&
+        invalidateOnOptionChange.size === 0 &&
+        invalidateOnEnvChange.size === 0 &&
+        !invalidateOnStartup &&
+        !invalidateOnBuild) {
+        return;
+    }
+    await api.runRequest({
+        id: 'config_request:' + configRequest.id,
+        type: RequestTracker_1.requestTypes.config_request,
+        run: async ({ api, options }) => {
+            for (let filePath of invalidateOnFileChange) {
+                api.invalidateOnFileUpdate(filePath);
+                api.invalidateOnFileDelete(filePath);
+            }
+            for (let { filePath, configKey } of invalidateOnConfigKeyChange) {
+                let contentHash = await getConfigKeyContentHash(filePath, configKey, options);
+                api.invalidateOnConfigKeyChange(filePath, configKey, contentHash);
+            }
+            for (let invalidation of invalidateOnFileCreate) {
+                api.invalidateOnFileCreate(invalidation);
+            }
+            for (let env of invalidateOnEnvChange) {
+                api.invalidateOnEnvChange(env);
+            }
+            for (let option of invalidateOnOptionChange) {
+                api.invalidateOnOptionChange(option);
+            }
+            if (invalidateOnStartup) {
+                api.invalidateOnStartup();
+            }
+            if (invalidateOnBuild) {
+                api.invalidateOnBuild();
+            }
+        },
+        input: null,
+    });
+}
+async function getConfigHash(config, pluginName, options) {
+    if (config.result == null) {
+        return '';
+    }
+    let hash = new rust_1.Hash();
+    hash.writeString(config.id);
+    // If there is no result hash set by the transformer, default to hashing the included
+    // files if any, otherwise try to hash the config result itself.
+    if (config.cacheKey == null) {
+        if (config.invalidateOnFileChange.size > 0) {
+            hash.writeString(await (0, assetUtils_1.getInvalidationHash)([...config.invalidateOnFileChange].map((filePath) => ({
+                type: 'file',
+                filePath,
+            })), options));
+        }
+        else if (config.result != null) {
+            try {
+                hash.writeBuffer((0, build_cache_1.serializeRaw)(config.result));
+            }
+            catch (err) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: 'Config result is not hashable because it contains non-serializable objects. Please use config.setCacheKey to set the hash manually.',
+                        origin: pluginName,
+                    },
+                });
+            }
+        }
+    }
+    else {
+        hash.writeString(config.cacheKey ?? '');
+    }
+    return hash.finish();
+}
+function getConfigRequests(configs) {
+    return configs
+        .filter((config) => {
+        // No need to send to the graph if there are no invalidations.
+        return (config.invalidateOnFileChange.size > 0 ||
+            config.invalidateOnConfigKeyChange.length > 0 ||
+            config.invalidateOnFileCreate.length > 0 ||
+            config.invalidateOnEnvChange.size > 0 ||
+            config.invalidateOnOptionChange.size > 0 ||
+            config.invalidateOnStartup ||
+            config.invalidateOnBuild);
+    })
+        .map((config) => ({
+        id: config.id,
+        invalidateOnFileChange: config.invalidateOnFileChange,
+        invalidateOnConfigKeyChange: config.invalidateOnConfigKeyChange,
+        invalidateOnFileCreate: config.invalidateOnFileCreate,
+        invalidateOnEnvChange: config.invalidateOnEnvChange,
+        invalidateOnOptionChange: config.invalidateOnOptionChange,
+        invalidateOnStartup: config.invalidateOnStartup,
+        invalidateOnBuild: config.invalidateOnBuild,
+    }));
+}

package/dist/requests/DevDepRequest.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevDependency = createDevDependency;
+exports.getDevDepRequests = getDevDepRequests;
+exports.invalidateDevDeps = invalidateDevDeps;
+exports.resolveDevDepRequestRef = resolveDevDepRequestRef;
+exports.runDevDepRequest = runDevDepRequest;
+exports.getWorkerDevDepRequests = getWorkerDevDepRequests;
+const build_cache_1 = require("@atlaspack/build-cache");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const assetUtils_1 = require("../assetUtils");
+const utils_1 = require("../utils");
+const projectPath_1 = require("../projectPath");
+const RequestTracker_1 = require("../RequestTracker");
+// A cache of dev dep requests keyed by invalidations.
+// If the package manager returns the same invalidation object, then
+// we can reuse the dev dep request rather than recomputing the project
+// paths and hashes.
+const devDepRequestCache = new WeakMap();
+async function createDevDependency(opts, requestDevDeps, options) {
+    let { specifier, resolveFrom, additionalInvalidations } = opts;
+    let key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
+    // If the request sent us a hash, we know the dev dep and all of its dependencies didn't change.
+    // Reuse the same hash in the response. No need to send back invalidations as the request won't
+    // be re-run anyway.
+    let hash = requestDevDeps.get(key);
+    if (hash != null) {
+        return {
+            type: 'ref',
+            specifier,
+            resolveFrom,
+            hash,
+        };
+    }
+    let resolveFromAbsolute = (0, projectPath_1.fromProjectPath)(options.projectRoot, resolveFrom);
+    // Ensure that the package manager has an entry for this resolution.
+    try {
+        await options.packageManager.resolve(specifier, resolveFromAbsolute);
+    }
+    catch (err) {
+        // ignore
+    }
+    let invalidations = options.packageManager.getInvalidations(specifier, resolveFromAbsolute);
+    let cached = devDepRequestCache.get(invalidations);
+    if (cached != null) {
+        return cached;
+    }
+    let invalidateOnFileChangeProject = [
+        ...invalidations.invalidateOnFileChange,
+    ].map((f) => (0, projectPath_1.toProjectPath)(options.projectRoot, f));
+    // It is possible for a transformer to have multiple different hashes due to
+    // different dependencies (e.g. conditional requires) so we must always
+    // recompute the hash and compare rather than only sending a transformer
+    // dev dependency once.
+    hash = await (0, assetUtils_1.getInvalidationHash)(invalidateOnFileChangeProject.map((f) => ({
+        type: 'file',
+        filePath: f,
+    })), options);
+    let devDepRequest = {
+        specifier,
+        resolveFrom,
+        hash,
+        invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map((i) => (0, utils_1.invalidateOnFileCreateToInternal)(options.projectRoot, i)),
+        invalidateOnFileChange: new Set(invalidateOnFileChangeProject),
+        invalidateOnStartup: invalidations.invalidateOnStartup,
+        additionalInvalidations,
+    };
+    devDepRequestCache.set(invalidations, devDepRequest);
+    return devDepRequest;
+}
+async function getDevDepRequests(api) {
+    async function getPreviousDevDepRequests() {
+        const allDevDepRequests = await Promise.all(api
+            .getSubRequests()
+            .filter((req) => req.requestType === RequestTracker_1.requestTypes.dev_dep_request)
+            .map(async (req) => [
+            req.id,
+            await api.getRequestResult(req.id),
+        ]));
+        const nonNullDevDepRequests = [];
+        for (const [id, result] of allDevDepRequests) {
+            if (result != null) {
+                nonNullDevDepRequests.push([id, result]);
+            }
+        }
+        // @ts-expect-error TS2769
+        return new Map(nonNullDevDepRequests);
+    }
+    const previousDevDepRequests = await getPreviousDevDepRequests();
+    return {
+        devDeps: new Map([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => api.canSkipSubrequest(id))
+            .map(([, req]) => [
+            `${req.specifier}:${(0, projectPath_1.fromProjectPathRelative)(req.resolveFrom)}`,
+            req.hash,
+        ])),
+        invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+            // @ts-expect-error TS2769
+            .filter(([id]) => !api.canSkipSubrequest(id))
+            .flatMap(([, req]) => {
+            return [
+                {
+                    specifier: req.specifier,
+                    resolveFrom: req.resolveFrom,
+                },
+                // @ts-expect-error TS7006
+                ...(req.additionalInvalidations ?? []).map((i) => ({
+                    specifier: i.specifier,
+                    resolveFrom: i.resolveFrom,
+                })),
+            ];
+        })),
+    };
+}
+// Tracks dev deps that have been invalidated during this build
+// so we don't invalidate the require cache more than once.
+const invalidatedDevDeps = (0, build_cache_1.createBuildCache)();
+function invalidateDevDeps(invalidDevDeps, options, config) {
+    for (let { specifier, resolveFrom } of invalidDevDeps) {
+        let key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
+        if (!invalidatedDevDeps.has(key)) {
+            config.invalidatePlugin(specifier);
+            options.packageManager.invalidate(specifier, (0, projectPath_1.fromProjectPath)(options.projectRoot, resolveFrom));
+            invalidatedDevDeps.set(key, true);
+        }
+    }
+}
+const devDepRequests = (0, build_cache_1.createBuildCache)();
+function resolveDevDepRequestRef(devDepRequestRef) {
+    const devDepRequest = 
+    // @ts-expect-error TS2339
+    devDepRequestRef.type === 'ref'
+        ? devDepRequests.get(devDepRequestRef.hash)
+        : devDepRequestRef;
+    if (devDepRequest == null) {
+        throw new Error(`Worker send back a reference to a missing dev dep request.
+
+This might happen due to internal in-memory build caches not being cleared
+between builds or due a race condition.
+${process.env.NODE_ENV === 'test'
+            ? `If this is a unit test, call atlaspack.clearBuildCaches() between tests`
+            : ''}
+
+This is a bug in Atlaspack.`);
+    }
+    // @ts-expect-error TS2339
+    if (devDepRequestRef.type !== 'ref') {
+        // @ts-expect-error TS2345
+        devDepRequests.set(devDepRequest.hash, devDepRequest);
+    }
+    // @ts-expect-error TS2322
+    return devDepRequest;
+}
+async function runDevDepRequest(api, devDepRequestRef) {
+    await api.runRequest({
+        id: 'dev_dep_request:' +
+            devDepRequestRef.specifier +
+            ':' +
+            devDepRequestRef.hash,
+        type: RequestTracker_1.requestTypes.dev_dep_request,
+        // @ts-expect-error TS2322
+        run: ({ api }) => {
+            const devDepRequest = resolveDevDepRequestRef(devDepRequestRef);
+            for (let filePath of (0, nullthrows_1.default)(devDepRequest.invalidateOnFileChange, 'DevDepRequest missing invalidateOnFileChange')) {
+                api.invalidateOnFileUpdate(filePath);
+                api.invalidateOnFileDelete(filePath);
+            }
+            for (let invalidation of (0, nullthrows_1.default)(devDepRequest.invalidateOnFileCreate, 'DevDepRequest missing invalidateOnFileCreate')) {
+                api.invalidateOnFileCreate(invalidation);
+            }
+            if (devDepRequest.invalidateOnStartup) {
+                api.invalidateOnStartup();
+            }
+            api.storeResult({
+                specifier: devDepRequest.specifier,
+                resolveFrom: devDepRequest.resolveFrom,
+                hash: devDepRequest.hash,
+                additionalInvalidations: devDepRequest.additionalInvalidations,
+            });
+        },
+        input: null,
+    });
+}
+// A cache of plugin dependency hashes that we've already sent to the main thread.
+// Automatically cleared before each build.
+const pluginCache = (0, build_cache_1.createBuildCache)();
+function getWorkerDevDepRequests(devDepRequests) {
+    return devDepRequests.map((devDepRequest) => {
+        // If we've already sent a matching transformer + hash to the main thread during this build,
+        // there's no need to repeat ourselves.
+        let { specifier, resolveFrom, hash } = devDepRequest;
+        if (hash === pluginCache.get(specifier)) {
+            return { type: 'ref', specifier, resolveFrom, hash };
+        }
+        else {
+            pluginCache.set(specifier, hash);
+            return devDepRequest;
+        }
+    });
+}