@atlaspack/core 2.12.1-dev.3443 → 2.12.1-dev.3460

package/src/atlaspack-v3/fs.js

@@ -1,6 +1,6 @@
 // @flow strict-local
 
-import type {FileSystem} from '@atlaspack/rust';
+import type {FileSystem, JsCallable} from '@atlaspack/rust';
 import type {
   Encoding,
   FilePath,
@@ -9,33 +9,47 @@ import type {
 
 import {jsCallable} from './jsCallable';
 
-// Move to @atlaspack/utils or a dedicated v3 / migration package later
-export function toFileSystemV3(fs: ClassicFileSystem): FileSystem {
-  return {
-    canonicalize: jsCallable((path: FilePath) => fs.realpathSync(path)),
-    createDirectory: jsCallable((path: FilePath) => fs.mkdirp(path)),
-    cwd: jsCallable(() => fs.cwd()),
-    readFile: jsCallable((path: string, encoding?: Encoding) => {
+export class FileSystemV3 implements FileSystem {
+  #fs: ClassicFileSystem;
+
+  constructor(fs: ClassicFileSystem) {
+    this.#fs = fs;
+  }
+
+  canonicalize: JsCallable<[FilePath], FilePath> = jsCallable(
+    (path: FilePath) => this.#fs.realpathSync(path),
+  );
+
+  createDirectory: JsCallable<[FilePath], Promise<void>> = jsCallable(
+    (path: FilePath) => this.#fs.mkdirp(path),
+  );
+
+  cwd: JsCallable<[], FilePath> = jsCallable(() => this.#fs.cwd());
+
+  isFile: JsCallable<[FilePath], boolean> = (path: string) => {
+    try {
+      return this.#fs.statSync(path).isFile();
+    } catch {
+      return false;
+    }
+  };
+
+  isDir: JsCallable<[FilePath], boolean> = (path: string) => {
+    try {
+      return this.#fs.statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  };
+
+  readFile: JsCallable<[FilePath, Encoding], string> = jsCallable(
+    (path: string, encoding?: Encoding) => {
       if (!encoding) {
         // $FlowFixMe
-        return [...fs.readFileSync(path)];
+        return [...this.#fs.readFileSync(path)];
       } else {
-        return fs.readFileSync(path, encoding);
-      }
-    }),
-    isFile: (path: string) => {
-      try {
-        return fs.statSync(path).isFile();
-      } catch {
-        return false;
+        return this.#fs.readFileSync(path, encoding);
       }
     },
-    isDir: (path: string) => {
-      try {
-        return fs.statSync(path).isDirectory();
-      } catch {
-        return false;
-      }
-    },
-  };
+  );
 }

package/src/atlaspack-v3/index.js

@@ -1,5 +1,5 @@
 // @flow
 
-export {toFileSystemV3} from './fs';
+export {FileSystemV3} from './fs';
 export {AtlaspackV3} from './AtlaspackV3';
 export type * from './AtlaspackV3';

package/src/atlaspack-v3/jsCallable.js

@@ -1,17 +1,18 @@
 // @flow strict-local
 
-export type JsCallable<Args: $ReadOnlyArray<mixed>, Return> = (
-  ...Args
-) => Return;
-
 export function jsCallable<Args: $ReadOnlyArray<mixed>, Return>(
-  fn: (...Args) => Return,
-): (...Args) => Return {
-  return (...args: Args) => {
+  fn: (...Args) => Return | Promise<Return>,
+): (...Args) => Promise<Return> {
+  return async (...args: Args): Promise<Return> => {
     try {
-      return fn(...args);
-    } catch (err) {
-      return err;
+      // $FlowFixMe "await" is needed to log the error from
+      // Promises and is safe to use on non-promises
+      return await fn(...args);
+      // $FlowFixMe
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+      throw error;
     }
   };
 }

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

@@ -0,0 +1,225 @@
+// @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[]) | null) {
+    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();
+  }
+}
+
+export class AssetSymbols implements ClassicAssetSymbols {
+  #symbols: Map<Symbol, AssetSymbol>;
+  #locals: Set<Symbol>;
+
+  get isCleared(): boolean {
+    return this.#symbols.size === 0;
+  }
+
+  constructor(inner: ?(NapiSymbol[]) | null) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {exported, local, loc} of inner || []) {
+      this.#set(exported, local, loc);
+    }
+  }
+
+  #set(exportSymbol: Symbol, local: Symbol, loc: ?SourceLocation): void {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {},
+    });
+  }
+
+  get(exportSymbol: Symbol): ?AssetSymbol {
+    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();
+  }
+
+  intoNapi(): NapiSymbol[] {
+    return [];
+  }
+
+  /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
+
+export class MutableAssetSymbols implements ClassicMutableAssetSymbols {
+  #symbols: Map<Symbol, AssetSymbol>;
+  #locals: Set<Symbol>;
+
+  get isCleared(): boolean {
+    return this.#symbols.size === 0;
+  }
+
+  constructor(inner: ?(NapiSymbol[]) | null) {
+    this.#symbols = new Map();
+    this.#locals = new Set();
+    for (const {exported, local, loc} of inner || []) {
+      this.set(exported, local, loc);
+    }
+  }
+
+  intoNapi(): NapiSymbol[] {
+    const results: NapiSymbol[] = [];
+    for (const [exportSymbol, {local, loc}] of this.#symbols.entries()) {
+      results.push({
+        exported: exportSymbol,
+        local,
+        loc: loc
+          ? {
+              filePath: loc.filePath,
+              start: {
+                line: loc.start.line,
+                column: loc.start.column,
+              },
+              end: {
+                line: loc.end.line,
+                column: loc.end.column,
+              },
+            }
+          : undefined,
+        // TODO
+        isWeak: false,
+        isEsmExport: false,
+        selfReferenced: false,
+      });
+    }
+    return results;
+  }
+
+  ensure(): void {
+    throw new Error('MutableAssetSymbols.ensure()');
+  }
+
+  set(exportSymbol: Symbol, local: Symbol, loc: ?SourceLocation): void {
+    this.#locals.add(local);
+    this.#symbols.set(exportSymbol, {
+      local,
+      loc,
+      meta: {},
+    });
+  }
+
+  get(exportSymbol: Symbol): ?AssetSymbol {
+    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();
+  }
+
+  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, AssetSymbol]> { return ({}: any); } */
+  // $FlowFixMe Flow can't do computed properties
+  [Symbol.iterator]() {
+    return this.#symbols.values();
+  }
+}
+
+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,100 @@
+// @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;
+  }
+
+  intoNullable(key: ?K): ?V {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.into(key);
+  }
+
+  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;
+  }
+
+  fromNullable(key: ?V): ?K {
+    if (key === undefined || key === null) {
+      return undefined;
+    }
+    return this.from(key);
+  }
+
+  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,10 @@
+// @flow
+export * from './bitflags';
+export * from './dependency';
+export * from './environment';
+export * from './target';
+export * from './plugin-config';
+export * from './plugin-tracer';
+export * from './plugin-logger';
+export * from './plugin-options';
+export * from './mutable-asset';