@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

package/dist/AtlaspackConfig.js

@@ -0,0 +1,324 @@
+"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.AtlaspackConfig = void 0;
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const json5_1 = __importDefault(require("json5"));
+const utils_1 = require("@atlaspack/utils");
+const path_1 = require("path");
+const loadAtlaspackPlugin_1 = __importDefault(require("./loadAtlaspackPlugin"));
+const projectPath_1 = require("./projectPath");
+class AtlaspackConfig {
+    constructor(config, options) {
+        this.options = options;
+        this.filePath = config.filePath;
+        this.resolvers = config.resolvers || [];
+        this.transformers = config.transformers || {};
+        this.runtimes = config.runtimes || [];
+        this.bundler = config.bundler;
+        this.namers = config.namers || [];
+        this.packagers = config.packagers || {};
+        this.optimizers = config.optimizers || {};
+        this.compressors = config.compressors || {};
+        this.reporters = config.reporters || [];
+        this.validators = config.validators || {};
+        this.pluginCache = new Map();
+        this.regexCache = new Map();
+    }
+    static deserialize(serialized) {
+        return new AtlaspackConfig(serialized.config, serialized.options);
+    }
+    getConfig() {
+        return {
+            filePath: this.filePath,
+            resolvers: this.resolvers,
+            transformers: this.transformers,
+            validators: this.validators,
+            runtimes: this.runtimes,
+            bundler: this.bundler,
+            namers: this.namers,
+            packagers: this.packagers,
+            optimizers: this.optimizers,
+            compressors: this.compressors,
+            reporters: this.reporters,
+        };
+    }
+    serialize() {
+        return {
+            $$raw: false,
+            config: this.getConfig(),
+            options: this.options,
+        };
+    }
+    _loadPlugin(node) {
+        let plugin = this.pluginCache.get(node.packageName);
+        if (plugin) {
+            return plugin;
+        }
+        plugin = (0, loadAtlaspackPlugin_1.default)(node.packageName, (0, projectPath_1.fromProjectPath)(this.options.projectRoot, node.resolveFrom), node.keyPath, this.options);
+        this.pluginCache.set(node.packageName, plugin);
+        return plugin;
+    }
+    async loadPlugin(node) {
+        let plugin = await this._loadPlugin(node);
+        // @ts-expect-error TS2322
+        return {
+            ...plugin,
+            name: node.packageName,
+            keyPath: node.keyPath,
+        };
+    }
+    invalidatePlugin(packageName) {
+        this.pluginCache.delete(packageName);
+    }
+    loadPlugins(plugins) {
+        return Promise.all(plugins.map((p) => this.loadPlugin(p)));
+    }
+    async getResolvers() {
+        if (this.resolvers.length === 0) {
+            throw await this.missingPluginError(this.resolvers, 'No resolver plugins specified in .parcelrc config', '/resolvers');
+        }
+        return this.loadPlugins(this.resolvers);
+    }
+    _getValidatorNodes(filePath) {
+        let validators = this.matchGlobMapPipelines(filePath, this.validators) || [];
+        return validators;
+    }
+    getValidatorNames(filePath) {
+        let validators = this._getValidatorNodes(filePath);
+        return validators.map((v) => v.packageName);
+    }
+    getValidators(filePath) {
+        let validators = this._getValidatorNodes(filePath);
+        return this.loadPlugins(validators);
+    }
+    getNamedPipelines() {
+        return Object.keys(this.transformers)
+            .filter((glob) => glob.includes(':'))
+            .map((glob) => glob.split(':')[0]);
+    }
+    async getTransformers(filePath, pipeline, allowEmpty) {
+        let transformers = this.matchGlobMapPipelines(filePath, this.transformers, pipeline);
+        if (!transformers || transformers.length === 0) {
+            if (allowEmpty) {
+                return [];
+            }
+            throw await this.missingPluginError(this.transformers, (0, diagnostic_1.md) `No transformers found for __${(0, projectPath_1.fromProjectPathRelative)(filePath)}__` +
+                (pipeline != null ? ` with pipeline: '${pipeline}'` : '') +
+                '.', '/transformers');
+        }
+        return this.loadPlugins(transformers);
+    }
+    async getBundler() {
+        if (!this.bundler) {
+            throw await this.missingPluginError([], 'No bundler specified in .parcelrc config', '/bundler');
+        }
+        return this.loadPlugin(this.bundler);
+    }
+    async getNamers() {
+        if (this.namers.length === 0) {
+            throw await this.missingPluginError(this.namers, 'No namer plugins specified in .parcelrc config', '/namers');
+        }
+        return this.loadPlugins(this.namers);
+    }
+    getRuntimes() {
+        if (!this.runtimes) {
+            return Promise.resolve([]);
+        }
+        return this.loadPlugins(this.runtimes);
+    }
+    async getPackager(filePath) {
+        let packager = this.matchGlobMap((0, projectPath_1.toProjectPathUnsafe)(filePath), this.packagers);
+        if (!packager) {
+            throw await this.missingPluginError(this.packagers, (0, diagnostic_1.md) `No packager found for __${filePath}__.`, '/packagers');
+        }
+        return this.loadPlugin(packager);
+    }
+    _getOptimizerNodes(filePath, pipeline) {
+        // If a pipeline is specified, but it doesn't exist in the optimizers config, ignore it.
+        // Pipelines for bundles come from their entry assets, so the pipeline likely exists in transformers.
+        if (pipeline) {
+            let prefix = pipeline + ':';
+            if (!Object.keys(this.optimizers).some((glob) => glob.startsWith(prefix))) {
+                pipeline = null;
+            }
+        }
+        return (this.matchGlobMapPipelines((0, projectPath_1.toProjectPathUnsafe)(filePath), this.optimizers, pipeline) ?? []);
+    }
+    getOptimizerNames(filePath, pipeline) {
+        let optimizers = this._getOptimizerNodes(filePath, pipeline);
+        return optimizers.map((o) => o.packageName);
+    }
+    getOptimizers(filePath, pipeline) {
+        let optimizers = this._getOptimizerNodes(filePath, pipeline);
+        if (optimizers.length === 0) {
+            return Promise.resolve([]);
+        }
+        return this.loadPlugins(optimizers);
+    }
+    async getCompressors(filePath) {
+        let compressors = this.matchGlobMapPipelines((0, projectPath_1.toProjectPathUnsafe)(filePath), this.compressors) ?? [];
+        if (compressors.length === 0) {
+            throw await this.missingPluginError(this.compressors, (0, diagnostic_1.md) `No compressors found for __${filePath}__.`, '/compressors');
+        }
+        return this.loadPlugins(compressors);
+    }
+    getReporters() {
+        return this.loadPlugins(this.reporters);
+    }
+    isGlobMatch(projectPath, pattern, pipeline) {
+        // glob's shouldn't be dependant on absolute paths anyway
+        let filePath = (0, projectPath_1.fromProjectPathRelative)(projectPath);
+        let [patternPipeline, patternGlob] = pattern.split(':');
+        if (!patternGlob) {
+            patternGlob = patternPipeline;
+            // @ts-expect-error TS2322
+            patternPipeline = null;
+        }
+        let re = this.regexCache.get(patternGlob);
+        if (!re) {
+            re = (0, utils_1.globToRegex)(patternGlob, { dot: true, nocase: true });
+            this.regexCache.set(patternGlob, re);
+        }
+        return ((pipeline === patternPipeline || (!pipeline && !patternPipeline)) &&
+            (re.test(filePath) || re.test((0, path_1.basename)(filePath))));
+    }
+    matchGlobMap(filePath, globMap) {
+        for (let pattern in globMap) {
+            if (this.isGlobMatch(filePath, pattern)) {
+                return globMap[pattern];
+            }
+        }
+        return null;
+    }
+    matchGlobMapPipelines(filePath, globMap, pipeline) {
+        let matches = [];
+        if (pipeline) {
+            // If a pipeline is requested, a the glob needs to match exactly
+            let exactMatch;
+            for (let pattern in globMap) {
+                if (this.isGlobMatch(filePath, pattern, pipeline)) {
+                    exactMatch = globMap[pattern];
+                    break;
+                }
+            }
+            if (!exactMatch) {
+                return [];
+            }
+            else {
+                matches.push(exactMatch);
+            }
+        }
+        for (let pattern in globMap) {
+            if (this.isGlobMatch(filePath, pattern)) {
+                // @ts-expect-error TS2345
+                matches.push(globMap[pattern]);
+            }
+        }
+        let flatten = () => {
+            let pipeline = matches.shift() || [];
+            let spreadIndex = pipeline.indexOf('...');
+            if (spreadIndex >= 0) {
+                pipeline = [
+                    ...pipeline.slice(0, spreadIndex),
+                    ...flatten(),
+                    ...pipeline.slice(spreadIndex + 1),
+                ];
+            }
+            if (pipeline.includes('...')) {
+                throw new Error('Only one spread parameter can be included in a config pipeline');
+            }
+            return pipeline;
+        };
+        let res = flatten();
+        // @ts-expect-error TS2322
+        return res;
+    }
+    async missingPluginError(plugins, message, key) {
+        let configsWithPlugin;
+        if (Array.isArray(plugins)) {
+            configsWithPlugin = new Set(getConfigPaths(this.options, plugins));
+        }
+        else {
+            configsWithPlugin = new Set(Object.keys(plugins).flatMap((k) => 
+            // @ts-expect-error TS7053
+            Array.isArray(plugins[k])
+                ? // @ts-expect-error TS7053
+                    getConfigPaths(this.options, plugins[k])
+                : // @ts-expect-error TS7053
+                    [getConfigPath(this.options, plugins[k])]));
+        }
+        if (configsWithPlugin.size === 0) {
+            configsWithPlugin.add((0, projectPath_1.fromProjectPath)(this.options.projectRoot, this.filePath));
+        }
+        let seenKey = false;
+        let codeFrames = await Promise.all([...configsWithPlugin].map(async (filePath) => {
+            let configContents = await this.options.inputFS.readFile(filePath, 'utf8');
+            if (!json5_1.default.parse(configContents)[key.slice(1)]) {
+                key = '';
+            }
+            else {
+                seenKey = true;
+            }
+            return {
+                filePath,
+                code: configContents,
+                codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(configContents, [{ key }]),
+            };
+        }));
+        return new diagnostic_1.default({
+            diagnostic: {
+                message,
+                origin: '@atlaspack/core',
+                codeFrames,
+                hints: !seenKey ? ['Try extending __@atlaspack/config-default__'] : [],
+            },
+        });
+    }
+}
+exports.AtlaspackConfig = AtlaspackConfig;
+function getConfigPaths(options, nodes) {
+    return (nodes
+        // @ts-expect-error TS2339
+        .map((node) => (node !== '...' ? getConfigPath(options, node) : null))
+        .filter(Boolean));
+}
+function getConfigPath(options, node) {
+    // @ts-expect-error TS2339
+    return (0, projectPath_1.fromProjectPath)(options.projectRoot, node.resolveFrom);
+}

package/dist/AtlaspackConfig.schema.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePackageName = validatePackageName;
+// Parcel validates plugin package names due to:
+// * https://github.com/parcel-bundler/parcel/issues/3397#issuecomment-521353931
+// Ultimately:
+// * We do not care about package names
+// * Validation makes interop between parcel/atlaspack confusing.
+function validatePackageName(
+// eslint-disable-next-line no-unused-vars
+pkg, 
+// eslint-disable-next-line no-unused-vars
+pluginType, 
+// eslint-disable-next-line no-unused-vars
+key) { }
+const validatePluginName = (pluginType, key) => {
+    return (val) => {
+        // allow plugin spread...
+        if (val === '...')
+            return;
+        try {
+            validatePackageName(val, pluginType, key);
+        }
+        catch (e) {
+            return e.message;
+        }
+    };
+};
+const validateExtends = (val) => {
+    // allow relative paths...
+    if (val.startsWith('.'))
+        return;
+    try {
+        validatePackageName(val, 'config', 'extends');
+    }
+    catch (e) {
+        return e.message;
+    }
+};
+const pipelineSchema = (pluginType, key) => {
+    return {
+        type: 'array',
+        items: {
+            type: 'string',
+            __validate: validatePluginName(pluginType, key),
+        },
+    };
+};
+const mapPipelineSchema = (pluginType, key) => {
+    return {
+        type: 'object',
+        properties: {},
+        additionalProperties: pipelineSchema(pluginType, key),
+    };
+};
+const mapStringSchema = (pluginType, key) => {
+    return {
+        type: 'object',
+        properties: {},
+        additionalProperties: {
+            type: 'string',
+            __validate: validatePluginName(pluginType, key),
+        },
+    };
+};
+exports.default = {
+    type: 'object',
+    properties: {
+        $schema: {
+            type: 'string',
+        },
+        extends: {
+            oneOf: [
+                {
+                    type: 'string',
+                    __validate: validateExtends,
+                },
+                {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        __validate: validateExtends,
+                    },
+                },
+            ],
+        },
+        bundler: {
+            type: 'string',
+            __validate: validatePluginName('bundler', 'bundler'),
+        },
+        resolvers: pipelineSchema('resolver', 'resolvers'),
+        transformers: mapPipelineSchema('transformer', 'transformers'),
+        validators: mapPipelineSchema('validator', 'validators'),
+        namers: pipelineSchema('namer', 'namers'),
+        packagers: mapStringSchema('packager', 'packagers'),
+        optimizers: mapPipelineSchema('optimizer', 'optimizers'),
+        compressors: mapPipelineSchema('compressor', 'compressors'),
+        reporters: pipelineSchema('reporter', 'reporters'),
+        runtimes: pipelineSchema('runtime', 'runtimes'),
+        filePath: {
+            type: 'string',
+        },
+        resolveFrom: {
+            type: 'string',
+        },
+    },
+    additionalProperties: false,
+};