@atlaspack/core 2.26.3-dev-compiled-hash-e5f8a1735.0 → 2.28.0

package/src/BundleGraph.ts

@@ -1435,6 +1435,158 @@ export default class BundleGraph {
     });
   }
 
+  // New method: Fast checks only (no caching of results)
+  isAssetReferencedFastCheck(bundle: Bundle, asset: Asset): boolean | null {
+    // Fast Check #1: If asset is in multiple bundles in same target, it's referenced
+    let bundlesWithAsset = this.getBundlesWithAsset(asset).filter(
+      (b) =>
+        b.target.name === bundle.target.name &&
+        b.target.distDir === bundle.target.distDir,
+    );
+
+    if (bundlesWithAsset.length > 1) {
+      return true;
+    }
+
+    // Fast Check #2: If asset is referenced by any async/conditional dependency, it's referenced
+    let assetNodeId = nullthrows(this._graph.getNodeIdByContentKey(asset.id));
+
+    if (
+      this._graph
+        .getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references)
+        .map((id) => this._graph.getNode(id))
+        .some(
+          (node) =>
+            node?.type === 'dependency' &&
+            (node.value.priority === Priority.lazy ||
+              node.value.priority === Priority.conditional) &&
+            node.value.specifierType !== SpecifierType.url,
+        )
+    ) {
+      return true;
+    }
+
+    // Fast checks failed - return null to indicate expensive computation needed
+    return null;
+  }
+
+  getReferencedAssets(bundle: Bundle): Set<Asset> {
+    let referencedAssets = new Set<Asset>();
+
+    // Build a map of all assets in this bundle with their dependencies
+    // This allows us to check all assets in a single traversal
+    let assetDependenciesMap = new Map<Asset, Array<Dependency>>();
+
+    this.traverseAssets(bundle, (asset) => {
+      // Always do fast checks (no caching)
+      let fastCheckResult = this.isAssetReferencedFastCheck(bundle, asset);
+
+      if (fastCheckResult === true) {
+        referencedAssets.add(asset);
+        return;
+      }
+
+      // Fast checks failed (fastCheckResult === null), need expensive computation
+      // Check if it's actually referenced via traversal
+
+      // Store dependencies for later batch checking
+      let dependencies = this._graph
+        .getNodeIdsConnectedTo(
+          nullthrows(this._graph.getNodeIdByContentKey(asset.id)),
+        )
+        .map((id) => nullthrows(this._graph.getNode(id)))
+        .filter((node) => node.type === 'dependency')
+        .map((node) => {
+          invariant(node.type === 'dependency');
+          return node.value;
+        });
+
+      if (dependencies.length > 0) {
+        assetDependenciesMap.set(asset, dependencies);
+      }
+    });
+
+    // If no assets need the expensive check, return early
+    if (assetDependenciesMap.size === 0) {
+      return referencedAssets;
+    }
+
+    // Get the assets we need to check once
+    let assetsToCheck = Array.from(assetDependenciesMap.keys());
+
+    // Helper function to check if all assets from assetDependenciesMap are in referencedAssets
+    const allAssetsReferenced = (): boolean =>
+      assetsToCheck.length <= referencedAssets.size &&
+      assetsToCheck.every((asset) => referencedAssets.has(asset));
+
+    // Do ONE traversal to check all remaining assets
+    // We can share visitedBundles across all assets because we check every asset
+    // against every visited bundle, which matches the original per-asset behavior
+    let siblingBundles = new Set(
+      this.getBundleGroupsContainingBundle(bundle).flatMap((bundleGroup) =>
+        this.getBundlesInBundleGroup(bundleGroup, {includeInline: true}),
+      ),
+    );
+
+    let visitedBundles: Set<Bundle> = new Set();
+
+    // Single traversal from all referencers
+    for (let referencer of siblingBundles) {
+      this.traverseBundles((descendant, _, actions) => {
+        if (descendant.id === bundle.id) {
+          return;
+        }
+
+        if (visitedBundles.has(descendant)) {
+          actions.skipChildren();
+          return;
+        }
+
+        visitedBundles.add(descendant);
+
+        if (
+          descendant.type !== bundle.type ||
+          fromEnvironmentId(descendant.env).context !==
+            fromEnvironmentId(bundle.env).context
+        ) {
+          // Don't skip children - they might be the right type!
+          return;
+        }
+
+        // Check ALL assets at once in this descendant bundle
+        for (let [asset, dependencies] of assetDependenciesMap) {
+          // Skip if already marked as referenced
+          if (referencedAssets.has(asset)) {
+            continue;
+          }
+
+          // Check if this descendant bundle references the asset
+          if (
+            !this.bundleHasAsset(descendant, asset) &&
+            dependencies.some((dependency) =>
+              this.bundleHasDependency(descendant, dependency),
+            )
+          ) {
+            referencedAssets.add(asset);
+          }
+        }
+
+        // If all assets from assetDependenciesMap are now marked as referenced, we can stop early
+        if (allAssetsReferenced()) {
+          actions.stop();
+          return;
+        }
+      }, referencer);
+
+      // If all assets from assetDependenciesMap are referenced, no need to check more sibling bundles
+      if (allAssetsReferenced()) {
+        break;
+      }
+    }
+
+    return referencedAssets;
+  }
+
   hasParentBundleOfType(bundle: Bundle, type: string): boolean {
     let parents = this.getParentBundles(bundle);
     return (

package/src/CommittedAsset.ts

@@ -3,7 +3,7 @@ import {Readable} from 'stream';
 import {deserializeRaw} from '@atlaspack/build-cache';
 import type {AST, Blob} from '@atlaspack/types';
 import {bufferStream, blobToStream, streamFromPromise} from '@atlaspack/utils';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 
 import {generateFromAST} from './assetUtils';
 import type {Asset, Dependency, AtlaspackOptions} from './types';

package/src/PackagerRunner.ts

@@ -7,7 +7,7 @@ import type {
   NamedBundle as NamedBundleType,
   Async,
 } from '@atlaspack/types';
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type {
   Bundle as InternalBundle,
   Config,

package/src/Transformation.ts

@@ -69,6 +69,7 @@ import {
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
 import invariant from 'assert';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import SourceMap from '@atlaspack/source-map';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type GenerateFunc = (input: UncommittedAsset) => Promise<GenerateOutput>;
@@ -460,7 +461,7 @@ export default class Transformation {
           if (asset.isASTDirty && asset.generate) {
             let output = await asset.generate();
             asset.content = output.content;
-            asset.mapBuffer = output.map?.toBuffer();
+            asset.mapBuffer = SourceMap.safeToBuffer(output.map);
           }
 
           asset.clearAST();
@@ -634,7 +635,7 @@ export default class Transformation {
     ) {
       let output = await asset.generate();
       asset.content = output.content;
-      asset.mapBuffer = output.map?.toBuffer();
+      asset.mapBuffer = SourceMap.safeToBuffer(output.map);
     }
 
     // Load config for the transformer.

package/src/UncommittedAsset.ts

@@ -11,7 +11,7 @@ import type {Asset, Dependency, AtlaspackOptions, Invalidations} from './types';
 
 import invariant from 'assert';
 import {Readable} from 'stream';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import {serializeRaw} from '@atlaspack/build-cache';
 import {
   blobToStream,
@@ -249,7 +249,7 @@ export default class UncommittedAsset {
 
     if (map) {
       this.map = map;
-      this.mapBuffer = map.toBuffer();
+      this.mapBuffer = SourceMap.safeToBuffer(map);
       this.setCode(code.replace(SOURCEMAP_RE, ''));
     }
 
@@ -425,7 +425,7 @@ export default class UncommittedAsset {
       content,
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
-      mapBuffer: result.map ? result.map.toBuffer() : null,
+      mapBuffer: SourceMap.safeToBuffer(result.map),
       code: this.code,
       invalidations: this.invalidations,
     });

package/src/assetUtils.ts

@@ -39,6 +39,7 @@ 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;
@@ -180,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(

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/compat/mutable-asset.ts

@@ -1,4 +1,4 @@
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import * as napi from '@atlaspack/rust';
 import {Readable} from 'stream';
 import type {

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(
@@ -161,7 +171,7 @@ export class AtlaspackWorker {
           type: 'resolved',
           filePath: result.filePath || '',
           canDefer: result.canDefer || false,
-          sideEffects: result.sideEffects || false,
+          sideEffects: result.sideEffects ?? true,
           code: result.code || undefined,
           meta: result.meta || undefined,
           pipeline: result.pipeline || undefined,

package/src/public/Asset.ts

@@ -1,4 +1,4 @@
-import type SourceMap from '@parcel/source-map';
+import type SourceMap from '@atlaspack/source-map';
 import type {Readable} from 'stream';
 import type {FileSystem} from '@atlaspack/fs';
 

package/src/public/BundleGraph.ts

@@ -198,6 +198,27 @@ export default class BundleGraph<TBundle extends IBundle>
     );
   }
 
+  isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null {
+    return this.#graph.isAssetReferencedFastCheck(
+      bundleToInternalBundle(bundle),
+      assetToAssetValue(asset),
+    );
+  }
+
+  getReferencedAssets(bundle: IBundle): Set<IAsset> {
+    let internalReferencedAssets = this.#graph.getReferencedAssets(
+      bundleToInternalBundle(bundle),
+    );
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set<IAsset>();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add(assetFromValue(internalAsset, this.#options));
+    }
+
+    return publicReferencedAssets;
+  }
+
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),

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(