@parcel/core/lib/PackagerRunner.js

"use strict";

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

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

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

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

var _stream = require("stream");

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

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

var _url = _interopRequireDefault(require("url"));

var _Bundle = require("./public/Bundle");

var _BundleGraph = _interopRequireWildcard(require("./public/BundleGraph"));

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

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

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

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 _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 PackagerRunner {
  constructor({
    config,
    farm,
    options,
    report
  }) {
    _defineProperty(this, "config", void 0);

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

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

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

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

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

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

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

    this.config = config;
    this.options = options;
    this.pluginOptions = new _PluginOptions.default(this.options);
    this.farm = farm;
    this.report = report;
    this.writeBundleFromWorker = farm ? farm.createHandle('runPackage') : () => {
      throw new Error('Cannot call PackagerRunner.writeBundleFromWorker() in a worker');
    };
  }

  async writeBundles(bundleGraph) {
    let farm = (0, _nullthrows.default)(this.farm);
    let {
      ref,
      dispose
    } = await farm.createSharedReference(bundleGraph);
    let promises = [];

    for (let bundle of bundleGraph.getBundles()) {
      // skip inline bundles, they will be processed via the parent bundle
      if (bundle.isInline) {
        continue;
      }

      promises.push(this.writeBundle(bundle, bundleGraph, ref).then(stats => {
        bundle.stats = stats;
      }));
    }

    await Promise.all(promises);
    await dispose();
  }

  async writeBundle(bundle, bundleGraph, bundleGraphReference) {
    let start = Date.now();
    let cacheKey = await this.getCacheKey(bundle, bundleGraph);
    let {
      size
    } = (await this.writeBundleFromCache({
      bundle,
      bundleGraph,
      cacheKey
    })) || (await this.writeBundleFromWorker({
      bundle,
      cacheKey,
      bundleGraphReference,
      options: this.options,
      config: this.config
    }));
    return {
      time: Date.now() - start,
      size
    };
  }

  async writeBundleFromCache({
    bundle,
    bundleGraph,
    cacheKey
  }) {
    if (this.options.disableCache) {
      return;
    }

    let cacheResult = await this.readFromCache(cacheKey);

    if (cacheResult == null) {
      return;
    }

    let {
      contents,
      map
    } = cacheResult;
    let {
      size
    } = await this.writeToDist({
      bundle,
      bundleGraph,
      contents,
      map
    });
    return {
      size
    };
  }

  async packageAndWriteBundle(bundle, bundleGraph, cacheKey) {
    let start = Date.now();
    let {
      contents,
      map
    } = await this.getBundleResult(bundle, bundleGraph, cacheKey);
    let {
      size
    } = await this.writeToDist({
      bundle,
      bundleGraph,
      contents,
      map
    });
    return {
      time: Date.now() - start,
      size
    };
  }

  async getBundleResult(bundle, bundleGraph, cacheKey) {
    let result;

    if (!cacheKey && !this.options.disableCache) {
      cacheKey = await this.getCacheKey(bundle, bundleGraph);
      let cacheResult = await this.readFromCache(cacheKey);

      if (cacheResult) {
        // NOTE: Returning a new object for flow
        return {
          contents: cacheResult.contents,
          map: cacheResult.map
        };
      }
    }

    let packaged = await this.package(bundle, bundleGraph);
    let res = await this.optimize(bundle, bundleGraph, packaged.contents, packaged.map);
    let map = res.map ? await this.generateSourceMap(bundle, res.map) : null;
    result = {
      contents: res.contents,
      map
    };

    if (cacheKey != null) {
      await this.writeToCache(cacheKey, result.contents, map);

      if (result.contents instanceof _stream.Readable) {
        return {
          contents: this.options.cache.getStream(getContentKey(cacheKey)),
          map: result.map
        };
      }
    }

    return result;
  }

  async package(internalBundle, bundleGraph) {
    let bundle = new _Bundle.NamedBundle(internalBundle, bundleGraph, this.options);
    this.report({
      type: 'buildProgress',
      phase: 'packaging',
      bundle
    });
    let packager = await this.config.getPackager(bundle.filePath);

    try {
      return await packager.plugin.package({
        bundle,
        bundleGraph: new _BundleGraph.default(bundleGraph, this.options),
        getSourceMapReference: map => {
          return bundle.isInline || bundle.target.sourceMap && bundle.target.sourceMap.inline ? this.generateSourceMap((0, _Bundle.bundleToInternalBundle)(bundle), map) : _path.default.basename(bundle.filePath) + '.map';
        },
        options: this.pluginOptions,
        logger: new _logger.PluginLogger({
          origin: packager.name
        }),
        getInlineBundleContents: (bundle, bundleGraph) => {
          if (!bundle.isInline) {
            throw new Error('Bundle is not inline and unable to retrieve contents');
          }

          return this.getBundleResult((0, _Bundle.bundleToInternalBundle)(bundle), (0, _BundleGraph.bundleGraphToInternalBundleGraph)(bundleGraph));
        }
      });
    } catch (e) {
      throw new _diagnostic.default({
        diagnostic: (0, _diagnostic.errorToDiagnostic)(e, packager.name)
      });
    }
  }

  async optimize(internalBundle, bundleGraph, contents, map) {
    let bundle = new _Bundle.NamedBundle(internalBundle, bundleGraph, this.options);
    let optimizers = await this.config.getOptimizers(bundle.filePath, internalBundle.pipeline);

    if (!optimizers.length) {
      return {
        contents,
        map
      };
    }

    this.report({
      type: 'buildProgress',
      phase: 'optimizing',
      bundle
    });
    let optimized = {
      contents,
      map
    };

    for (let optimizer of optimizers) {
      try {
        optimized = await optimizer.plugin.optimize({
          bundle,
          contents: optimized.contents,
          map: optimized.map,
          options: this.pluginOptions,
          logger: new _logger.PluginLogger({
            origin: optimizer.name
          })
        });
      } catch (e) {
        throw new _diagnostic.default({
          diagnostic: (0, _diagnostic.errorToDiagnostic)(e, optimizer.name)
        });
      }
    }

    return optimized;
  }

  generateSourceMap(bundle, map) {
    // sourceRoot should be a relative path between outDir and rootDir for node.js targets
    let filePath = (0, _nullthrows.default)(bundle.filePath);

    let sourceRoot = _path.default.relative(_path.default.dirname(filePath), this.options.projectRoot);

    let inlineSources = false;

    if (bundle.target) {
      if (bundle.target.sourceMap && bundle.target.sourceMap.sourceRoot !== undefined) {
        sourceRoot = bundle.target.sourceMap.sourceRoot;
      } else if (bundle.target.env.context === 'browser' && this.options.mode !== 'production') {
        sourceRoot = '/__parcel_source_root';
      }

      if (bundle.target.sourceMap && bundle.target.sourceMap.inlineSources !== undefined) {
        inlineSources = bundle.target.sourceMap.inlineSources;
      } else if (bundle.target.env.context !== 'node') {
        // inlining should only happen in production for browser targets by default
        inlineSources = this.options.mode === 'production';
      }
    }

    return map.stringify({
      file: _path.default.basename(filePath + '.map'),
      fs: this.options.inputFS,
      rootDir: this.options.projectRoot,
      sourceRoot: !inlineSources ? _url.default.format(_url.default.parse(sourceRoot + '/')) : undefined,
      inlineSources,
      inlineMap: bundle.isInline || bundle.target.sourceMap && bundle.target.sourceMap.inline
    });
  }

  getCacheKey(bundle, bundleGraph) {
    let filePath = (0, _nullthrows.default)(bundle.filePath); // TODO: include packagers and optimizers used in inline bundles as well

    let packager = this.config.getPackagerName(filePath);
    let optimizers = this.config.getOptimizerNames(filePath);
    let deps = Promise.all([packager, ...optimizers].map(async pkg => {
      let {
        pkg: resolvedPkg
      } = await this.options.packageManager.resolve(`${pkg}/package.json`, `${this.config.filePath}/index`);
      let version = (0, _nullthrows.default)(resolvedPkg).version;
      return [pkg, version];
    })); // TODO: add third party configs to the cache key

    let {
      minify,
      scopeHoist,
      sourceMaps
    } = this.options;
    return (0, _utils.md5FromObject)({
      parcelVersion: _constants.PARCEL_VERSION,
      deps,
      opts: {
        minify,
        scopeHoist,
        sourceMaps
      },
      hash: bundleGraph.getHash(bundle)
    });
  }

  async readFromCache(cacheKey) {
    let contentKey = getContentKey(cacheKey);
    let mapKey = getMapKey(cacheKey);
    let contentExists = await this.options.cache.blobExists(contentKey);

    if (!contentExists) {
      return null;
    }

    let mapExists = await this.options.cache.blobExists(mapKey);
    return {
      contents: this.options.cache.getStream(contentKey),
      map: mapExists ? this.options.cache.getStream(mapKey) : null
    };
  }

  async writeToDist({
    bundle,
    bundleGraph,
    contents,
    map
  }) {
    let {
      inputFS,
      outputFS
    } = this.options;
    let filePath = (0, _nullthrows.default)(bundle.filePath);

    let dir = _path.default.dirname(filePath);

    await outputFS.mkdirp(dir); // ? Got rid of dist exists, is this an expensive operation
    // Use the file mode from the entry asset as the file mode for the bundle.
    // Don't do this for browser builds, as the executable bit in particular is unnecessary.

    let publicBundle = new _Bundle.NamedBundle(bundle, bundleGraph, this.options);
    let writeOptions = publicBundle.env.isBrowser() ? undefined : {
      mode: (await inputFS.stat((0, _nullthrows.default)(publicBundle.getMainEntry()).filePath)).mode
    };
    let size;

    if (contents instanceof _stream.Readable) {
      size = await writeFileStream(outputFS, filePath, contents, writeOptions);
    } else {
      await outputFS.writeFile(filePath, contents, writeOptions);
      size = contents.length;
    }

    if (map != null) {
      if (map instanceof _stream.Readable) {
        await writeFileStream(outputFS, filePath + '.map', map);
      } else {
        await outputFS.writeFile(filePath + '.map', map);
      }
    }

    return {
      size
    };
  }

  async writeToCache(cacheKey, contents, map) {
    let contentKey = getContentKey(cacheKey);
    await this.options.cache.setStream(contentKey, (0, _utils.blobToStream)(contents));

    if (map != null) {
      let mapKey = getMapKey(cacheKey);
      await this.options.cache.setStream(mapKey, (0, _utils.blobToStream)(map));
    }
  }

}

exports.default = PackagerRunner;

function writeFileStream(fs, filePath, stream, options) {
  return new Promise((resolve, reject) => {
    let fsStream = fs.createWriteStream(filePath, options);
    stream.pipe(fsStream) // $FlowFixMe
    .on('finish', () => resolve(fsStream.bytesWritten)).on('error', reject);
  });
}

function getContentKey(cacheKey) {
  return (0, _utils.md5FromString)(`${cacheKey}:content`);
}

function getMapKey(cacheKey) {
  return (0, _utils.md5FromString)(`${cacheKey}:map`);
}