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

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

package/dist/requests/EntryRequest.js

@@ -0,0 +1,314 @@
+"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.EntryResolver = void 0;
+exports.default = createEntryRequest;
+const utils_1 = require("@atlaspack/utils");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const path_1 = __importDefault(require("path"));
+const json_sourcemap_1 = require("@mischnic/json-sourcemap");
+const RequestTracker_1 = require("../RequestTracker");
+const projectPath_1 = require("../projectPath");
+const type = 'entry_request';
+function createEntryRequest(input) {
+    return {
+        id: `${type}:${(0, projectPath_1.fromProjectPathRelative)(input)}`,
+        type: RequestTracker_1.requestTypes.entry_request,
+        run,
+        input,
+    };
+}
+// @ts-expect-error TS7031
+async function run({ input, api, options }) {
+    let entryResolver = new EntryResolver(options);
+    let filePath = (0, projectPath_1.fromProjectPath)(options.projectRoot, input);
+    let result = await entryResolver.resolveEntry(filePath);
+    // Connect files like package.json that affect the entry
+    // resolution so we invalidate when they change.
+    for (let file of result.files) {
+        api.invalidateOnFileUpdate(file.filePath);
+        api.invalidateOnFileDelete(file.filePath);
+    }
+    // If the entry specifier is a glob, add a glob node so
+    // we invalidate when a new file matches.
+    for (let glob of result.globs) {
+        api.invalidateOnFileCreate({
+            glob: (0, projectPath_1.toProjectPath)(options.projectRoot, glob),
+        });
+    }
+    // Invalidate whenever an entry is deleted.
+    // If the entry was a glob, we'll re-evaluate it, and otherwise
+    // a proper entry error will be thrown.
+    for (let entry of result.entries) {
+        api.invalidateOnFileDelete(entry.filePath);
+    }
+    return result;
+}
+async function assertFile(fs, entry, relativeSource, pkgFilePath, keyPath, options) {
+    let source = path_1.default.join(entry, relativeSource);
+    let stat;
+    try {
+        stat = await fs.stat(source);
+    }
+    catch (err) {
+        let contents = await fs.readFile(pkgFilePath, 'utf8');
+        let alternatives = await (0, utils_1.findAlternativeFiles)(fs, relativeSource, entry, options.projectRoot, false);
+        throw new diagnostic_1.default({
+            diagnostic: {
+                origin: '@atlaspack/core',
+                message: (0, diagnostic_1.md) `${path_1.default.relative(process.cwd(), source)} does not exist.`,
+                codeFrames: [
+                    {
+                        filePath: pkgFilePath,
+                        codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                            {
+                                key: keyPath,
+                                type: 'value',
+                            },
+                        ]),
+                    },
+                ],
+                hints: alternatives.map((r) => {
+                    return (0, diagnostic_1.md) `Did you mean '__${r}__'?`;
+                }),
+            },
+        });
+    }
+    if (!stat.isFile()) {
+        let contents = await fs.readFile(pkgFilePath, 'utf8');
+        throw new diagnostic_1.default({
+            diagnostic: {
+                origin: '@atlaspack/core',
+                message: (0, diagnostic_1.md) `${path_1.default.relative(process.cwd(), source)} is not a file.`,
+                codeFrames: [
+                    {
+                        filePath: pkgFilePath,
+                        codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                            {
+                                key: keyPath,
+                                type: 'value',
+                            },
+                        ]),
+                    },
+                ],
+            },
+        });
+    }
+}
+class EntryResolver {
+    constructor(options) {
+        this.options = options;
+    }
+    async resolveEntry(entry) {
+        let stat;
+        try {
+            stat = await this.options.inputFS.stat(entry);
+        }
+        catch (err) {
+            if (!(0, utils_1.isGlob)(entry)) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: (0, diagnostic_1.md) `Entry ${entry} does not exist`,
+                    },
+                });
+            }
+            let files = await (0, utils_1.glob)(entry, this.options.inputFS, {
+                absolute: true,
+                onlyFiles: false,
+            });
+            let results = await Promise.all(files.map((f) => this.resolveEntry(path_1.default.normalize(f))));
+            return results.reduce((p, res) => ({
+                entries: p.entries.concat(res.entries),
+                files: p.files.concat(res.files),
+                globs: p.globs.concat(res.globs),
+            }), { entries: [], files: [], globs: [entry] });
+        }
+        if (stat.isDirectory()) {
+            let pkg = await this.readPackage(entry);
+            if (pkg) {
+                let { filePath } = pkg;
+                let entries = [];
+                let files = [
+                    {
+                        filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, filePath),
+                    },
+                ];
+                let globs = [];
+                let targetsWithSources = 0;
+                if (pkg.targets) {
+                    for (let targetName in pkg.targets) {
+                        let target = pkg.targets[targetName];
+                        if (target.source != null) {
+                            targetsWithSources++;
+                            let targetSources = Array.isArray(target.source)
+                                ? target.source
+                                : [target.source];
+                            let i = 0;
+                            for (let source of targetSources) {
+                                let sources;
+                                if ((0, utils_1.isGlob)(source)) {
+                                    globs.push(source);
+                                    sources = await (0, utils_1.glob)(source, this.options.inputFS, {
+                                        onlyFiles: true,
+                                        cwd: entry,
+                                    });
+                                }
+                                else {
+                                    sources = [source];
+                                }
+                                let keyPath = `/targets/${targetName}/source${Array.isArray(target.source) ? `/${i}` : ''}`;
+                                for (let relativeSource of sources) {
+                                    let source = path_1.default.join(entry, relativeSource);
+                                    await assertFile(this.options.inputFS, entry, relativeSource, filePath, keyPath, this.options);
+                                    entries.push({
+                                        filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, source),
+                                        packagePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, entry),
+                                        target: targetName,
+                                        loc: {
+                                            filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, pkg.filePath),
+                                            ...(0, diagnostic_1.getJSONSourceLocation)(pkg.map.pointers[keyPath], 'value'),
+                                        },
+                                    });
+                                    i++;
+                                }
+                            }
+                        }
+                    }
+                }
+                let allTargetsHaveSource = targetsWithSources > 0 &&
+                    pkg != null &&
+                    pkg.targets != null &&
+                    Object.keys(pkg.targets).length === targetsWithSources;
+                if (!allTargetsHaveSource && pkg.source != null) {
+                    let pkgSources = Array.isArray(pkg.source)
+                        ? pkg.source
+                        : [pkg.source];
+                    let i = 0;
+                    for (let pkgSource of pkgSources) {
+                        let sources;
+                        if ((0, utils_1.isGlob)(pkgSource)) {
+                            globs.push(pkgSource);
+                            sources = await (0, utils_1.glob)(pkgSource, this.options.inputFS, {
+                                onlyFiles: true,
+                                cwd: path_1.default.dirname(filePath),
+                            });
+                        }
+                        else {
+                            sources = [pkgSource];
+                        }
+                        let keyPath = `/source${Array.isArray(pkg.source) ? `/${i}` : ''}`;
+                        for (let relativeSource of sources) {
+                            let source = path_1.default.join(path_1.default.dirname(filePath), relativeSource);
+                            await assertFile(this.options.inputFS, entry, relativeSource, filePath, keyPath, this.options);
+                            entries.push({
+                                filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, source),
+                                packagePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, entry),
+                                loc: {
+                                    filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, pkg.filePath),
+                                    ...(0, diagnostic_1.getJSONSourceLocation)(pkg.map.pointers[keyPath], 'value'),
+                                },
+                            });
+                            i++;
+                        }
+                    }
+                }
+                // Only return if we found any valid entries
+                if (entries.length && files.length) {
+                    return {
+                        entries,
+                        files,
+                        globs,
+                    };
+                }
+            }
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: (0, diagnostic_1.md) `Could not find entry: ${entry}`,
+                },
+            });
+        }
+        else if (stat.isFile()) {
+            let projectRoot = this.options.projectRoot;
+            let packagePath = (0, utils_1.isDirectoryInside)(this.options.inputFS.cwd(), projectRoot)
+                ? this.options.inputFS.cwd()
+                : projectRoot;
+            return {
+                entries: [
+                    {
+                        filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, entry),
+                        packagePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, packagePath),
+                    },
+                ],
+                files: [],
+                globs: [],
+            };
+        }
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: (0, diagnostic_1.md) `Unknown entry: ${entry}`,
+            },
+        });
+    }
+    async readPackage(entry) {
+        let content, pkg;
+        let pkgFile = path_1.default.join(entry, 'package.json');
+        try {
+            content = await this.options.inputFS.readFile(pkgFile, 'utf8');
+        }
+        catch (err) {
+            return null;
+        }
+        try {
+            pkg = JSON.parse(content);
+        }
+        catch (err) {
+            // TODO: code frame?
+            throw new diagnostic_1.default({
+                diagnostic: {
+                    message: (0, diagnostic_1.md) `Error parsing ${path_1.default.relative(this.options.inputFS.cwd(), pkgFile)}: ${err.message}`,
+                },
+            });
+        }
+        return {
+            ...pkg,
+            filePath: pkgFile,
+            map: (0, json_sourcemap_1.parse)(content, undefined, { tabWidth: 1 }),
+        };
+    }
+}
+exports.EntryResolver = EntryResolver;

package/dist/requests/PackageRequest.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageRequest = createPackageRequest;
+const RequestTracker_1 = require("../RequestTracker");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const ConfigRequest_1 = require("./ConfigRequest");
+const DevDepRequest_1 = require("./DevDepRequest");
+const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+function createPackageRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.package_request,
+        id: input.bundleGraph.getHash(input.bundle),
+        run,
+        input,
+    };
+}
+// @ts-expect-error TS7031
+async function run({ input, api, farm }) {
+    let { bundleGraphReference, optionsRef, bundle, useMainThread } = input;
+    let runPackage = farm.createHandle('runPackage', useMainThread);
+    let start = Date.now();
+    let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
+    let { cachePath } = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let { devDepRequests, configRequests, bundleInfo, invalidations } = (await runPackage({
+        bundle,
+        bundleGraphReference,
+        optionsRef,
+        configCachePath: cachePath,
+        previousDevDeps: devDeps,
+        invalidDevDeps,
+        previousInvalidations: api.getInvalidations(),
+    }));
+    for (let devDepRequest of devDepRequests) {
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+    for (let configRequest of configRequests) {
+        await (0, ConfigRequest_1.runConfigRequest)(api, configRequest);
+    }
+    for (let invalidation of invalidations) {
+        switch (invalidation.type) {
+            case 'file':
+                api.invalidateOnFileUpdate(invalidation.filePath);
+                api.invalidateOnFileDelete(invalidation.filePath);
+                break;
+            case 'env':
+                api.invalidateOnEnvChange(invalidation.key);
+                break;
+            case 'option':
+                api.invalidateOnOptionChange(invalidation.key);
+                break;
+            default:
+                // @ts-expect-error TS2339
+                throw new Error(`Unknown invalidation type: ${invalidation.type}`);
+        }
+    }
+    // @ts-expect-error TS2540
+    bundleInfo.time = Date.now() - start;
+    api.storeResult(bundleInfo);
+    return bundleInfo;
+}