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

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,89 @@
+"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"));
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+function createPackageRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.package_request,
+        id: input.bundleGraph.getHash(input.bundle),
+        run,
+        input,
+    };
+}
+async function run({ input, api, farm, rustAtlaspack }) {
+    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)(await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let packagingResult;
+    if ((0, feature_flags_1.getFeatureFlag)('nativePackager') &&
+        (0, feature_flags_1.getFeatureFlag)('nativePackagerSSRDev') &&
+        rustAtlaspack &&
+        (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context === 'tesseract' &&
+        bundle.type === 'js') {
+        // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
+        let result = await rustAtlaspack.package(bundle.id, { inlineRequires: true });
+        let error = null;
+        [packagingResult, error] = result;
+        if (error) {
+            throw new diagnostic_1.default({
+                diagnostic: error,
+            });
+        }
+        logger_1.default.verbose({
+            message: JSON.stringify(packagingResult, null, 2),
+            origin: '@atlaspack/core',
+        });
+    }
+    else {
+        packagingResult = (await runPackage({
+            bundle,
+            bundleGraphReference,
+            optionsRef,
+            configCachePath: cachePath,
+            previousDevDeps: devDeps,
+            invalidDevDeps,
+            previousInvalidations: api.getInvalidations(),
+        }));
+    }
+    let { devDepRequests, configRequests, bundleInfo, invalidations } = packagingResult;
+    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;
+}