@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

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

@@ -0,0 +1,9 @@
+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 → mutable-asset.ts}

@@ -1,6 +1,4 @@
-// @flow
-
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import * as napi from '@atlaspack/rust';
 import {Readable} from 'stream';
 import type {
@@ -21,39 +19,43 @@ import type {
 import {bundleBehaviorMap} from './bitflags';
 import {MutableAssetSymbols} from './asset-symbols';
 
+// @ts-expect-error TS2694
 export type InnerAsset = napi.Asset;
 
 export class MutableAsset implements IMutableAsset {
-  bundleBehavior: ?BundleBehavior;
+  bundleBehavior: BundleBehavior | null | undefined;
   env: Environment;
   filePath: FilePath;
   fs: FileSystem;
   id: string;
   isBundleSplittable: boolean;
+  // @ts-expect-error TS2564
   isMapDirty: boolean;
   isSource: boolean;
   meta: Meta;
-  pipeline: ?string;
+  pipeline: string | null | undefined;
   query: URLSearchParams;
   sideEffects: boolean;
   stats: Stats;
+  // @ts-expect-error TS2416
   symbols: MutableAssetSymbols;
   type: string;
-  uniqueKey: ?string;
+  uniqueKey: string | null | undefined;
 
   #astDirty: boolean;
-  #ast: ?AST;
+  #ast: AST | null | undefined;
   #contents: Buffer;
   #inner: InnerAsset;
-  #map: ?string;
+  #map: string | null | undefined;
   #projectRoot: string;
-  #sourceMap: ?SourceMap;
+  #sourceMap: SourceMap | null | undefined;
 
-  get astGenerator(): ?ASTGenerator {
+  get astGenerator(): ASTGenerator | null | undefined {
     throw new Error('get MutableAsset.astGenerator');
   }
 
-  set astGenerator(value: ?ASTGenerator) {
+  // @ts-expect-error TS1051
+  set astGenerator(value?: ASTGenerator | null) {
     throw new Error('set MutableAsset.astGenerator');
   }
 
@@ -62,7 +64,7 @@ export class MutableAsset implements IMutableAsset {
     contents: Buffer,
     env: Environment,
     fs: FileSystem,
-    map: ?string,
+    map: string | null | undefined,
     projectRoot: string,
   ) {
     this.bundleBehavior = bundleBehaviorMap.fromNullable(asset.bundleBehavior);
@@ -89,7 +91,7 @@ export class MutableAsset implements IMutableAsset {
   }
 
   // eslint-disable-next-line require-await
-  async getAST(): Promise<?AST> {
+  async getAST(): Promise<AST | null | undefined> {
     return this.#ast;
   }
 
@@ -125,7 +127,7 @@ export class MutableAsset implements IMutableAsset {
   }
 
   setStream(stream: Readable): void {
-    const data = [];
+    const data: Array<Buffer> = [];
 
     stream.on('data', (chunk) => {
       data.push(chunk);
@@ -140,11 +142,10 @@ export class MutableAsset implements IMutableAsset {
     });
   }
 
-  getMap(): Promise<?SourceMap> {
+  getMap(): Promise<SourceMap | null | undefined> {
     // Only create the source map if it is requested
     if (!this.#sourceMap && this.#map && typeof this.#map === 'string') {
       let sourceMap = new SourceMap(this.#projectRoot);
-      // $FlowFixMe Flow is dumb
       sourceMap.addVLQMap(JSON.parse(this.#map));
       this.#sourceMap = sourceMap;
     }
@@ -153,18 +154,18 @@ export class MutableAsset implements IMutableAsset {
   }
 
   // eslint-disable-next-line no-unused-vars
-  setMap(sourceMap: ?SourceMap): void {
+  setMap(sourceMap?: SourceMap | null): void {
     this.isMapDirty = true;
     this.#sourceMap = sourceMap;
   }
 
-  getMapBuffer(): Promise<?Buffer> {
+  getMapBuffer(): Promise<Buffer | null | undefined> {
     throw new Error(
       'getMapBuffer() is considered an internal implementation detail, please use getMap() instead',
     );
   }
 
-  getDependencies(): $ReadOnlyArray<Dependency> {
+  getDependencies(): ReadonlyArray<Dependency> {
     throw new Error('MutableAsset.getDependencies');
   }
 
@@ -174,7 +175,7 @@ export class MutableAsset implements IMutableAsset {
   }
 
   // eslint-disable-next-line no-unused-vars
-  addURLDependency(url: string, opts: $Shape<DependencyOptions>): string {
+  addURLDependency(url: string, opts: Partial<DependencyOptions>): string {
     throw new Error('MutableAsset.addURLDependency()');
   }
 

package/src/atlaspack-v3/worker/compat/{plugin-config.js → plugin-config.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   Config as IPluginConfig,
   DevDepOptions,
@@ -8,58 +6,25 @@ import type {
   FileCreateInvalidation,
   ConfigResultWithFilePath,
   PackageJSON,
-  PackageManager as IPackageManager,
 } from '@atlaspack/types';
 
-import type {FileSystem as IFileSystem} from '@atlaspack/fs';
 import ClassicPublicConfig from '../../../public/Config';
-
-export type PluginConfigOptions = {|
-  isSource: boolean,
-  searchPath: FilePath,
-  projectRoot: FilePath,
-  env: Environment,
-  fs: IFileSystem,
-  packageManager: IPackageManager,
-|};
+import {type ConfigOpts, createConfig} from '../../../InternalConfig';
 
 export class PluginConfig implements IPluginConfig {
   isSource: boolean;
   searchPath: FilePath;
-  #projectRoot: FilePath;
   env: Environment;
   #inner: ClassicPublicConfig;
 
-  constructor({
-    env,
-    isSource,
-    searchPath,
-    projectRoot,
-    fs,
-    packageManager,
-  }: PluginConfigOptions) {
-    this.env = env;
-    this.isSource = isSource;
-    this.searchPath = searchPath;
+  constructor(configOpts: ConfigOpts, options: any) {
+    let internalConfig = createConfig(configOpts);
 
-    this.#inner = new ClassicPublicConfig(
-      // $FlowFixMe
-      {
-        invalidateOnConfigKeyChange: [],
-        invalidateOnFileCreate: [],
-        invalidateOnFileChange: new Set(),
-        devDeps: [],
-        // $FlowFixMe
-        searchPath: searchPath.replace(projectRoot + '/', ''),
-      },
-      // $FlowFixMe
-      {
-        projectRoot,
-        inputFS: fs,
-        outputFS: fs,
-        packageManager,
-      },
-    );
+    this.isSource = internalConfig.isSource;
+    this.searchPath = internalConfig.searchPath;
+    // @ts-expect-error TS2564
+    this.env = internalConfig.env;
+    this.#inner = new ClassicPublicConfig(internalConfig, options);
   }
 
   // eslint-disable-next-line no-unused-vars
@@ -85,12 +50,12 @@ export class PluginConfig implements IPluginConfig {
     // 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>> {
+    options?: {
+      packageKey?: string;
+      parse?: boolean;
+      exclude?: boolean;
+    },
+  ): Promise<ConfigResultWithFilePath<T> | null | undefined> {
     return this.#inner.getConfig(filePaths, options);
   }
 
@@ -100,16 +65,20 @@ export class PluginConfig implements IPluginConfig {
     // 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>> {
+    options?:
+      | {
+          packageKey?: string;
+          parse?: boolean;
+          exclude?: boolean;
+        }
+      | {
+          readTracking?: boolean;
+        },
+  ): Promise<ConfigResultWithFilePath<T> | null | undefined> {
     return this.#inner.getConfigFrom(searchPath, filePaths, options);
   }
 
-  getPackage(): Promise<?PackageJSON> {
+  getPackage(): Promise<PackageJSON | null | undefined> {
     return this.#inner.getPackage();
   }
 }

package/src/atlaspack-v3/worker/compat/{plugin-logger.js → plugin-logger.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import type {PluginLogger as IPlguinLogger} from '@atlaspack/types';
 import type {
   Diagnostifiable,

package/src/atlaspack-v3/worker/compat/{plugin-options.js → plugin-options.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   PluginOptions as IPluginOptions,
   LogLevel,
@@ -16,6 +14,7 @@ import type {FeatureFlags} from '@atlaspack/feature-flags';
 
 export class PluginOptions implements IPluginOptions {
   #options: IPluginOptions;
+  used = false;
 
   get env(): EnvMap {
     if (!('env' in this.#options)) {
@@ -29,6 +28,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('projectRoot' in this.#options)) {
       throw new Error('PluginOptions.projectRoot');
     }
+    this.used = true;
     return this.#options.projectRoot;
   }
 
@@ -36,6 +36,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('packageManager' in this.#options)) {
       throw new Error('PluginOptions.packageManager');
     }
+    this.used = true;
     return this.#options.packageManager;
   }
 
@@ -43,6 +44,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('mode' in this.#options)) {
       throw new Error('PluginOptions.mode');
     }
+    this.used = true;
     return this.#options.mode;
   }
 
@@ -51,13 +53,15 @@ export class PluginOptions implements IPluginOptions {
       return 'UNKNOWN VERSION';
       // throw new Error('PluginOptions.parcelVersion');
     }
+    this.used = true;
     return this.#options.parcelVersion;
   }
 
-  get hmrOptions(): ?HMROptions {
+  get hmrOptions(): HMROptions | null | undefined {
     if (!('hmrOptions' in this.#options)) {
       throw new Error('PluginOptions.hmrOptions');
     }
+    this.used = true;
     return this.#options.hmrOptions;
   }
 
@@ -65,6 +69,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('serveOptions' in this.#options)) {
       throw new Error('PluginOptions.serveOptions');
     }
+    this.used = true;
     return this.#options.serveOptions;
   }
 
@@ -72,6 +77,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('shouldBuildLazily' in this.#options)) {
       throw new Error('PluginOptions.shouldBuildLazily');
     }
+    this.used = true;
     return this.#options.shouldBuildLazily;
   }
 
@@ -79,6 +85,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('shouldAutoInstall' in this.#options)) {
       throw new Error('PluginOptions.shouldAutoInstall');
     }
+    this.used = true;
     return this.#options.shouldAutoInstall;
   }
 
@@ -93,6 +100,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('cacheDir' in this.#options)) {
       throw new Error('PluginOptions.cacheDir');
     }
+    this.used = true;
     return this.#options.cacheDir;
   }
 
@@ -100,6 +108,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('inputFS' in this.#options)) {
       throw new Error('PluginOptions.inputFS');
     }
+    this.used = true;
     return this.#options.inputFS;
   }
 
@@ -107,6 +116,7 @@ export class PluginOptions implements IPluginOptions {
     if (!('outputFS' in this.#options)) {
       throw new Error('PluginOptions.outputFS');
     }
+    this.used = true;
     return this.#options.outputFS;
   }
 
@@ -114,13 +124,15 @@ export class PluginOptions implements IPluginOptions {
     if (!('instanceId' in this.#options)) {
       throw new Error('PluginOptions.instanceId');
     }
+    this.used = true;
     return this.#options.instanceId;
   }
 
-  get detailedReport(): ?DetailedReportOptions {
+  get detailedReport(): DetailedReportOptions | null | undefined {
     if (!('detailedReport' in this.#options)) {
       throw new Error('PluginOptions.detailedReport');
     }
+    this.used = true;
     return this.#options.detailedReport;
   }
 
@@ -128,10 +140,12 @@ export class PluginOptions implements IPluginOptions {
     if (!('featureFlags' in this.#options)) {
       throw new Error('PluginOptions.featureFlags');
     }
+    this.used = true;
     return this.#options.featureFlags;
   }
 
-  constructor(options: $Partial<IPluginOptions>) {
+  constructor(options: Partial<IPluginOptions>) {
+    // @ts-expect-error TS2322
     this.#options = options;
   }
 }

package/src/atlaspack-v3/worker/compat/{plugin-tracer.js → plugin-tracer.ts}

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

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

@@ -1,5 +1,4 @@
-// @flow
-
+// @ts-expect-error TS2305
 import type {Target as NapiTarget} from '@atlaspack/rust';
 import type {
   Target as ITarget,
@@ -9,12 +8,12 @@ import type {
 } from '@atlaspack/types';
 
 export class Target implements ITarget {
-  distEntry: ?FilePath;
+  distEntry: FilePath | null | undefined;
   distDir: FilePath;
   env: Environment;
   name: string;
   publicUrl: string;
-  loc: ?SourceLocation;
+  loc: SourceLocation | null | undefined;
 
   constructor(inner: NapiTarget, env: Environment) {
     this.distDir = inner.distDir;

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

@@ -1,5 +1,6 @@
 if (
-  process.env.ATLASPACK_BUILD_ENV !== 'production' ||
+  process.env.ATLASPACK_SOURCES === 'true' ||
+  process.env.ATLASPACK_BUILD_ENV === 'test' ||
   process.env.ATLASPACK_SELF_BUILD
 ) {
   require('@atlaspack/babel-register');