@atlaspack/core 2.13.2-dev.3689 → 2.14.0

package/lib/AtlaspackConfig.js

@@ -1,298 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AtlaspackConfig = void 0;
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _json() {
-  const data = _interopRequireDefault(require("json5"));
-  _json = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = require("path");
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-var _loadAtlaspackPlugin = _interopRequireDefault(require("./loadAtlaspackPlugin"));
-var _projectPath = require("./projectPath");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-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.default)(node.packageName, (0, _projectPath.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);
-    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().md)`No transformers found for __${(0, _projectPath.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.toProjectPathUnsafe)(filePath), this.packagers);
-    if (!packager) {
-      throw await this.missingPluginError(this.packagers, (0, _diagnostic().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.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.toProjectPathUnsafe)(filePath), this.compressors) ?? [];
-    if (compressors.length === 0) {
-      throw await this.missingPluginError(this.compressors, (0, _diagnostic().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.fromProjectPathRelative)(projectPath);
-    let [patternPipeline, patternGlob] = pattern.split(':');
-    if (!patternGlob) {
-      patternGlob = patternPipeline;
-      patternPipeline = null;
-    }
-    let re = this.regexCache.get(patternGlob);
-    if (!re) {
-      re = (0, _utils().globToRegex)(patternGlob, {
-        dot: true,
-        nocase: true
-      });
-      this.regexCache.set(patternGlob, re);
-    }
-    return (pipeline === patternPipeline || !pipeline && !patternPipeline) && (re.test(filePath) || re.test((0, _path().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)) {
-        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();
-    // $FlowFixMe afaik this should work
-    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 => Array.isArray(plugins[k]) ? getConfigPaths(this.options, plugins[k]) : [getConfigPath(this.options, plugins[k])]));
-    }
-    if (configsWithPlugin.size === 0) {
-      configsWithPlugin.add((0, _projectPath.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 (!_json().default.parse(configContents)[key.slice(1)]) {
-        key = '';
-      } else {
-        seenKey = true;
-      }
-      return {
-        filePath,
-        code: configContents,
-        codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(configContents, [{
-          key
-        }])
-      };
-    }));
-    return new (_diagnostic().default)({
-      diagnostic: {
-        message,
-        origin: '@atlaspack/core',
-        codeFrames,
-        hints: !seenKey ? ['Try extending __@atlaspack/config-default__'] : []
-      }
-    });
-  }
-}
-exports.AtlaspackConfig = AtlaspackConfig;
-function getConfigPaths(options, nodes) {
-  return nodes.map(node => node !== '...' ? getConfigPath(options, node) : null).filter(Boolean);
-}
-function getConfigPath(options, node) {
-  return (0, _projectPath.fromProjectPath)(options.projectRoot, node.resolveFrom);
-}

package/lib/AtlaspackConfig.schema.js

@@ -1,103 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-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() {}
-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)
-    }
-  };
-};
-var _default = 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
-};