@atlaspack/core 2.12.1-canary.3354

package/lib/TargetDescriptor.schema.js

@@ -0,0 +1,115 @@
+"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'
+    }
+  },
+  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

@@ -0,0 +1,536 @@
+"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;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _Dependency = require("./Dependency");
+var _AtlaspackConfig = _interopRequireDefault(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.
+
+    // If the transformer request passed code, use a hash in addition
+    // to the filename as the base for the id to ensure it is unique.
+    let idBase = (0, _projectPath.fromProjectPathRelative)(filePath);
+    if (code != null) {
+      idBase += (0, _rust().hashString)(code);
+    }
+    return new _UncommittedAsset.default({
+      idBase,
+      value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
+        idBase,
+        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;
+  });
+}