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

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()');
+  }
+}

package/src/atlaspack-v3/worker/compat/plugin-config.js

@@ -0,0 +1,94 @@
+// @flow
+
+import type {
+  Config as IPluginConfig,
+  DevDepOptions,
+  FilePath,
+  Environment,
+  FileCreateInvalidation,
+  ConfigResultWithFilePath,
+  PackageJSON,
+} from '@atlaspack/types';
+
+export type PluginConfigOptions = {|
+  isSource: boolean,
+  searchPath: FilePath,
+  env: Environment,
+|};
+
+export class PluginConfig implements IPluginConfig {
+  isSource: boolean;
+  searchPath: FilePath;
+  env: Environment;
+
+  constructor({env, isSource, searchPath}: PluginConfigOptions) {
+    this.env = env;
+    this.isSource = isSource;
+    this.searchPath = searchPath;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileChange(filePath: FilePath): void {
+    throw new Error('PluginOptions.invalidateOnFileChange');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnFileCreate(invalidations: FileCreateInvalidation): void {
+    throw new Error('PluginOptions.invalidateOnFileCreate');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  invalidateOnEnvChange(invalidation: string): void {
+    throw new Error('PluginOptions.invalidateOnEnvChange');
+  }
+
+  invalidateOnStartup(): void {
+    throw new Error('PluginOptions.invalidateOnStartup');
+  }
+
+  invalidateOnBuild(): void {
+    throw new Error('PluginOptions.invalidateOnBuild');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  addDevDependency(options: DevDepOptions): void {
+    throw new Error('PluginOptions.addDevDependency');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  setCacheKey(key: string): void {
+    throw new Error('PluginOptions.setCacheKey');
+  }
+
+  getConfig<T>(
+    // eslint-disable-next-line no-unused-vars
+    filePaths: Array<FilePath>,
+    // eslint-disable-next-line no-unused-vars
+    options?: {|
+      packageKey?: string,
+      parse?: boolean,
+      exclude?: boolean,
+    |},
+  ): Promise<?ConfigResultWithFilePath<T>> {
+    throw new Error('PluginOptions.getConfig');
+  }
+
+  getConfigFrom<T>(
+    // eslint-disable-next-line no-unused-vars
+    searchPath: FilePath,
+    // eslint-disable-next-line no-unused-vars
+    filePaths: Array<FilePath>,
+    // eslint-disable-next-line no-unused-vars
+    options?: {|
+      packageKey?: string,
+      parse?: boolean,
+      exclude?: boolean,
+    |},
+  ): Promise<?ConfigResultWithFilePath<T>> {
+    throw new Error('PluginOptions.getConfigFrom');
+  }
+
+  getPackage(): Promise<?PackageJSON> {
+    throw new Error('PluginOptions.getPackage');
+  }
+}

package/src/atlaspack-v3/worker/compat/plugin-logger.js

@@ -0,0 +1,47 @@
+// @flow
+
+import type {PluginLogger as IPlguinLogger} from '@atlaspack/types';
+import type {
+  Diagnostifiable,
+  DiagnosticWithoutOrigin,
+} from '@atlaspack/diagnostic';
+
+export class PluginLogger implements IPlguinLogger {
+  verbose(
+    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
+  ): void {
+    // eslint-disable-next-line no-console
+    console.log(diagnostic);
+  }
+
+  info(
+    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
+  ): void {
+    // eslint-disable-next-line no-console
+    console.info(diagnostic);
+  }
+
+  log(
+    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
+  ): void {
+    // eslint-disable-next-line no-console
+    console.log(diagnostic);
+  }
+
+  warn(
+    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
+  ): void {
+    // eslint-disable-next-line no-console
+    console.warn(diagnostic);
+  }
+
+  error(
+    input:
+      | Diagnostifiable
+      | DiagnosticWithoutOrigin
+      | Array<DiagnosticWithoutOrigin>,
+  ): void {
+    // eslint-disable-next-line no-console
+    console.error(input);
+  }
+}

package/src/atlaspack-v3/worker/compat/plugin-options.js

@@ -0,0 +1,137 @@
+// @flow
+
+import type {
+  PluginOptions as IPluginOptions,
+  LogLevel,
+  FileSystem,
+  PackageManager,
+  EnvMap,
+  FilePath,
+  HMROptions,
+  ServerOptions,
+  DetailedReportOptions,
+  BuildMode,
+} from '@atlaspack/types';
+import type {FeatureFlags} from '@atlaspack/feature-flags';
+
+export class PluginOptions implements IPluginOptions {
+  #options: IPluginOptions;
+
+  get env(): EnvMap {
+    if (!('env' in this.#options)) {
+      return process.env;
+      // throw new Error('PluginOptions.env');
+    }
+    return this.#options.env;
+  }
+
+  get projectRoot(): FilePath {
+    if (!('projectRoot' in this.#options)) {
+      throw new Error('PluginOptions.projectRoot');
+    }
+    return this.#options.projectRoot;
+  }
+
+  get packageManager(): PackageManager {
+    if (!('packageManager' in this.#options)) {
+      throw new Error('PluginOptions.packageManager');
+    }
+    return this.#options.packageManager;
+  }
+
+  get mode(): BuildMode {
+    if (!('mode' in this.#options)) {
+      throw new Error('PluginOptions.mode');
+    }
+    return this.#options.mode;
+  }
+
+  get parcelVersion(): string {
+    if (!('parcelVersion' in this.#options)) {
+      return 'UNKNOWN VERSION';
+      // throw new Error('PluginOptions.parcelVersion');
+    }
+    return this.#options.parcelVersion;
+  }
+
+  get hmrOptions(): ?HMROptions {
+    if (!('hmrOptions' in this.#options)) {
+      throw new Error('PluginOptions.hmrOptions');
+    }
+    return this.#options.hmrOptions;
+  }
+
+  get serveOptions(): ServerOptions | false {
+    if (!('serveOptions' in this.#options)) {
+      throw new Error('PluginOptions.serveOptions');
+    }
+    return this.#options.serveOptions;
+  }
+
+  get shouldBuildLazily(): boolean {
+    if (!('shouldBuildLazily' in this.#options)) {
+      throw new Error('PluginOptions.shouldBuildLazily');
+    }
+    return this.#options.shouldBuildLazily;
+  }
+
+  get shouldAutoInstall(): boolean {
+    if (!('shouldAutoInstall' in this.#options)) {
+      throw new Error('PluginOptions.shouldAutoInstall');
+    }
+    return this.#options.shouldAutoInstall;
+  }
+
+  get logLevel(): LogLevel {
+    if (!('logLevel' in this.#options)) {
+      throw new Error('PluginOptions.logLevel');
+    }
+    return this.#options.logLevel;
+  }
+
+  get cacheDir(): string {
+    if (!('cacheDir' in this.#options)) {
+      throw new Error('PluginOptions.cacheDir');
+    }
+    return this.#options.cacheDir;
+  }
+
+  get inputFS(): FileSystem {
+    if (!('inputFS' in this.#options)) {
+      throw new Error('PluginOptions.inputFS');
+    }
+    return this.#options.inputFS;
+  }
+
+  get outputFS(): FileSystem {
+    if (!('outputFS' in this.#options)) {
+      throw new Error('PluginOptions.outputFS');
+    }
+    return this.#options.outputFS;
+  }
+
+  get instanceId(): string {
+    if (!('instanceId' in this.#options)) {
+      throw new Error('PluginOptions.instanceId');
+    }
+    return this.#options.instanceId;
+  }
+
+  get detailedReport(): ?DetailedReportOptions {
+    if (!('detailedReport' in this.#options)) {
+      throw new Error('PluginOptions.detailedReport');
+    }
+    return this.#options.detailedReport;
+  }
+
+  get featureFlags(): FeatureFlags {
+    if (!('featureFlags' in this.#options)) {
+      throw new Error('PluginOptions.featureFlags');
+    }
+    return this.#options.featureFlags;
+  }
+
+  constructor(options: $Partial<IPluginOptions>) {
+    this.#options = options;
+  }
+}

package/src/atlaspack-v3/worker/compat/plugin-tracer.js

@@ -0,0 +1,11 @@
+// @flow
+
+import type {PluginTracer as IPluginTracer} from '@atlaspack/types';
+
+export class PluginTracer implements IPluginTracer {
+  enabled: false;
+
+  createMeasurement() {
+    throw new Error('PluginTracer.createMeasurement');
+  }
+}

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;
+  }
+}