@atlaspack/core 2.12.1-dev.3450 → 2.12.1-dev.3466

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';

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

@@ -0,0 +1,184 @@
+// @flow
+
+import type SourceMap from '@parcel/source-map';
+import * as napi from '@atlaspack/rust';
+import {Readable} from 'stream';
+import type {
+  MutableAsset as IMutableAsset,
+  Stats,
+  FileSystem,
+  FilePath,
+  Environment,
+  Meta,
+  BundleBehavior,
+  ASTGenerator,
+  AST,
+  Dependency,
+  DependencyOptions,
+  FileCreateInvalidation,
+  EnvironmentOptions,
+} from '@atlaspack/types';
+import {bundleBehaviorMap} from './bitflags';
+import {MutableAssetSymbols} from './asset-symbols';
+
+export type InnerAsset = napi.Asset;
+
+export class MutableAsset implements IMutableAsset {
+  fs: FileSystem;
+  env: Environment;
+  symbols: MutableAssetSymbols;
+  stats: Stats;
+  id: string;
+  filePath: FilePath;
+  type: string;
+  query: URLSearchParams;
+  isSource: boolean;
+  meta: Meta;
+  bundleBehavior: ?BundleBehavior;
+  isBundleSplittable: boolean;
+  sideEffects: boolean;
+  uniqueKey: ?string;
+  pipeline: ?string;
+
+  #inner: InnerAsset;
+  #ast: ?AST;
+  #contents: Buffer;
+
+  get astGenerator(): ?ASTGenerator {
+    throw new Error('get MutableAsset.astGenerator');
+  }
+
+  set astGenerator(value: ?ASTGenerator) {
+    throw new Error('set MutableAsset.astGenerator');
+  }
+
+  constructor(asset: InnerAsset, fs: FileSystem, env: Environment) {
+    this.#inner = asset;
+    this.stats = asset.stats;
+    this.id = asset.id;
+    this.filePath = asset.filePath;
+    this.type;
+    this.symbols = new MutableAssetSymbols(asset.symbols);
+    this.stats = asset.stats;
+    this.id = asset.id;
+    this.filePath = asset.filePath;
+    this.type = asset.type;
+    this.query = new URLSearchParams(asset.query);
+    this.isSource = asset.isSource;
+    this.meta = asset.meta;
+    this.bundleBehavior = bundleBehaviorMap.fromNullable(asset.bundleBehavior);
+    this.isBundleSplittable = asset.isBundleSplittable;
+    this.sideEffects = asset.sideEffects;
+    this.uniqueKey = asset.uniqueKey;
+    this.pipeline = asset.pipeline;
+    this.#contents = Buffer.from(asset.code);
+    this.fs = fs;
+    this.env = env;
+  }
+
+  // eslint-disable-next-line require-await
+  async getAST(): Promise<?AST> {
+    return this.#ast;
+  }
+
+  setAST(ast: AST): void {
+    this.#ast = ast;
+  }
+
+  isASTDirty(): boolean {
+    throw new Error('MutableAsset.isASTDirty()');
+  }
+
+  // eslint-disable-next-line require-await
+  async getCode(): Promise<string> {
+    return this.#contents.toString();
+  }
+
+  setCode(code: string): void {
+    this.#contents = Buffer.from(code);
+  }
+
+  // eslint-disable-next-line require-await
+  async getBuffer(): Promise<Buffer> {
+    return this.#contents;
+  }
+
+  setBuffer(buf: Buffer): void {
+    this.#contents = buf;
+  }
+
+  getStream(): Readable {
+    return Readable.from(this.#contents);
+  }
+
+  setStream(stream: Readable): void {
+    const data = [];
+
+    stream.on('data', (chunk) => {
+      data.push(chunk);
+    });
+
+    stream.on('end', () => {
+      this.#contents = Buffer.concat(data);
+    });
+
+    stream.on('error', () => {
+      throw new Error('MutableAsset.setStream()');
+    });
+  }
+
+  getMap(): Promise<?SourceMap> {
+    throw new Error('MutableAsset.getMap');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setMap(sourceMap: ?SourceMap): void {
+    throw new Error('MutableAsset.setMap()');
+  }
+
+  getMapBuffer(): Promise<?Buffer> {
+    throw new Error('MutableAsset.getMapBuffer');
+  }
+
+  getDependencies(): $ReadOnlyArray<Dependency> {
+    throw new Error('MutableAsset.getDependencies');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addDependency(options: DependencyOptions): string {
+    throw new Error('MutableAsset.addDependency()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addURLDependency(url: string, opts: $Shape<DependencyOptions>): string {
+    throw new Error('MutableAsset.addURLDependency()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setEnvironment(opts: EnvironmentOptions): void {
+    throw new Error('MutableAsset.setEnvironment()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileChange(invalidation: FilePath): void {
+    throw new Error('MutableAsset.invalidateOnFileChange()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileCreate(invalidation: FileCreateInvalidation): void {
+    throw new Error('MutableAsset.invalidateOnFileCreate()');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnEnvChange(invalidation: string): void {
+    throw new Error('MutableAsset.invalidateOnEnvChange()');
+  }
+
+  invalidateOnStartup(): void {
+    throw new Error('MutableAsset.invalidateOnStartup()');
+  }
+
+  invalidateOnBuild(): void {
+    throw new Error('MutableAsset.invalidateOnBuild()');
+  }
+}