@atlaspack/core 2.12.1-canary.3354

package/lib/applyRuntimes.js

@@ -0,0 +1,279 @@
+"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 _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]');
+}
+async function applyRuntimes({
+  bundleGraph,
+  config,
+  options,
+  pluginOptions,
+  api,
+  optionsRef,
+  previousDevDeps,
+  devDepRequests,
+  configs
+}) {
+  let runtimes = await config.getRuntimes();
+  let connections = [];
+
+  // As manifest bundles may be added during runtimes we process them in reverse topological
+  // sort order. This allows bundles to be added to their bundle groups before they are referenced
+  // by other bundle groups by loader runtimes
+  let bundles = [];
+  bundleGraph.traverseBundles({
+    exit(bundle) {
+      bundles.push(bundle);
+    }
+  });
+  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 (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);
+              nameRuntimeBundle(connectionBundle, bundle);
+            }
+            connections.push({
+              bundle: connectionBundle,
+              assetGroup,
+              dependency,
+              isEntry
+            });
+          }
+        }
+      } catch (e) {
+        throw new (_diagnostic().default)({
+          diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
+            origin: runtime.name
+          })
+        });
+      } finally {
+        measurement && measurement.end();
+      }
+    }
+  }
+
+  // Correct connection order after generating runtimes in reverse order
+  connections.reverse();
+
+  // 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);
+  }
+  let {
+    assetGraph: runtimesAssetGraph,
+    changedAssets
+  } = await reconcileNewRuntimes(api, connections, optionsRef);
+  let runtimesGraph = _BundleGraph2.default.fromAssetGraph(runtimesAssetGraph, options.mode === 'production', bundleGraph._publicIdByAssetId, bundleGraph._assetPublicIds);
+
+  // Merge the runtimes graph into the main bundle graph.
+  bundleGraph.merge(runtimesGraph);
+  for (let [assetId, publicId] of runtimesGraph._publicIdByAssetId) {
+    bundleGraph._publicIdByAssetId.set(assetId, publicId);
+    bundleGraph._assetPublicIds.add(publicId);
+  }
+  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');
+    let resolution = dependency && bundleGraph.getResolvedAsset((0, _Dependency.dependencyToInternalDependency)(dependency), bundle);
+    let runtimesGraphRuntimeNodeId = runtimesGraph._graph.getNodeIdByContentKey(runtimeNode.id);
+    let duplicatedContentKeys = new Set();
+    runtimesGraph._graph.traverse((nodeId, _, actions) => {
+      let node = (0, _nullthrows().default)(runtimesGraph._graph.getNode(nodeId));
+      if (node.type !== 'dependency') {
+        return;
+      }
+      let assets = runtimesGraph._graph.getNodeIdsConnectedFrom(nodeId).map(assetNodeId => {
+        let assetNode = (0, _nullthrows().default)(runtimesGraph._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();
+        }
+      }
+    }, runtimesGraphRuntimeNodeId);
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+    let bundleGraphRuntimeNodeId = bundleGraph._graph.getNodeIdByContentKey(runtimeNode.id); // the node id is not constant between graphs
+
+    runtimesGraph._graph.traverse((nodeId, _, actions) => {
+      let node = (0, _nullthrows().default)(runtimesGraph._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);
+      }
+    }, runtimesGraphRuntimeNodeId);
+    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

@@ -0,0 +1,189 @@
+"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 _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 _buildCache = require("./buildCache");
+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;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function createAssetIdFromOptions(options) {
+  let uniqueKey = options.uniqueKey ?? '';
+  let idBase = options.idBase != null ? options.idBase : (0, _projectPath.fromProjectPathRelative)(options.filePath);
+  return (0, _rust().hashString)(idBase + options.type + options.env.id + uniqueKey + ':' + (options.pipeline ?? '') + ':' + (options.query ?? ''));
+}
+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

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AtlaspackV3 = void 0;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _worker_threads() {
+  const data = require("worker_threads");
+  _worker_threads = 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');
+class AtlaspackV3 {
+  constructor({
+    fs,
+    nodeWorkers,
+    packageManager,
+    threads,
+    ...options
+  }) {
+    this._internal = new (_rust().AtlaspackNapi)({
+      fs,
+      nodeWorkers,
+      packageManager,
+      threads,
+      options
+    });
+  }
+  async build() {
+    const [workers, registerWorker] = this.#createWorkers();
+    let result = await this._internal.build({
+      registerWorker
+    });
+    for (const worker of workers) worker.terminate();
+    return result;
+  }
+  async buildAssetGraph() {
+    const [workers, registerWorker] = this.#createWorkers();
+    let result = await this._internal.buildAssetGraph({
+      registerWorker
+    });
+    for (const worker of workers) worker.terminate();
+    return result;
+  }
+  #createWorkers() {
+    const workers = [];
+    return [workers, tx_worker => {
+      let worker = new (_worker_threads().Worker)(WORKER_PATH, {
+        workerData: {
+          tx_worker
+        }
+      });
+      workers.push(worker);
+    }];
+  }
+}
+exports.AtlaspackV3 = AtlaspackV3;

package/lib/atlaspack-v3/fs.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toFileSystemV3 = toFileSystemV3;
+var _jsCallable = require("./jsCallable");
+// Move to @atlaspack/utils or a dedicated v3 / migration package later
+function toFileSystemV3(fs) {
+  return {
+    canonicalize: (0, _jsCallable.jsCallable)(path => fs.realpathSync(path)),
+    createDirectory: (0, _jsCallable.jsCallable)(path => fs.mkdirp(path)),
+    cwd: (0, _jsCallable.jsCallable)(() => fs.cwd()),
+    readFile: (0, _jsCallable.jsCallable)((path, encoding) => fs.readFileSync(path, encoding ?? 'utf8')),
+    isFile: path => {
+      try {
+        return fs.statSync(path).isFile();
+      } catch {
+        return false;
+      }
+    },
+    isDir: path => {
+      try {
+        return fs.statSync(path).isDirectory();
+      } catch {
+        return false;
+      }
+    }
+  };
+}

package/lib/atlaspack-v3/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AtlaspackV3", {
+  enumerable: true,
+  get: function () {
+    return _AtlaspackV.AtlaspackV3;
+  }
+});
+Object.defineProperty(exports, "toFileSystemV3", {
+  enumerable: true,
+  get: function () {
+    return _fs.toFileSystemV3;
+  }
+});
+var _fs = require("./fs");
+var _AtlaspackV = require("./AtlaspackV3");

package/lib/atlaspack-v3/jsCallable.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsCallable = jsCallable;
+function jsCallable(fn) {
+  return (...args) => {
+    try {
+      return fn(...args);
+    } catch (err) {
+      return err;
+    }
+  };
+}

package/lib/atlaspack-v3/plugins/Resolver.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResolverNapi = void 0;
+class ResolverNapi {
+  constructor() {}
+  loadConfig() {}
+  resolve() {}
+}
+exports.ResolverNapi = ResolverNapi;

package/lib/atlaspack-v3/plugins/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Resolver = require("./Resolver");
+Object.keys(_Resolver).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Resolver[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Resolver[key];
+    }
+  });
+});

package/lib/atlaspack-v3/worker/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require('./worker');

package/lib/atlaspack-v3/worker/worker.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AtlaspackWorker = void 0;
+function napi() {
+  const data = _interopRequireWildcard(require("@atlaspack/rust"));
+  napi = function () {
+    return data;
+  };
+  return data;
+}
+function _worker_threads() {
+  const data = require("worker_threads");
+  _worker_threads = 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; }
+class AtlaspackWorker {
+  #resolvers;
+  ping() {
+    // console.log('Hi');
+  }
+}
+exports.AtlaspackWorker = AtlaspackWorker;
+napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());