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

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',
@@ -470,20 +533,22 @@ export function propagateSymbols({
             incomingDep.value.symbols != null &&
             incomingDep.usedSymbolsUp.size === 0
           ) {
-            let assetGroups = assetGraph.getNodeIdsConnectedFrom(
+            let connectedNodeIds = assetGraph.getNodeIdsConnectedFrom(
               assetGraph.getNodeIdByContentKey(incomingDep.id),
             );
-            if (assetGroups.length === 1) {
-              let [assetGroupId] = assetGroups;
-              let assetGroup = nullthrows(assetGraph.getNode(assetGroupId));
-              if (
-                assetGroup.type === 'asset_group' &&
-                assetGroup.value.sideEffects === false
-              ) {
-                incomingDep.excluded = true;
-              }
-            } else {
-              invariant(assetGroups.length === 0);
+
+            let sideEffectFree = connectedNodeIds.every((nodeId) => {
+              let connectedNode = nullthrows(assetGraph.getNode(nodeId));
+              // Dependencies should only connect to asset_groups or assets
+              invariant(
+                connectedNode.type === 'asset' ||
+                  connectedNode.type === 'asset_group',
+              );
+              return connectedNode.value.sideEffects === false;
+            });
+
+            if (sideEffectFree) {
+              incomingDep.excluded = true;
             }
           }
         }
@@ -496,7 +561,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 +578,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 +665,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 +683,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 +702,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 +711,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 +742,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 +794,7 @@ function propagateSymbolsUp(
     } else {
       let connectedNodes = assetGraph.getNodeIdsConnectedTo(queuedNodeId);
       if (connectedNodes.length > 0) {
+        // @ts-expect-error TS2556
         queue.add(...connectedNodes);
       }
     }
@@ -735,22 +809,46 @@ function getDependencyResolution(
 ): Array<NodeId> {
   let depNodeId = graph.getNodeIdByContentKey(depId);
   let connected = graph.getNodeIdsConnectedFrom(depNodeId);
-  invariant(connected.length <= 1);
-  let child = connected[0];
-  if (child) {
+
+  let resolvedNodeIds: Array<NodeId> = [];
+
+  // If any of the resolved nodes is an asset_group, we need to resolve its
+  // assets here.
+  for (let child of connected) {
+    if (!child) {
+      continue;
+    }
+
     let childNode = nullthrows(graph.getNode(child));
     if (childNode.type === 'asset_group') {
-      return graph.getNodeIdsConnectedFrom(child);
+      resolvedNodeIds.push(...graph.getNodeIdsConnectedFrom(child));
     } else {
-      return [child];
+      resolvedNodeIds.push(child);
     }
   }
-  return [];
+
+  return resolvedNodeIds;
 }
 
 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 +865,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 +886,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,
 };