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

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {WorkerApi} from '@atlaspack/workers';
 import type {AssetGroup, AtlaspackOptions, ReportFn} from './types';
 import type {Validator, ValidateResult} from '@atlaspack/types';
@@ -18,29 +16,34 @@ import summarizeRequest from './summarizeRequest';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {PluginTracer} from '@atlaspack/profiler';
 
-export type ValidationOpts = {|
-  config: AtlaspackConfig,
+export type ValidationOpts = {
+  config: AtlaspackConfig;
   /**
    * If true, this Validation instance will run all validators that implement the single-threaded "validateAll" method.
    * If falsy, it will run validators that implement the one-asset-at-a-time "validate" method.
    */
-  dedicatedThread?: boolean,
-  options: AtlaspackOptions,
-  requests: AssetGroup[],
-  report: ReportFn,
-  workerApi?: WorkerApi,
-|};
+  dedicatedThread?: boolean;
+  options: AtlaspackOptions;
+  requests: AssetGroup[];
+  report: ReportFn;
+  workerApi?: WorkerApi;
+};
 
 export default class Validation {
-  allAssets: {[validatorName: string]: UncommittedAsset[], ...} = {};
-  allValidators: {[validatorName: string]: Validator, ...} = {};
+  allAssets: {
+    [validatorName: string]: UncommittedAsset[];
+  } = {};
+  allValidators: {
+    [validatorName: string]: Validator;
+  } = {};
   dedicatedThread: boolean;
-  impactfulOptions: $Shape<AtlaspackOptions>;
+  // @ts-expect-error TS2564
+  impactfulOptions: Partial<AtlaspackOptions>;
   options: AtlaspackOptions;
   atlaspackConfig: AtlaspackConfig;
   report: ReportFn;
   requests: AssetGroup[];
-  workerApi: ?WorkerApi;
+  workerApi: WorkerApi | null | undefined;
 
   constructor({
     config,
@@ -71,10 +74,12 @@ export default class Validation {
             origin: validatorName,
             category: 'validator',
           });
-          let validatorResults: Array<?ValidateResult> = [];
+          let validatorResults: Array<ValidateResult | null | undefined> = [];
           try {
             // If the plugin supports the single-threading validateAll method, pass all assets to it.
+            // @ts-expect-error TS2339
             if (plugin.validateAll && this.dedicatedThread) {
+              // @ts-expect-error TS2339
               validatorResults = await plugin.validateAll({
                 assets: assets.map((asset) => new Asset(asset)),
                 options: pluginOptions,
@@ -94,12 +99,15 @@ export default class Validation {
             }
 
             // Otherwise, pass the assets one-at-a-time
+            // @ts-expect-error TS2339
             else if (plugin.validate && !this.dedicatedThread) {
               await Promise.all(
                 assets.map(async (input) => {
                   let config = null;
                   let publicAsset = new Asset(input);
+                  // @ts-expect-error TS2339
                   if (plugin.getConfig) {
+                    // @ts-expect-error TS2339
                     config = await plugin.getConfig({
                       asset: publicAsset,
                       options: pluginOptions,
@@ -115,6 +123,7 @@ export default class Validation {
                     });
                   }
 
+                  // @ts-expect-error TS2339
                   let validatorResult = await plugin.validate({
                     asset: publicAsset,
                     options: pluginOptions,
@@ -127,7 +136,7 @@ export default class Validation {
               );
             }
             this.handleResults(validatorResults);
-          } catch (e) {
+          } catch (e: any) {
             throw new ThrowableDiagnostic({
               diagnostic: errorToDiagnostic(e, {
                 origin: validatorName,
@@ -145,12 +154,14 @@ export default class Validation {
       this.requests.map(async (request) => {
         this.report({
           type: 'validation',
+          // @ts-expect-error TS2322
           filePath: fromProjectPath(this.options.projectRoot, request.filePath),
         });
 
         let asset = await this.loadAsset(request);
 
         let validators = await this.atlaspackConfig.getValidators(
+          // @ts-expect-error TS2345
           request.filePath,
         );
 
@@ -166,7 +177,7 @@ export default class Validation {
     );
   }
 
-  handleResults(validatorResults: Array<?ValidateResult>) {
+  handleResults(validatorResults: Array<ValidateResult | null | undefined>) {
     let warnings: Array<Diagnostic> = [];
     let errors: Array<Diagnostic> = [];
     validatorResults.forEach((result) => {
@@ -192,6 +203,7 @@ export default class Validation {
     let {content, size, isSource} = await summarizeRequest(
       this.options.inputFS,
       {
+        // @ts-expect-error TS2322
         filePath: fromProjectPath(this.options.projectRoot, request.filePath),
       },
     );
@@ -199,10 +211,13 @@ export default class Validation {
     return new UncommittedAsset({
       value: createAsset(this.options.projectRoot, {
         code,
+        // @ts-expect-error TS2322
         filePath: filePath,
         isSource,
+        // @ts-expect-error TS2345
         type: path.extname(fromProjectPathRelative(filePath)).slice(1),
         query,
+        // @ts-expect-error TS2322
         env: env,
         stats: {
           time: 0,

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {ContentKey} from '@atlaspack/graph';
 import type {Dependency, NamedBundle as INamedBundle} from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
@@ -11,6 +9,7 @@ import type {
   DevDepRequest,
   AtlaspackOptions,
   DevDepRequestRef,
+  DependencyNode,
 } from './types';
 import type {AtlaspackConfig} from './AtlaspackConfig';
 import type PluginOptions from './public/PluginOptions';
@@ -21,6 +20,7 @@ import assert from 'assert';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import {nodeFromAssetGroup} from './AssetGraph';
+import type AssetGraph from './AssetGraph';
 import BundleGraph from './public/BundleGraph';
 import InternalBundleGraph, {bundleGraphEdgeTypes} from './BundleGraph';
 import {NamedBundle} from './public/Bundle';
@@ -34,13 +34,15 @@ import {createDevDependency, runDevDepRequest} from './requests/DevDepRequest';
 import {toProjectPath, fromProjectPathRelative} from './projectPath';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {DefaultMap} from '@atlaspack/utils';
+import {fromEnvironmentId} from './EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
-type RuntimeConnection = {|
-  bundle: InternalBundle,
-  assetGroup: AssetGroup,
-  dependency: ?Dependency,
-  isEntry: ?boolean,
-|};
+type RuntimeConnection = {
+  bundle: InternalBundle;
+  assetGroup: AssetGroup;
+  dependency: Dependency | null | undefined;
+  isEntry: boolean | null | undefined;
+};
 
 function nameRuntimeBundle(
   bundle: InternalBundle,
@@ -70,7 +72,7 @@ function nameRuntimeBundle(
  * Introduction of manifest bundles: https://github.com/parcel-bundler/parcel/pull/8837
  * Introduction of reverse topology: https://github.com/parcel-bundler/parcel/pull/8981
  */
-export default async function applyRuntimes<TResult: RequestResult>({
+export default async function applyRuntimes<TResult extends RequestResult>({
   bundleGraph,
   config,
   options,
@@ -80,17 +82,17 @@ export default async function applyRuntimes<TResult: RequestResult>({
   previousDevDeps,
   devDepRequests,
   configs,
-}: {|
-  bundleGraph: InternalBundleGraph,
-  config: AtlaspackConfig,
-  options: AtlaspackOptions,
-  optionsRef: SharedReference,
-  pluginOptions: PluginOptions,
-  api: RunAPI<TResult>,
-  previousDevDeps: Map<string, string>,
-  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>,
-  configs: Map<string, Config>,
-|}): Promise<Map<string, Asset>> {
+}: {
+  bundleGraph: InternalBundleGraph;
+  config: AtlaspackConfig;
+  options: AtlaspackOptions;
+  optionsRef: SharedReference;
+  pluginOptions: PluginOptions;
+  api: RunAPI<TResult>;
+  previousDevDeps: Map<string, string>;
+  devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+  configs: Map<string, Config>;
+}): Promise<Map<string, Asset>> {
   let runtimes = await config.getRuntimes();
 
   /**
@@ -106,9 +108,11 @@ export default async function applyRuntimes<TResult: RequestResult>({
    * order), so that children will always be available when parents try to reference
    * them.
    */
-  let bundles = [];
+  // @ts-expect-error TS2304
+  let bundles: Array<Bundle> = [];
   bundleGraph.traverseBundles({
-    exit(bundle) {
+    // @ts-expect-error TS2304
+    exit(bundle: Bundle) {
       bundles.push(bundle);
     },
   });
@@ -149,7 +153,9 @@ export default async function applyRuntimes<TResult: RequestResult>({
             filePath,
             isEntry,
             env,
+            runtimeAssetRequiringExecutionOnLoad,
             priority,
+            symbolData,
           } of runtimeAssets) {
             let sourceName = path.join(
               path.dirname(filePath),
@@ -158,11 +164,17 @@ export default async function applyRuntimes<TResult: RequestResult>({
 
             let assetGroup = {
               code,
+              runtimeAssetRequiringExecutionOnLoad,
               filePath: toProjectPath(options.projectRoot, sourceName),
-              env: mergeEnvironments(options.projectRoot, bundle.env, env),
+              env: mergeEnvironments(
+                options.projectRoot,
+                fromEnvironmentId(bundle.env),
+                env,
+              ),
               // Runtime assets should be considered source, as they should be
               // e.g. compiled to run in the target environment
               isSource: true,
+              symbolData,
             };
 
             let connectionBundle = bundle;
@@ -200,6 +212,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
               nameRuntimeBundle(connectionBundle, bundle);
             }
 
+            // @ts-expect-error TS2345
             connectionMap.get(connectionBundle).push({
               bundle: connectionBundle,
               assetGroup,
@@ -208,7 +221,7 @@ export default async function applyRuntimes<TResult: RequestResult>({
             });
           }
         }
-      } catch (e) {
+      } catch (e: any) {
         throw new ThrowableDiagnostic({
           diagnostic: errorToDiagnostic(e, {
             origin: runtime.name,
@@ -238,7 +251,8 @@ export default async function applyRuntimes<TResult: RequestResult>({
    */
   let connections: Array<RuntimeConnection> = [];
   bundleGraph.traverseBundles({
-    enter(bundle) {
+    // @ts-expect-error TS2304
+    enter(bundle: Bundle) {
       connections.push(...connectionMap.get(bundle));
     },
   });
@@ -267,6 +281,11 @@ export default async function applyRuntimes<TResult: RequestResult>({
   let {assetGraph: runtimesAssetGraph, changedAssets} =
     await reconcileNewRuntimes(api, connections, optionsRef);
 
+  if (getFeatureFlag('skipRuntimeSymbolProp')) {
+    // Apply pre-computed symbol data from runtime assets to skip symbol propagation
+    applyRuntimeSymbolData(runtimesAssetGraph, connections);
+  }
+
   // Convert the runtime AssetGraph into a BundleGraph, this includes assigning
   // the assets their public ids
   let runtimesBundleGraph = InternalBundleGraph.fromAssetGraph(
@@ -389,7 +408,94 @@ export default async function applyRuntimes<TResult: RequestResult>({
   return changedAssets;
 }
 
-function reconcileNewRuntimes<TResult: RequestResult>(
+/**
+ * Apply pre-computed symbol data from runtime assets to the asset graph
+ * to avoid running symbol propagation on runtime code we control.
+ */
+function applyRuntimeSymbolData(
+  assetGraph: AssetGraph,
+  connections: Array<RuntimeConnection>,
+) {
+  for (let {assetGroup} of connections) {
+    let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    let assetGroupAssetNodeIds = assetGraph.getNodeIdsConnectedFrom(
+      assetGraph.getNodeIdByContentKey(assetGroupNode.id),
+    );
+
+    if (assetGroupAssetNodeIds.length !== 1) {
+      continue;
+    }
+
+    let runtimeAssetNodeId = assetGroupAssetNodeIds[0];
+    let runtimeAssetNode = assetGraph.getNode(runtimeAssetNodeId);
+    if (!runtimeAssetNode || runtimeAssetNode.type !== 'asset') {
+      continue;
+    }
+
+    let symbolData = assetGroup.symbolData;
+    if (!symbolData) {
+      // We completely skip symbol propagation for runtime assets, so symbolData
+      // is required
+      throw new Error('Runtime asset is missing symbol data');
+    }
+
+    if (symbolData.symbols) {
+      // Convert from SymbolData format to internal Asset.symbols format
+      let internalSymbols = new Map();
+      for (let [symbol, data] of symbolData.symbols) {
+        internalSymbols.set(symbol, {
+          local: data.local,
+          loc: data.loc || null,
+          meta: data.meta,
+        });
+      }
+      runtimeAssetNode.value.symbols = internalSymbols;
+    }
+
+    if (symbolData.dependencies && symbolData.dependencies.length > 0) {
+      let outgoingDeps = assetGraph
+        .getNodeIdsConnectedFrom(runtimeAssetNodeId)
+        .map((id) => assetGraph.getNode(id))
+        .filter((node) => node?.type === 'dependency')
+        .map((node) => node as DependencyNode);
+
+      for (let depSymbolData of symbolData.dependencies) {
+        let matchingDep = outgoingDeps.find(
+          (depNode) => depNode.value.specifier === depSymbolData.specifier,
+        );
+
+        if (matchingDep) {
+          if (depSymbolData.symbols) {
+            let internalDepSymbols = new Map();
+            for (let [symbol, data] of depSymbolData.symbols) {
+              internalDepSymbols.set(symbol, {
+                local: data.local,
+                loc: data.loc || null,
+                isWeak: data.isWeak,
+                meta: data.meta,
+              });
+            }
+            matchingDep.value.symbols = internalDepSymbols;
+          }
+
+          if (depSymbolData.usedSymbols) {
+            matchingDep.usedSymbolsDown = new Set(depSymbolData.usedSymbols);
+            // For runtime assets, usedSymbolsUp will be the same as usedSymbolsDown
+            // since we know exactly what we're using
+            let usedSymbolsUp = new Map();
+            for (let symbol of depSymbolData.usedSymbols) {
+              // Mark as resolved to external (null) since runtime deps are typically external
+              usedSymbolsUp.set(symbol, null);
+            }
+            matchingDep.usedSymbolsUp = usedSymbolsUp;
+          }
+        }
+      }
+    }
+  }
+}
+
+function reconcileNewRuntimes<TResult extends RequestResult>(
   api: RunAPI<TResult>,
   connections: Array<RuntimeConnection>,
   optionsRef: SharedReference,
@@ -399,6 +505,9 @@ function reconcileNewRuntimes<TResult: RequestResult>(
     name: 'Runtimes',
     assetGroups,
     optionsRef,
+    skipSymbolProp:
+      getFeatureFlag('skipRuntimeSymbolProp') ||
+      getFeatureFlag('rustSymbolTracker'),
   });
 
   // rebuild the graph

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   ASTGenerator,
   BundleBehavior,
@@ -16,7 +14,6 @@ import type {
   Asset,
   RequestInvalidation,
   Dependency,
-  Environment,
   AtlaspackOptions,
 } from './types';
 
@@ -32,7 +29,7 @@ import PluginOptions from './public/PluginOptions';
 import {blobToStream, hashFile} from '@atlaspack/utils';
 import {hashFromOption, toInternalSourceLocation} from './utils';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPath,
   fromProjectPathRelative,
 } from './projectPath';
@@ -40,45 +37,58 @@ import {hashString, createAssetId as createAssetIdRust} from '@atlaspack/rust';
 import {BundleBehavior as BundleBehaviorMap} from './types';
 import {PluginTracer} from '@atlaspack/profiler';
 import {identifierRegistry} from './IdentifierRegistry';
+import type {EnvironmentRef} from './EnvironmentManager';
+import {toEnvironmentId} from './EnvironmentManager';
+import SourceMap from '@atlaspack/source-map';
 
-export type AssetOptions = {|
-  id?: string,
-  committed?: boolean,
-  code: string | void | null,
-  filePath: ProjectPath,
-  query?: ?string,
-  type: string,
-  contentKey?: ?string,
-  mapKey?: ?string,
-  astKey?: ?string,
-  astGenerator?: ?ASTGenerator,
-  dependencies?: Map<string, Dependency>,
-  bundleBehavior?: ?BundleBehavior,
-  isBundleSplittable?: ?boolean,
-  isSource: boolean,
-  env: Environment,
-  meta?: Meta,
-  outputHash?: ?string,
-  pipeline?: ?string,
-  stats: Stats,
-  symbols?: ?Map<Symbol, {|local: Symbol, loc: ?SourceLocation, meta?: ?Meta|}>,
-  sideEffects?: boolean,
-  uniqueKey?: ?string,
-  plugin?: PackageName,
-  configPath?: ProjectPath,
-  configKeyPath?: string,
-|};
+export type AssetOptions = {
+  id?: string;
+  committed?: boolean;
+  code: string | undefined | null;
+  filePath: ProjectPath;
+  query?: string | null | undefined;
+  type: string;
+  contentKey?: string | null | undefined;
+  mapKey?: string | null | undefined;
+  astKey?: string | null | undefined;
+  astGenerator?: ASTGenerator | null | undefined;
+  dependencies?: Map<string, Dependency>;
+  bundleBehavior?: BundleBehavior | null | undefined;
+  isBundleSplittable?: boolean | null | undefined;
+  isSource: boolean;
+  env: EnvironmentRef;
+  meta?: Meta;
+  outputHash?: string | null | undefined;
+  pipeline?: string | null | undefined;
+  stats: Stats;
+  symbols?:
+    | Map<
+        symbol,
+        {
+          local: symbol;
+          loc: SourceLocation | null | undefined;
+          meta?: Meta | null | undefined;
+        }
+      >
+    | null
+    | undefined;
+  sideEffects?: boolean;
+  uniqueKey?: string | null | undefined;
+  plugin?: PackageName;
+  configPath?: ProjectPath;
+  configKeyPath?: string;
+};
 
 export function createAssetIdFromOptions(options: AssetOptions): string {
   const data = {
-    environmentId: options.env.id,
+    environmentId: toEnvironmentId(options.env),
     filePath: options.filePath,
     code: options.code,
     pipeline: options.pipeline,
     query: options.query,
     uniqueKey: options.uniqueKey,
     fileType: options.type,
-  };
+  } as const;
   const id = createAssetIdRust(data);
   identifierRegistry.addIdentifier('asset', id, data);
   return id;
@@ -112,7 +122,7 @@ export function createAsset(
     symbols:
       options.symbols &&
       new Map(
-        [...options.symbols].map(([k, v]) => [
+        [...options.symbols].map(([k, v]: [any, any]) => [
           k,
           {
             local: v.local,
@@ -149,7 +159,7 @@ async function _generateFromAST(asset: CommittedAsset | UncommittedAsset) {
   }
 
   let pluginName = nullthrows(asset.value.plugin);
-  let {plugin} = await loadPlugin<Transformer<mixed>>(
+  let {plugin} = await loadPlugin<Transformer<unknown>>(
     pluginName,
     fromProjectPath(
       asset.options.projectRoot,
@@ -171,7 +181,7 @@ async function _generateFromAST(asset: CommittedAsset | UncommittedAsset) {
     tracer: new PluginTracer({origin: pluginName, category: 'asset-generate'}),
   });
 
-  let mapBuffer = map?.toBuffer();
+  let mapBuffer = SourceMap.safeToBuffer(map);
   // Store the results in the cache so we can avoid generating again next time
   await Promise.all([
     asset.options.cache.setStream(
@@ -200,6 +210,7 @@ export function getInvalidationId(invalidation: RequestInvalidation): string {
     case 'option':
       return 'option:' + invalidation.key;
     default:
+      // @ts-expect-error TS2339
       throw new Error('Unknown invalidation type: ' + invalidation.type);
   }
 }
@@ -240,9 +251,11 @@ export async function getInvalidationHash(
         break;
       case 'option':
         hashes +=
+          // @ts-expect-error TS7053
           invalidation.key + ':' + hashFromOption(options[invalidation.key]);
         break;
       default:
+        // @ts-expect-error TS2339
         throw new Error('Unknown invalidation type: ' + invalidation.type);
     }
   }