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

package/dist/TargetDescriptor.schema.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMON_TARGET_DESCRIPTOR_SCHEMA = exports.DESCRIPTOR_SCHEMA = exports.PACKAGE_DESCRIPTOR_SCHEMA = exports.ENGINES_SCHEMA = void 0;
+exports.ENGINES_SCHEMA = {
+    type: 'object',
+    properties: {
+        browsers: {
+            oneOf: [
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                    },
+                },
+                {
+                    type: 'string',
+                },
+            ],
+        },
+    },
+    __forbiddenProperties: ['browser'],
+    additionalProperties: {
+        type: 'string',
+    },
+};
+exports.PACKAGE_DESCRIPTOR_SCHEMA = {
+    type: 'object',
+    properties: {
+        context: {
+            type: 'string',
+            enum: [
+                'node',
+                'browser',
+                'web-worker',
+                'electron-main',
+                'electron-renderer',
+                'service-worker',
+                'tesseract',
+            ],
+        },
+        includeNodeModules: {
+            oneOf: [
+                {
+                    type: 'boolean',
+                },
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        __type: 'a wildcard or filepath',
+                    },
+                },
+                {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: {
+                        type: 'boolean',
+                    },
+                },
+            ],
+        },
+        outputFormat: {
+            type: 'string',
+            enum: ['global', 'esmodule', 'commonjs'],
+        },
+        distDir: {
+            type: 'string',
+        },
+        publicUrl: {
+            type: 'string',
+        },
+        isLibrary: {
+            type: 'boolean',
+        },
+        source: {
+            oneOf: [
+                {
+                    type: 'string',
+                },
+                {
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            ],
+        },
+        sourceMap: {
+            oneOf: [
+                {
+                    type: 'boolean',
+                },
+                {
+                    type: 'object',
+                    properties: {
+                        inlineSources: {
+                            type: 'boolean',
+                        },
+                        sourceRoot: {
+                            type: 'string',
+                        },
+                        inline: {
+                            type: 'boolean',
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            ],
+        },
+        engines: exports.ENGINES_SCHEMA,
+        optimize: {
+            type: 'boolean',
+        },
+        scopeHoist: {
+            type: 'boolean',
+        },
+        __unstable_singleFileOutput: {
+            type: 'boolean',
+        },
+        env: {
+            type: 'object',
+            additionalProperties: {
+                type: 'string',
+            },
+        },
+    },
+    additionalProperties: false,
+};
+exports.DESCRIPTOR_SCHEMA = {
+    ...exports.PACKAGE_DESCRIPTOR_SCHEMA,
+    properties: {
+        ...exports.PACKAGE_DESCRIPTOR_SCHEMA.properties,
+        distEntry: {
+            type: 'string',
+        },
+    },
+};
+exports.COMMON_TARGET_DESCRIPTOR_SCHEMA = {
+    oneOf: [
+        exports.PACKAGE_DESCRIPTOR_SCHEMA,
+        {
+            enum: [false],
+        },
+    ],
+};

package/dist/Transformation.js

@@ -0,0 +1,487 @@
+"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 });
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const logger_1 = __importStar(require("@atlaspack/logger"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const Dependency_1 = require("./Dependency");
+// TODO: eventually call path request as sub requests
+const PathRequest_1 = require("./requests/PathRequest");
+const Asset_1 = require("./public/Asset");
+const UncommittedAsset_1 = __importDefault(require("./UncommittedAsset"));
+const assetUtils_1 = require("./assetUtils");
+const summarizeRequest_1 = __importDefault(require("./summarizeRequest"));
+const PluginOptions_1 = __importDefault(require("./public/PluginOptions"));
+const utils_2 = require("./utils");
+const InternalConfig_1 = require("./InternalConfig");
+const ConfigRequest_1 = require("./requests/ConfigRequest");
+const DevDepRequest_1 = require("./requests/DevDepRequest");
+const projectPath_1 = require("./projectPath");
+const utils_3 = require("./utils");
+const assert_1 = __importDefault(require("assert"));
+const profiler_1 = require("@atlaspack/profiler");
+class Transformation {
+    constructor({ request, options, config, workerApi }) {
+        this.configs = new Map();
+        this.atlaspackConfig = config;
+        this.options = options;
+        this.request = request;
+        this.workerApi = workerApi;
+        this.invalidations = (0, utils_3.createInvalidations)();
+        this.devDepRequests = new Map();
+        this.pluginDevDeps = [];
+        this.resolverRunner = new PathRequest_1.ResolverRunner({
+            config,
+            options,
+            previousDevDeps: request.devDeps,
+        });
+        this.pluginOptions = new PluginOptions_1.default((0, utils_2.optionsProxy)(this.options, (option) => {
+            this.invalidations.invalidateOnOptionChange.add(option);
+        }, (devDep) => {
+            this.pluginDevDeps.push(devDep);
+        }));
+    }
+    async run() {
+        let asset = await this.loadAsset();
+        let existing;
+        if (!asset.mapBuffer && utils_1.SOURCEMAP_EXTENSIONS.has(asset.value.type)) {
+            // Load existing sourcemaps, this automatically runs the source contents extraction
+            try {
+                existing = await asset.loadExistingSourcemap();
+            }
+            catch (err) {
+                logger_1.default.verbose([
+                    {
+                        origin: '@atlaspack/core',
+                        message: (0, diagnostic_1.md) `Could not load existing source map for ${(0, projectPath_1.fromProjectPathRelative)(asset.value.filePath)}`,
+                    },
+                    {
+                        origin: '@atlaspack/core',
+                        message: (0, diagnostic_1.escapeMarkdown)(err.message),
+                    },
+                ]);
+            }
+        }
+        if (existing == null &&
+            // Don't buffer an entire stream into memory since it may not need sourceContent,
+            // e.g. large binary files
+            !(asset.content instanceof stream_1.Readable)) {
+            // If no existing sourcemap was found, initialize asset.sourceContent
+            // with the original contents. This will be used when the transformer
+            // calls setMap to ensure the source content is in the sourcemap.
+            asset.sourceContent = await asset.getCode();
+        }
+        (0, DevDepRequest_1.invalidateDevDeps)(this.request.invalidDevDeps, this.options, this.atlaspackConfig);
+        let pipeline = await this.loadPipeline(
+        // @ts-expect-error TS2345
+        this.request.filePath, asset.value.isSource, asset.value.pipeline);
+        let assets, error;
+        try {
+            let results = await this.runPipelines(pipeline, asset);
+            await Promise.all(results.map((asset) => asset.commit()));
+            assets = results.map((a) => a.value);
+        }
+        catch (e) {
+            error = e;
+        }
+        let configRequests = (0, ConfigRequest_1.getConfigRequests)([
+            ...this.configs.values(),
+            ...this.resolverRunner.configs.values(),
+        ]);
+        let devDepRequests = (0, DevDepRequest_1.getWorkerDevDepRequests)([
+            ...this.devDepRequests.values(),
+            ...this.resolverRunner.devDepRequests.values(),
+        ]);
+        return {
+            // @ts-expect-error TS2353
+            $$raw: true,
+            assets,
+            configRequests,
+            // When throwing an error, this (de)serialization is done automatically by the WorkerFarm
+            error: error ? (0, diagnostic_1.anyToDiagnostic)(error) : undefined,
+            invalidations: this.invalidations,
+            devDepRequests,
+        };
+    }
+    async loadAsset() {
+        let { filePath, env, code, pipeline, isSource: isSourceOverride, sideEffects, query, } = this.request;
+        let { content, size, isSource: summarizedIsSource, } = await (0, summarizeRequest_1.default)(this.options.inputFS, {
+            // @ts-expect-error TS2322
+            filePath: (0, projectPath_1.fromProjectPath)(this.options.projectRoot, filePath),
+            code,
+        });
+        // Prefer `isSource` originating from the AssetRequest.
+        let isSource = isSourceOverride ?? summarizedIsSource;
+        return new UncommittedAsset_1.default({
+            value: (0, assetUtils_1.createAsset)(this.options.projectRoot, {
+                code,
+                // @ts-expect-error TS2322
+                filePath,
+                isSource,
+                // @ts-expect-error TS2345
+                type: path_1.default.extname((0, projectPath_1.fromProjectPathRelative)(filePath)).slice(1),
+                pipeline,
+                // @ts-expect-error TS2322
+                env,
+                query,
+                stats: {
+                    time: 0,
+                    size,
+                },
+                sideEffects,
+            }),
+            options: this.options,
+            content,
+            invalidations: this.invalidations,
+        });
+    }
+    async runPipelines(pipeline, initialAsset) {
+        let initialType = initialAsset.value.type;
+        let assets;
+        try {
+            assets = await this.runPipeline(pipeline, initialAsset);
+        }
+        finally {
+            // Add dev dep requests for each transformer
+            for (let transformer of pipeline.transformers) {
+                await this.addDevDependency({
+                    specifier: transformer.name,
+                    resolveFrom: transformer.resolveFrom,
+                    range: transformer.range,
+                });
+            }
+            // Add dev dep requests for dependencies of transformer plugins
+            // (via proxied packageManager.require calls).
+            for (let devDep of this.pluginDevDeps) {
+                await this.addDevDependency(devDep);
+            }
+        }
+        let finalAssets = [];
+        for (let asset of assets) {
+            let nextPipeline;
+            if (asset.value.type !== initialType) {
+                nextPipeline = await this.loadNextPipeline({
+                    filePath: initialAsset.value.filePath,
+                    isSource: asset.value.isSource,
+                    newType: asset.value.type,
+                    newPipeline: asset.value.pipeline,
+                    currentPipeline: pipeline,
+                });
+            }
+            if (nextPipeline) {
+                let nextPipelineAssets = await this.runPipelines(nextPipeline, asset);
+                finalAssets = finalAssets.concat(nextPipelineAssets);
+            }
+            else {
+                finalAssets.push(asset);
+            }
+        }
+        if (!pipeline.postProcess) {
+            return finalAssets;
+        }
+        (0, assert_1.default)(pipeline.postProcess != null);
+        let processedFinalAssets = (await pipeline.postProcess(finalAssets)) ?? [];
+        return processedFinalAssets;
+    }
+    async addDevDependency(opts) {
+        let { specifier, resolveFrom, range } = opts;
+        let key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
+        if (this.devDepRequests.has(key)) {
+            return;
+        }
+        // Ensure that the package manager has an entry for this resolution.
+        try {
+            await this.options.packageManager.resolve(specifier, (0, projectPath_1.fromProjectPath)(this.options.projectRoot, opts.resolveFrom), {
+                range,
+            });
+        }
+        catch (err) {
+            // ignore
+        }
+        let devDepRequest = await (0, DevDepRequest_1.createDevDependency)(opts, this.request.devDeps, this.options);
+        this.devDepRequests.set(key, devDepRequest);
+    }
+    async runPipeline(pipeline, initialAsset) {
+        if (pipeline.transformers.length === 0) {
+            return [initialAsset];
+        }
+        let initialType = initialAsset.value.type;
+        let inputAssets = [initialAsset];
+        let resultingAssets = [];
+        let finalAssets = [];
+        for (let transformer of pipeline.transformers) {
+            resultingAssets = [];
+            for (let asset of inputAssets) {
+                if (asset.value.type !== initialType &&
+                    (await this.loadNextPipeline({
+                        filePath: initialAsset.value.filePath,
+                        isSource: asset.value.isSource,
+                        newType: asset.value.type,
+                        newPipeline: asset.value.pipeline,
+                        currentPipeline: pipeline,
+                    }))) {
+                    finalAssets.push(asset);
+                    continue;
+                }
+                try {
+                    const measurement = profiler_1.tracer.createMeasurement(transformer.name, 'transform', (0, projectPath_1.fromProjectPathRelative)(initialAsset.value.filePath));
+                    let transformerResults = await this.runTransformer(pipeline, asset, transformer.plugin, transformer.name, transformer.config, transformer.configKeyPath, this.atlaspackConfig);
+                    measurement && measurement.end();
+                    for (let result of transformerResults) {
+                        if (result instanceof UncommittedAsset_1.default) {
+                            resultingAssets.push(result);
+                            continue;
+                        }
+                        resultingAssets.push(asset.createChildAsset(result, transformer.name, this.atlaspackConfig.filePath, transformer.configKeyPath));
+                    }
+                }
+                catch (e) {
+                    let diagnostic = (0, diagnostic_1.errorToDiagnostic)(e, {
+                        origin: transformer.name,
+                        filePath: (0, projectPath_1.fromProjectPath)(this.options.projectRoot, asset.value.filePath),
+                    });
+                    // If this request is a virtual asset that might not exist on the filesystem,
+                    // add the `code` property to each code frame in the diagnostics that match the
+                    // request's filepath. This can't be done by the transformer because it might not
+                    // have access to the original code (e.g. an inline script tag in HTML).
+                    if (this.request.code != null) {
+                        for (let d of diagnostic) {
+                            if (d.codeFrames) {
+                                for (let codeFrame of d.codeFrames) {
+                                    if (codeFrame.code == null &&
+                                        codeFrame.filePath === this.request.filePath) {
+                                        codeFrame.code = this.request.code;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    throw new diagnostic_1.default({
+                        diagnostic,
+                    });
+                }
+            }
+            inputAssets = resultingAssets;
+        }
+        // Make assets with ASTs generate unless they are CSS modules. This parallelizes generation
+        // and distributes work more evenly across workers than if one worker needed to
+        // generate all assets in a large bundle during packaging.
+        await Promise.all(resultingAssets
+            .filter((asset) => asset.ast != null &&
+            !(this.options.mode === 'production' &&
+                asset.value.type === 'css' &&
+                asset.value.symbols))
+            .map(async (asset) => {
+            if (asset.isASTDirty && asset.generate) {
+                let output = await asset.generate();
+                asset.content = output.content;
+                asset.mapBuffer = output.map?.toBuffer();
+            }
+            asset.clearAST();
+        }));
+        return finalAssets.concat(resultingAssets);
+    }
+    async loadPipeline(filePath, isSource, pipeline) {
+        let transformers = await this.atlaspackConfig.getTransformers(filePath, pipeline, this.request.isURL);
+        for (let transformer of transformers) {
+            let config = await this.loadTransformerConfig(transformer, isSource);
+            if (config) {
+                this.configs.set(transformer.name, config);
+            }
+        }
+        return {
+            id: transformers.map((t) => t.name).join(':'),
+            transformers: transformers.map((transformer) => ({
+                name: transformer.name,
+                resolveFrom: transformer.resolveFrom,
+                config: this.configs.get(transformer.name)?.result,
+                configKeyPath: transformer.keyPath,
+                plugin: transformer.plugin,
+            })),
+            options: this.options,
+            pluginOptions: this.pluginOptions,
+            workerApi: this.workerApi,
+        };
+    }
+    async loadNextPipeline({ filePath, isSource, newType, newPipeline, currentPipeline, }) {
+        let filePathRelative = (0, projectPath_1.fromProjectPathRelative)(filePath);
+        let nextFilePath = (0, projectPath_1.toProjectPathUnsafe)(filePathRelative.slice(0, -path_1.default.extname(filePathRelative).length) +
+            '.' +
+            newType);
+        let nextPipeline = await this.loadPipeline(nextFilePath, isSource, newPipeline);
+        if (nextPipeline.id === currentPipeline.id) {
+            return null;
+        }
+        return nextPipeline;
+    }
+    async loadTransformerConfig(transformer, isSource) {
+        let loadConfig = transformer.plugin.loadConfig;
+        if (!loadConfig) {
+            return;
+        }
+        let config = (0, InternalConfig_1.createConfig)({
+            plugin: transformer.name,
+            isSource,
+            // @ts-expect-error TS2322
+            searchPath: this.request.filePath,
+            env: this.request.env,
+        });
+        await (0, ConfigRequest_1.loadPluginConfig)(transformer, config, this.options);
+        for (let devDep of config.devDeps) {
+            await this.addDevDependency(devDep);
+        }
+        return config;
+    }
+    async runTransformer(pipeline, asset, transformer, transformerName, preloadedConfig, configKeyPath, atlaspackConfig) {
+        const logger = new logger_1.PluginLogger({ origin: transformerName });
+        const tracer = new profiler_1.PluginTracer({
+            origin: transformerName,
+            category: 'transform',
+        });
+        const resolve = async (from, to, options) => {
+            let result = await this.resolverRunner.resolve((0, Dependency_1.createDependency)(this.options.projectRoot, {
+                env: asset.value.env,
+                specifier: to,
+                specifierType: options?.specifierType || 'esm',
+                packageConditions: options?.packageConditions,
+                sourcePath: from,
+            }));
+            if (result.invalidateOnFileCreate) {
+                this.invalidations.invalidateOnFileCreate.push(...result.invalidateOnFileCreate.map((i) => (0, utils_3.invalidateOnFileCreateToInternal)(this.options.projectRoot, i)));
+            }
+            if (result.invalidateOnFileChange) {
+                for (let filePath of result.invalidateOnFileChange) {
+                    this.invalidations.invalidateOnFileChange.add((0, projectPath_1.toProjectPath)(this.options.projectRoot, filePath));
+                }
+            }
+            if (result.diagnostics && result.diagnostics.length > 0) {
+                throw new diagnostic_1.default({ diagnostic: result.diagnostics });
+            }
+            // @ts-expect-error TS2322
+            return (0, projectPath_1.fromProjectPath)(this.options.projectRoot, (0, nullthrows_1.default)(result.assetGroup).filePath);
+        };
+        // If an ast exists on the asset, but we cannot reuse it,
+        // use the previous transform to generate code that we can re-parse.
+        if (asset.ast &&
+            asset.isASTDirty &&
+            (!transformer.canReuseAST ||
+                !transformer.canReuseAST({
+                    ast: asset.ast,
+                    options: pipeline.pluginOptions,
+                    logger,
+                    tracer,
+                })) &&
+            asset.generate) {
+            let output = await asset.generate();
+            asset.content = output.content;
+            asset.mapBuffer = output.map?.toBuffer();
+        }
+        // Load config for the transformer.
+        let config = preloadedConfig;
+        // Parse if there is no AST available from a previous transform.
+        let parse = transformer.parse?.bind(transformer);
+        if (!asset.ast && parse) {
+            let ast = await parse({
+                asset: new Asset_1.Asset(asset),
+                config,
+                options: pipeline.pluginOptions,
+                resolve,
+                logger,
+                tracer,
+            });
+            if (ast) {
+                asset.setAST(ast);
+                asset.isASTDirty = false;
+            }
+        }
+        // Transform.
+        // @ts-expect-error TS2322
+        let transfomerResult = await transformer.transform({
+            asset: new Asset_1.MutableAsset(asset),
+            config,
+            options: pipeline.pluginOptions,
+            resolve,
+            logger,
+            tracer,
+        });
+        let results = await normalizeAssets(this.options, transfomerResult);
+        // Create generate and postProcess function that can be called later
+        asset.generate = () => {
+            let publicAsset = new Asset_1.Asset(asset);
+            if (transformer.generate && asset.ast) {
+                let generated = transformer.generate({
+                    asset: publicAsset,
+                    ast: asset.ast,
+                    options: pipeline.pluginOptions,
+                    logger,
+                    tracer,
+                });
+                asset.clearAST();
+                return Promise.resolve(generated);
+            }
+            throw new Error('Asset has an AST but no generate method is available on the transform');
+        };
+        let postProcess = transformer.postProcess;
+        if (postProcess) {
+            pipeline.postProcess = async (assets) => {
+                let results = await postProcess.call(transformer, {
+                    assets: assets.map((asset) => new Asset_1.MutableAsset(asset)),
+                    config,
+                    options: pipeline.pluginOptions,
+                    resolve,
+                    logger,
+                    tracer,
+                });
+                return Promise.all(results.map((result) => asset.createChildAsset(result, transformerName, atlaspackConfig.filePath)));
+            };
+        }
+        return results;
+    }
+}
+exports.default = Transformation;
+function normalizeAssets(options, results) {
+    return results.map((result) => {
+        if (result instanceof Asset_1.MutableAsset) {
+            return (0, Asset_1.mutableAssetToUncommittedAsset)(result);
+        }
+        return result;
+    });
+}