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

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Asset as IAsset,
   Bundle as IBundle,
@@ -11,6 +9,7 @@ import type {
 } from '@atlaspack/types';
 import type {
   AtlaspackOptions,
+  BundleGraphNode,
   BundleGroup as InternalBundleGroup,
   BundleNode,
 } from '../types';
@@ -32,13 +31,16 @@ import {BundleBehavior} from '../types';
 import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
 import type {ProjectPath} from '../projectPath';
 import {identifierRegistry} from '../IdentifierRegistry';
-
-function createBundleId(data: {|
-  entryAssetId: string | null,
-  uniqueKey: string | null,
-  distDir: ProjectPath,
-  bundleBehavior: string | null,
-|}): string {
+import {toEnvironmentRef} from '../EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import type {ContentKey} from '@atlaspack/graph';
+
+function createBundleId(data: {
+  entryAssetId: string | null;
+  uniqueKey: string | null;
+  distDir: ProjectPath;
+  bundleBehavior: string | null;
+}): string {
   const {entryAssetId, uniqueKey, distDir, bundleBehavior} = data;
   const id = hashString(
     `bundle:${String(
@@ -53,9 +55,9 @@ export default class MutableBundleGraph
   extends BundleGraph<IBundle>
   implements IMutableBundleGraph
 {
-  #graph /*: InternalBundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundlePublicIds /*: Set<string> */ = new Set<string>();
+  #graph: InternalBundleGraph;
+  #options: AtlaspackOptions;
+  #bundlePublicIds: Set<string> = new Set<string>();
 
   constructor(graph: InternalBundleGraph, options: AtlaspackOptions) {
     super(graph, Bundle.get.bind(Bundle), options);
@@ -73,13 +75,16 @@ export default class MutableBundleGraph
   addAssetGraphToBundle(
     asset: IAsset,
     bundle: IBundle,
-    shouldSkipDependency?: (IDependency) => boolean,
+    shouldSkipDependency?: (arg1: IDependency) => boolean,
   ) {
     this.#graph.addAssetGraphToBundle(
       assetToAssetValue(asset),
       bundleToInternalBundle(bundle),
+      // @ts-expect-error TS2345
       shouldSkipDependency
-        ? (d) => shouldSkipDependency(new Dependency(d, this.#options))
+        ? (d: Dependency) =>
+            // @ts-expect-error TS2345
+            shouldSkipDependency(new Dependency(d, this.#options))
         : undefined,
     );
   }
@@ -87,13 +92,16 @@ export default class MutableBundleGraph
   addEntryToBundle(
     asset: IAsset,
     bundle: IBundle,
-    shouldSkipDependency?: (IDependency) => boolean,
+    shouldSkipDependency?: (arg1: IDependency) => boolean,
   ) {
     this.#graph.addEntryToBundle(
       assetToAssetValue(asset),
       bundleToInternalBundle(bundle),
+      // @ts-expect-error TS2345
       shouldSkipDependency
-        ? (d) => shouldSkipDependency(new Dependency(d, this.#options))
+        ? (d: Dependency) =>
+            // @ts-expect-error TS2345
+            shouldSkipDependency(new Dependency(d, this.#options))
         : undefined,
     );
   }
@@ -194,19 +202,23 @@ export default class MutableBundleGraph
   }
 
   createBundle(opts: CreateBundleOpts): Bundle {
+    // @ts-expect-error TS2339
     let entryAsset = opts.entryAsset
-      ? assetToAssetValue(opts.entryAsset)
+      ? // @ts-expect-error TS2339
+        assetToAssetValue(opts.entryAsset)
       : null;
 
     let target = targetToInternalTarget(opts.target);
     let bundleId = createBundleId({
       entryAssetId: entryAsset?.id ?? null,
+      // @ts-expect-error TS2339
       uniqueKey: opts.uniqueKey ?? null,
       distDir: target.distDir,
       bundleBehavior: opts.bundleBehavior ?? null,
     });
 
-    let existing = this.#graph._graph.getNodeByContentKey(bundleId);
+    let existing: BundleGraphNode | null | undefined =
+      this.#graph._graph.getNodeByContentKey(bundleId);
     if (existing != null) {
       invariant(existing.type === 'bundle');
       return Bundle.get(existing.value, this.#graph, this.#options);
@@ -226,6 +238,18 @@ export default class MutableBundleGraph
       isPlaceholder = entryAssetNode.requested === false;
     }
 
+    let entryAssetIds: Array<ContentKey> | Array<ContentKey | string> = [];
+    if (entryAsset) {
+      entryAssetIds = [entryAsset.id];
+      if (getFeatureFlag('supportWebpackChunkName')) {
+        // @ts-expect-error TS2339
+        let bundleRoots = opts.bundleRoots ?? [entryAsset];
+        let bundleRootIds = bundleRoots
+          .map(({id}: any) => id)
+          .filter((assetId: any) => assetId !== entryAsset.id);
+        entryAssetIds.push(...bundleRootIds);
+      }
+    }
     let bundleNode: BundleNode = {
       type: 'bundle',
       id: bundleId,
@@ -234,21 +258,28 @@ export default class MutableBundleGraph
         hashReference: this.#options.shouldContentHash
           ? HASH_REF_PREFIX + bundleId
           : bundleId.slice(-8),
+        // @ts-expect-error TS2339
         type: opts.entryAsset ? opts.entryAsset.type : opts.type,
+        // @ts-expect-error TS2339
         env: opts.env
-          ? environmentToInternalEnvironment(opts.env)
+          ? // @ts-expect-error TS2339
+            toEnvironmentRef(environmentToInternalEnvironment(opts.env))
           : nullthrows(entryAsset).env,
-        entryAssetIds: entryAsset ? [entryAsset.id] : [],
+        entryAssetIds,
         mainEntryId: entryAsset?.id,
+        // @ts-expect-error TS2339
         pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
         needsStableName: opts.needsStableName,
         bundleBehavior:
           opts.bundleBehavior != null
             ? BundleBehavior[opts.bundleBehavior]
             : null,
+        // @ts-expect-error TS2339
         isSplittable: opts.entryAsset
-          ? opts.entryAsset.isBundleSplittable
-          : opts.isSplittable,
+          ? // @ts-expect-error TS2339
+            opts.entryAsset.isBundleSplittable
+          : // @ts-expect-error TS2339
+            opts.isSplittable,
         isPlaceholder,
         target,
         name: null,
@@ -263,10 +294,10 @@ export default class MutableBundleGraph
       bundleNode,
     );
 
-    if (opts.entryAsset) {
+    for (let assetId of entryAssetIds) {
       this.#graph._graph.addEdge(
         bundleNodeId,
-        this.#graph._graph.getNodeIdByContentKey(opts.entryAsset.id),
+        this.#graph._graph.getNodeIdByContentKey(assetId),
       );
     }
     return Bundle.get(bundleNode.value, this.#graph, this.#options);

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   BuildMode,
   EnvMap,
@@ -12,15 +11,16 @@ import type {
 import type {FileSystem} from '@atlaspack/fs';
 import type {PackageManager} from '@atlaspack/package-manager';
 import type {AtlaspackOptions} from '../types';
-import {type FeatureFlags} from '@atlaspack/feature-flags';
+import {FeatureFlags} from '@atlaspack/feature-flags';
 
 let parcelOptionsToPluginOptions: WeakMap<AtlaspackOptions, PluginOptions> =
   new WeakMap();
 
 export default class PluginOptions implements IPluginOptions {
-  #options /*: AtlaspackOptions */;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
 
-  constructor(options: AtlaspackOptions): PluginOptions {
+  constructor(options: AtlaspackOptions) {
     let existing = parcelOptionsToPluginOptions.get(options);
     if (existing != null) {
       return existing;
@@ -47,7 +47,7 @@ export default class PluginOptions implements IPluginOptions {
     return this.#options.parcelVersion;
   }
 
-  get hmrOptions(): ?HMROptions {
+  get hmrOptions(): HMROptions | null | undefined {
     return this.#options.hmrOptions;
   }
 
@@ -89,7 +89,7 @@ export default class PluginOptions implements IPluginOptions {
     return this.#options.packageManager;
   }
 
-  get detailedReport(): ?DetailedReportOptions {
+  get detailedReport(): DetailedReportOptions | null | undefined {
     return this.#options.detailedReport;
   }
 

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;