@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   BundleBehavior,
   DependencyPriority,
@@ -8,13 +6,15 @@ import type {
 
 /// BitFlags is used to map number/string types from napi types
 export class BitFlags<K, V> {
-  #kv: {[key: K]: V};
-  #vk: {[key: V]: K};
+  // @ts-expect-error TS2344
+  #kv: Partial<Record<K, V>>;
+  // @ts-expect-error TS2344
+  #vk: Partial<Record<V, K>>;
 
-  constructor(source: {[key: K]: V}) {
+  // @ts-expect-error TS2344
+  constructor(source: Partial<Record<K, V>>) {
     this.#kv = source;
     this.#vk = Object.fromEntries(
-      // $FlowFixMe
       Object.entries(source).map((a) => a.reverse()),
     );
   }
@@ -22,13 +22,12 @@ export class BitFlags<K, V> {
   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 {
+  intoNullable(key?: K | null): V | null | undefined {
     if (key === undefined || key === null) {
       return undefined;
     }
@@ -42,13 +41,12 @@ export class BitFlags<K, V> {
   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 {
+  fromNullable(key?: V | null): K | null | undefined {
     if (key === undefined || key === null) {
       return undefined;
     }
@@ -64,6 +62,7 @@ export const bundleBehaviorMap: BitFlags<BundleBehavior, number> = new BitFlags(
   {
     inline: 0,
     isolated: 1,
+    inlineIsolated: 2,
   },
 );
 

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

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,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,5 +1,3 @@
-// @flow
-
 import SourceMap from '@parcel/source-map';
 import * as napi from '@atlaspack/rust';
 import {Readable} from 'stream';
@@ -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,
@@ -14,18 +12,19 @@ import type {
 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,
-|};
+export type PluginConfigOptions = {
+  isSource: boolean;
+  searchPath: FilePath;
+  projectRoot: FilePath;
+  env: Environment;
+  fs: IFileSystem;
+  packageManager: IPackageManager;
+};
 
 export class PluginConfig implements IPluginConfig {
   isSource: boolean;
   searchPath: FilePath;
+  // @ts-expect-error TS2564
   #projectRoot: FilePath;
   env: Environment;
   #inner: ClassicPublicConfig;
@@ -43,16 +42,14 @@ export class PluginConfig implements IPluginConfig {
     this.searchPath = searchPath;
 
     this.#inner = new ClassicPublicConfig(
-      // $FlowFixMe
+      // @ts-expect-error TS2345
       {
         invalidateOnConfigKeyChange: [],
         invalidateOnFileCreate: [],
         invalidateOnFileChange: new Set(),
         devDeps: [],
-        // $FlowFixMe
         searchPath: searchPath.replace(projectRoot + '/', ''),
       },
-      // $FlowFixMe
       {
         projectRoot,
         inputFS: fs,
@@ -85,12 +82,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 +97,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,
@@ -54,7 +52,7 @@ export class PluginOptions implements IPluginOptions {
     return this.#options.parcelVersion;
   }
 
-  get hmrOptions(): ?HMROptions {
+  get hmrOptions(): HMROptions | null | undefined {
     if (!('hmrOptions' in this.#options)) {
       throw new Error('PluginOptions.hmrOptions');
     }
@@ -117,7 +115,7 @@ export class PluginOptions implements IPluginOptions {
     return this.#options.instanceId;
   }
 
-  get detailedReport(): ?DetailedReportOptions {
+  get detailedReport(): DetailedReportOptions | null | undefined {
     if (!('detailedReport' in this.#options)) {
       throw new Error('PluginOptions.detailedReport');
     }
@@ -131,7 +129,8 @@ export class PluginOptions implements IPluginOptions {
     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');