@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

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

@@ -1,15 +1,14 @@
-// @flow
-
 import type {ContentKey, NodeId} from '@atlaspack/graph';
 import type {Meta, Symbol} from '@atlaspack/types';
 import type {Diagnostic} from '@atlaspack/diagnostic';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import type {
   AssetNode,
   DependencyNode,
   InternalSourceLocation,
   AtlaspackOptions,
 } from './types';
-import {type default as AssetGraph} from './AssetGraph';
+import {default as AssetGraph} from './AssetGraph';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
@@ -17,7 +16,7 @@ import {setEqual} from '@atlaspack/utils';
 import logger from '@atlaspack/logger';
 import {md, convertSourceLocationToHighlight} from '@atlaspack/diagnostic';
 import {instrument} from '@atlaspack/logger';
-import {BundleBehavior, Priority} from './types';
+import {BundleBehavior, Priority, SpecifierType} from './types';
 import {fromProjectPathRelative, fromProjectPath} from './projectPath';
 
 export function propagateSymbols({
@@ -26,13 +25,13 @@ export function propagateSymbols({
   changedAssetsPropagation,
   assetGroupsWithRemovedParents,
   previousErrors,
-}: {|
-  options: AtlaspackOptions,
-  assetGraph: AssetGraph,
-  changedAssetsPropagation: Set<string>,
-  assetGroupsWithRemovedParents: Set<NodeId>,
-  previousErrors?: ?Map<NodeId, Array<Diagnostic>>,
-|}): Map<NodeId, Array<Diagnostic>> {
+}: {
+  options: AtlaspackOptions;
+  assetGraph: AssetGraph;
+  changedAssetsPropagation: Set<string>;
+  assetGroupsWithRemovedParents: Set<NodeId>;
+  previousErrors?: Map<NodeId, Array<Diagnostic>> | null | undefined;
+}): Map<NodeId, Array<Diagnostic>> {
   return instrument('propagateSymbols', () => {
     let changedAssets = new Set(
       [...changedAssetsPropagation].map((id) =>
@@ -62,11 +61,25 @@ export function propagateSymbols({
       changedAssets,
       assetGroupsWithRemovedParents,
       (assetNode, incomingDeps, outgoingDeps) => {
+        if (
+          assetNode.value.meta.emptyFileStarReexport &&
+          incomingDeps.every((d) => d.value.specifierType === SpecifierType.esm)
+        ) {
+          assetNode.value.symbols?.delete('*');
+        }
+
         // exportSymbol -> identifier
-        let assetSymbols: ?$ReadOnlyMap<
-          Symbol,
-          {|local: Symbol, loc: ?InternalSourceLocation, meta?: ?Meta|},
-        > = assetNode.value.symbols;
+        let assetSymbols:
+          | ReadonlyMap<
+              Symbol,
+              {
+                local: Symbol;
+                loc: InternalSourceLocation | null | undefined;
+                meta?: Meta | null | undefined;
+              }
+            >
+          | null
+          | undefined = assetNode.value.symbols;
         // identifier -> exportSymbol
         let assetSymbolsInverse;
         if (assetSymbols) {
@@ -143,8 +156,15 @@ export function propagateSymbols({
 
         // Incomding dependency with cleared symbols, add everything
         if (addAll) {
-          assetSymbols?.forEach((_, exportSymbol) =>
-            assetNode.usedSymbols.add(exportSymbol),
+          assetSymbols?.forEach(
+            (
+              _: {
+                loc: InternalSourceLocation | null | undefined;
+                local: Symbol;
+                meta?: Meta | null | undefined;
+              },
+              exportSymbol: Symbol,
+            ) => assetNode.usedSymbols.add(exportSymbol),
           );
         }
 
@@ -153,6 +173,7 @@ export function propagateSymbols({
         for (let dep of outgoingDeps) {
           let depUsedSymbolsDownOld = dep.usedSymbolsDown;
           let depUsedSymbolsDown = new Set();
+          // @ts-expect-error TS2322
           dep.usedSymbolsDown = depUsedSymbolsDown;
           if (
             assetNode.value.sideEffects ||
@@ -233,10 +254,10 @@ export function propagateSymbols({
     );
 
     const logFallbackNamespaceInsertion = (
-      assetNode,
+      assetNode: AssetNode,
       symbol: Symbol,
-      depNode1,
-      depNode2,
+      depNode1: DependencyNode,
+      depNode2: DependencyNode,
     ) => {
       if (options.logLevel === 'verbose') {
         logger.warn({
@@ -260,10 +281,17 @@ export function propagateSymbols({
       changedDepsUsedSymbolsUpDirtyDown,
       previousErrors,
       (assetNode, incomingDeps, outgoingDeps) => {
-        let assetSymbols: ?$ReadOnlyMap<
-          Symbol,
-          {|local: Symbol, loc: ?InternalSourceLocation, meta?: ?Meta|},
-        > = assetNode.value.symbols;
+        let assetSymbols:
+          | ReadonlyMap<
+              Symbol,
+              {
+                local: Symbol;
+                loc: InternalSourceLocation | null | undefined;
+                meta?: Meta | null | undefined;
+              }
+            >
+          | null
+          | undefined = assetNode.value.symbols;
 
         let assetSymbolsInverse = null;
         if (assetSymbols) {
@@ -281,7 +309,12 @@ export function propagateSymbols({
         // the symbols that are reexported (not used in `asset`) -> asset they resolved to
         let reexportedSymbols = new Map<
           Symbol,
-          ?{|asset: ContentKey, symbol: ?Symbol|},
+          | {
+              asset: ContentKey;
+              symbol: Symbol | null | undefined;
+            }
+          | null
+          | undefined
         >();
         // the symbols that are reexported (not used in `asset`) -> the corresponding outgoingDep(s)
         // To generate the diagnostic when there are multiple dependencies with non-statically
@@ -367,7 +400,36 @@ export function propagateSymbols({
 
         let errors: Array<Diagnostic> = [];
 
-        function usedSymbolsUpAmbiguous(old, current, s, value) {
+        function usedSymbolsUpAmbiguous(
+          old: Map<
+            Symbol,
+            | {
+                asset: ContentKey;
+                symbol: Symbol | null | undefined;
+              }
+            | null
+            | undefined
+          >,
+          current: Map<
+            Symbol,
+            | {
+                asset: ContentKey;
+                symbol: Symbol | null | undefined;
+              }
+            | null
+            | undefined
+          >,
+          s: Symbol,
+          value:
+            | {
+                asset: ContentKey;
+                symbol: Symbol;
+              }
+            | {
+                asset: ContentKey;
+                symbol: Symbol | null | undefined;
+              },
+        ) {
           if (old.has(s)) {
             let valueOld = old.get(s);
             if (
@@ -439,6 +501,7 @@ export function propagateSymbols({
 
               errors.push({
                 message: md`${fromProjectPathRelative(
+                  // @ts-expect-error TS2345
                   resolution.value.filePath,
                 )} does not export '${s}'`,
                 origin: '@atlaspack/core',
@@ -496,7 +559,10 @@ export function propagateSymbols({
     // See https://github.com/parcel-bundler/parcel/pull/8212
     for (let dep of changedDeps) {
       dep.usedSymbolsUp = new Map(
-        [...dep.usedSymbolsUp].sort(([a], [b]) => a.localeCompare(b)),
+        // @ts-expect-error TS2345
+        [...dep.usedSymbolsUp].sort(([a]: [any], [b]: [any]) =>
+          a.localeCompare(b),
+        ),
       );
     }
 
@@ -510,8 +576,8 @@ function propagateSymbolsDown(
   assetGroupsWithRemovedParents: Set<NodeId>,
   visit: (
     assetNode: AssetNode,
-    incoming: $ReadOnlyArray<DependencyNode>,
-    outgoing: $ReadOnlyArray<DependencyNode>,
+    incoming: ReadonlyArray<DependencyNode>,
+    outgoing: ReadonlyArray<DependencyNode>,
   ) => void,
 ) {
   if (changedAssets.size === 0 && assetGroupsWithRemovedParents.size === 0) {
@@ -597,11 +663,11 @@ function propagateSymbolsUp(
   assetGraph: AssetGraph,
   changedAssets: Set<NodeId>,
   changedDepsUsedSymbolsUpDirtyDown: Set<ContentKey>,
-  previousErrors: ?Map<NodeId, Array<Diagnostic>>,
+  previousErrors: Map<NodeId, Array<Diagnostic>> | null | undefined,
   visit: (
     assetNode: AssetNode,
-    incoming: $ReadOnlyArray<DependencyNode>,
-    outgoing: $ReadOnlyArray<DependencyNode>,
+    incoming: ReadonlyArray<DependencyNode>,
+    outgoing: ReadonlyArray<DependencyNode>,
   ) => Array<Diagnostic>,
 ): Map<NodeId, Array<Diagnostic>> {
   // For graphs in general (so with cyclic dependencies), some nodes will have to be revisited. So
@@ -615,7 +681,8 @@ function propagateSymbolsUp(
 
   let errors: Map<NodeId, Array<Diagnostic>> = previousErrors
     ? // Some nodes might have been removed since the last build
-      new Map([...previousErrors].filter(([n]) => assetGraph.hasNode(n)))
+      // @ts-expect-error TS2769
+      new Map([...previousErrors].filter(([n]: [any]) => assetGraph.hasNode(n)))
     : new Map();
 
   let changedDepsUsedSymbolsUpDirtyDownAssets = new Set([
@@ -633,6 +700,7 @@ function propagateSymbolsUp(
     assetGraph.nodes.length * (1 / 6) * 0.5 <
     changedDepsUsedSymbolsUpDirtyDownAssets.size;
 
+  // @ts-expect-error TS7034
   let dirtyDeps;
   if (runFullPass) {
     dirtyDeps = new Set<NodeId>();
@@ -641,7 +709,7 @@ function propagateSymbolsUp(
       'A root node is required to traverse',
     );
 
-    const nodeVisitor = (nodeId) => {
+    const nodeVisitor = (nodeId: NodeId) => {
       let node = nullthrows(assetGraph.getNode(nodeId));
 
       if (node.type === 'asset') {
@@ -672,13 +740,16 @@ function propagateSymbolsUp(
       } else {
         if (node.type === 'dependency') {
           if (node.usedSymbolsUpDirtyUp) {
+            // @ts-expect-error TS7005
             dirtyDeps.add(nodeId);
           } else {
+            // @ts-expect-error TS7005
             dirtyDeps.delete(nodeId);
           }
         }
       }
     };
+    // @ts-expect-error TS2345
     assetGraph.postOrderDfsFast(nodeVisitor, rootNodeId);
   }
 
@@ -721,6 +792,7 @@ function propagateSymbolsUp(
     } else {
       let connectedNodes = assetGraph.getNodeIdsConnectedTo(queuedNodeId);
       if (connectedNodes.length > 0) {
+        // @ts-expect-error TS2556
         queue.add(...connectedNodes);
       }
     }
@@ -749,8 +821,24 @@ function getDependencyResolution(
 }
 
 function equalMap<K>(
-  a: $ReadOnlyMap<K, ?{|asset: ContentKey, symbol: ?Symbol|}>,
-  b: $ReadOnlyMap<K, ?{|asset: ContentKey, symbol: ?Symbol|}>,
+  a: ReadonlyMap<
+    K,
+    | {
+        asset: ContentKey;
+        symbol: Symbol | null | undefined;
+      }
+    | null
+    | undefined
+  >,
+  b: ReadonlyMap<
+    K,
+    | {
+        asset: ContentKey;
+        symbol: Symbol | null | undefined;
+      }
+    | null
+    | undefined
+  >,
 ) {
   if (a.size !== b.size) return false;
   for (let [k, v] of a) {
@@ -767,14 +855,20 @@ function setPop<T>(set: Set<T>): T {
   return v;
 }
 
-function outgoingDependencyNodesFromAsset(assetGraph, assetNode) {
+function outgoingDependencyNodesFromAsset(
+  assetGraph: AssetGraph,
+  assetNode: NodeId,
+) {
   return dependencyNodesFromIds(
     assetGraph,
     assetGraph.getNodeIdsConnectedFrom(assetNode),
   );
 }
 
-function dependencyNodesFromIds(assetGraph, dependencyIds) {
+function dependencyNodesFromIds(
+  assetGraph: AssetGraph,
+  dependencyIds: Array<NodeId>,
+) {
   return dependencyIds.map((depNodeId) => {
     let depNode = nullthrows(assetGraph.getNode(depNodeId));
     invariant(depNode.type === 'dependency');
@@ -782,7 +876,11 @@ function dependencyNodesFromIds(assetGraph, dependencyIds) {
   });
 }
 
-function incomingDependencyNodesFromAsset(assetGraph, assetNodeValue) {
+function incomingDependencyNodesFromAsset(
+  assetGraph: AssetGraph,
+  // @ts-expect-error TS2552
+  assetNodeValue: Asset,
+) {
   return assetGraph.getIncomingDependencies(assetNodeValue).map((d) => {
     let n = assetGraph.getNodeByContentKey(d.id);
     invariant(n && n.type === 'dependency');

package/src/{TargetDescriptor.schema.js → TargetDescriptor.schema.ts}

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {SchemaEntity, SchemaObject} from '@atlaspack/utils';
 
 export const ENGINES_SCHEMA: SchemaEntity = {
@@ -36,6 +35,7 @@ export const PACKAGE_DESCRIPTOR_SCHEMA: SchemaObject = {
         'electron-main',
         'electron-renderer',
         'service-worker',
+        'tesseract',
       ],
     },
     includeNodeModules: {
@@ -115,6 +115,12 @@ export const PACKAGE_DESCRIPTOR_SCHEMA: SchemaObject = {
     __unstable_singleFileOutput: {
       type: 'boolean',
     },
+    env: {
+      type: 'object',
+      additionalProperties: {
+        type: 'string',
+      },
+    },
   },
   additionalProperties: false,
 };

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   FilePath,
   GenerateOutput,
@@ -31,7 +29,7 @@ import ThrowableDiagnostic, {
   errorToDiagnostic,
   escapeMarkdown,
   md,
-  type Diagnostic,
+  Diagnostic,
 } from '@atlaspack/diagnostic';
 import {SOURCEMAP_EXTENSIONS} from '@atlaspack/utils';
 
@@ -48,12 +46,13 @@ import UncommittedAsset from './UncommittedAsset';
 import {createAsset} from './assetUtils';
 import summarizeRequest from './summarizeRequest';
 import PluginOptions from './public/PluginOptions';
+import {fromEnvironmentId} from './EnvironmentManager';
 import {optionsProxy} from './utils';
 import {createConfig} from './InternalConfig';
 import {
   loadPluginConfig,
   getConfigRequests,
-  type ConfigRequest,
+  ConfigRequest,
 } from './requests/ConfigRequest';
 import {
   createDevDependency,
@@ -61,7 +60,7 @@ import {
   getWorkerDevDepRequests,
 } from './requests/DevDepRequest';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
   toProjectPathUnsafe,
@@ -74,23 +73,23 @@ import {tracer, PluginTracer} from '@atlaspack/profiler';
 type GenerateFunc = (input: UncommittedAsset) => Promise<GenerateOutput>;
 
 type PostProcessFunc = (
-  Array<UncommittedAsset>,
+  arg1: Array<UncommittedAsset>,
 ) => Promise<Array<UncommittedAsset> | null>;
 
-export type TransformationOpts = {|
-  options: AtlaspackOptions,
-  config: AtlaspackConfig,
-  request: TransformationRequest,
-  workerApi: WorkerApi,
-|};
-
-export type TransformationResult = {|
-  assets?: Array<AssetValue>,
-  error?: Array<Diagnostic>,
-  configRequests: Array<ConfigRequest>,
-  invalidations: Invalidations,
-  devDepRequests: Array<DevDepRequest | DevDepRequestRef>,
-|};
+export type TransformationOpts = {
+  options: AtlaspackOptions;
+  config: AtlaspackConfig;
+  request: TransformationRequest;
+  workerApi: WorkerApi;
+};
+
+export type TransformationResult = {
+  assets?: Array<AssetValue>;
+  error?: Array<Diagnostic>;
+  configRequests: Array<ConfigRequest>;
+  invalidations: Invalidations;
+  devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
+};
 
 export default class Transformation {
   request: TransformationRequest;
@@ -140,7 +139,7 @@ export default class Transformation {
       // Load existing sourcemaps, this automatically runs the source contents extraction
       try {
         existing = await asset.loadExistingSourcemap();
-      } catch (err) {
+      } catch (err: any) {
         logger.verbose([
           {
             origin: '@atlaspack/core',
@@ -175,6 +174,7 @@ export default class Transformation {
     );
 
     let pipeline = await this.loadPipeline(
+      // @ts-expect-error TS2345
       this.request.filePath,
       asset.value.isSource,
       asset.value.pipeline,
@@ -184,7 +184,7 @@ export default class Transformation {
       let results = await this.runPipelines(pipeline, asset);
       await Promise.all(results.map((asset) => asset.commit()));
       assets = results.map((a) => a.value);
-    } catch (e) {
+    } catch (e: any) {
       error = e;
     }
 
@@ -197,8 +197,8 @@ export default class Transformation {
       ...this.resolverRunner.devDepRequests.values(),
     ]);
 
-    // $FlowFixMe because of $$raw
     return {
+      // @ts-expect-error TS2353
       $$raw: true,
       assets,
       configRequests,
@@ -224,6 +224,7 @@ export default class Transformation {
       size,
       isSource: summarizedIsSource,
     } = await summarizeRequest(this.options.inputFS, {
+      // @ts-expect-error TS2322
       filePath: fromProjectPath(this.options.projectRoot, filePath),
       code,
     });
@@ -234,10 +235,13 @@ export default class Transformation {
     return new UncommittedAsset({
       value: createAsset(this.options.projectRoot, {
         code,
+        // @ts-expect-error TS2322
         filePath,
         isSource,
+        // @ts-expect-error TS2345
         type: path.extname(fromProjectPathRelative(filePath)).slice(1),
         pipeline,
+        // @ts-expect-error TS2322
         env,
         query,
         stats: {
@@ -325,7 +329,7 @@ export default class Transformation {
           range,
         },
       );
-    } catch (err) {
+    } catch (err: any) {
       // ignore
     }
 
@@ -347,8 +351,8 @@ export default class Transformation {
 
     let initialType = initialAsset.value.type;
     let inputAssets = [initialAsset];
-    let resultingAssets = [];
-    let finalAssets = [];
+    let resultingAssets: Array<UncommittedAsset> = [];
+    let finalAssets: Array<UncommittedAsset> = [];
     for (let transformer of pipeline.transformers) {
       resultingAssets = [];
       for (let asset of inputAssets) {
@@ -399,7 +403,7 @@ export default class Transformation {
               ),
             );
           }
-        } catch (e) {
+        } catch (e: any) {
           let diagnostic = errorToDiagnostic(e, {
             origin: transformer.name,
             filePath: fromProjectPath(
@@ -466,7 +470,7 @@ export default class Transformation {
   async loadPipeline(
     filePath: ProjectPath,
     isSource: boolean,
-    pipeline: ?string,
+    pipeline?: string | null,
   ): Promise<Pipeline> {
     let transformers = await this.atlaspackConfig.getTransformers(
       filePath,
@@ -502,13 +506,13 @@ export default class Transformation {
     newType,
     newPipeline,
     currentPipeline,
-  }: {|
-    filePath: ProjectPath,
-    isSource: boolean,
-    newType: string,
-    newPipeline: ?string,
-    currentPipeline: Pipeline,
-  |}): Promise<?Pipeline> {
+  }: {
+    filePath: ProjectPath;
+    isSource: boolean;
+    newType: string;
+    newPipeline: string | null | undefined;
+    currentPipeline: Pipeline;
+  }): Promise<Pipeline | null | undefined> {
     let filePathRelative = fromProjectPathRelative(filePath);
     let nextFilePath = toProjectPathUnsafe(
       filePathRelative.slice(0, -path.extname(filePathRelative).length) +
@@ -529,9 +533,9 @@ export default class Transformation {
   }
 
   async loadTransformerConfig(
-    transformer: LoadedPlugin<Transformer<mixed>>,
+    transformer: LoadedPlugin<Transformer<unknown>>,
     isSource: boolean,
-  ): Promise<?Config> {
+  ): Promise<Config | null | undefined> {
     let loadConfig = transformer.plugin.loadConfig;
     if (!loadConfig) {
       return;
@@ -540,6 +544,7 @@ export default class Transformation {
     let config = createConfig({
       plugin: transformer.name,
       isSource,
+      // @ts-expect-error TS2322
       searchPath: this.request.filePath,
       env: this.request.env,
     });
@@ -556,12 +561,12 @@ export default class Transformation {
   async runTransformer(
     pipeline: Pipeline,
     asset: UncommittedAsset,
-    transformer: Transformer<mixed>,
+    transformer: Transformer<unknown>,
     transformerName: string,
-    preloadedConfig: ?Config,
-    configKeyPath?: string,
+    preloadedConfig: Config | null | undefined,
+    configKeyPath: string | null | undefined,
     atlaspackConfig: AtlaspackConfig,
-  ): Promise<$ReadOnlyArray<TransformerResult | UncommittedAsset>> {
+  ): Promise<ReadonlyArray<TransformerResult | UncommittedAsset>> {
     const logger = new PluginLogger({origin: transformerName});
     const tracer = new PluginTracer({
       origin: transformerName,
@@ -603,6 +608,7 @@ export default class Transformation {
         throw new ThrowableDiagnostic({diagnostic: result.diagnostics});
       }
 
+      // @ts-expect-error TS2322
       return fromProjectPath(
         this.options.projectRoot,
         nullthrows(result.assetGroup).filePath,
@@ -649,8 +655,8 @@ export default class Transformation {
     }
 
     // Transform.
+    // @ts-expect-error TS2322
     let transfomerResult: Array<TransformerResult | MutableAsset> =
-      // $FlowFixMe the returned IMutableAsset really is a MutableAsset
       await transformer.transform({
         asset: new MutableAsset(asset),
         config,
@@ -712,27 +718,27 @@ export default class Transformation {
   }
 }
 
-type Pipeline = {|
-  id: string,
-  transformers: Array<TransformerWithNameAndConfig>,
-  options: AtlaspackOptions,
-  pluginOptions: PluginOptions,
-  workerApi: WorkerApi,
-  postProcess?: PostProcessFunc,
-  generate?: GenerateFunc,
-|};
-
-type TransformerWithNameAndConfig = {|
-  name: PackageName,
-  plugin: Transformer<mixed>,
-  config: ?Config,
-  configKeyPath?: string,
-  resolveFrom: ProjectPath,
-  range?: ?SemverRange,
-|};
+type Pipeline = {
+  id: string;
+  transformers: Array<TransformerWithNameAndConfig>;
+  options: AtlaspackOptions;
+  pluginOptions: PluginOptions;
+  workerApi: WorkerApi;
+  postProcess?: PostProcessFunc;
+  generate?: GenerateFunc;
+};
+
+type TransformerWithNameAndConfig = {
+  name: PackageName;
+  plugin: Transformer<unknown>;
+  config: Config | null | undefined;
+  configKeyPath?: string;
+  resolveFrom: ProjectPath;
+  range?: SemverRange | null | undefined;
+};
 
 function normalizeAssets(
-  options,
+  options: AtlaspackOptions,
   results: Array<TransformerResult | MutableAsset>,
 ): Array<TransformerResult | UncommittedAsset> {
   return results.map((result) => {