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

package/dist/requests/PathRequest.js

@@ -0,0 +1,349 @@
+"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.ResolverRunner = void 0;
+exports.default = createPathRequest;
+const build_cache_1 = require("@atlaspack/build-cache");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const logger_1 = require("@atlaspack/logger");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@atlaspack/utils");
+const ReporterRunner_1 = require("../ReporterRunner");
+const Dependency_1 = require("../public/Dependency");
+const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
+const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
+const utils_2 = require("../utils");
+const projectPath_1 = require("../projectPath");
+const types_1 = require("../types");
+const InternalConfig_1 = require("../InternalConfig");
+const ConfigRequest_1 = require("./ConfigRequest");
+const DevDepRequest_1 = require("./DevDepRequest");
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+const PIPELINE_REGEX = /^([a-z0-9-]+?):(.*)$/i;
+function createPathRequest(input) {
+    return {
+        id: input.dependency.id + ':' + input.name,
+        type: RequestTracker_1.requestTypes.path_request,
+        run,
+        input,
+    };
+}
+// @ts-expect-error TS7031
+async function run({ input, api, options }) {
+    let configResult = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let config = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, options);
+    let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
+    (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, options, config);
+    let resolverRunner = new ResolverRunner({
+        options,
+        config,
+        previousDevDeps: devDeps,
+    });
+    let result = await resolverRunner.resolve(input.dependency);
+    if (result.invalidateOnEnvChange) {
+        for (let env of result.invalidateOnEnvChange) {
+            api.invalidateOnEnvChange(env);
+        }
+    }
+    if (result.invalidateOnFileCreate) {
+        for (let file of result.invalidateOnFileCreate) {
+            api.invalidateOnFileCreate((0, utils_2.invalidateOnFileCreateToInternal)(options.projectRoot, file));
+        }
+    }
+    if (result.invalidateOnFileChange) {
+        for (let filePath of result.invalidateOnFileChange) {
+            let pp = (0, projectPath_1.toProjectPath)(options.projectRoot, filePath);
+            api.invalidateOnFileUpdate(pp);
+            api.invalidateOnFileDelete(pp);
+        }
+    }
+    for (let config of resolverRunner.configs.values()) {
+        await (0, ConfigRequest_1.runConfigRequest)(api, config);
+    }
+    for (let devDepRequest of resolverRunner.devDepRequests.values()) {
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+    if (result.assetGroup) {
+        api.invalidateOnFileDelete(result.assetGroup.filePath);
+        return result.assetGroup;
+    }
+    if (result.diagnostics && result.diagnostics.length > 0) {
+        let err = new diagnostic_1.default({ diagnostic: result.diagnostics });
+        // @ts-expect-error TS2339
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+    }
+}
+const configCache = (0, build_cache_1.createBuildCache)();
+class ResolverRunner {
+    constructor({ config, options, previousDevDeps }) {
+        this.config = config;
+        this.options = options;
+        this.pluginOptions = new PluginOptions_1.default(this.options);
+        this.previousDevDeps = previousDevDeps;
+        this.devDepRequests = new Map();
+        this.configs = new Map();
+    }
+    async getDiagnostic(dependency, message) {
+        let diagnostic = {
+            message,
+            origin: '@atlaspack/core',
+        };
+        if (dependency.loc && dependency.sourcePath != null) {
+            let filePath = (0, projectPath_1.fromProjectPath)(this.options.projectRoot, dependency.sourcePath);
+            diagnostic.codeFrames = [
+                {
+                    filePath,
+                    code: await this.options.inputFS
+                        .readFile(filePath, 'utf8')
+                        .catch(() => ''),
+                    codeHighlights: dependency.loc
+                        ? [(0, diagnostic_1.convertSourceLocationToHighlight)(dependency.loc)]
+                        : [],
+                },
+            ];
+        }
+        return diagnostic;
+    }
+    async loadConfigs(resolvers) {
+        for (let plugin of resolvers) {
+            // Only load config for a plugin once per build.
+            let config = configCache.get(plugin.name);
+            if (!config && plugin.plugin.loadConfig != null) {
+                config = (0, InternalConfig_1.createConfig)({
+                    plugin: plugin.name,
+                    searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
+                });
+                // @ts-expect-error TS2345
+                await (0, ConfigRequest_1.loadPluginConfig)(plugin, config, this.options);
+                configCache.set(plugin.name, config);
+                // @ts-expect-error TS2345
+                this.configs.set(plugin.name, config);
+            }
+            if (config) {
+                // @ts-expect-error TS2339
+                for (let devDep of config.devDeps) {
+                    let devDepRequest = await (0, DevDepRequest_1.createDevDependency)(devDep, this.previousDevDeps, this.options);
+                    this.runDevDepRequest(devDepRequest);
+                }
+                // @ts-expect-error TS2345
+                this.configs.set(plugin.name, config);
+            }
+        }
+    }
+    runDevDepRequest(devDepRequest) {
+        // @ts-expect-error TS2339
+        if (devDepRequest.type !== 'ref') {
+            let { specifier, resolveFrom } = devDepRequest;
+            let key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
+            // @ts-expect-error TS2345
+            this.devDepRequests.set(key, devDepRequest);
+        }
+    }
+    async resolve(dependency) {
+        let dep = (0, Dependency_1.getPublicDependency)(dependency, this.options);
+        (0, ReporterRunner_1.report)({
+            type: 'buildProgress',
+            phase: 'resolving',
+            dependency: dep,
+        });
+        let resolvers = await this.config.getResolvers();
+        await this.loadConfigs(resolvers);
+        let pipeline;
+        let specifier;
+        let validPipelines = new Set(this.config.getNamedPipelines());
+        let match = dependency.specifier.match(PIPELINE_REGEX);
+        if (match &&
+            // Don't consider absolute paths. Absolute paths are only supported for entries,
+            // and include e.g. `C:\` on Windows, conflicting with pipelines.
+            !path_1.default.isAbsolute(dependency.specifier)) {
+            [, pipeline, specifier] = match;
+            if (!validPipelines.has(pipeline)) {
+                // This may be a url protocol or scheme rather than a pipeline, such as
+                // `url('http://example.com/foo.png')`. Pass it to resolvers to handle.
+                specifier = dependency.specifier;
+                pipeline = null;
+            }
+        }
+        else {
+            specifier = dependency.specifier;
+        }
+        // Entrypoints, convert ProjectPath in module specifier to absolute path
+        if (dep.resolveFrom == null) {
+            specifier = path_1.default.join(this.options.projectRoot, specifier);
+        }
+        let diagnostics = [];
+        let invalidateOnFileCreate = [];
+        let invalidateOnFileChange = [];
+        let invalidateOnEnvChange = [];
+        for (let resolver of resolvers) {
+            let measurement;
+            try {
+                measurement = profiler_1.tracer.createMeasurement(resolver.name, 'resolve', specifier);
+                let result = await resolver.plugin.resolve({
+                    specifier,
+                    pipeline,
+                    dependency: dep,
+                    options: this.pluginOptions,
+                    logger: new logger_1.PluginLogger({ origin: resolver.name }),
+                    tracer: new profiler_1.PluginTracer({
+                        origin: resolver.name,
+                        category: 'resolver',
+                    }),
+                    config: this.configs.get(resolver.name)?.result,
+                });
+                measurement && measurement.end();
+                if (result) {
+                    if (result.meta) {
+                        dependency.resolverMeta = result.meta;
+                        dependency.meta = {
+                            ...dependency.meta,
+                            ...result.meta,
+                        };
+                    }
+                    if (result.priority != null) {
+                        dependency.priority = types_1.Priority[result.priority];
+                        if ((0, feature_flags_1.getFeatureFlag)('hmrImprovements')) {
+                            dependency.resolverPriority = dependency.priority;
+                        }
+                    }
+                    if (result.invalidateOnEnvChange) {
+                        invalidateOnEnvChange.push(...result.invalidateOnEnvChange);
+                    }
+                    if (result.invalidateOnFileCreate) {
+                        invalidateOnFileCreate.push(...result.invalidateOnFileCreate);
+                    }
+                    if (result.invalidateOnFileChange) {
+                        invalidateOnFileChange.push(...result.invalidateOnFileChange);
+                    }
+                    if (result.isExcluded) {
+                        return {
+                            assetGroup: null,
+                            invalidateOnFileCreate,
+                            invalidateOnFileChange,
+                            invalidateOnEnvChange,
+                        };
+                    }
+                    if (result.filePath != null) {
+                        let resultFilePath = result.filePath;
+                        if (!path_1.default.isAbsolute(resultFilePath)) {
+                            throw new Error((0, diagnostic_1.md) `Resolvers must return an absolute path, ${resolver.name} returned: ${resultFilePath}`);
+                        }
+                        return {
+                            assetGroup: {
+                                canDefer: result.canDefer,
+                                filePath: (0, projectPath_1.toProjectPath)(this.options.projectRoot, resultFilePath),
+                                query: result.query?.toString(),
+                                sideEffects: result.sideEffects,
+                                code: result.code,
+                                env: dependency.env,
+                                pipeline: result.pipeline === undefined
+                                    ? (pipeline ?? dependency.pipeline)
+                                    : result.pipeline,
+                                isURL: dep.specifierType === 'url',
+                            },
+                            invalidateOnFileCreate,
+                            invalidateOnFileChange,
+                            invalidateOnEnvChange,
+                        };
+                    }
+                    if (result.diagnostics != null &&
+                        !(Array.isArray(result.diagnostics) &&
+                            result.diagnostics.length === 0)) {
+                        let errorDiagnostic = (0, diagnostic_1.errorToDiagnostic)(new diagnostic_1.default({ diagnostic: result.diagnostics }), {
+                            origin: resolver.name,
+                            filePath: specifier,
+                        });
+                        diagnostics.push(...errorDiagnostic);
+                    }
+                }
+            }
+            catch (e) {
+                // Add error to error map, we'll append these to the standard error if we can't resolve the asset
+                let errorDiagnostic = (0, diagnostic_1.errorToDiagnostic)(e, {
+                    origin: resolver.name,
+                    filePath: specifier,
+                });
+                if (Array.isArray(errorDiagnostic)) {
+                    diagnostics.push(...errorDiagnostic);
+                }
+                else {
+                    diagnostics.push(errorDiagnostic);
+                }
+                break;
+            }
+            finally {
+                measurement && measurement.end();
+                // Add dev dependency for the resolver. This must be done AFTER running it due to
+                // the potential for lazy require() that aren't executed until the request runs.
+                let devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+                    specifier: resolver.name,
+                    resolveFrom: resolver.resolveFrom,
+                }, this.previousDevDeps, this.options);
+                this.runDevDepRequest(devDepRequest);
+            }
+        }
+        if (dep.isOptional) {
+            return {
+                assetGroup: null,
+                invalidateOnFileCreate,
+                invalidateOnFileChange,
+                invalidateOnEnvChange,
+            };
+        }
+        let resolveFrom = dependency.resolveFrom ?? dependency.sourcePath;
+        let dir = resolveFrom != null
+            ? (0, utils_1.normalizePath)((0, projectPath_1.fromProjectPathRelative)(resolveFrom))
+            : '';
+        let diagnostic = await this.getDiagnostic(dependency, (0, diagnostic_1.md) `Failed to resolve '${dependency.specifier}' ${dir ? `from '${dir}'` : ''}`);
+        diagnostics.unshift(diagnostic);
+        return {
+            assetGroup: null,
+            invalidateOnFileCreate,
+            invalidateOnFileChange,
+            invalidateOnEnvChange,
+            diagnostics,
+        };
+    }
+}
+exports.ResolverRunner = ResolverRunner;