@atlaspack/core 2.26.2 → 2.27.0

package/lib/requests/AssetGraphRequestRust.js

@@ -38,6 +38,7 @@ var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
 var _Environment = require("../Environment");
+var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
@@ -47,12 +48,24 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       let options = input.options;
       let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
 
-      // @ts-expect-error TS7006
+      // Newly created nodes
       serializedAssetGraph.nodes = serializedAssetGraph.nodes.map(node => JSON.parse(node));
+
+      // Updated existing nodes
+      serializedAssetGraph.updates = serializedAssetGraph.updates.map(node => JSON.parse(node));
+
+      // Don't reuse a previous asset graph result if Rust didn't have one too
+      let prevResult = null;
+      if (serializedAssetGraph.hadPreviousGraph) {
+        prevResult = await input.api.getPreviousResult();
+      }
       let {
         assetGraph,
         changedAssets
-      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
+      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => {
+        var _prevResult;
+        return getAssetGraph(serializedAssetGraph, (_prevResult = prevResult) === null || _prevResult === void 0 ? void 0 : _prevResult.assetGraph);
+      });
       let changedAssetsPropagation = new Set(changedAssets.keys());
       let errors = (0, _SymbolPropagation.propagateSymbols)({
         options,
@@ -69,7 +82,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
           diagnostic: [...errors.values()][0]
         });
       }
-      return {
+      await (0, _dumpGraphToGraphViz.default)(assetGraph, 'AssetGraphV3');
+      let result = {
         assetGraph,
         assetRequests: [],
         assetGroupsWithRemovedParents: new Set(),
@@ -77,17 +91,54 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         changedAssetsPropagation,
         previousSymbolPropagationErrors: undefined
       };
+      await input.api.storeResult(result);
+      input.api.invalidateOnBuild();
+      return result;
     },
     input
   });
 }
-function getAssetGraph(serializedGraph) {
-  let graph = new _AssetGraph.default({
-    _contentKeyToNodeId: new Map(),
-    _nodeIdToContentKey: new Map(),
-    initialCapacity: serializedGraph.edges.length
-  });
-  graph.safeToIncrementallyBundle = false;
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+  let graph;
+  let reuseEdges = false;
+  if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+      nodes: prevAssetGraph.nodes,
+      rootNodeId: prevAssetGraph.rootNodeId,
+      adjacencyList: prevAssetGraph.adjacencyList
+    });
+    reuseEdges = true;
+  } else if (prevAssetGraph && (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)) {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+      nodes: prevAssetGraph.nodes,
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+      rootNodeId: prevAssetGraph.rootNodeId
+    });
+    graph.safeToIncrementallyBundle = false;
+  } else {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: new Map(),
+      _nodeIdToContentKey: new Map(),
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: serializedGraph.nodes.length + 1
+    });
+    let rootNodeId = graph.addNodeByContentKey('@@root', {
+      id: '@@root',
+      type: 'root',
+      value: null
+    });
+    graph.setRootNodeId(rootNodeId);
+    graph.safeToIncrementallyBundle = false;
+  }
+  (0, _assert().default)(graph, 'Asset graph not initialized');
+  (0, _assert().default)(graph.rootNodeId != null, 'Asset graph has no root node');
 
   // @ts-expect-error TS7031
   function mapSymbols({
@@ -118,20 +169,26 @@ function getAssetGraph(serializedGraph) {
     let envKey = [env.context, env.engines.atlaspack, env.engines.browsers, env.engines.electron, env.engines.node, env.includeNodeModules, env.isLibrary, env.outputFormat, env.shouldScopeHoist, env.shouldOptimize, env.sourceType].join(':');
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = `${envs.size}`;
+      envId = envs.size.toString();
       envs.set(envKey, envId);
     }
     return envId;
   };
-  for (let node of serializedGraph.nodes) {
-    if (node.type === 'root') {
-      let index = graph.addNodeByContentKey('@@root', {
-        id: '@@root',
-        type: 'root',
-        value: null
-      });
-      graph.setRootNodeId(index);
-    } else if (node.type === 'entry') {
+  function updateNode(newNode, isUpdateNode) {
+    if (isUpdateNode) {
+      let existingNode = graph.getNodeByContentKey(newNode.id);
+      (0, _assert().default)(existingNode && existingNode.type === newNode.type);
+      Object.assign(existingNode, newNode);
+    } else {
+      graph.addNodeByContentKey(newNode.id, newNode);
+    }
+  }
+  let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+  let nodesCount = serializedGraph.nodes.length + serializedGraph.updates.length;
+  for (let index = 0; index < nodesCount; index++) {
+    let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+    let node = isUpdateNode ? serializedGraph.updates[index - nodeTypeSwitchoverIndex] : serializedGraph.nodes[index];
+    if (node.type === 'entry') {
       let id = 'entry:' + ++entry;
       graph.addNodeByContentKey(id, {
         id: id,
@@ -159,14 +216,15 @@ function getAssetGraph(serializedGraph) {
         asset.symbols = new Map(asset.symbols.map(mapSymbols));
       }
       changedAssets.set(id, asset);
-      graph.addNodeByContentKey(id, {
+      let assetNode = {
         id,
         type: 'asset',
         usedSymbols: new Set(),
         usedSymbolsDownDirty: true,
         usedSymbolsUpDirty: true,
         value: asset
-      });
+      };
+      updateNode(assetNode, isUpdateNode);
     } else if (node.type === 'dependency') {
       let {
         dependency,
@@ -187,7 +245,7 @@ function getAssetGraph(serializedGraph) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);
       }
-      graph.addNodeByContentKey(id, {
+      let depNode = {
         id,
         type: 'dependency',
         deferred: false,
@@ -200,21 +258,24 @@ function getAssetGraph(serializedGraph) {
         usedSymbolsUpDirtyDown: true,
         usedSymbolsUpDirtyUp: true,
         value: dependency
-      });
+      };
+      updateNode(depNode, isUpdateNode);
     }
   }
-  for (let i = 0; i < serializedGraph.edges.length; i += 2) {
-    let from = serializedGraph.edges[i];
-    let to = serializedGraph.edges[i + 1];
-    let fromNode = graph.getNode(from);
-    let toNode = graph.getNode(to);
-    if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
-      (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
-    }
-    if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
-      fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+  if (!reuseEdges) {
+    for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+      let from = serializedGraph.edges[i];
+      let to = serializedGraph.edges[i + 1];
+      let fromNode = graph.getNode(from);
+      let toNode = graph.getNode(to);
+      if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
+        (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
+      }
+      if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
+        fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+      }
+      graph.addEdge(from, to);
     }
-    graph.addEdge(from, to);
   }
   return {
     assetGraph: graph,

package/lib/requests/AtlaspackConfigRequest.js

@@ -161,33 +161,23 @@ async function resolveAtlaspackConfig(options) {
     extendedFiles
   } = await parseAndProcessConfig(configPath, contents, options);
   if (options.additionalReporters.length > 0) {
-    if (options.featureFlags.deduplicateReporters) {
-      var _config$reporters;
-      const reporterMap = new Map();
-      options.additionalReporters.forEach(({
+    var _config$reporters;
+    const reporterMap = new Map();
+    options.additionalReporters.forEach(({
+      packageName,
+      resolveFrom
+    }) => {
+      reporterMap.set(packageName, {
         packageName,
         resolveFrom
-      }) => {
-        reporterMap.set(packageName, {
-          packageName,
-          resolveFrom
-        });
-      });
-      (_config$reporters = config.reporters) === null || _config$reporters === void 0 || _config$reporters.forEach(reporter => {
-        if (!reporterMap.has(reporter.packageName)) {
-          reporterMap.set(reporter.packageName, reporter);
-        }
       });
-      config.reporters = Array.from(reporterMap.values());
-    } else {
-      config.reporters = [...options.additionalReporters.map(({
-        packageName,
-        resolveFrom
-      }) => ({
-        packageName,
-        resolveFrom
-      })), ...(config.reporters ?? [])];
-    }
+    });
+    (_config$reporters = config.reporters) === null || _config$reporters === void 0 || _config$reporters.forEach(reporter => {
+      if (!reporterMap.has(reporter.packageName)) {
+        reporterMap.set(reporter.packageName, reporter);
+      }
+    });
+    config.reporters = Array.from(reporterMap.values());
   }
   return {
     config,

package/lib/types/atlaspack-v3/worker/compat/bitflags.d.ts

@@ -1,15 +1,14 @@
 import type { BundleBehavior, DependencyPriority, SpecifierType } from '@atlaspack/types';
-export declare class BitFlags<K, V> {
+export declare class BitFlags<K> {
     #private;
-    constructor(source: Partial<Record<K, V>>);
-    into(key: K): V;
-    intoNullable(key?: K | null): V | null | undefined;
-    intoArray(keys: K[]): V[];
-    from(key: V): K;
-    fromNullable(key?: V | null): K | null | undefined;
-    fromArray(keys: V[]): K[];
+    constructor(source: Partial<Record<K, number>>);
+    into(key: K): number;
+    intoNullable(key?: K | null): number | null | undefined;
+    from(key: number): K;
+    fromNullable(key?: number | null): K | null | undefined;
+    toArray(keys: number): K[];
 }
-export declare const bundleBehaviorMap: BitFlags<BundleBehavior, number>;
-export declare const dependencyPriorityMap: BitFlags<DependencyPriority, number>;
-export declare const packageConditionsMap: BitFlags<string, number>;
-export declare const specifierTypeMap: BitFlags<SpecifierType, number>;
+export declare const bundleBehaviorMap: BitFlags<BundleBehavior>;
+export declare const dependencyPriorityMap: BitFlags<DependencyPriority>;
+export declare const packageConditionsMap: BitFlags<string>;
+export declare const specifierTypeMap: BitFlags<SpecifierType>;

package/lib/types/requests/AssetGraphRequestRust.d.ts

@@ -14,7 +14,7 @@ type AssetGraphRequest = {
     input: AssetGraphRequestInput;
 };
 export declare function createAssetGraphRequestRust(rustAtlaspack: AtlaspackV3): (input: AssetGraphRequestInput) => AssetGraphRequest;
-export declare function getAssetGraph(serializedGraph: any): {
+export declare function getAssetGraph(serializedGraph: any, prevAssetGraph?: AssetGraph): {
     assetGraph: AssetGraph;
     changedAssets: Map<string, Asset>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.26.2",
+  "version": "2.27.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -24,20 +24,20 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/cache": "3.2.32",
+    "@atlaspack/cache": "3.2.33",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.26.1",
-    "@atlaspack/fs": "2.15.32",
-    "@atlaspack/graph": "3.5.26",
-    "@atlaspack/logger": "2.14.29",
-    "@atlaspack/package-manager": "2.14.37",
-    "@atlaspack/plugin": "2.14.37",
-    "@atlaspack/profiler": "2.14.34",
-    "@atlaspack/rust": "3.9.1",
-    "@atlaspack/types": "2.15.27",
-    "@atlaspack/utils": "3.1.1",
-    "@atlaspack/workers": "2.14.37",
+    "@atlaspack/feature-flags": "2.26.2",
+    "@atlaspack/fs": "2.15.33",
+    "@atlaspack/graph": "3.6.0",
+    "@atlaspack/logger": "2.14.30",
+    "@atlaspack/package-manager": "2.14.38",
+    "@atlaspack/plugin": "2.14.38",
+    "@atlaspack/profiler": "2.14.35",
+    "@atlaspack/rust": "3.10.0",
+    "@atlaspack/types": "2.15.28",
+    "@atlaspack/utils": "3.1.2",
+    "@atlaspack/workers": "2.14.38",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",

package/src/atlaspack-v3/worker/compat/bitflags.ts

@@ -5,21 +5,20 @@ import type {
 } from '@atlaspack/types';
 
 /// BitFlags is used to map number/string types from napi types
-export class BitFlags<K, V> {
+export class BitFlags<K> {
   // @ts-expect-error TS2344
-  #kv: Partial<Record<K, V>>;
-  // @ts-expect-error TS2344
-  #vk: Partial<Record<V, K>>;
+  #kv: Partial<Record<K, number>>;
+  #vk: Partial<Record<number, K>>;
 
   // @ts-expect-error TS2344
-  constructor(source: Partial<Record<K, V>>) {
+  constructor(source: Partial<Record<K, number>>) {
     this.#kv = source;
     this.#vk = Object.fromEntries(
       Object.entries(source).map((a) => a.reverse()),
     );
   }
 
-  into(key: K): V {
+  into(key: K): number {
     const found = this.#kv[key];
     if (found === undefined) {
       throw new Error(`Invalid BundleBehavior(${key})`);
@@ -27,18 +26,14 @@ export class BitFlags<K, V> {
     return found;
   }
 
-  intoNullable(key?: K | null): V | null | undefined {
+  intoNullable(key?: K | null): number | null | undefined {
     if (key === undefined || key === null) {
       return undefined;
     }
     return this.into(key);
   }
 
-  intoArray(keys: K[]): V[] {
-    return keys.map((key) => this.into(key));
-  }
-
-  from(key: V): K {
+  from(key: number): K {
     const found = this.#vk[key];
     if (found === undefined) {
       throw new Error(`Invalid BundleBehavior(${key})`);
@@ -46,52 +41,60 @@ export class BitFlags<K, V> {
     return found;
   }
 
-  fromNullable(key?: V | null): K | null | undefined {
+  fromNullable(key?: number | null): K | null | undefined {
     if (key === undefined || key === null) {
       return undefined;
     }
     return this.from(key);
   }
 
-  fromArray(keys: V[]): K[] {
-    return keys.map((key) => this.from(key));
+  toArray(keys: number): K[] {
+    let values = [];
+    for (let [key, value] of Object.entries(this.#kv) as [K, number][]) {
+      if ((keys & value) !== 0) {
+        values.push(key);
+      }
+    }
+
+    return values;
   }
 }
 
-export const bundleBehaviorMap: BitFlags<BundleBehavior, number> = new BitFlags(
-  {
-    inline: 0,
-    isolated: 1,
-    inlineIsolated: 2,
-  },
-);
+export const bundleBehaviorMap: BitFlags<BundleBehavior> = new BitFlags({
+  inline: 0,
+  isolated: 1,
+  inlineIsolated: 2,
+});
 
-export const dependencyPriorityMap: BitFlags<DependencyPriority, number> =
-  new BitFlags({
+export const dependencyPriorityMap: BitFlags<DependencyPriority> = new BitFlags(
+  {
     sync: 0,
     parallel: 1,
     lazy: 2,
     conditional: 3,
-  });
+  },
+);
 
-export const packageConditionsMap: BitFlags<string, number> = new BitFlags({
-  import: 0,
-  require: 1,
-  module: 2,
-  node: 3,
-  browser: 4,
-  worker: 5,
-  worklet: 6,
-  electron: 7,
-  development: 8,
-  production: 9,
-  types: 10,
-  default: 11,
-  style: 12,
-  sass: 13,
+// Note: The bitflags must match the bitflags in the Rust code.
+// crates/atlaspack_core/src/types/package_json.rs
+export const packageConditionsMap: BitFlags<string> = new BitFlags({
+  import: 1 << 0,
+  require: 1 << 1,
+  module: 1 << 2,
+  node: 1 << 3,
+  browser: 1 << 4,
+  worker: 1 << 5,
+  worklet: 1 << 6,
+  electron: 1 << 7,
+  development: 1 << 8,
+  production: 1 << 9,
+  types: 1 << 10,
+  default: 1 << 11,
+  style: 1 << 12,
+  sass: 1 << 13,
 });
 
-export const specifierTypeMap: BitFlags<SpecifierType, number> = new BitFlags({
+export const specifierTypeMap: BitFlags<SpecifierType> = new BitFlags({
   esm: 0,
   commonjs: 1,
   url: 2,

package/src/atlaspack-v3/worker/compat/dependency.ts

@@ -70,7 +70,7 @@ export class Dependency implements IDependency {
     this.isOptional = inner.isOptional;
     this.isEntry = inner.isEntry;
     this.loc = inner.loc;
-    this.packageConditions = packageConditionsMap.fromArray(
+    this.packageConditions = packageConditionsMap.toArray(
       inner.packageConditions || [],
     );
     this.sourceAssetId = inner.sourceAssetId;

package/src/atlaspack-v3/worker/worker.ts

@@ -33,27 +33,37 @@ export class AtlaspackWorker {
   #resolvers: Map<string, ResolverState<any>>;
   #transformers: Map<string, TransformerState<any>>;
   #fs: FileSystem;
+  #packageManager: NodePackageManager;
 
   constructor() {
     this.#resolvers = new Map();
     this.#transformers = new Map();
     this.#fs = new NodeFS();
+    this.#packageManager = new NodePackageManager(this.#fs, '/');
   }
 
   loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>> = jsCallable(
     async ({kind, specifier, resolveFrom, featureFlags}) => {
-      let customRequire = module.createRequire(resolveFrom);
-      let resolvedPath = customRequire.resolve(specifier);
-      let resolvedModule = await import(resolvedPath);
+      // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
+      let resolvedModule = await this.#packageManager.require(
+        specifier,
+        resolveFrom,
+        {shouldAutoInstall: false},
+      );
 
       let instance = undefined;
-      if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+      // Check for CommonJS export (module.exports = new Plugin(...))
+      if (resolvedModule[CONFIG]) {
+        instance = resolvedModule[CONFIG];
+      } else if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+        // ESM default export
         instance = resolvedModule.default[CONFIG];
       } else if (
         resolvedModule.default &&
         resolvedModule.default.default &&
         resolvedModule.default.default[CONFIG]
       ) {
+        // Double-wrapped default export
         instance = resolvedModule.default.default[CONFIG];
       } else {
         throw new Error(

package/src/requests/AssetGraphRequest.ts

@@ -81,7 +81,7 @@ export default function createAssetGraphRequest(
         await input.api.getPreviousResult<AssetGraphRequestResult>();
 
       let builder = new AssetGraphBuilder(input, prevResult);
-      let assetGraphRequest = await await builder.build();
+      let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
       assetGraphRequest.assetGraph.setDisableIncrementalBundling(