@atlaspack/core 2.13.2-dev.3689 → 2.14.0

package/lib/applyRuntimes.js

@@ -1,355 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = applyRuntimes;
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-var _AssetGraph = require("./AssetGraph");
-var _BundleGraph = _interopRequireDefault(require("./public/BundleGraph"));
-var _BundleGraph2 = _interopRequireWildcard(require("./BundleGraph"));
-var _Bundle = require("./public/Bundle");
-function _logger() {
-  const data = require("@atlaspack/logger");
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-var _Dependency = require("./public/Dependency");
-var _Environment = require("./Environment");
-var _AssetGraphRequest = _interopRequireDefault(require("./requests/AssetGraphRequest"));
-var _DevDepRequest = require("./requests/DevDepRequest");
-var _projectPath = require("./projectPath");
-function _profiler() {
-  const data = require("@atlaspack/profiler");
-  _profiler = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = 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 }; }
-function nameRuntimeBundle(bundle, siblingBundle) {
-  // We don't run custom namers on runtime bundles as the runtime assumes that they are
-  // located at the same nesting level as their owning bundle. Custom naming could
-  // be added in future as long as the custom name is validated.
-  let {
-    hashReference
-  } = bundle;
-  let name = (0, _nullthrows().default)(siblingBundle.name)
-  // Remove the existing hash from standard file patterns
-  // e.g. 'main.[hash].js' -> 'main.js' or 'main~[hash].js' -> 'main.js'
-  .replace(new RegExp(`[\\.~\\-_]?${siblingBundle.hashReference}`), '')
-  // Ensure the file ends with 'runtime.[hash].js'
-  .replace(`.${bundle.type}`, `.runtime.${hashReference}.${bundle.type}`);
-  bundle.name = name;
-  bundle.displayName = name.replace(hashReference, '[hash]');
-}
-
-/**
- * The applyRuntimes function is responsible for generating all the runtimes
- * (assets created during the build that don't actually exist on disk) and then
- * linking them into the bundle graph.
- *
- * Introduction of manifest bundles: https://github.com/parcel-bundler/parcel/pull/8837
- * Introduction of reverse topology: https://github.com/parcel-bundler/parcel/pull/8981
- */
-async function applyRuntimes({
-  bundleGraph,
-  config,
-  options,
-  pluginOptions,
-  api,
-  optionsRef,
-  previousDevDeps,
-  devDepRequests,
-  configs
-}) {
-  let runtimes = await config.getRuntimes();
-
-  /**
-   * Usually, the assets returned from a runtime will go in the same bundle. It is
-   * possible though, for a runtime to return an asset with a `parallel` priority,
-   * which allows it to be moved to a separate bundle. In practice, this is
-   * usually used to generate application manifest files.
-   *
-   * When adding a manifest bundle (a whole new separate bundle) during a runtime,
-   * it needs to be added to a bundle group which will be potentially referenced
-   * by another bundle group. To avoid trying to reference a manifest entry which
-   * hasn't been created yet, we process the bundles from the bottom up (topological
-   * order), so that children will always be available when parents try to reference
-   * them.
-   */
-  let bundles = [];
-  bundleGraph.traverseBundles({
-    exit(bundle) {
-      bundles.push(bundle);
-    }
-  });
-  let connectionMap = new (_utils().DefaultMap)(() => []);
-  for (let bundle of bundles) {
-    for (let runtime of runtimes) {
-      let measurement;
-      try {
-        var _configs$get;
-        const namedBundle = _Bundle.NamedBundle.get(bundle, bundleGraph, options);
-        measurement = _profiler().tracer.createMeasurement(runtime.name, 'applyRuntime', namedBundle.displayName);
-        let applied = await runtime.plugin.apply({
-          bundle: namedBundle,
-          bundleGraph: new _BundleGraph.default(bundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options),
-          config: (_configs$get = configs.get(runtime.name)) === null || _configs$get === void 0 ? void 0 : _configs$get.result,
-          options: pluginOptions,
-          logger: new (_logger().PluginLogger)({
-            origin: runtime.name
-          }),
-          tracer: new (_profiler().PluginTracer)({
-            origin: runtime.name,
-            category: 'applyRuntime'
-          })
-        });
-        if (applied) {
-          let runtimeAssets = Array.isArray(applied) ? applied : [applied];
-          for (let {
-            code,
-            dependency,
-            filePath,
-            isEntry,
-            env,
-            priority
-          } of runtimeAssets) {
-            let sourceName = _path().default.join(_path().default.dirname(filePath), `runtime-${(0, _rust().hashString)(code)}.${bundle.type}`);
-            let assetGroup = {
-              code,
-              filePath: (0, _projectPath.toProjectPath)(options.projectRoot, sourceName),
-              env: (0, _Environment.mergeEnvironments)(options.projectRoot, bundle.env, env),
-              // Runtime assets should be considered source, as they should be
-              // e.g. compiled to run in the target environment
-              isSource: true
-            };
-            let connectionBundle = bundle;
-
-            /**
-             * If a runtime asset is marked with a priority of `parallel` this
-             * means we need to create a new bundle for the asset and add it to
-             * all the same bundle groups.
-             */
-            if (priority === 'parallel' && !bundle.needsStableName) {
-              let bundleGroups = bundleGraph.getBundleGroupsContainingBundle(bundle);
-              connectionBundle = (0, _nullthrows().default)(bundleGraph.createBundle({
-                type: bundle.type,
-                needsStableName: false,
-                env: bundle.env,
-                target: bundle.target,
-                uniqueKey: 'runtime-manifest:' + bundle.id,
-                shouldContentHash: options.shouldContentHash
-              }));
-              for (let bundleGroup of bundleGroups) {
-                bundleGraph.addBundleToBundleGroup(connectionBundle, bundleGroup);
-              }
-              bundleGraph.createBundleReference(bundle, connectionBundle);
-
-              // Ensure we name the bundle now as all other bundles have already
-              // been named as this point.
-              nameRuntimeBundle(connectionBundle, bundle);
-            }
-            connectionMap.get(connectionBundle).push({
-              bundle: connectionBundle,
-              assetGroup,
-              dependency,
-              isEntry
-            });
-          }
-        }
-      } catch (e) {
-        throw new (_diagnostic().default)({
-          diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
-            origin: runtime.name
-          })
-        });
-      } finally {
-        measurement && measurement.end();
-      }
-    }
-  }
-
-  /**
-   * When merging the connections in to the bundle graph, the topological
-   * order can create module not found errors in some situations, often when HMR
-   * is enabled. To fix this, we put the connections into DFS order.
-   *
-   * Note: While DFS order seems to be the most reliable order to process the
-   * connections, this is likely due to it being close to the order that the bundles were
-   * inserted into the graph. There is a known issue where runtime assets marked
-   * as `isEntry` can create scenarios where there is no correct load order that
-   * won't error, as the entry runtime assets are added to many bundles in a
-   * single bundle group but their dependencies are not.
-   *
-   * This issue is almost exclusive to HMR scenarios as the two HMR runtime
-   * plugins (@atlaspack/runtime-browser-hmr and @atlaspack/runtime-react-refresh)
-   * are the only known cases where a runtime asset is marked as `isEntry`.
-   */
-  let connections = [];
-  bundleGraph.traverseBundles({
-    enter(bundle) {
-      connections.push(...connectionMap.get(bundle));
-    }
-  });
-
-  // Add dev deps for runtime plugins AFTER running them, to account for lazy require().
-  for (let runtime of runtimes) {
-    let devDepRequest = await (0, _DevDepRequest.createDevDependency)({
-      specifier: runtime.name,
-      resolveFrom: runtime.resolveFrom
-    }, previousDevDeps, options);
-    devDepRequests.set(`${devDepRequest.specifier}:${(0, _projectPath.fromProjectPathRelative)(devDepRequest.resolveFrom)}`, devDepRequest);
-    await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
-  }
-
-  // Create a new AssetGraph from the generated runtime assets which also runs
-  // transforms and resolves all dependencies.
-  let {
-    assetGraph: runtimesAssetGraph,
-    changedAssets
-  } = await reconcileNewRuntimes(api, connections, optionsRef);
-
-  // Convert the runtime AssetGraph into a BundleGraph, this includes assigning
-  // the assets their public ids
-  let runtimesBundleGraph = _BundleGraph2.default.fromAssetGraph(runtimesAssetGraph, options.mode === 'production', bundleGraph._publicIdByAssetId, bundleGraph._assetPublicIds);
-
-  // Merge the runtimes bundle graph into the main bundle graph.
-  bundleGraph.merge(runtimesBundleGraph);
-
-  // Add the public id mappings from the runtumes bundlegraph to the main bundle graph
-  for (let [assetId, publicId] of runtimesBundleGraph._publicIdByAssetId) {
-    bundleGraph._publicIdByAssetId.set(assetId, publicId);
-    bundleGraph._assetPublicIds.add(publicId);
-  }
-
-  // Connect each of the generated runtime assets to bundles in the main bundle
-  // graph. This is like a mini-bundling algorithm for runtime assets.
-  for (let {
-    bundle,
-    assetGroup,
-    dependency,
-    isEntry
-  } of connections) {
-    let assetGroupNode = (0, _AssetGraph.nodeFromAssetGroup)(assetGroup);
-    let assetGroupAssetNodeIds = runtimesAssetGraph.getNodeIdsConnectedFrom(runtimesAssetGraph.getNodeIdByContentKey(assetGroupNode.id));
-    (0, _assert().default)(assetGroupAssetNodeIds.length === 1);
-    let runtimeNodeId = assetGroupAssetNodeIds[0];
-    let runtimeNode = (0, _nullthrows().default)(runtimesAssetGraph.getNode(runtimeNodeId));
-    (0, _assert().default)(runtimeNode.type === 'asset');
-
-    // Find the asset that the runtime asset should be connected from by resolving
-    // it's dependency.
-    let resolution = dependency && bundleGraph.getResolvedAsset((0, _Dependency.dependencyToInternalDependency)(dependency), bundle);
-
-    // Walk all the dependencies of the runtime assets and check if they are
-    // already reachable from the bundle that the runtime asset is assigned to.
-    // If so, we add them to `duplicatedContentKeys` to be skipped when assigning
-    // assets to bundles.
-    let runtimesBundleGraphRuntimeNodeId = runtimesBundleGraph._graph.getNodeIdByContentKey(runtimeNode.id);
-    let duplicatedContentKeys = new Set();
-    runtimesBundleGraph._graph.traverse((nodeId, _, actions) => {
-      let node = (0, _nullthrows().default)(runtimesBundleGraph._graph.getNode(nodeId));
-      if (node.type !== 'dependency') {
-        return;
-      }
-      let assets = runtimesBundleGraph._graph.getNodeIdsConnectedFrom(nodeId).map(assetNodeId => {
-        let assetNode = (0, _nullthrows().default)(runtimesBundleGraph._graph.getNode(assetNodeId));
-        (0, _assert().default)(assetNode.type === 'asset');
-        return assetNode.value;
-      });
-      for (let asset of assets) {
-        if (bundleGraph.isAssetReachableFromBundle(asset, bundle) || (resolution === null || resolution === void 0 ? void 0 : resolution.id) === asset.id) {
-          duplicatedContentKeys.add(asset.id);
-          actions.skipChildren();
-        }
-      }
-    }, runtimesBundleGraphRuntimeNodeId);
-    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
-    let bundleGraphRuntimeNodeId = bundleGraph._graph.getNodeIdByContentKey(runtimeNode.id); // the node id is not constant between graphs
-
-    // Assign the runtime assets and all of it's depepdencies to the bundle unless
-    // we have detected it as already being reachable from this bundle via `duplicatedContentKeys`.
-    runtimesBundleGraph._graph.traverse((nodeId, _, actions) => {
-      let node = (0, _nullthrows().default)(runtimesBundleGraph._graph.getNode(nodeId));
-      if (node.type === 'asset' || node.type === 'dependency') {
-        if (duplicatedContentKeys.has(node.id)) {
-          actions.skipChildren();
-          return;
-        }
-        const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id); // the node id is not constant between graphs
-        bundleGraph._graph.addEdge(bundleNodeId, bundleGraphNodeId, _BundleGraph2.bundleGraphEdgeTypes.contains);
-      }
-    }, runtimesBundleGraphRuntimeNodeId);
-    if (isEntry) {
-      bundleGraph._graph.addEdge(bundleNodeId, bundleGraphRuntimeNodeId);
-      bundle.entryAssetIds.unshift(runtimeNode.id);
-    }
-    if (dependency == null) {
-      // Verify this asset won't become an island
-      (0, _assert().default)(bundleGraph._graph.getNodeIdsConnectedTo(bundleGraphRuntimeNodeId).length > 0, 'Runtime must have an inbound dependency or be an entry');
-    } else {
-      let dependencyNodeId = bundleGraph._graph.getNodeIdByContentKey(dependency.id);
-      bundleGraph._graph.addEdge(dependencyNodeId, bundleGraphRuntimeNodeId);
-    }
-  }
-  return changedAssets;
-}
-function reconcileNewRuntimes(api, connections, optionsRef) {
-  let assetGroups = connections.map(t => t.assetGroup);
-  let request = (0, _AssetGraphRequest.default)({
-    name: 'Runtimes',
-    assetGroups,
-    optionsRef
-  });
-
-  // rebuild the graph
-  return api.runRequest(request, {
-    force: true
-  });
-}

package/lib/assetUtils.js

@@ -1,205 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createAsset = createAsset;
-exports.createAssetIdFromOptions = createAssetIdFromOptions;
-exports.generateFromAST = generateFromAST;
-exports.getInvalidationHash = getInvalidationHash;
-exports.getInvalidationId = getInvalidationId;
-function _stream() {
-  const data = require("stream");
-  _stream = function () {
-    return data;
-  };
-  return data;
-}
-function _buildCache() {
-  const data = require("@atlaspack/build-cache");
-  _buildCache = function () {
-    return data;
-  };
-  return data;
-}
-function _logger() {
-  const data = require("@atlaspack/logger");
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-var _CommittedAsset = _interopRequireDefault(require("./CommittedAsset"));
-var _UncommittedAsset = _interopRequireDefault(require("./UncommittedAsset"));
-var _loadAtlaspackPlugin = _interopRequireDefault(require("./loadAtlaspackPlugin"));
-var _Asset = require("./public/Asset");
-var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-var _utils2 = require("./utils");
-var _projectPath = require("./projectPath");
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-var _types = require("./types");
-function _profiler() {
-  const data = require("@atlaspack/profiler");
-  _profiler = function () {
-    return data;
-  };
-  return data;
-}
-var _IdentifierRegistry = require("./IdentifierRegistry");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function createAssetIdFromOptions(options) {
-  const data = {
-    environmentId: options.env.id,
-    filePath: options.filePath,
-    code: options.code,
-    pipeline: options.pipeline,
-    query: options.query,
-    uniqueKey: options.uniqueKey,
-    fileType: options.type
-  };
-  const id = (0, _rust().createAssetId)(data);
-  _IdentifierRegistry.identifierRegistry.addIdentifier('asset', id, data);
-  return id;
-}
-function createAsset(projectRoot, options) {
-  return {
-    id: options.id != null ? options.id : createAssetIdFromOptions(options),
-    committed: options.committed ?? false,
-    filePath: options.filePath,
-    query: options.query,
-    bundleBehavior: options.bundleBehavior ? _types.BundleBehavior[options.bundleBehavior] : null,
-    isBundleSplittable: options.isBundleSplittable ?? true,
-    type: options.type,
-    contentKey: options.contentKey,
-    mapKey: options.mapKey,
-    astKey: options.astKey,
-    astGenerator: options.astGenerator,
-    dependencies: options.dependencies || new Map(),
-    isSource: options.isSource,
-    outputHash: options.outputHash,
-    pipeline: options.pipeline,
-    env: options.env,
-    meta: options.meta || {},
-    stats: options.stats,
-    symbols: options.symbols && new Map([...options.symbols].map(([k, v]) => [k, {
-      local: v.local,
-      meta: v.meta,
-      loc: (0, _utils2.toInternalSourceLocation)(projectRoot, v.loc)
-    }])),
-    sideEffects: options.sideEffects ?? true,
-    uniqueKey: options.uniqueKey,
-    plugin: options.plugin,
-    configPath: options.configPath,
-    configKeyPath: options.configKeyPath
-  };
-}
-const generateResults = new WeakMap();
-function generateFromAST(asset) {
-  let output = generateResults.get(asset.value);
-  if (output == null) {
-    output = _generateFromAST(asset);
-    generateResults.set(asset.value, output);
-  }
-  return output;
-}
-async function _generateFromAST(asset) {
-  var _plugin$generate;
-  let ast = await asset.getAST();
-  if (ast == null) {
-    throw new Error('Asset has no AST');
-  }
-  let pluginName = (0, _nullthrows().default)(asset.value.plugin);
-  let {
-    plugin
-  } = await (0, _loadAtlaspackPlugin.default)(pluginName, (0, _projectPath.fromProjectPath)(asset.options.projectRoot, (0, _nullthrows().default)(asset.value.configPath)), (0, _nullthrows().default)(asset.value.configKeyPath), asset.options);
-  let generate = (_plugin$generate = plugin.generate) === null || _plugin$generate === void 0 ? void 0 : _plugin$generate.bind(plugin);
-  if (!generate) {
-    throw new Error(`${pluginName} does not have a generate method`);
-  }
-  let {
-    content,
-    map
-  } = await generate({
-    asset: new _Asset.Asset(asset),
-    ast,
-    options: new _PluginOptions.default(asset.options),
-    logger: new (_logger().PluginLogger)({
-      origin: pluginName
-    }),
-    tracer: new (_profiler().PluginTracer)({
-      origin: pluginName,
-      category: 'asset-generate'
-    })
-  });
-  let mapBuffer = map === null || map === void 0 ? void 0 : map.toBuffer();
-  // Store the results in the cache so we can avoid generating again next time
-  await Promise.all([asset.options.cache.setStream((0, _nullthrows().default)(asset.value.contentKey), (0, _utils().blobToStream)(content)), mapBuffer != null && asset.options.cache.setBlob((0, _nullthrows().default)(asset.value.mapKey), mapBuffer)]);
-  return {
-    content: content instanceof _stream().Readable ? asset.options.cache.getStream((0, _nullthrows().default)(asset.value.contentKey)) : content,
-    map
-  };
-}
-function getInvalidationId(invalidation) {
-  switch (invalidation.type) {
-    case 'file':
-      return 'file:' + (0, _projectPath.fromProjectPathRelative)(invalidation.filePath);
-    case 'env':
-      return 'env:' + invalidation.key;
-    case 'option':
-      return 'option:' + invalidation.key;
-    default:
-      throw new Error('Unknown invalidation type: ' + invalidation.type);
-  }
-}
-const hashCache = (0, _buildCache().createBuildCache)();
-async function getInvalidationHash(invalidations, options) {
-  if (invalidations.length === 0) {
-    return '';
-  }
-  let sortedInvalidations = invalidations.slice().sort((a, b) => getInvalidationId(a) < getInvalidationId(b) ? -1 : 1);
-  let hashes = '';
-  for (let invalidation of sortedInvalidations) {
-    switch (invalidation.type) {
-      case 'file':
-        {
-          // Only recompute the hash of this file if we haven't seen it already during this build.
-          let fileHash = hashCache.get(invalidation.filePath);
-          if (fileHash == null) {
-            fileHash = (0, _utils().hashFile)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, invalidation.filePath));
-            hashCache.set(invalidation.filePath, fileHash);
-          }
-          hashes += await fileHash;
-          break;
-        }
-      case 'env':
-        hashes += invalidation.key + ':' + (options.env[invalidation.key] || '');
-        break;
-      case 'option':
-        hashes += invalidation.key + ':' + (0, _utils2.hashFromOption)(options[invalidation.key]);
-        break;
-      default:
-        throw new Error('Unknown invalidation type: ' + invalidation.type);
-    }
-  }
-  return (0, _rust().hashString)(hashes);
-}

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AtlaspackV3 = void 0;
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-var _NapiWorkerPool = require("./NapiWorkerPool");
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-class AtlaspackV3 {
-  constructor({
-    fs,
-    packageManager,
-    threads,
-    lmdb,
-    napiWorkerPool = new _NapiWorkerPool.NapiWorkerPool(),
-    ...options
-  }) {
-    options.logLevel = options.logLevel || 'error';
-    options.defaultTargetOptions = options.defaultTargetOptions || {};
-    // $FlowFixMe "engines" are readonly
-    options.defaultTargetOptions.engines = options.defaultTargetOptions.engines || {};
-    this._internal = _rust().AtlaspackNapi.create({
-      fs,
-      packageManager,
-      threads,
-      options,
-      napiWorkerPool
-    }, lmdb);
-  }
-  async buildAssetGraph() {
-    let [graph, error] = await this._internal.buildAssetGraph();
-    if (error !== null) {
-      throw new (_diagnostic().default)({
-        diagnostic: error
-      });
-    }
-    return graph;
-  }
-  respondToFsEvents(events) {
-    return this._internal.respondToFsEvents(events);
-  }
-}
-exports.AtlaspackV3 = AtlaspackV3;

package/lib/atlaspack-v3/NapiWorkerPool.js

@@ -1,71 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.NapiWorkerPool = void 0;
-function _worker_threads() {
-  const data = require("worker_threads");
-  _worker_threads = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _process() {
-  const data = _interopRequireDefault(require("process"));
-  _process = function () {
-    return data;
-  };
-  return data;
-}
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const WORKER_PATH = _path().default.join(__dirname, 'worker', 'index.js');
-const ATLASPACK_NAPI_WORKERS = _process().default.env.ATLASPACK_NAPI_WORKERS && parseInt(_process().default.env.ATLASPACK_NAPI_WORKERS, 10);
-class NapiWorkerPool {
-  #workers;
-  #napiWorkers;
-  #workerCount;
-  constructor({
-    workerCount
-  } = {
-    workerCount: undefined
-  }) {
-    this.#workerCount = workerCount ?? ATLASPACK_NAPI_WORKERS ?? (0, _rust().getAvailableThreads)();
-    if (!this.#workerCount) {
-      // TODO use main thread if workerCount is 0
-    }
-    this.#workers = [];
-    this.#napiWorkers = [];
-    for (let i = 0; i < this.#workerCount; i++) {
-      let worker = new (_worker_threads().Worker)(WORKER_PATH);
-      this.#workers.push(worker);
-      this.#napiWorkers.push(new Promise(res => worker.once('message', res)));
-    }
-  }
-  workerCount() {
-    return this.#workerCount;
-  }
-  getWorkers() {
-    return Promise.all(this.#napiWorkers);
-  }
-  shutdown() {
-    for (const worker of this.#workers) {
-      worker.terminate();
-    }
-  }
-}
-exports.NapiWorkerPool = NapiWorkerPool;