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

package/src/public/{Symbols.js → Symbols.ts}

@@ -1,4 +1,3 @@
-// @flow
 import type {
   Symbol as ISymbol,
   MutableAssetSymbols as IMutableAssetSymbols,
@@ -16,13 +15,13 @@ const EMPTY_ITERABLE = {
   [Symbol.iterator]() {
     return EMPTY_ITERATOR;
   },
-};
+} as const;
 
 const EMPTY_ITERATOR = {
   next() {
     return {done: true};
   },
-};
+} as const;
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -31,10 +30,12 @@ export class AssetSymbols implements IAssetSymbols {
   /*::
   @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
   */
+  // @ts-expect-error TS2564
   #value: Asset;
+  // @ts-expect-error TS2564
   #options: AtlaspackOptions;
 
-  constructor(options: AtlaspackOptions, asset: Asset): AssetSymbols {
+  constructor(options: AtlaspackOptions, asset: Asset) {
     let existing = valueToSymbols.get(asset);
     if (existing != null) {
       return existing;
@@ -60,9 +61,14 @@ export class AssetSymbols implements IAssetSymbols {
     return false;
   }
 
-  get(
-    exportSymbol: ISymbol,
-  ): ?{|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|} {
+  get(exportSymbol: ISymbol):
+    | {
+        local: ISymbol;
+        loc: SourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+      }
+    | null
+    | undefined {
     return fromInternalAssetSymbol(
       this.#options.projectRoot,
       this.#value.symbols?.get(exportSymbol),
@@ -76,19 +82,18 @@ export class AssetSymbols implements IAssetSymbols {
   exportSymbols(): Iterable<ISymbol> {
     return this.#value.symbols?.keys() ?? [];
   }
-  // $FlowFixMe
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#value.symbols
       ? this.#value.symbols[Symbol.iterator]()
       : EMPTY_ITERATOR;
   }
 
-  // $FlowFixMe
   [inspect]() {
     return `AssetSymbols(${
       this.#value.symbols
         ? [...this.#value.symbols]
-            .map(([s, {local}]) => `${s}:${local}`)
+            .map(([s, {local}]: [any, any]) => `${s}:${local}`)
             .join(', ')
         : null
     })`;
@@ -101,10 +106,12 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
   /*::
   @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
   */
+  // @ts-expect-error TS2564
   #value: Asset;
+  // @ts-expect-error TS2564
   #options: AtlaspackOptions;
 
-  constructor(options: AtlaspackOptions, asset: Asset): MutableAssetSymbols {
+  constructor(options: AtlaspackOptions, asset: Asset) {
     let existing = valueToMutableAssetSymbols.get(asset);
     if (existing != null) {
       return existing;
@@ -130,9 +137,14 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
     return false;
   }
 
-  get(
-    exportSymbol: ISymbol,
-  ): ?{|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|} {
+  get(exportSymbol: ISymbol):
+    | {
+        local: ISymbol;
+        loc: SourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+      }
+    | null
+    | undefined {
     return fromInternalAssetSymbol(
       this.#options.projectRoot,
       this.#value.symbols?.get(exportSymbol),
@@ -144,22 +156,21 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
   }
 
   exportSymbols(): Iterable<ISymbol> {
-    // $FlowFixMe
+    // @ts-expect-error TS2322
     return this.#value.symbols.keys();
   }
-  // $FlowFixMe
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#value.symbols
       ? this.#value.symbols[Symbol.iterator]()
       : EMPTY_ITERATOR;
   }
 
-  // $FlowFixMe
   [inspect]() {
     return `MutableAssetSymbols(${
       this.#value.symbols
         ? [...this.#value.symbols]
-            .map(([s, {local}]) => `${s}:${local}`)
+            .map(([s, {local}]: [any, any]) => `${s}:${local}`)
             .join(', ')
         : null
     })`;
@@ -176,8 +187,8 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
   set(
     exportSymbol: ISymbol,
     local: ISymbol,
-    loc: ?SourceLocation,
-    meta: ?Meta,
+    loc?: SourceLocation | null,
+    meta?: Meta | null,
   ) {
     nullthrows(this.#value.symbols).set(exportSymbol, {
       local,
@@ -193,19 +204,18 @@ export class MutableAssetSymbols implements IMutableAssetSymbols {
 
 let valueToMutableDependencySymbols: WeakMap<
   Dependency,
-  MutableDependencySymbols,
+  MutableDependencySymbols
 > = new WeakMap();
 export class MutableDependencySymbols implements IMutableDependencySymbols {
   /*::
   @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|}]> { return ({}: any); }
   */
+  // @ts-expect-error TS2564
   #value: Dependency;
+  // @ts-expect-error TS2564
   #options: AtlaspackOptions;
 
-  constructor(
-    options: AtlaspackOptions,
-    dep: Dependency,
-  ): MutableDependencySymbols {
+  constructor(options: AtlaspackOptions, dep: Dependency) {
     let existing = valueToMutableDependencySymbols.get(dep);
     if (existing != null) {
       return existing;
@@ -230,9 +240,15 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
     return false;
   }
 
-  get(
-    exportSymbol: ISymbol,
-  ): ?{|local: ISymbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|} {
+  get(exportSymbol: ISymbol):
+    | {
+        local: ISymbol;
+        loc: SourceLocation | null | undefined;
+        isWeak: boolean;
+        meta?: Meta | null | undefined;
+      }
+    | null
+    | undefined {
     return fromInternalDependencySymbol(
       this.#options.projectRoot,
       nullthrows(this.#value.symbols).get(exportSymbol),
@@ -244,23 +260,25 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
   }
 
   exportSymbols(): Iterable<ISymbol> {
-    // $FlowFixMe
+    // @ts-expect-error TS2322
     return this.#value.symbols ? this.#value.symbols.keys() : EMPTY_ITERABLE;
   }
 
-  // $FlowFixMe
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#value.symbols
       ? this.#value.symbols[Symbol.iterator]()
       : EMPTY_ITERATOR;
   }
 
-  // $FlowFixMe
   [inspect]() {
     return `MutableDependencySymbols(${
       this.#value.symbols
         ? [...this.#value.symbols]
-            .map(([s, {local, isWeak}]) => `${s}:${local}${isWeak ? '?' : ''}`)
+            .map(
+              ([s, {local, isWeak}]: [any, any]) =>
+                `${s}:${local}${isWeak ? '?' : ''}`,
+            )
             .join(', ')
         : null
     })`;
@@ -277,8 +295,8 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
   set(
     exportSymbol: ISymbol,
     local: ISymbol,
-    loc: ?SourceLocation,
-    isWeak: ?boolean,
+    loc?: SourceLocation | null,
+    isWeak?: boolean | null,
   ) {
     let symbols = nullthrows(this.#value.symbols);
     symbols.set(exportSymbol, {
@@ -293,7 +311,17 @@ export class MutableDependencySymbols implements IMutableDependencySymbols {
   }
 }
 
-function fromInternalAssetSymbol(projectRoot: string, value) {
+function fromInternalAssetSymbol(
+  projectRoot: string,
+  value:
+    | undefined
+    | {
+        // @ts-expect-error TS2304
+        loc: InternalSourceLocation | null | undefined;
+        local: ISymbol;
+        meta?: Meta | null | undefined;
+      },
+) {
   return (
     value && {
       local: value.local,
@@ -303,7 +331,18 @@ function fromInternalAssetSymbol(projectRoot: string, value) {
   );
 }
 
-function fromInternalDependencySymbol(projectRoot: string, value) {
+function fromInternalDependencySymbol(
+  projectRoot: string,
+  value:
+    | undefined
+    | {
+        isWeak: boolean;
+        // @ts-expect-error TS2304
+        loc: InternalSourceLocation | null | undefined;
+        local: ISymbol;
+        meta?: Meta | null | undefined;
+      },
+) {
   return (
     value && {
       local: value.local,

package/src/public/{Target.js → Target.ts}

@@ -1,4 +1,3 @@
-// @flow
 import type {
   FilePath,
   Target as ITarget,
@@ -11,6 +10,7 @@ import nullthrows from 'nullthrows';
 import Environment from './Environment';
 import {fromProjectPath} from '../projectPath';
 import {fromInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -21,10 +21,12 @@ export function targetToInternalTarget(target: ITarget): TargetValue {
 }
 
 export default class Target implements ITarget {
-  #target /*: TargetValue */;
-  #options /*: AtlaspackOptions */;
+  // @ts-expect-error TS2564
+  #target: TargetValue;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
 
-  constructor(target: TargetValue, options: AtlaspackOptions): Target {
+  constructor(target: TargetValue, options: AtlaspackOptions) {
     let existing = internalTargetToTarget.get(target);
     if (existing != null) {
       return existing;
@@ -37,7 +39,7 @@ export default class Target implements ITarget {
     return this;
   }
 
-  get distEntry(): ?FilePath {
+  get distEntry(): FilePath | null | undefined {
     return this.#target.distEntry;
   }
 
@@ -46,7 +48,7 @@ export default class Target implements ITarget {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#target.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#target.env), this.#options);
   }
 
   get name(): string {
@@ -57,15 +59,15 @@ export default class Target implements ITarget {
     return this.#target.publicUrl;
   }
 
-  get loc(): ?SourceLocation {
+  get loc(): SourceLocation | null | undefined {
     return fromInternalSourceLocation(
       this.#options.projectRoot,
       this.#target.loc,
     );
   }
 
-  // $FlowFixMe[unsupported-syntax]
   [inspect](): string {
+    // @ts-expect-error TS7053
     return `Target(${this.name} - ${this.env[inspect]()})`;
   }
 }

package/src/{registerCoreWithSerializer.js → registerCoreWithSerializer.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import {registerSerializableClass} from '@atlaspack/build-cache';
 import {Graph} from '@atlaspack/graph';
 
@@ -11,26 +9,30 @@ import BundleGraph from './BundleGraph';
 import Config from './public/Config';
 import {RequestGraph} from './RequestTracker';
 
+// flow-to-ts helpers
+export type Class<T> = new (...args: any[]) => T;
+// /flow-to-ts helpers
+
+// @ts-expect-error TS7034
 let coreRegistered;
 export function registerCoreWithSerializer() {
+  // @ts-expect-error TS7005
   if (coreRegistered) {
     return;
   }
-  const packageVersion: mixed = packageJson.version;
+  const packageVersion: unknown = packageJson.version;
   if (typeof packageVersion !== 'string') {
     throw new Error('Expected package version to be a string');
   }
 
-  // $FlowFixMe[incompatible-cast]
-  for (let [name, ctor] of (Object.entries({
+  for (let [name, ctor] of Object.entries({
     AssetGraph,
     Config,
     BundleGraph,
     Graph,
     AtlaspackConfig,
     RequestGraph,
-    // $FlowFixMe[unclear-type]
-  }): Array<[string, Class<any>]>)) {
+  }) as Array<[string, Class<any>]>) {
     registerSerializableClass(packageVersion + ':' + name, ctor);
   }
   coreRegistered = true;

package/src/requests/{AssetGraphRequest.js → AssetGraphRequest.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {NodeId} from '@atlaspack/graph';
 import type {Async} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
@@ -20,6 +18,7 @@ import logger from '@atlaspack/logger';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {PromiseQueue, setEqual} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -30,44 +29,46 @@ import createEntryRequest from './EntryRequest';
 import createTargetRequest from './TargetRequest';
 import createAssetRequest from './AssetRequest';
 import createPathRequest from './PathRequest';
-import {type ProjectPath, fromProjectPathRelative} from '../projectPath';
+import {ProjectPath, fromProjectPathRelative} from '../projectPath';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
 import {propagateSymbols} from '../SymbolPropagation';
 import {requestTypes} from '../RequestTracker';
 
-export type AssetGraphRequestInput = {|
-  entries?: Array<ProjectPath>,
-  assetGroups?: Array<AssetGroup>,
-  optionsRef: SharedReference,
-  name: string,
-  shouldBuildLazily?: boolean,
-  lazyIncludes?: RegExp[],
-  lazyExcludes?: RegExp[],
-  requestedAssetIds?: Set<string>,
-|};
-
-export type AssetGraphRequestResult = {|
-  assetGraph: AssetGraph,
+export type AssetGraphRequestInput = {
+  entries?: Array<ProjectPath>;
+  assetGroups?: Array<AssetGroup>;
+  optionsRef: SharedReference;
+  name: string;
+  shouldBuildLazily?: boolean;
+  lazyIncludes?: RegExp[];
+  lazyExcludes?: RegExp[];
+  requestedAssetIds?: Set<string>;
+};
+
+export type AssetGraphRequestResult = {
+  assetGraph: AssetGraph;
   /** Assets added/modified since the last successful build. */
-  changedAssets: Map<string, Asset>,
+  changedAssets: Map<string, Asset>;
   /** Assets added/modified since the last symbol propagation invocation. */
-  changedAssetsPropagation: Set<string>,
-  assetGroupsWithRemovedParents: ?Set<NodeId>,
-  previousSymbolPropagationErrors: ?Map<NodeId, Array<Diagnostic>>,
-  assetRequests: Array<AssetGroup>,
-|};
-
-type RunInput = {|
-  input: AssetGraphRequestInput,
-  ...StaticRunOpts<AssetGraphRequestResult>,
-|};
-
-type AssetGraphRequest = {|
-  id: string,
-  +type: typeof requestTypes.asset_graph_request,
-  run: (RunInput) => Async<AssetGraphRequestResult>,
-  input: AssetGraphRequestInput,
-|};
+  changedAssetsPropagation: Set<string>;
+  assetGroupsWithRemovedParents: Set<NodeId> | null | undefined;
+  previousSymbolPropagationErrors:
+    | Map<NodeId, Array<Diagnostic>>
+    | null
+    | undefined;
+  assetRequests: Array<AssetGroup>;
+};
+
+type RunInput = {
+  input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
+
+type AssetGraphRequest = {
+  id: string;
+  readonly type: typeof requestTypes.asset_graph_request;
+  run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+  input: AssetGraphRequestInput;
+};
 
 export default function createAssetGraphRequest(
   requestInput: AssetGraphRequestInput,
@@ -80,9 +81,14 @@ export default function createAssetGraphRequest(
         await input.api.getPreviousResult<AssetGraphRequestResult>();
 
       let builder = new AssetGraphBuilder(input, prevResult);
-      let assetGraphRequest = await await builder.build();
+      let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
+      assetGraphRequest.assetGraph.setDisableIncrementalBundling(
+        !input.options.shouldBundleIncrementally ||
+          input.options.mode === 'production',
+      );
+
       if (
         !input.options.shouldBundleIncrementally ||
         input.options.mode === 'production'
@@ -106,10 +112,10 @@ const typesWithRequests = new Set([
 export class AssetGraphBuilder {
   assetGraph: AssetGraph;
   assetRequests: Array<AssetGroup> = [];
-  queue: PromiseQueue<mixed>;
+  queue: PromiseQueue<unknown>;
   changedAssets: Map<string, Asset>;
   changedAssetsPropagation: Set<string>;
-  prevChangedAssetsPropagation: ?Set<string>;
+  prevChangedAssetsPropagation: Set<string> | null | undefined;
   optionsRef: SharedReference;
   options: AtlaspackOptions;
   api: RunAPI<AssetGraphRequestResult>;
@@ -125,7 +131,7 @@ export class AssetGraphBuilder {
 
   constructor(
     {input, api, options}: RunInput,
-    prevResult: ?AssetGraphRequestResult,
+    prevResult?: AssetGraphRequestResult | null,
   ) {
     let {
       entries,
@@ -161,20 +167,30 @@ export class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey =
-      hashString(
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
           options.mode
         }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-AssetGraph';
+      );
+      this.cacheKey = `AssetGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey =
+        hashString(
+          `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
+            options.mode
+          }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+        ) + '-AssetGraph';
+    }
 
     this.isSingleChangeRebuild =
       api
         .getInvalidSubRequests()
+        // @ts-expect-error TS2367
         .filter((req) => req.requestType === 'asset_request').length === 1;
     this.queue = new PromiseQueue();
 
-    assetGraph.onNodeRemoved = (nodeId) => {
+    assetGraph.onNodeRemoved = (nodeId: NodeId) => {
       this.assetGroupsWithRemovedParents.delete(nodeId);
 
       // This needs to mark all connected nodes that doesn't become orphaned
@@ -196,7 +212,7 @@ export class AssetGraphBuilder {
   }
 
   async build(): Promise<AssetGraphRequestResult> {
-    let errors = [];
+    let errors: Array<Error> = [];
     let rootNodeId = nullthrows(
       this.assetGraph.rootNodeId,
       'A root node is required to traverse',
@@ -224,6 +240,7 @@ export class AssetGraphBuilder {
       for (let childNodeId of this.assetGraph.getNodeIdsConnectedFrom(nodeId)) {
         let child = nullthrows(this.assetGraph.getNode(childNodeId));
         if (
+          // @ts-expect-error TS2339
           (!visited.has(childNodeId) || child.hasDeferred) &&
           this.shouldVisitChild(nodeId, childNodeId)
         ) {
@@ -310,7 +327,7 @@ export class AssetGraphBuilder {
             diagnostic: [...errors.values()][0],
           });
         }
-      } catch (e) {
+      } catch (e: any) {
         await dumpGraphToGraphViz(
           this.assetGraph,
           'AssetGraph_' + this.name + '_failed',
@@ -428,9 +445,12 @@ export class AssetGraphBuilder {
   shouldSkipRequest(nodeId: NodeId): boolean {
     let node = nullthrows(this.assetGraph.getNode(nodeId));
     return (
+      // @ts-expect-error TS2339
       node.complete === true ||
       !typesWithRequests.has(node.type) ||
+      // @ts-expect-error TS2339
       (node.correspondingRequest != null &&
+        // @ts-expect-error TS2339
         this.api.canSkipSubrequest(node.correspondingRequest))
     );
   }
@@ -459,7 +479,7 @@ export class AssetGraphBuilder {
           `Can not queue corresponding request of node with type ${node.type}`,
         );
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve: (result: Promise<null> | null) => void) => {
       this.queue.add(() =>
         promise.then(
           () => {
@@ -501,6 +521,7 @@ export class AssetGraphBuilder {
 
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
+        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -515,15 +536,16 @@ export class AssetGraphBuilder {
 
   async runPathRequest(input: Dependency) {
     let request = createPathRequest({dependency: input, name: this.name});
-    let result = await this.api.runRequest<PathRequestInput, ?AssetGroup>(
-      request,
-      {force: true},
-    );
+    let result = await this.api.runRequest<
+      PathRequestInput,
+      AssetGroup | null | undefined
+    >(request, {force: true});
     this.assetGraph.resolveDependency(input, result, request.id);
   }
 
   async runAssetRequest(input: AssetGroup) {
     this.assetRequests.push(input);
+    // @ts-expect-error TS2345
     let request = createAssetRequest({
       ...input,
       name: this.name,
@@ -538,16 +560,28 @@ export class AssetGraphBuilder {
 
     if (assets != null) {
       for (let asset of assets) {
+        // Pass the runtimeAssetRequiringExecutionOnLoad flag from the asset
+        // group down to the asset itself, for reading in the packager.
+        if (input.runtimeAssetRequiringExecutionOnLoad) {
+          asset.meta = {
+            ...(asset.meta ?? {}),
+            runtimeAssetRequiringExecutionOnLoad:
+              input.runtimeAssetRequiringExecutionOnLoad,
+          };
+        }
+
         if (this.assetGraph.safeToIncrementallyBundle) {
           let otherAsset = this.assetGraph.getNodeByContentKey(asset.id);
           if (otherAsset != null) {
             invariant(otherAsset.type === 'asset');
             if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
               this.assetGraph.safeToIncrementallyBundle = false;
+              this.assetGraph.setNeedsBundling();
             }
           } else {
             // adding a new entry or dependency
             this.assetGraph.safeToIncrementallyBundle = false;
+            this.assetGraph.setNeedsBundling();
           }
         }
         this.changedAssets.set(asset.id, asset);
@@ -556,6 +590,7 @@ export class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
+      this.assetGraph.setNeedsBundling();
     }
 
     this.isSingleChangeRebuild = false;