@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

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

@@ -1,5 +1,4 @@
-// @flow
-
+// @ts-expect-error TS2305
 import type {Dependency as NapiDependency} from '@atlaspack/rust';
 import type {
   Dependency as IDependency,
@@ -27,23 +26,23 @@ import {
 export class Dependency implements IDependency {
   env: IEnvironment;
   meta: Meta;
-  target: ?ITarget;
+  target: ITarget | null | undefined;
   symbols: IMutableDependencySymbols;
   specifier: DependencySpecifier;
   specifierType: SpecifierType;
   priority: DependencyPriority;
-  bundleBehavior: ?BundleBehavior;
+  bundleBehavior: BundleBehavior | null | undefined;
   needsStableName: boolean;
   isOptional: boolean;
   isEntry: boolean;
-  loc: ?SourceLocation;
-  packageConditions: ?Array<string>;
-  sourceAssetId: ?string;
-  sourcePath: ?FilePath;
-  sourceAssetType: ?string;
-  resolveFrom: ?FilePath;
-  range: ?SemverRange;
-  pipeline: ?string;
+  loc: SourceLocation | null | undefined;
+  packageConditions: Array<string> | null | undefined;
+  sourceAssetId: string | null | undefined;
+  sourcePath: FilePath | null | undefined;
+  sourceAssetType: string | null | undefined;
+  resolveFrom: FilePath | null | undefined;
+  range: SemverRange | null | undefined;
+  pipeline: string | null | undefined;
 
   get id(): string {
     throw new Error('Dependency.id');
@@ -62,6 +61,7 @@ export class Dependency implements IDependency {
       this.bundleBehavior = bundleBehaviorMap.from(inner.bundleBehavior);
     }
     this.bundleBehavior = undefined;
+    // @ts-expect-error TS2322
     this.symbols = new MutableDependencySymbols(inner.symbols || []);
     this.specifier = inner.specifier;
     this.specifierType = specifierTypeMap.from(inner.specifierType);
@@ -70,7 +70,7 @@ export class Dependency implements IDependency {
     this.isOptional = inner.isOptional;
     this.isEntry = inner.isEntry;
     this.loc = inner.loc;
-    this.packageConditions = packageConditionsMap.fromArray(
+    this.packageConditions = packageConditionsMap.toArray(
       inner.packageConditions || [],
     );
     this.sourceAssetId = inner.sourceAssetId;

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

@@ -1,5 +1,4 @@
-// @flow
-
+// @ts-expect-error TS2724
 import type {Environment as NapiEnvironment} from '@atlaspack/rust';
 import type {
   Environment as IEnvironment,
@@ -12,6 +11,7 @@ import type {
   SourceLocation,
   VersionMap,
   EnvironmentFeature,
+  EnvMap,
 } from '@atlaspack/types';
 
 export class Environment implements IEnvironment {
@@ -19,7 +19,7 @@ export class Environment implements IEnvironment {
   includeNodeModules:
     | boolean
     | Array<PackageName>
-    | {[PackageName]: boolean, ...};
+    | Partial<Record<PackageName, boolean>>;
   context: EnvironmentContext;
   engines: Engines;
   outputFormat: OutputFormat;
@@ -27,20 +27,18 @@ export class Environment implements IEnvironment {
   isLibrary: boolean;
   shouldOptimize: boolean;
   shouldScopeHoist: boolean;
-  sourceMap: ?TargetSourceMapOptions;
-  loc: ?SourceLocation;
+  sourceMap: TargetSourceMapOptions | null | undefined;
+  loc: SourceLocation | null | undefined;
   unstableSingleFileOutput: boolean;
+  customEnv: EnvMap | null | undefined;
 
   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;
@@ -48,12 +46,14 @@ export class Environment implements IEnvironment {
     this.sourceMap = inner.sourceMap;
     this.loc = inner.loc;
     this.unstableSingleFileOutput = false;
+    this.customEnv = inner.customEnv;
   }
 
   isBrowser(): boolean {
     return (
       this.context === 'browser' ||
       this.isWorker() ||
+      this.isTesseract() ||
       this.isWorklet() ||
       this.context === 'electron-renderer'
     );
@@ -77,8 +77,12 @@ export class Environment implements IEnvironment {
     return this.context === 'worklet';
   }
 
+  isTesseract(): boolean {
+    return this.context === 'tesseract';
+  }
+
   isIsolated(): boolean {
-    return this.isWorker() || this.isWorklet();
+    return this.isWorker() || this.isTesseract() || this.isWorklet();
   }
 
   // TODO

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

@@ -0,0 +1,8 @@
+export * from './bitflags';
+export * from './dependency';
+export * from './environment';
+export * from './target';
+export * from './plugin-config';
+export * from './plugin-tracer';
+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-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');