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

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   Dependency as IDependency,
   Environment as IEnvironment,
@@ -27,6 +26,7 @@ import {
 } from '../types';
 import {fromProjectPath} from '../projectPath';
 import {fromInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const SpecifierTypeNames = Object.keys(SpecifierTypeMap);
 const PriorityNames = Object.keys(Priority);
@@ -37,7 +37,7 @@ const internalDependencyToDependency: WeakMap<InternalDependency, Dependency> =
   new WeakMap();
 const _dependencyToInternalDependency: WeakMap<
   IDependency,
-  InternalDependency,
+  InternalDependency
 > = new WeakMap();
 export function dependencyToInternalDependency(
   dependency: IDependency,
@@ -58,10 +58,10 @@ export function getPublicDependency(
 }
 
 export default class Dependency implements IDependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
+  #dep: InternalDependency;
+  #options: AtlaspackOptions;
 
-  constructor(dep: InternalDependency, options: AtlaspackOptions): Dependency {
+  constructor(dep: InternalDependency, options: AtlaspackOptions) {
     this.#dep = dep;
     this.#options = options;
     _dependencyToInternalDependency.set(this, dep);
@@ -69,7 +69,6 @@ export default class Dependency implements IDependency {
     return this;
   }
 
-  // $FlowFixMe
   [inspect](): string {
     return `Dependency(${String(this.sourcePath)} -> ${this.specifier})`;
   }
@@ -83,10 +82,12 @@ export default class Dependency implements IDependency {
   }
 
   get specifierType(): SpecifierType {
+    // @ts-expect-error TS2322
     return SpecifierTypeNames[this.#dep.specifierType];
   }
 
   get priority(): DependencyPriority {
+    // @ts-expect-error TS2322
     return PriorityNames[this.#dep.priority];
   }
 
@@ -94,7 +95,7 @@ export default class Dependency implements IDependency {
     return this.#dep.needsStableName;
   }
 
-  get bundleBehavior(): ?BundleBehavior {
+  get bundleBehavior(): BundleBehavior | null | undefined {
     let bundleBehavior = this.#dep.bundleBehavior;
     return bundleBehavior == null ? null : BundleBehaviorNames[bundleBehavior];
   }
@@ -107,15 +108,15 @@ export default class Dependency implements IDependency {
     return this.#dep.isOptional;
   }
 
-  get loc(): ?SourceLocation {
+  get loc(): SourceLocation | null | undefined {
     return fromInternalSourceLocation(this.#options.projectRoot, this.#dep.loc);
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#dep.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#dep.env), this.#options);
   }
 
-  get packageConditions(): ?Array<string> {
+  get packageConditions(): Array<string> | null | undefined {
     // Merge custom conditions with conditions stored as bitflags.
     // Order is not important because exports conditions are resolved
     // in the order they are declared in the package.json.
@@ -123,6 +124,7 @@ export default class Dependency implements IDependency {
     if (this.#dep.packageConditions) {
       conditions = conditions ? [...conditions] : [];
       for (let key in ExportsCondition) {
+        // @ts-expect-error TS7053
         if (this.#dep.packageConditions & ExportsCondition[key]) {
           conditions.push(key);
         }
@@ -137,40 +139,41 @@ export default class Dependency implements IDependency {
   }
 
   get symbols(): IMutableDependencySymbols {
+    // @ts-expect-error TS2322
     return new MutableDependencySymbols(this.#options, this.#dep);
   }
 
-  get target(): ?Target {
+  get target(): Target | null | undefined {
     let target = this.#dep.target;
     return target ? new Target(target, this.#options) : null;
   }
 
-  get sourceAssetId(): ?string {
+  get sourceAssetId(): string | null | undefined {
     // TODO: does this need to be public?
     return this.#dep.sourceAssetId;
   }
 
-  get sourcePath(): ?FilePath {
+  get sourcePath(): FilePath | null | undefined {
     // TODO: does this need to be public?
     return fromProjectPath(this.#options.projectRoot, this.#dep.sourcePath);
   }
 
-  get sourceAssetType(): ?string {
+  get sourceAssetType(): string | null | undefined {
     return this.#dep.sourceAssetType;
   }
 
-  get resolveFrom(): ?string {
+  get resolveFrom(): string | null | undefined {
     return fromProjectPath(
       this.#options.projectRoot,
       this.#dep.resolveFrom ?? this.#dep.sourcePath,
     );
   }
 
-  get range(): ?string {
+  get range(): string | null | undefined {
     return this.#dep.range;
   }
 
-  get pipeline(): ?string {
+  get pipeline(): string | null | undefined {
     return this.#dep.pipeline;
   }
 }

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {
   Environment as IEnvironment,
   EnvironmentContext,
@@ -10,6 +9,7 @@ import type {
   SourceLocation,
   SourceType,
   TargetSourceMapOptions,
+  EnvMap,
 } from '@atlaspack/types';
 import type {
   Environment as InternalEnvironment,
@@ -27,12 +27,17 @@ export const BROWSER_ENVS: Set<string> = new Set<string>([
   'web-worker',
   'service-worker',
   'worklet',
+  'tesseract',
   'electron-renderer',
 ]);
 const ELECTRON_ENVS = new Set(['electron-main', 'electron-renderer']);
 const NODE_ENVS = new Set(['node', ...ELECTRON_ENVS]);
 const WORKER_ENVS = new Set(['web-worker', 'service-worker']);
-export const ISOLATED_ENVS: Set<string> = new Set([...WORKER_ENVS, 'worklet']);
+export const ISOLATED_ENVS: Set<string> = new Set([
+  ...WORKER_ENVS,
+  'worklet',
+  'tesseract',
+]);
 
 const ALL_BROWSERS = [
   'chrome',
@@ -139,15 +144,15 @@ const supportData = {
     android: '71',
     samsung: '10.1',
   },
-};
+} as const;
 
 const internalEnvironmentToEnvironment: WeakMap<
   InternalEnvironment,
-  Environment,
+  Environment
 > = new WeakMap();
 const _environmentToInternalEnvironment: WeakMap<
   IEnvironment,
-  InternalEnvironment,
+  InternalEnvironment
 > = new WeakMap();
 export function environmentToInternalEnvironment(
   environment: IEnvironment,
@@ -156,13 +161,12 @@ export function environmentToInternalEnvironment(
 }
 
 export default class Environment implements IEnvironment {
-  #environment /*: InternalEnvironment */;
-  #options /*: AtlaspackOptions */;
+  // @ts-expect-error TS2564
+  #environment: InternalEnvironment;
+  // @ts-expect-error TS2564
+  #options: AtlaspackOptions;
 
-  constructor(
-    env: InternalEnvironment,
-    options: AtlaspackOptions,
-  ): Environment {
+  constructor(env: InternalEnvironment, options: AtlaspackOptions) {
     let existing = internalEnvironmentToEnvironment.get(env);
     if (existing != null) {
       return existing;
@@ -190,7 +194,7 @@ export default class Environment implements IEnvironment {
   get includeNodeModules():
     | boolean
     | Array<PackageName>
-    | {[PackageName]: boolean, ...} {
+    | Partial<Record<PackageName, boolean>> {
     return this.#environment.includeNodeModules;
   }
 
@@ -214,11 +218,11 @@ export default class Environment implements IEnvironment {
     return this.#environment.shouldScopeHoist;
   }
 
-  get sourceMap(): ?TargetSourceMapOptions {
+  get sourceMap(): TargetSourceMapOptions | null | undefined {
     return this.#environment.sourceMap;
   }
 
-  get loc(): ?SourceLocation {
+  get loc(): SourceLocation | null | undefined {
     return fromInternalSourceLocation(
       this.#options.projectRoot,
       this.#environment.loc,
@@ -229,7 +233,10 @@ export default class Environment implements IEnvironment {
     return this.#environment.unstableSingleFileOutput;
   }
 
-  // $FlowFixMe[unsupported-syntax]
+  get customEnv(): EnvMap | null | undefined {
+    return this.#environment.customEnv;
+  }
+
   [inspect](): string {
     return `Env(${this.#environment.context})`;
   }
@@ -258,9 +265,13 @@ export default class Environment implements IEnvironment {
     return this.#environment.context === 'worklet';
   }
 
+  isTesseract(): boolean {
+    return this.#environment.context === 'tesseract';
+  }
+
   matchesEngines(
     minVersions: VersionMap,
-    defaultValue?: boolean = false,
+    defaultValue: boolean = false,
   ): boolean {
     // Determine if the environment matches some minimum version requirements.
     // For browsers, we run a browserslist query with and without the minimum
@@ -306,7 +317,7 @@ export default class Environment implements IEnvironment {
 }
 
 function getExcludedBrowsers(minVersions: VersionMap) {
-  let browsers = [];
+  let browsers: Array<string> = [];
   for (let browser of ALL_BROWSERS) {
     let version = minVersions[browser];
     if (version) {

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