@parcel/core/lib/Transformation.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _assert = _interopRequireDefault(require("assert"));

var _path = _interopRequireDefault(require("path"));

var _nullthrows = _interopRequireDefault(require("nullthrows"));

var _utils = require("@parcel/utils");

var _logger = require("@parcel/logger");

var _diagnostic = _interopRequireWildcard(require("@parcel/diagnostic"));

var _ConfigLoader = _interopRequireDefault(require("./ConfigLoader"));

var _Dependency = require("./Dependency");

var _ParcelConfig = _interopRequireDefault(require("./ParcelConfig"));

var _ResolverRunner = _interopRequireDefault(require("./ResolverRunner"));

var _Asset = require("./public/Asset");

var _InternalAsset = _interopRequireWildcard(require("./InternalAsset"));

var _summarizeRequest = _interopRequireDefault(require("./summarizeRequest"));

var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));

var _constants = require("./constants");

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

class Transformation {
  constructor({
    report,
    request,
    options,
    workerApi
  }) {
    _defineProperty(this, "request", void 0);

    _defineProperty(this, "configLoader", void 0);

    _defineProperty(this, "configRequests", void 0);

    _defineProperty(this, "options", void 0);

    _defineProperty(this, "impactfulOptions", void 0);

    _defineProperty(this, "workerApi", void 0);

    _defineProperty(this, "parcelConfig", void 0);

    _defineProperty(this, "report", void 0);

    this.configRequests = [];
    this.configLoader = new _ConfigLoader.default(options);
    this.options = options;
    this.report = report;
    this.request = request;
    this.workerApi = workerApi; // TODO: these options may not impact all transformations, let transformers decide if they care or not

    let {
      minify,
      hot,
      scopeHoist
    } = this.options;
    this.impactfulOptions = {
      minify,
      hot,
      scopeHoist
    };
  }

  async loadConfig(configRequest) {
    let result = await this.configLoader.load(configRequest);
    this.configRequests.push({
      request: configRequest,
      result
    });
    return result;
  }

  async run() {
    this.report({
      type: 'buildProgress',
      phase: 'transforming',
      filePath: this.request.filePath
    });
    let asset = await this.loadAsset();
    let pipeline = await this.loadPipeline(this.request.filePath, asset.value.isSource, this.request.pipeline);
    let results = await this.runPipelines(pipeline, asset);
    let assets = results.map(a => a.value);

    for (let {
      request,
      result
    } of this.configRequests) {
      let plugin = request.plugin != null && (await this.parcelConfig.loadPlugin(request.plugin));

      if (plugin && plugin.preSerializeConfig) {
        plugin.preSerializeConfig({
          config: result
        });
      }
    }

    return {
      assets,
      configRequests: this.configRequests
    };
  }

  async loadAsset() {
    let {
      filePath,
      env,
      code,
      pipeline,
      sideEffects
    } = this.request;
    let {
      content,
      size,
      hash,
      isSource
    } = await (0, _summarizeRequest.default)(this.options.inputFS, this.request); // If the transformer request passed code rather than a filename,
    // use a hash as the base for the id to ensure it is unique.

    let idBase = code != null ? hash : filePath;
    return new _InternalAsset.default({
      idBase,
      value: (0, _InternalAsset.createAsset)({
        idBase,
        filePath,
        isSource,
        type: _path.default.extname(filePath).slice(1),
        hash,
        pipeline,
        env,
        stats: {
          time: 0,
          size
        },
        sideEffects
      }),
      options: this.options,
      content
    });
  }

  async runPipelines(pipeline, initialAsset) {
    var _ref;

    let initialType = initialAsset.value.type;
    let initialAssetCacheKey = this.getCacheKey([initialAsset], pipeline.configs);
    let initialCacheEntry = await this.readFromCache(initialAssetCacheKey);
    let assets = initialCacheEntry || (await this.runPipeline(pipeline, initialAsset));

    if (!initialCacheEntry) {
      await this.writeToCache(initialAssetCacheKey, assets, pipeline.configs);
    }

    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,
          nextType: asset.value.type,
          currentPipeline: pipeline
        });
      }

      if (nextPipeline) {
        let nextPipelineAssets = await this.runPipelines(nextPipeline, asset);
        finalAssets = finalAssets.concat(nextPipelineAssets);
      } else {
        finalAssets.push(asset);
      }
    }

    if (!pipeline.postProcess) {
      return finalAssets;
    }

    let processedCacheEntry = await this.readFromCache(this.getCacheKey(finalAssets, pipeline.configs));
    (0, _assert.default)(pipeline.postProcess != null);
    let processedFinalAssets = (_ref = processedCacheEntry !== null && processedCacheEntry !== void 0 ? processedCacheEntry : await pipeline.postProcess(finalAssets)) !== null && _ref !== void 0 ? _ref : [];

    if (!processedCacheEntry) {
      await this.writeToCache(this.getCacheKey(processedFinalAssets, pipeline.configs), processedFinalAssets, pipeline.configs);
    }

    return processedFinalAssets;
  }

  async runPipeline(pipeline, 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,
          nextType: asset.value.type,
          currentPipeline: pipeline
        }))) {
          finalAssets.push(asset);
          continue;
        }

        try {
          let transformerResults = await runTransformer(pipeline, asset, transformer.plugin, transformer.name, transformer.config);

          for (let result of transformerResults) {
            resultingAssets.push(asset.createChildAsset(result));
          }
        } catch (e) {
          throw new _diagnostic.default({
            diagnostic: (0, _diagnostic.errorToDiagnostic)(e, transformer.name)
          });
        }
      }

      inputAssets = resultingAssets;
    }

    finalAssets = finalAssets.concat(resultingAssets);
    return Promise.all(finalAssets.map(asset => finalize((0, _nullthrows.default)(asset), (0, _nullthrows.default)(pipeline.generate))));
  }

  async readFromCache(cacheKey) {
    if (this.options.disableCache || this.request.code != null) {
      return null;
    }

    let cachedAssets = await this.options.cache.get(cacheKey);

    if (!cachedAssets) {
      return null;
    }

    return cachedAssets.map(value => new _InternalAsset.default({
      value,
      options: this.options
    }));
  }

  async writeToCache(cacheKey, assets, configs) {
    await Promise.all( // TODO: account for impactfulOptions maybe being different per pipeline
    assets.map(asset => asset.commit((0, _utils.md5FromObject)({
      impactfulOptions: this.impactfulOptions,
      configs: getImpactfulConfigInfo(configs)
    }))));
    this.options.cache.set(cacheKey, assets.map(a => a.value));
  }

  getCacheKey(assets, configs) {
    let assetsKeyInfo = assets.map(a => ({
      filePath: a.value.filePath,
      hash: a.value.hash
    }));
    return (0, _utils.md5FromObject)({
      parcelVersion: _constants.PARCEL_VERSION,
      assets: assetsKeyInfo,
      configs: getImpactfulConfigInfo(configs),
      env: this.request.env,
      impactfulOptions: this.impactfulOptions
    });
  }

  async loadPipeline(filePath, isSource, pipelineName) {
    let configRequest = {
      filePath,
      env: this.request.env,
      isSource,
      pipeline: pipelineName,
      meta: {
        actionType: 'transformation'
      }
    };
    let configs = new Map();
    let config = await this.loadConfig(configRequest);
    let result = (0, _nullthrows.default)(config.result);
    let parcelConfig = new _ParcelConfig.default(config.result, this.options.packageManager); // A little hacky

    this.parcelConfig = parcelConfig;
    configs.set('parcel', config);

    for (let [moduleName] of config.devDeps) {
      let plugin = await parcelConfig.loadPlugin(moduleName); // TODO: implement loadPlugin in existing plugins that require config

      if (plugin.loadConfig) {
        let thirdPartyConfig = await this.loadTransformerConfig({
          filePath,
          plugin: moduleName,
          parcelConfigPath: result.filePath,
          isSource
        });
        configs.set(moduleName, thirdPartyConfig);
      }
    }

    let transformers = await parcelConfig.getTransformers(filePath, pipelineName);
    let pipeline = {
      id: transformers.map(t => t.name).join(':'),
      transformers: transformers.map(transformer => {
        var _configs$get;

        return {
          name: transformer.name,
          config: (_configs$get = configs.get(transformer.name)) === null || _configs$get === void 0 ? void 0 : _configs$get.result,
          plugin: transformer.plugin
        };
      }),
      configs,
      options: this.options,
      resolverRunner: new _ResolverRunner.default({
        config: new _ParcelConfig.default((0, _nullthrows.default)((0, _nullthrows.default)(configs.get('parcel')).result), this.options.packageManager),
        options: this.options
      }),
      pluginOptions: new _PluginOptions.default(this.options),
      workerApi: this.workerApi
    };
    return pipeline;
  }

  async loadNextPipeline({
    filePath,
    isSource,
    nextType,
    currentPipeline
  }) {
    let nextFilePath = filePath.slice(0, -_path.default.extname(filePath).length) + '.' + nextType;
    let nextPipeline = await this.loadPipeline(nextFilePath, isSource, this.request.pipeline);

    if (nextPipeline.id === currentPipeline.id) {
      return null;
    }

    return nextPipeline;
  }

  loadTransformerConfig({
    filePath,
    plugin,
    parcelConfigPath,
    isSource
  }) {
    let configRequest = {
      filePath,
      env: this.request.env,
      plugin,
      isSource,
      meta: {
        parcelConfigPath
      }
    };
    return this.loadConfig(configRequest);
  }

}

exports.default = Transformation;

async function runTransformer(pipeline, asset, transformer, transformerName, preloadedConfig) {
  const logger = new _logger.PluginLogger({
    origin: transformerName
  });

  const resolve = async (from, to) => {
    return (0, _nullthrows.default)((await pipeline.resolverRunner.resolve((0, _Dependency.createDependency)({
      env: asset.value.env,
      moduleSpecifier: to,
      sourcePath: from
    })))).filePath;
  }; // Load config for the transformer.


  let config = preloadedConfig;

  if (transformer.getConfig) {
    // TODO: deprecate getConfig
    config = await transformer.getConfig({
      asset: new _Asset.MutableAsset(asset),
      options: pipeline.pluginOptions,
      resolve,
      logger
    });
  } // 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 && (!transformer.canReuseAST || !transformer.canReuseAST({
    ast: asset.ast,
    options: pipeline.pluginOptions,
    logger
  })) && pipeline.generate) {
    let output = await pipeline.generate(new _Asset.MutableAsset(asset));
    asset.content = output.code;
    asset.ast = null;
  } // Parse if there is no AST available from a previous transform.


  if (!asset.ast && transformer.parse) {
    asset.ast = await transformer.parse({
      asset: new _Asset.MutableAsset(asset),
      config,
      options: pipeline.pluginOptions,
      resolve,
      logger
    });
  } // Transform.


  let results = await normalizeAssets(( // $FlowFixMe
  await transformer.transform({
    asset: new _Asset.MutableAsset(asset),
    config,
    options: pipeline.pluginOptions,
    resolve,
    logger
  }))); // Create generate and postProcess functions that can be called later

  pipeline.generate = input => {
    if (transformer.generate) {
      return Promise.resolve(transformer.generate({
        asset: input,
        config,
        options: pipeline.pluginOptions,
        resolve,
        logger
      }));
    }

    throw new Error('Asset has an AST but no generate method is available on the transform');
  }; // For Flow


  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
      });
      return Promise.all(results.map(result => asset.createChildAsset(result)));
    };
  }

  return results;
}

async function finalize(asset, generate) {
  if (asset.ast && generate) {
    let result = await generate(new _Asset.MutableAsset(asset));
    return asset.createChildAsset(_objectSpread({
      type: asset.value.type,
      uniqueKey: asset.value.uniqueKey
    }, result));
  }

  return asset;
}

function normalizeAssets(results) {
  return results.map(result => {
    if (!(result instanceof _Asset.MutableAsset)) {
      return result;
    }

    let internalAsset = (0, _Asset.assetToInternalAsset)(result);
    return {
      type: result.type,
      content: internalAsset.content,
      ast: result.ast,
      map: internalAsset.map,
      // $FlowFixMe
      dependencies: [...internalAsset.value.dependencies.values()],
      includedFiles: result.getIncludedFiles(),
      // $FlowFixMe
      env: result.env,
      isIsolated: result.isIsolated,
      isInline: result.isInline,
      pipeline: internalAsset.value.pipeline,
      meta: result.meta,
      uniqueKey: internalAsset.value.uniqueKey
    };
  });
}

function getImpactfulConfigInfo(configs) {
  let impactfulConfigInfo = {};

  for (let [configType, {
    devDeps,
    resultHash
  }] of configs) {
    let devDepsObject = {};

    for (let [moduleName, version] of devDeps) {
      devDepsObject[moduleName] = version;
    }

    impactfulConfigInfo[configType] = {
      devDeps: devDepsObject,
      resultHash
    };
  }

  return impactfulConfigInfo;
}