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

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