@atlaspack/core 2.12.1-canary.3443 → 2.12.1-canary.3445

package/lib/atlaspack-v3/worker/{compat.js → compat/asset-compat.js}

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AssetCompat = void 0;
-var _Environment = _interopRequireDefault(require("../../public/Environment"));
-var _types = require("../../types");
+var _Environment = _interopRequireDefault(require("../../../public/Environment"));
+var _types = require("../../../types");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class AssetCompat {
   // TODO: Type properly

package/lib/atlaspack-v3/worker/compat/asset-symbols.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MutableDependencySymbols = exports.MutableAssetSymbols = exports.AssetSymbols = void 0;
+class MutableDependencySymbols {
+  #symbols;
+  #locals;
+  get isCleared() {
+    return this.#symbols.size === 0;
+  }
+  constructor(inner) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {
+      exported,
+      local,
+      loc,
+      isWeak
+    } of inner) {
+      this.set(exported, local, loc, isWeak);
+    }
+  }
+  ensure() {
+    throw new Error('MutableDependencySymbols.ensure()');
+  }
+  get(exportSymbol) {
+    return this.#symbols.get(exportSymbol);
+  }
+  hasExportSymbol(exportSymbol) {
+    return this.#symbols.has(exportSymbol);
+  }
+  hasLocalSymbol(local) {
+    return this.#locals.has(local);
+  }
+  exportSymbols() {
+    return this.#symbols.keys();
+  }
+  set(exportSymbol, local, loc, isWeak) {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {},
+      isWeak: isWeak ?? false
+    });
+  }
+  delete(exportSymbol) {
+    let existing = this.#symbols.get(exportSymbol);
+    if (!existing) return;
+    this.#locals.delete(existing.local);
+    this.#symbols.delete(exportSymbol);
+  }
+
+  /*::  @@iterator(): Iterator<[Symbol, DependencyAssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
+
+// TODO
+exports.MutableDependencySymbols = MutableDependencySymbols;
+class AssetSymbols extends Array {
+  // eslint-disable-next-line no-unused-vars
+  get() {}
+
+  // eslint-disable-next-line no-unused-vars
+  hasExportSymbol() {
+    throw new Error('AssetSymbols.hasExportSymbol');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  hasLocalSymbol() {
+    throw new Error('AssetSymbols.hasExportSymbol');
+  }
+  exportSymbols() {
+    return [];
+  }
+}
+
+// TODO
+exports.AssetSymbols = AssetSymbols;
+class MutableAssetSymbols extends AssetSymbols {
+  ensure() {}
+  set() {}
+
+  // eslint-disable-next-line no-unused-vars
+  delete() {}
+}
+exports.MutableAssetSymbols = MutableAssetSymbols;

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

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.specifierTypeMap = exports.packageConditionsMap = exports.dependencyPriorityMap = exports.bundleBehaviorMap = exports.BitFlags = void 0;
+/// BitFlags is used to map number/string types from napi types
+class BitFlags {
+  #kv;
+  #vk;
+  constructor(source) {
+    this.#kv = source;
+    this.#vk = Object.fromEntries(
+    // $FlowFixMe
+    Object.entries(source).map(a => a.reverse()));
+  }
+  into(key) {
+    const found = this.#kv[key];
+    if (found === undefined) {
+      // $FlowFixMe
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+  intoArray(keys) {
+    return keys.map(key => this.into(key));
+  }
+  from(key) {
+    const found = this.#vk[key];
+    if (found === undefined) {
+      // $FlowFixMe
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+  fromArray(keys) {
+    return keys.map(key => this.from(key));
+  }
+}
+exports.BitFlags = BitFlags;
+const bundleBehaviorMap = exports.bundleBehaviorMap = new BitFlags({
+  inline: 0,
+  isolated: 1
+});
+const dependencyPriorityMap = exports.dependencyPriorityMap = new BitFlags({
+  sync: 0,
+  parallel: 1,
+  lazy: 2,
+  conditional: 3
+});
+const packageConditionsMap = exports.packageConditionsMap = new BitFlags({
+  import: 0,
+  require: 1,
+  module: 2,
+  node: 3,
+  browser: 4,
+  worker: 5,
+  worklet: 6,
+  electron: 7,
+  development: 8,
+  production: 9,
+  types: 10,
+  default: 11,
+  style: 12,
+  sass: 13
+});
+const specifierTypeMap = exports.specifierTypeMap = new BitFlags({
+  esm: 0,
+  commonjs: 1,
+  url: 2,
+  custom: 3
+});

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Dependency = void 0;
+var _target = require("./target");
+var _assetSymbols = require("./asset-symbols");
+var _bitflags = require("./bitflags");
+class Dependency {
+  get id() {
+    throw new Error('Dependency.id');
+  }
+  constructor(inner, env) {
+    this.env = env;
+    this.meta = inner.meta || {};
+    this.target = undefined;
+    if (inner.target) {
+      this.target = new _target.Target(inner.target, this.env);
+    }
+    if (!inner.bundleBehavior) {
+      this.bundleBehavior = undefined;
+    } else {
+      this.bundleBehavior = _bitflags.bundleBehaviorMap.from(inner.bundleBehavior);
+    }
+    this.bundleBehavior = undefined;
+    this.symbols = new _assetSymbols.MutableDependencySymbols(inner.symbols || []);
+    this.specifier = inner.specifier;
+    this.specifierType = _bitflags.specifierTypeMap.from(inner.specifierType);
+    this.priority = _bitflags.dependencyPriorityMap.from(inner.priority);
+    this.needsStableName = inner.needsStableName;
+    this.isOptional = inner.isOptional;
+    this.isEntry = inner.isEntry;
+    this.loc = inner.loc;
+    this.packageConditions = _bitflags.packageConditionsMap.fromArray(inner.packageConditions || []);
+    this.sourceAssetId = inner.sourceAssetId;
+    this.sourcePath = inner.sourcePath;
+    this.sourceAssetType = inner.sourceAssetType;
+    this.resolveFrom = inner.resolveFrom;
+    this.range = inner.range;
+    this.pipeline = inner.pipeline;
+  }
+}
+exports.Dependency = Dependency;

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Environment = void 0;
+class Environment {
+  constructor(inner) {
+    // TODO
+    this.id = '';
+    this.includeNodeModules = inner.includeNodeModules;
+    // $FlowFixMe
+    this.context = inner.context;
+    this.engines = inner.engines;
+    // $FlowFixMe
+    this.outputFormat = inner.outputFormat;
+    // $FlowFixMe
+    this.sourceType = inner.sourceType;
+    this.isLibrary = inner.isLibrary;
+    this.shouldOptimize = inner.shouldOptimize;
+    this.shouldScopeHoist = inner.shouldScopeHoist;
+    this.sourceMap = inner.sourceMap;
+    this.loc = inner.loc;
+  }
+
+  // TODO
+  isBrowser() {
+    return true;
+  }
+
+  // TODO
+  isNode() {
+    return false;
+  }
+
+  // TODO
+  isElectron() {
+    return false;
+  }
+
+  // TODO
+  isWorker() {
+    return false;
+  }
+
+  // TODO
+  isWorklet() {
+    return false;
+  }
+
+  // TODO
+  isIsolated() {
+    return false;
+  }
+
+  // TODO
+  // eslint-disable-next-line no-unused-vars
+  matchesEngines() {
+    return true;
+  }
+
+  // TODO
+  // eslint-disable-next-line no-unused-vars
+  supports() {
+    return true;
+  }
+}
+exports.Environment = Environment;

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

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _assetCompat = require("./asset-compat");
+Object.keys(_assetCompat).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _assetCompat[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _assetCompat[key];
+    }
+  });
+});
+var _assetSymbols = require("./asset-symbols");
+Object.keys(_assetSymbols).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _assetSymbols[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _assetSymbols[key];
+    }
+  });
+});
+var _bitflags = require("./bitflags");
+Object.keys(_bitflags).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitflags[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bitflags[key];
+    }
+  });
+});
+var _dependency = require("./dependency");
+Object.keys(_dependency).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dependency[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dependency[key];
+    }
+  });
+});
+var _environment = require("./environment");
+Object.keys(_environment).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _environment[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _environment[key];
+    }
+  });
+});
+var _target = require("./target");
+Object.keys(_target).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _target[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _target[key];
+    }
+  });
+});

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Target = void 0;
+class Target {
+  constructor(inner, env) {
+    this.distDir = inner.distDir;
+    this.distEntry = inner.distEntry;
+    this.name = inner.name;
+    this.publicUrl = inner.publicUrl;
+    this.loc = inner.loc;
+    this.env = env;
+  }
+}
+exports.Target = Target;

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

@@ -48,7 +48,6 @@ function _module() {
 }
 var _compat = require("./compat");
 var _jsCallable = require("../jsCallable");
-var _Environment = _interopRequireDefault(require("../../public/Environment"));
 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 }; }
@@ -87,7 +86,7 @@ class AtlaspackWorker {
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
-    dependency,
+    dependency: napiDependency,
     specifier,
     pipeline,
     projectRoot
@@ -101,6 +100,8 @@ class AtlaspackWorker {
       packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
       state.packageManager = packageManager;
     }
+    const env = new _compat.Environment(napiDependency.env);
+    const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
       get logger() {
         // $FlowFixMe
@@ -154,10 +155,7 @@ class AtlaspackWorker {
           isSource: true,
           searchPath: '',
           // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
-          env: new _Environment.default(dependency.env, {
-            projectRoot,
-            hmrOptions: undefined
-          }),
+          env,
           invalidateOnFileChange() {},
           invalidateOnFileCreate() {},
           invalidateOnEnvChange() {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3443+15e45b97e",
+  "version": "2.12.1-canary.3445+ba8fb88af",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/diagnostic": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/events": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/feature-flags": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/fs": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/graph": "3.2.1-canary.3443+15e45b97e",
-    "@atlaspack/logger": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/package-manager": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/plugin": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/profiler": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/rust": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/types": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/utils": "2.12.1-canary.3443+15e45b97e",
-    "@atlaspack/workers": "2.12.1-canary.3443+15e45b97e",
+    "@atlaspack/cache": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/diagnostic": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/events": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/feature-flags": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/fs": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/graph": "3.2.1-canary.3445+ba8fb88af",
+    "@atlaspack/logger": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/package-manager": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/plugin": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/profiler": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/rust": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/types": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/utils": "2.12.1-canary.3445+ba8fb88af",
+    "@atlaspack/workers": "2.12.1-canary.3445+ba8fb88af",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "15e45b97efca8057803259d2b6362ac1f3e50567"
+  "gitHead": "ba8fb88af15c3c574f5de99f9fbc18470821d763"
 }

package/src/atlaspack-v3/worker/{compat.js → compat/asset-compat.js}

@@ -1,11 +1,11 @@
 // @flow
 import type {PluginOptions, BundleBehavior, AST} from '@atlaspack/types';
 
-import Environment from '../../public/Environment';
+import Environment from '../../../public/Environment';
 import {
   BundleBehaviorNames,
   BundleBehavior as BundleBehaviorMap,
-} from '../../types';
+} from '../../../types';
 
 export type InnerAsset = {|
   id: string,

package/src/atlaspack-v3/worker/compat/asset-symbols.js

@@ -0,0 +1,132 @@
+// @flow
+
+import type {Symbol as NapiSymbol} from '@atlaspack/rust';
+import type {
+  AssetSymbols as ClassicAssetSymbols,
+  MutableAssetSymbols as ClassicMutableAssetSymbols,
+  MutableDependencySymbols as ClassicMutableDependencySymbols,
+  Symbol,
+  SourceLocation,
+  Meta,
+} from '@atlaspack/types';
+
+export class MutableDependencySymbols
+  implements ClassicMutableDependencySymbols
+{
+  #symbols: Map<Symbol, DependencyAssetSymbol>;
+  #locals: Set<Symbol>;
+
+  get isCleared(): boolean {
+    return this.#symbols.size === 0;
+  }
+
+  constructor(inner: NapiSymbol[]) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {exported, local, loc, isWeak} of inner) {
+      this.set(exported, local, loc, isWeak);
+    }
+  }
+
+  ensure(): void {
+    throw new Error('MutableDependencySymbols.ensure()');
+  }
+
+  get(exportSymbol: Symbol): ?DependencyAssetSymbol {
+    return this.#symbols.get(exportSymbol);
+  }
+
+  hasExportSymbol(exportSymbol: Symbol): boolean {
+    return this.#symbols.has(exportSymbol);
+  }
+
+  hasLocalSymbol(local: Symbol): boolean {
+    return this.#locals.has(local);
+  }
+
+  exportSymbols(): Iterable<Symbol> {
+    return this.#symbols.keys();
+  }
+
+  set(
+    exportSymbol: Symbol,
+    local: Symbol,
+    loc: ?SourceLocation,
+    isWeak: ?boolean,
+  ): void {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {},
+      isWeak: isWeak ?? false,
+    });
+  }
+
+  delete(exportSymbol: Symbol): void {
+    let existing = this.#symbols.get(exportSymbol);
+    if (!existing) return;
+    this.#locals.delete(existing.local);
+    this.#symbols.delete(exportSymbol);
+  }
+
+  /*::  @@iterator(): Iterator<[Symbol, DependencyAssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
+
+// TODO
+export class AssetSymbols
+  extends Array<[Symbol, AssetSymbol]>
+  implements ClassicAssetSymbols
+{
+  isCleared: boolean;
+
+  // eslint-disable-next-line no-unused-vars
+  get(exportSymbol: Symbol): ?AssetSymbol {}
+
+  // eslint-disable-next-line no-unused-vars
+  hasExportSymbol(exportSymbol: Symbol): boolean {
+    throw new Error('AssetSymbols.hasExportSymbol');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  hasLocalSymbol(local: Symbol): boolean {
+    throw new Error('AssetSymbols.hasExportSymbol');
+  }
+
+  exportSymbols(): Iterable<Symbol> {
+    return [];
+  }
+}
+
+// TODO
+export class MutableAssetSymbols
+  extends AssetSymbols
+  implements ClassicMutableAssetSymbols
+{
+  ensure(): void {}
+  set(
+    // eslint-disable-next-line no-unused-vars
+    exportSymbol: Symbol,
+    // eslint-disable-next-line no-unused-vars
+    local: Symbol,
+    // eslint-disable-next-line no-unused-vars
+    loc: ?SourceLocation,
+    // eslint-disable-next-line no-unused-vars
+    meta?: ?Meta,
+  ): void {}
+
+  // eslint-disable-next-line no-unused-vars
+  delete(exportSymbol: Symbol): void {}
+}
+
+export type AssetSymbol = {|local: Symbol, loc: ?SourceLocation, meta?: ?Meta|};
+export type DependencyAssetSymbol = {|
+  local: Symbol,
+  loc: ?SourceLocation,
+  meta?: ?Meta,
+  isWeak: boolean,
+|};

package/src/atlaspack-v3/worker/compat/bitflags.js

@@ -0,0 +1,86 @@
+// @flow
+
+import type {
+  BundleBehavior,
+  DependencyPriority,
+  SpecifierType,
+} from '@atlaspack/types';
+
+/// BitFlags is used to map number/string types from napi types
+export class BitFlags<K, V> {
+  #kv: {[key: K]: V};
+  #vk: {[key: V]: K};
+
+  constructor(source: {[key: K]: V}) {
+    this.#kv = source;
+    this.#vk = Object.fromEntries(
+      // $FlowFixMe
+      Object.entries(source).map(a => a.reverse()),
+    );
+  }
+
+  into(key: K): V {
+    const found = this.#kv[key];
+    if (found === undefined) {
+      // $FlowFixMe
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+
+  intoArray(keys: K[]): V[] {
+    return keys.map(key => this.into(key));
+  }
+
+  from(key: V): K {
+    const found = this.#vk[key];
+    if (found === undefined) {
+      // $FlowFixMe
+      throw new Error(`Invalid BundleBehavior(${key})`);
+    }
+    return found;
+  }
+
+  fromArray(keys: V[]): K[] {
+    return keys.map(key => this.from(key));
+  }
+}
+
+export const bundleBehaviorMap: BitFlags<BundleBehavior, number> = new BitFlags(
+  {
+    inline: 0,
+    isolated: 1,
+  },
+);
+
+export const dependencyPriorityMap: BitFlags<DependencyPriority, number> =
+  new BitFlags({
+    sync: 0,
+    parallel: 1,
+    lazy: 2,
+    conditional: 3,
+  });
+
+export const packageConditionsMap: BitFlags<string, number> = new BitFlags({
+  import: 0,
+  require: 1,
+  module: 2,
+  node: 3,
+  browser: 4,
+  worker: 5,
+  worklet: 6,
+  electron: 7,
+  development: 8,
+  production: 9,
+  types: 10,
+  default: 11,
+  style: 12,
+  sass: 13,
+});
+
+export const specifierTypeMap: BitFlags<SpecifierType, number> = new BitFlags({
+  esm: 0,
+  commonjs: 1,
+  url: 2,
+  custom: 3,
+});

package/src/atlaspack-v3/worker/compat/dependency.js

@@ -0,0 +1,83 @@
+// @flow
+
+import type {Dependency as NapiDependency} from '@atlaspack/rust';
+import type {
+  Dependency as ClassicDependency,
+  DependencySpecifier,
+  SpecifierType,
+  DependencyPriority,
+  BundleBehavior,
+  SourceLocation,
+  Environment as ClassicEnvironment,
+  Meta,
+  Target as ClassicTarget,
+  FilePath,
+  SemverRange,
+  MutableDependencySymbols as ClassicMutableDependencySymbols,
+} from '@atlaspack/types';
+import {Target} from './target';
+import {MutableDependencySymbols} from './asset-symbols';
+import {
+  bundleBehaviorMap,
+  specifierTypeMap,
+  dependencyPriorityMap,
+  packageConditionsMap,
+} from './bitflags';
+
+export class Dependency implements ClassicDependency {
+  env: ClassicEnvironment;
+  meta: Meta;
+  target: ?ClassicTarget;
+  symbols: ClassicMutableDependencySymbols;
+  specifier: DependencySpecifier;
+  specifierType: SpecifierType;
+  priority: DependencyPriority;
+  bundleBehavior: ?BundleBehavior;
+  needsStableName: boolean;
+  isOptional: boolean;
+  isEntry: boolean;
+  loc: ?SourceLocation;
+  packageConditions: ?Array<string>;
+  sourceAssetId: ?string;
+  sourcePath: ?FilePath;
+  sourceAssetType: ?string;
+  resolveFrom: ?FilePath;
+  range: ?SemverRange;
+  pipeline: ?string;
+
+  get id(): string {
+    throw new Error('Dependency.id');
+  }
+
+  constructor(inner: NapiDependency, env: ClassicEnvironment) {
+    this.env = env;
+    this.meta = inner.meta || {};
+    this.target = undefined;
+    if (inner.target) {
+      this.target = new Target(inner.target, this.env);
+    }
+    if (!inner.bundleBehavior) {
+      this.bundleBehavior = undefined;
+    } else {
+      this.bundleBehavior = bundleBehaviorMap.from(inner.bundleBehavior);
+    }
+    this.bundleBehavior = undefined;
+    this.symbols = new MutableDependencySymbols(inner.symbols || []);
+    this.specifier = inner.specifier;
+    this.specifierType = specifierTypeMap.from(inner.specifierType);
+    this.priority = dependencyPriorityMap.from(inner.priority);
+    this.needsStableName = inner.needsStableName;
+    this.isOptional = inner.isOptional;
+    this.isEntry = inner.isEntry;
+    this.loc = inner.loc;
+    this.packageConditions = packageConditionsMap.fromArray(
+      inner.packageConditions || [],
+    );
+    this.sourceAssetId = inner.sourceAssetId;
+    this.sourcePath = inner.sourcePath;
+    this.sourceAssetType = inner.sourceAssetType;
+    this.resolveFrom = inner.resolveFrom;
+    this.range = inner.range;
+    this.pipeline = inner.pipeline;
+  }
+}

package/src/atlaspack-v3/worker/compat/environment.js

@@ -0,0 +1,92 @@
+// @flow
+
+import type {Environment as NapiEnvironment} from '@atlaspack/rust';
+import type {
+  Environment as ClassicEnvironment,
+  EnvironmentContext,
+  Engines,
+  PackageName,
+  OutputFormat,
+  SourceType,
+  TargetSourceMapOptions,
+  SourceLocation,
+  VersionMap,
+  EnvironmentFeature,
+} from '@atlaspack/types';
+
+export class Environment implements ClassicEnvironment {
+  id: string;
+  includeNodeModules:
+    | boolean
+    | Array<PackageName>
+    | {[PackageName]: boolean, ...};
+  context: EnvironmentContext;
+  engines: Engines;
+  outputFormat: OutputFormat;
+  sourceType: SourceType;
+  isLibrary: boolean;
+  shouldOptimize: boolean;
+  shouldScopeHoist: boolean;
+  sourceMap: ?TargetSourceMapOptions;
+  loc: ?SourceLocation;
+
+  constructor(inner: NapiEnvironment) {
+    // TODO
+    this.id = '';
+    this.includeNodeModules = inner.includeNodeModules;
+    // $FlowFixMe
+    this.context = inner.context;
+    this.engines = inner.engines;
+    // $FlowFixMe
+    this.outputFormat = inner.outputFormat;
+    // $FlowFixMe
+    this.sourceType = inner.sourceType;
+    this.isLibrary = inner.isLibrary;
+    this.shouldOptimize = inner.shouldOptimize;
+    this.shouldScopeHoist = inner.shouldScopeHoist;
+    this.sourceMap = inner.sourceMap;
+    this.loc = inner.loc;
+  }
+
+  // TODO
+  isBrowser(): boolean {
+    return true;
+  }
+
+  // TODO
+  isNode(): boolean {
+    return false;
+  }
+
+  // TODO
+  isElectron(): boolean {
+    return false;
+  }
+
+  // TODO
+  isWorker(): boolean {
+    return false;
+  }
+
+  // TODO
+  isWorklet(): boolean {
+    return false;
+  }
+
+  // TODO
+  isIsolated(): boolean {
+    return false;
+  }
+
+  // TODO
+  // eslint-disable-next-line no-unused-vars
+  matchesEngines(minVersions: VersionMap, defaultValue?: boolean): boolean {
+    return true;
+  }
+
+  // TODO
+  // eslint-disable-next-line no-unused-vars
+  supports(feature: EnvironmentFeature, defaultValue?: boolean): boolean {
+    return true;
+  }
+}

package/src/atlaspack-v3/worker/compat/index.js

@@ -0,0 +1,7 @@
+// @flow
+export * from './asset-compat';
+export * from './asset-symbols';
+export * from './bitflags';
+export * from './dependency';
+export * from './environment';
+export * from './target';

package/src/atlaspack-v3/worker/compat/target.js

@@ -0,0 +1,27 @@
+// @flow
+
+import type {Target as NapiTarget} from '@atlaspack/rust';
+import type {
+  Target as ClassicTarget,
+  FilePath,
+  Environment,
+  SourceLocation,
+} from '@atlaspack/types';
+
+export class Target implements ClassicTarget {
+  distEntry: ?FilePath;
+  distDir: FilePath;
+  env: Environment;
+  name: string;
+  publicUrl: string;
+  loc: ?SourceLocation;
+
+  constructor(inner: NapiTarget, env: Environment) {
+    this.distDir = inner.distDir;
+    this.distEntry = inner.distEntry;
+    this.name = inner.name;
+    this.publicUrl = inner.publicUrl;
+    this.loc = inner.loc;
+    this.env = env;
+  }
+}

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

@@ -7,7 +7,6 @@ import type {
   Resolver,
   Transformer,
   PluginOptions,
-  Dependency,
   FilePath,
   FileSystem,
   ConfigResultWithFilePath,
@@ -16,11 +15,10 @@ import type {
 import {workerData} from 'worker_threads';
 import * as module from 'module';
 
-import {AssetCompat} from './compat';
+import {AssetCompat, Environment, Dependency} from './compat';
 import type {InnerAsset} from './compat';
 import {jsCallable} from '../jsCallable';
 import type {JsCallable} from '../jsCallable';
-import Environment from '../../public/Environment';
 
 const CONFIG = Symbol.for('parcel-plugin-config');
 
@@ -67,7 +65,13 @@ export class AtlaspackWorker {
     [RunResolverResolveOptions],
     Promise<RunResolverResolveResult>,
   > = jsCallable(
-    async ({key, dependency, specifier, pipeline, projectRoot}) => {
+    async ({
+      key,
+      dependency: napiDependency,
+      specifier,
+      pipeline,
+      projectRoot,
+    }) => {
       const state = this.#resolvers.get(key);
       if (!state) {
         throw new Error(`Resolver not found: ${key}`);
@@ -79,6 +83,9 @@ export class AtlaspackWorker {
         state.packageManager = packageManager;
       }
 
+      const env = new Environment(napiDependency.env);
+      const dependency = new Dependency(napiDependency, env);
+
       const defaultOptions = {
         get logger() {
           // $FlowFixMe
@@ -132,10 +139,7 @@ export class AtlaspackWorker {
             isSource: true,
             searchPath: '',
             // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
-            env: new Environment(dependency.env, {
-              projectRoot,
-              hmrOptions: undefined,
-            }),
+            env,
             invalidateOnFileChange(): void {},
             invalidateOnFileCreate(): void {},
             invalidateOnEnvChange(): void {},
@@ -280,7 +284,7 @@ type LoadPluginOptions = {|
 
 type RunResolverResolveOptions = {|
   key: string,
-  dependency: Dependency,
+  dependency: napi.Dependency,
   specifier: FilePath,
   pipeline: ?string,
   projectRoot: string,