@atlaspack/core 2.13.2-dev.3682 → 2.14.0

package/lib/PackagerRunner.js

@@ -1,525 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _buildCache() {
-  const data = require("@atlaspack/build-cache");
-  _buildCache = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-function _logger() {
-  const data = require("@atlaspack/logger");
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = 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 _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _url() {
-  const data = _interopRequireDefault(require("url"));
-  _url = function () {
-    return data;
-  };
-  return data;
-}
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-var _Bundle = require("./public/Bundle");
-var _BundleGraph = _interopRequireWildcard(require("./public/BundleGraph"));
-var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));
-var _Config = _interopRequireDefault(require("./public/Config"));
-var _constants = require("./constants");
-var _projectPath = require("./projectPath");
-var _InternalConfig = require("./InternalConfig");
-var _ConfigRequest = require("./requests/ConfigRequest");
-var _DevDepRequest = require("./requests/DevDepRequest");
-var _assetUtils = require("./assetUtils");
-var _utils2 = require("./utils");
-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 }; }
-const BOUNDARY_LENGTH = _constants.HASH_REF_PREFIX.length + 32 - 1;
-
-// Packager/optimizer configs are not bundle-specific, so we only need to
-// load them once per build.
-const pluginConfigs = (0, _buildCache().createBuildCache)();
-class PackagerRunner {
-  constructor({
-    config,
-    options,
-    report,
-    previousDevDeps,
-    previousInvalidations
-  }) {
-    this.config = config;
-    this.options = options;
-    this.report = report;
-    this.previousDevDeps = previousDevDeps;
-    this.devDepRequests = new Map();
-    this.previousInvalidations = previousInvalidations;
-    this.invalidations = new Map();
-    this.pluginOptions = new _PluginOptions.default((0, _utils2.optionsProxy)(this.options, option => {
-      let invalidation = {
-        type: 'option',
-        key: option
-      };
-      this.invalidations.set((0, _assetUtils.getInvalidationId)(invalidation), invalidation);
-    }));
-  }
-  async run(bundleGraph, bundle, invalidDevDeps) {
-    (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, this.options, this.config);
-    let {
-      configs,
-      bundleConfigs
-    } = await this.loadConfigs(bundleGraph, bundle);
-    let bundleInfo = (await this.getBundleInfoFromCache(bundleGraph, bundle, configs, bundleConfigs)) ?? (await this.getBundleInfo(bundle, bundleGraph, configs, bundleConfigs));
-    let configRequests = (0, _ConfigRequest.getConfigRequests)([...configs.values(), ...bundleConfigs.values()]);
-    let devDepRequests = (0, _DevDepRequest.getWorkerDevDepRequests)([...this.devDepRequests.values()]);
-    return {
-      bundleInfo,
-      configRequests,
-      devDepRequests,
-      invalidations: [...this.invalidations.values()]
-    };
-  }
-  async loadConfigs(bundleGraph, bundle) {
-    let configs = new Map();
-    let bundleConfigs = new Map();
-    await this.loadConfig(bundleGraph, bundle, configs, bundleConfigs);
-    for (let inlineBundle of bundleGraph.getInlineBundles(bundle)) {
-      await this.loadConfig(bundleGraph, inlineBundle, configs, bundleConfigs);
-    }
-    return {
-      configs,
-      bundleConfigs
-    };
-  }
-  async loadConfig(bundleGraph, bundle, configs, bundleConfigs) {
-    let name = (0, _nullthrows().default)(bundle.name);
-    let plugin = await this.config.getPackager(name);
-    await this.loadPluginConfig(bundleGraph, bundle, plugin, configs, bundleConfigs);
-    let optimizers = await this.config.getOptimizers(name, bundle.pipeline);
-    for (let optimizer of optimizers) {
-      await this.loadPluginConfig(bundleGraph, bundle, optimizer, configs, bundleConfigs);
-    }
-  }
-  async loadPluginConfig(bundleGraph, bundle, plugin, configs, bundleConfigs) {
-    if (!configs.has(plugin.name)) {
-      // Only load config for a plugin once per build.
-      let existing = pluginConfigs.get(plugin.name);
-      if (existing != null) {
-        configs.set(plugin.name, existing);
-      } else {
-        if (plugin.plugin.loadConfig != null) {
-          let config = (0, _InternalConfig.createConfig)({
-            plugin: plugin.name,
-            searchPath: (0, _projectPath.toProjectPathUnsafe)('index')
-          });
-          await (0, _ConfigRequest.loadPluginConfig)(plugin, config, this.options);
-          for (let devDep of config.devDeps) {
-            let devDepRequest = await (0, _DevDepRequest.createDevDependency)(devDep, this.previousDevDeps, this.options);
-            let key = `${devDep.specifier}:${(0, _projectPath.fromProjectPath)(this.options.projectRoot, devDep.resolveFrom)}`;
-            this.devDepRequests.set(key, devDepRequest);
-          }
-          pluginConfigs.set(plugin.name, config);
-          configs.set(plugin.name, config);
-        }
-      }
-    }
-    let loadBundleConfig = plugin.plugin.loadBundleConfig;
-    if (!bundleConfigs.has(plugin.name) && loadBundleConfig != null) {
-      let config = (0, _InternalConfig.createConfig)({
-        plugin: plugin.name,
-        searchPath: (0, _projectPath.joinProjectPath)(bundle.target.distDir, bundle.name ?? bundle.id)
-      });
-      config.result = await loadBundleConfig({
-        bundle: _Bundle.NamedBundle.get(bundle, bundleGraph, this.options),
-        bundleGraph: new _BundleGraph.default(bundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), this.options),
-        config: new _Config.default(config, this.options),
-        options: new _PluginOptions.default(this.options),
-        logger: new (_logger().PluginLogger)({
-          origin: plugin.name
-        }),
-        tracer: new (_profiler().PluginTracer)({
-          origin: plugin.name,
-          category: 'loadConfig'
-        })
-      });
-      bundleConfigs.set(plugin.name, config);
-    }
-  }
-  async getBundleInfoFromCache(bundleGraph, bundle, configs, bundleConfigs) {
-    if (this.options.shouldDisableCache) {
-      return;
-    }
-    let cacheKey = await this.getCacheKey(bundle, bundleGraph, configs, bundleConfigs, this.previousInvalidations);
-    let infoKey = PackagerRunner.getInfoKey(cacheKey);
-    return this.options.cache.get(infoKey);
-  }
-  async getBundleInfo(bundle, bundleGraph, configs, bundleConfigs) {
-    let {
-      type,
-      contents,
-      map
-    } = await this.getBundleResult(bundle, bundleGraph, configs, bundleConfigs);
-
-    // Recompute cache keys as they may have changed due to dev dependencies.
-    let cacheKey = await this.getCacheKey(bundle, bundleGraph, configs, bundleConfigs, [...this.invalidations.values()]);
-    let cacheKeys = {
-      content: PackagerRunner.getContentKey(cacheKey),
-      map: PackagerRunner.getMapKey(cacheKey),
-      info: PackagerRunner.getInfoKey(cacheKey)
-    };
-    return this.writeToCache(cacheKeys, type, contents, map);
-  }
-  async getBundleResult(bundle, bundleGraph, configs, bundleConfigs) {
-    let packaged = await this.package(bundle, bundleGraph, configs, bundleConfigs);
-    let type = packaged.type ?? bundle.type;
-    let res = await this.optimize(bundle, bundleGraph, type, packaged.contents, packaged.map, configs, bundleConfigs);
-    let map = res.map != null ? await this.generateSourceMap(bundle, res.map) : null;
-    return {
-      type: res.type ?? type,
-      contents: res.contents,
-      map
-    };
-  }
-  getSourceMapReference(bundle, map) {
-    if (map && bundle.env.sourceMap && bundle.bundleBehavior !== 'inline') {
-      if (bundle.env.sourceMap && bundle.env.sourceMap.inline) {
-        return this.generateSourceMap((0, _Bundle.bundleToInternalBundle)(bundle), map);
-      } else {
-        return _path().default.basename(bundle.name) + '.map';
-      }
-    } else {
-      return null;
-    }
-  }
-  async package(internalBundle, bundleGraph, configs, bundleConfigs) {
-    let bundle = _Bundle.NamedBundle.get(internalBundle, bundleGraph, this.options);
-    this.report({
-      type: 'buildProgress',
-      phase: 'packaging',
-      bundle
-    });
-    let packager = await this.config.getPackager(bundle.name);
-    let {
-      name,
-      resolveFrom,
-      plugin
-    } = packager;
-    let measurement;
-    try {
-      var _configs$get, _bundleConfigs$get;
-      measurement = _profiler().tracer.createMeasurement(name, 'packaging', bundle.name, {
-        type: bundle.type
-      });
-      return await plugin.package({
-        config: (_configs$get = configs.get(name)) === null || _configs$get === void 0 ? void 0 : _configs$get.result,
-        bundleConfig: (_bundleConfigs$get = bundleConfigs.get(name)) === null || _bundleConfigs$get === void 0 ? void 0 : _bundleConfigs$get.result,
-        bundle,
-        bundleGraph: new _BundleGraph.default(bundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), this.options),
-        getSourceMapReference: map => {
-          return this.getSourceMapReference(bundle, map);
-        },
-        options: this.pluginOptions,
-        logger: new (_logger().PluginLogger)({
-          origin: name
-        }),
-        tracer: new (_profiler().PluginTracer)({
-          origin: name,
-          category: 'package'
-        }),
-        getInlineBundleContents: async (bundle, bundleGraph) => {
-          if (bundle.bundleBehavior !== 'inline') {
-            throw new Error('Bundle is not inline and unable to retrieve contents');
-          }
-          let res = await this.getBundleResult((0, _Bundle.bundleToInternalBundle)(bundle),
-          // $FlowFixMe
-          (0, _BundleGraph.bundleGraphToInternalBundleGraph)(bundleGraph), configs, bundleConfigs);
-          return {
-            contents: res.contents
-          };
-        }
-      });
-    } catch (e) {
-      throw new (_diagnostic().default)({
-        diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
-          origin: name,
-          filePath: _path().default.join(bundle.target.distDir, bundle.name)
-        })
-      });
-    } finally {
-      measurement && measurement.end();
-      // Add dev dependency for the packager. This must be done AFTER running it due to
-      // the potential for lazy require() that aren't executed until the request runs.
-      let devDepRequest = await (0, _DevDepRequest.createDevDependency)({
-        specifier: name,
-        resolveFrom
-      }, this.previousDevDeps, this.options);
-      this.devDepRequests.set(`${name}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`, devDepRequest);
-    }
-  }
-  async optimize(internalBundle, internalBundleGraph, type, contents, map, configs, bundleConfigs) {
-    let bundle = _Bundle.NamedBundle.get(internalBundle, internalBundleGraph, this.options);
-    let bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), this.options);
-    let optimizers = await this.config.getOptimizers(bundle.name, internalBundle.pipeline);
-    if (!optimizers.length) {
-      return {
-        type: bundle.type,
-        contents,
-        map
-      };
-    }
-    this.report({
-      type: 'buildProgress',
-      phase: 'optimizing',
-      bundle
-    });
-    let optimized = {
-      type,
-      contents,
-      map
-    };
-    for (let optimizer of optimizers) {
-      let measurement;
-      try {
-        var _configs$get2, _bundleConfigs$get2;
-        measurement = _profiler().tracer.createMeasurement(optimizer.name, 'optimize', bundle.name);
-        let next = await optimizer.plugin.optimize({
-          config: (_configs$get2 = configs.get(optimizer.name)) === null || _configs$get2 === void 0 ? void 0 : _configs$get2.result,
-          bundleConfig: (_bundleConfigs$get2 = bundleConfigs.get(optimizer.name)) === null || _bundleConfigs$get2 === void 0 ? void 0 : _bundleConfigs$get2.result,
-          bundle,
-          bundleGraph,
-          contents: optimized.contents,
-          map: optimized.map,
-          getSourceMapReference: map => {
-            return this.getSourceMapReference(bundle, map);
-          },
-          options: this.pluginOptions,
-          logger: new (_logger().PluginLogger)({
-            origin: optimizer.name
-          }),
-          tracer: new (_profiler().PluginTracer)({
-            origin: optimizer.name,
-            category: 'optimize'
-          })
-        });
-        optimized.type = next.type ?? optimized.type;
-        optimized.contents = next.contents;
-        optimized.map = next.map;
-      } catch (e) {
-        throw new (_diagnostic().default)({
-          diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
-            origin: optimizer.name,
-            filePath: _path().default.join(bundle.target.distDir, bundle.name)
-          })
-        });
-      } finally {
-        measurement && measurement.end();
-        // Add dev dependency for the optimizer. This must be done AFTER running it due to
-        // the potential for lazy require() that aren't executed until the request runs.
-        let devDepRequest = await (0, _DevDepRequest.createDevDependency)({
-          specifier: optimizer.name,
-          resolveFrom: optimizer.resolveFrom
-        }, this.previousDevDeps, this.options);
-        this.devDepRequests.set(`${optimizer.name}:${(0, _projectPath.fromProjectPathRelative)(optimizer.resolveFrom)}`, devDepRequest);
-      }
-    }
-    return optimized;
-  }
-  async generateSourceMap(bundle, map) {
-    // sourceRoot should be a relative path between outDir and rootDir for node.js targets
-    let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, (0, _nullthrows().default)(bundle.name));
-    let fullPath = (0, _projectPath.fromProjectPath)(this.options.projectRoot, filePath);
-    let sourceRoot = _path().default.relative(_path().default.dirname(fullPath), this.options.projectRoot);
-    let inlineSources = false;
-    if (bundle.target) {
-      if (bundle.env.sourceMap && bundle.env.sourceMap.sourceRoot !== undefined) {
-        sourceRoot = bundle.env.sourceMap.sourceRoot;
-      } else if (this.options.serveOptions && bundle.target.env.context === 'browser') {
-        sourceRoot = '/__parcel_source_root';
-      }
-      if (bundle.env.sourceMap && bundle.env.sourceMap.inlineSources !== undefined) {
-        inlineSources = bundle.env.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';
-      }
-    }
-    let isInlineMap = bundle.env.sourceMap && bundle.env.sourceMap.inline;
-    let stringified = await map.stringify({
-      file: _path().default.basename(fullPath + '.map'),
-      // $FlowFixMe
-      fs: this.options.inputFS,
-      rootDir: this.options.projectRoot,
-      sourceRoot: !inlineSources ? _url().default.format(_url().default.parse(sourceRoot + '/')) : undefined,
-      inlineSources,
-      format: isInlineMap ? 'inline' : 'string'
-    });
-    (0, _assert().default)(typeof stringified === 'string');
-    return stringified;
-  }
-  async getCacheKey(bundle, bundleGraph, configs, bundleConfigs, invalidations) {
-    let configResults = {};
-    for (let [pluginName, config] of configs) {
-      if (config) {
-        configResults[pluginName] = await (0, _ConfigRequest.getConfigHash)(config, pluginName, this.options);
-      }
-    }
-    let globalInfoResults = {};
-    for (let [pluginName, config] of bundleConfigs) {
-      if (config) {
-        globalInfoResults[pluginName] = await (0, _ConfigRequest.getConfigHash)(config, pluginName, this.options);
-      }
-    }
-    let devDepHashes = await this.getDevDepHashes(bundle);
-    for (let inlineBundle of bundleGraph.getInlineBundles(bundle)) {
-      devDepHashes += await this.getDevDepHashes(inlineBundle);
-    }
-    let invalidationHash = await (0, _assetUtils.getInvalidationHash)(invalidations, this.options);
-    return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
-  }
-  async getDevDepHashes(bundle) {
-    var _this$devDepRequests$;
-    let name = (0, _nullthrows().default)(bundle.name);
-    let packager = await this.config.getPackager(name);
-    let optimizers = await this.config.getOptimizers(name);
-    let key = `${packager.name}:${(0, _projectPath.fromProjectPathRelative)(packager.resolveFrom)}`;
-    let devDepHashes = ((_this$devDepRequests$ = this.devDepRequests.get(key)) === null || _this$devDepRequests$ === void 0 ? void 0 : _this$devDepRequests$.hash) ?? this.previousDevDeps.get(key) ?? '';
-    for (let {
-      name,
-      resolveFrom
-    } of optimizers) {
-      var _this$devDepRequests$2;
-      let key = `${name}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
-      devDepHashes += ((_this$devDepRequests$2 = this.devDepRequests.get(key)) === null || _this$devDepRequests$2 === void 0 ? void 0 : _this$devDepRequests$2.hash) ?? this.previousDevDeps.get(key) ?? '';
-    }
-    return devDepHashes;
-  }
-  async readFromCache(cacheKey) {
-    let contentKey = PackagerRunner.getContentKey(cacheKey);
-    let mapKey = PackagerRunner.getMapKey(cacheKey);
-    let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = isLargeBlob || (await this.options.cache.has(contentKey));
-    if (!contentExists) {
-      return null;
-    }
-    let mapExists = await this.options.cache.has(mapKey);
-    return {
-      contents: isLargeBlob ? this.options.cache.getStream(contentKey) : (0, _utils().blobToStream)(await this.options.cache.getBlob(contentKey)),
-      map: mapExists ? (0, _utils().blobToStream)(await this.options.cache.getBlob(mapKey)) : null
-    };
-  }
-  async writeToCache(cacheKeys, type, contents, map) {
-    let size = 0;
-    let hash;
-    let hashReferences = [];
-    let isLargeBlob = false;
-
-    // TODO: don't replace hash references in binary files??
-    if (contents instanceof _stream().Readable) {
-      isLargeBlob = true;
-      let boundaryStr = '';
-      let h = new (_rust().Hash)();
-      await this.options.cache.setStream(cacheKeys.content, (0, _utils().blobToStream)(contents).pipe(new (_utils().TapStream)(buf => {
-        let str = boundaryStr + buf.toString();
-        hashReferences = hashReferences.concat(str.match(_constants.HASH_REF_REGEX) ?? []);
-        size += buf.length;
-        h.writeBuffer(buf);
-        boundaryStr = str.slice(str.length - BOUNDARY_LENGTH);
-      })));
-      hash = h.finish();
-    } else if (typeof contents === 'string') {
-      let buffer = Buffer.from(contents);
-      size = buffer.byteLength;
-      hash = (0, _rust().hashBuffer)(buffer);
-      hashReferences = contents.match(_constants.HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
-    } else {
-      size = contents.length;
-      hash = (0, _rust().hashBuffer)(contents);
-      hashReferences = contents.toString().match(_constants.HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
-    }
-    if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
-    }
-    let info = {
-      type,
-      size,
-      hash,
-      hashReferences,
-      cacheKeys,
-      isLargeBlob
-    };
-    await this.options.cache.set(cacheKeys.info, info);
-    return info;
-  }
-  static getContentKey(cacheKey) {
-    return (0, _rust().hashString)(`${cacheKey}:content`);
-  }
-  static getMapKey(cacheKey) {
-    return (0, _rust().hashString)(`${cacheKey}:map`);
-  }
-  static getInfoKey(cacheKey) {
-    return (0, _rust().hashString)(`${cacheKey}:info`);
-  }
-}
-exports.default = PackagerRunner;

package/lib/ReporterRunner.js

@@ -1,151 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.report = report;
-exports.reportWorker = reportWorker;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-var _Bundle = require("./public/Bundle");
-function _workers() {
-  const data = _interopRequireWildcard(require("@atlaspack/workers"));
-  _workers = function () {
-    return data;
-  };
-  return data;
-}
-function _logger() {
-  const data = _interopRequireWildcard(require("@atlaspack/logger"));
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));
-var _BundleGraph = _interopRequireDefault(require("./BundleGraph"));
-function _profiler() {
-  const data = require("@atlaspack/profiler");
-  _profiler = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = require("@atlaspack/diagnostic");
-  _diagnostic = 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 }; }
-const instances = new Set();
-class ReporterRunner {
-  constructor(opts) {
-    this.errors = [];
-    this.options = opts.options;
-    this.reporters = opts.reporters;
-    this.workerFarm = opts.workerFarm;
-    this.pluginOptions = new _PluginOptions.default(this.options);
-    _logger().default.onLog(event => this.report(event));
-    _profiler().tracer.onTrace(event => this.report(event));
-    _workers().bus.on('reporterEvent', this.eventHandler);
-    instances.add(this);
-    if (this.options.shouldPatchConsole) {
-      (0, _logger().patchConsole)();
-    } else {
-      (0, _logger().unpatchConsole)();
-    }
-  }
-  eventHandler = event => {
-    if (event.type === 'buildProgress' && (event.phase === 'optimizing' || event.phase === 'packaging') && !(event.bundle instanceof _Bundle.NamedBundle)) {
-      // $FlowFixMe[prop-missing]
-      let bundleGraphRef = event.bundleGraphRef;
-      // $FlowFixMe[incompatible-exact]
-      let bundle = event.bundle;
-      // Convert any internal bundles back to their public equivalents as reporting
-      // is public api
-      let bundleGraph = this.workerFarm.workerApi.getSharedReference(
-      // $FlowFixMe
-      bundleGraphRef);
-      (0, _assert().default)(bundleGraph instanceof _BundleGraph.default);
-      // $FlowFixMe[incompatible-call]
-      this.report({
-        ...event,
-        bundle: _Bundle.NamedBundle.get(bundle, bundleGraph, this.options)
-      });
-      return;
-    }
-    this.report(event);
-  };
-  async report(unsanitisedEvent) {
-    let event = unsanitisedEvent;
-    if (event.diagnostics) {
-      // Sanitise input before passing to reporters
-      // $FlowFixMe too complex to narrow down by type
-      event = {
-        ...event,
-        diagnostics: (0, _diagnostic().anyToDiagnostic)(event.diagnostics)
-      };
-    }
-    for (let reporter of this.reporters) {
-      let measurement;
-      try {
-        // To avoid an infinite loop we don't measure trace events, as they'll
-        // result in another trace!
-        if (event.type !== 'trace') {
-          measurement = _profiler().tracer.createMeasurement(reporter.name, 'reporter');
-        }
-        await reporter.plugin.report({
-          // $FlowFixMe
-          event,
-          options: this.pluginOptions,
-          logger: new (_logger().PluginLogger)({
-            origin: reporter.name
-          }),
-          tracer: new (_profiler().PluginTracer)({
-            origin: reporter.name,
-            category: 'reporter'
-          })
-        });
-      } catch (reportError) {
-        if (event.type !== 'buildSuccess') {
-          // This will be captured by consumers
-          _logger().INTERNAL_ORIGINAL_CONSOLE.error(reportError);
-        }
-        this.errors.push(reportError);
-      } finally {
-        measurement && measurement.end();
-      }
-    }
-  }
-  dispose() {
-    _workers().bus.off('reporterEvent', this.eventHandler);
-    instances.delete(this);
-  }
-}
-exports.default = ReporterRunner;
-function reportWorker(workerApi, event) {
-  if (event.type === 'buildProgress' && (event.phase === 'optimizing' || event.phase === 'packaging')) {
-    // Convert any public api bundles to their internal equivalents for
-    // easy serialization
-    _workers().bus.emit('reporterEvent', {
-      ...event,
-      bundle: (0, _Bundle.bundleToInternalBundle)(event.bundle),
-      bundleGraphRef: workerApi.resolveSharedReference((0, _Bundle.bundleToInternalBundleGraph)(event.bundle))
-    });
-    return;
-  }
-  _workers().bus.emit('reporterEvent', event);
-}
-async function report(event) {
-  await Promise.all([...instances].map(instance => instance.report(event)));
-}