@atlaspack/core 2.13.2-dev.3682 → 2.14.0

package/lib/TargetDescriptor.schema.js

@@ -1,118 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PACKAGE_DESCRIPTOR_SCHEMA = exports.ENGINES_SCHEMA = exports.DESCRIPTOR_SCHEMA = exports.COMMON_TARGET_DESCRIPTOR_SCHEMA = void 0;
-const ENGINES_SCHEMA = exports.ENGINES_SCHEMA = {
-  type: 'object',
-  properties: {
-    browsers: {
-      oneOf: [{
-        type: 'array',
-        items: {
-          type: 'string'
-        }
-      }, {
-        type: 'string'
-      }]
-    }
-  },
-  __forbiddenProperties: ['browser'],
-  additionalProperties: {
-    type: 'string'
-  }
-};
-const PACKAGE_DESCRIPTOR_SCHEMA = exports.PACKAGE_DESCRIPTOR_SCHEMA = {
-  type: 'object',
-  properties: {
-    context: {
-      type: 'string',
-      enum: ['node', 'browser', 'web-worker', 'electron-main', 'electron-renderer', 'service-worker']
-    },
-    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: ENGINES_SCHEMA,
-    optimize: {
-      type: 'boolean'
-    },
-    scopeHoist: {
-      type: 'boolean'
-    },
-    __unstable_singleFileOutput: {
-      type: 'boolean'
-    }
-  },
-  additionalProperties: false
-};
-const DESCRIPTOR_SCHEMA = exports.DESCRIPTOR_SCHEMA = {
-  ...PACKAGE_DESCRIPTOR_SCHEMA,
-  properties: {
-    ...PACKAGE_DESCRIPTOR_SCHEMA.properties,
-    distEntry: {
-      type: 'string'
-    }
-  }
-};
-const COMMON_TARGET_DESCRIPTOR_SCHEMA = exports.COMMON_TARGET_DESCRIPTOR_SCHEMA = {
-  oneOf: [PACKAGE_DESCRIPTOR_SCHEMA, {
-    enum: [false]
-  }]
-};

package/lib/Transformation.js

@@ -1,522 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _stream() {
-  const data = require("stream");
-  _stream = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-function _logger() {
-  const data = _interopRequireWildcard(require("@atlaspack/logger"));
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-var _Dependency = require("./Dependency");
-var _AtlaspackConfig = require("./AtlaspackConfig");
-var _PathRequest = require("./requests/PathRequest");
-var _Asset = require("./public/Asset");
-var _UncommittedAsset = _interopRequireDefault(require("./UncommittedAsset"));
-var _assetUtils = require("./assetUtils");
-var _summarizeRequest = _interopRequireDefault(require("./summarizeRequest"));
-var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));
-var _utils2 = require("./utils");
-var _InternalConfig = require("./InternalConfig");
-var _ConfigRequest = require("./requests/ConfigRequest");
-var _DevDepRequest = require("./requests/DevDepRequest");
-var _projectPath = require("./projectPath");
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _profiler() {
-  const data = require("@atlaspack/profiler");
-  _profiler = function () {
-    return data;
-  };
-  return data;
-}
-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; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// TODO: eventually call path request as sub requests
-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, _utils2.createInvalidations)();
-    this.devDepRequests = new Map();
-    this.pluginDevDeps = [];
-    this.resolverRunner = new _PathRequest.ResolverRunner({
-      config,
-      options,
-      previousDevDeps: request.devDeps
-    });
-    this.pluginOptions = new _PluginOptions.default((0, _utils2.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().SOURCEMAP_EXTENSIONS.has(asset.value.type)) {
-      // Load existing sourcemaps, this automatically runs the source contents extraction
-      try {
-        existing = await asset.loadExistingSourcemap();
-      } catch (err) {
-        _logger().default.verbose([{
-          origin: '@atlaspack/core',
-          message: (0, _diagnostic().md)`Could not load existing source map for ${(0, _projectPath.fromProjectPathRelative)(asset.value.filePath)}`
-        }, {
-          origin: '@atlaspack/core',
-          message: (0, _diagnostic().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().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.invalidateDevDeps)(this.request.invalidDevDeps, this.options, this.atlaspackConfig);
-    let pipeline = await this.loadPipeline(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.getConfigRequests)([...this.configs.values(), ...this.resolverRunner.configs.values()]);
-    let devDepRequests = (0, _DevDepRequest.getWorkerDevDepRequests)([...this.devDepRequests.values(), ...this.resolverRunner.devDepRequests.values()]);
-
-    // $FlowFixMe because of $$raw
-    return {
-      $$raw: true,
-      assets,
-      configRequests,
-      // When throwing an error, this (de)serialization is done automatically by the WorkerFarm
-      error: error ? (0, _diagnostic().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.default)(this.options.inputFS, {
-      filePath: (0, _projectPath.fromProjectPath)(this.options.projectRoot, filePath),
-      code
-    });
-
-    // Prefer `isSource` originating from the AssetRequest.
-
-    return new _UncommittedAsset.default({
-      value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        code,
-        filePath,
-        isSource: isSourceOverride ?? summarizedIsSource,
-        type: _path().default.extname((0, _projectPath.fromProjectPathRelative)(filePath)).slice(1),
-        pipeline,
-        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().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.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.fromProjectPath)(this.options.projectRoot, opts.resolveFrom), {
-        range
-      });
-    } catch (err) {
-      // ignore
-    }
-    let devDepRequest = await (0, _DevDepRequest.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().tracer.createMeasurement(transformer.name, 'transform', (0, _projectPath.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.default) {
-              resultingAssets.push(result);
-              continue;
-            }
-            resultingAssets.push(asset.createChildAsset(result, transformer.name, this.atlaspackConfig.filePath, transformer.configKeyPath));
-          }
-        } catch (e) {
-          let diagnostic = (0, _diagnostic().errorToDiagnostic)(e, {
-            origin: transformer.name,
-            filePath: (0, _projectPath.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().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) {
-        var _output$map;
-        let output = await asset.generate();
-        asset.content = output.content;
-        asset.mapBuffer = (_output$map = output.map) === null || _output$map === void 0 ? void 0 : _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 => {
-        var _this$configs$get;
-        return {
-          name: transformer.name,
-          resolveFrom: transformer.resolveFrom,
-          config: (_this$configs$get = this.configs.get(transformer.name)) === null || _this$configs$get === void 0 ? void 0 : _this$configs$get.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.fromProjectPathRelative)(filePath);
-    let nextFilePath = (0, _projectPath.toProjectPathUnsafe)(filePathRelative.slice(0, -_path().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.createConfig)({
-      plugin: transformer.name,
-      isSource,
-      searchPath: this.request.filePath,
-      env: this.request.env
-    });
-    await (0, _ConfigRequest.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) {
-    var _transformer$parse;
-    const logger = new (_logger().PluginLogger)({
-      origin: transformerName
-    });
-    const tracer = new (_profiler().PluginTracer)({
-      origin: transformerName,
-      category: 'transform'
-    });
-    const resolve = async (from, to, options) => {
-      let result = await this.resolverRunner.resolve((0, _Dependency.createDependency)(this.options.projectRoot, {
-        env: asset.value.env,
-        specifier: to,
-        specifierType: (options === null || options === void 0 ? void 0 : options.specifierType) || 'esm',
-        packageConditions: options === null || options === void 0 ? void 0 : options.packageConditions,
-        sourcePath: from
-      }));
-      if (result.invalidateOnFileCreate) {
-        this.invalidations.invalidateOnFileCreate.push(...result.invalidateOnFileCreate.map(i => (0, _utils2.invalidateOnFileCreateToInternal)(this.options.projectRoot, i)));
-      }
-      if (result.invalidateOnFileChange) {
-        for (let filePath of result.invalidateOnFileChange) {
-          this.invalidations.invalidateOnFileChange.add((0, _projectPath.toProjectPath)(this.options.projectRoot, filePath));
-        }
-      }
-      if (result.diagnostics && result.diagnostics.length > 0) {
-        throw new (_diagnostic().default)({
-          diagnostic: result.diagnostics
-        });
-      }
-      return (0, _projectPath.fromProjectPath)(this.options.projectRoot, (0, _nullthrows().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) {
-      var _output$map2;
-      let output = await asset.generate();
-      asset.content = output.content;
-      asset.mapBuffer = (_output$map2 = output.map) === null || _output$map2 === void 0 ? void 0 : _output$map2.toBuffer();
-    }
-
-    // Load config for the transformer.
-    let config = preloadedConfig;
-
-    // Parse if there is no AST available from a previous transform.
-    let parse = (_transformer$parse = transformer.parse) === null || _transformer$parse === void 0 ? void 0 : _transformer$parse.bind(transformer);
-    if (!asset.ast && parse) {
-      let ast = await parse({
-        asset: new _Asset.Asset(asset),
-        config,
-        options: pipeline.pluginOptions,
-        resolve,
-        logger,
-        tracer
-      });
-      if (ast) {
-        asset.setAST(ast);
-        asset.isASTDirty = false;
-      }
-    }
-
-    // Transform.
-    let transfomerResult =
-    // $FlowFixMe the returned IMutableAsset really is a MutableAsset
-    await transformer.transform({
-      asset: new _Asset.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.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.MutableAsset(asset)),
-          config,
-          options: pipeline.pluginOptions,
-          resolve,
-          logger,
-          tracer
-        });
-        return Promise.all(results.map(result => asset.createChildAsset(result, transformerName, atlaspackConfig.filePath
-        // configKeyPath,
-        )));
-      };
-    }
-
-    return results;
-  }
-}
-exports.default = Transformation;
-function normalizeAssets(options, results) {
-  return results.map(result => {
-    if (result instanceof _Asset.MutableAsset) {
-      return (0, _Asset.mutableAssetToUncommittedAsset)(result);
-    }
-    return result;
-  });
-}