@atlaspack/core 2.33.1 → 2.35.0

package/src/PackagerRunner.ts

@@ -30,7 +30,6 @@ import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {Readable} from 'stream';
 import nullthrows from 'nullthrows';
 import path from 'path';
-import url from 'url';
 import {hashString, hashBuffer, Hash} from '@atlaspack/rust';
 
 import {NamedBundle, bundleToInternalBundle} from './public/Bundle';
@@ -60,9 +59,9 @@ import {
 import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
+import {computeSourceMapRoot} from './requests/WriteBundleRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {fromEnvironmentId} from './EnvironmentManager';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type Opts = {
   config: AtlaspackConfig;
@@ -590,64 +589,24 @@ export default class PackagerRunner {
     bundle: InternalBundle,
     map: SourceMap,
   ): Promise<string> {
-    // sourceRoot should be a relative path between outDir and rootDir for node.js targets
+    let sourceRoot = computeSourceMapRoot(bundle, this.options);
+    let inlineSources = sourceRoot === undefined;
+
     let filePath = joinProjectPath(
       bundle.target.distDir,
       nullthrows(bundle.name),
     );
     let fullPath = fromProjectPath(this.options.projectRoot, filePath);
-    let sourceRoot: string = path.relative(
-      path.dirname(fullPath),
-      this.options.projectRoot,
-    );
-    let inlineSources = false;
+    let mapFilename = fullPath + '.map';
 
     const bundleEnv = fromEnvironmentId(bundle.env);
-    if (bundle.target) {
-      const bundleTargetEnv = fromEnvironmentId(bundle.target.env);
-
-      if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
-        sourceRoot = bundleEnv.sourceMap.sourceRoot;
-      } else if (
-        this.options.serveOptions &&
-        bundleTargetEnv.context === 'browser'
-      ) {
-        sourceRoot = '/__parcel_source_root';
-      }
-
-      if (
-        bundleEnv.sourceMap &&
-        bundleEnv.sourceMap.inlineSources !== undefined
-      ) {
-        inlineSources = bundleEnv.sourceMap.inlineSources;
-      } else if (bundleTargetEnv.context !== 'node') {
-        // inlining should only happen in production for browser targets by default
-        inlineSources = this.options.mode === 'production';
-      }
-    }
-
-    let mapFilename = fullPath + '.map';
     let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
 
-    if (getFeatureFlag('omitSourcesContentInMemory') && !isInlineMap) {
-      if (
-        !(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)
-      ) {
-        /*
-          We're omitting sourcesContent during transformation to allow GC to run.
-          Ensure sources are still inlined into the final source maps written to disk. UNLESS the user explicitly disabled inlineSources.
-        */
-        inlineSources = true;
-      }
-    }
-
     let stringified = await map.stringify({
       file: path.basename(mapFilename),
       fs: this.options.inputFS,
       rootDir: this.options.projectRoot,
-      sourceRoot: !inlineSources
-        ? url.format(url.parse(sourceRoot + '/'))
-        : undefined,
+      sourceRoot,
       inlineSources,
       format: isInlineMap ? 'inline' : 'string',
     });
@@ -694,21 +653,6 @@ export default class PackagerRunner {
       this.options,
     );
 
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const hash = hashString(
-        ATLASPACK_VERSION +
-          devDepHashes +
-          invalidationHash +
-          bundle.target.publicUrl +
-          bundleGraph.getHash(bundle) +
-          JSON.stringify(configResults) +
-          JSON.stringify(globalInfoResults) +
-          this.options.mode +
-          (this.options.shouldBuildLazily ? 'lazy' : 'eager'),
-      );
-      return path.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
-    }
-
     return hashString(
       ATLASPACK_VERSION +
         devDepHashes +
@@ -755,27 +699,20 @@ export default class PackagerRunner {
     let mapKey = PackagerRunner.getMapKey(cacheKey);
 
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = getFeatureFlag('cachePerformanceImprovements')
-      ? isLargeBlob
-      : isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists =
+      isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = getFeatureFlag('cachePerformanceImprovements')
-      ? await this.options.cache.hasLargeBlob(mapKey)
-      : await this.options.cache.has(mapKey);
+    let mapExists = await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(
-            getFeatureFlag('cachePerformanceImprovements')
-              ? await this.options.cache.getLargeBlob(mapKey)
-              : await this.options.cache.getBlob(mapKey),
-          )
+        ? blobToStream(await this.options.cache.getBlob(mapKey))
         : null,
     };
   }
@@ -790,13 +727,11 @@ export default class PackagerRunner {
     let hash;
     // @ts-expect-error TS2702
     let hashReferences: RegExp.matchResult | Array<string> = [];
-    let isLargeBlob = getFeatureFlag('cachePerformanceImprovements');
+    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      if (!getFeatureFlag('cachePerformanceImprovements')) {
-        isLargeBlob = true;
-      }
+      isLargeBlob = true;
 
       let boundaryStr = '';
       let h = new Hash();
@@ -822,29 +757,17 @@ export default class PackagerRunner {
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
 
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, buffer);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, buffer);
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
 
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, contents);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, contents);
     }
 
     if (map != null) {
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.map, map);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.map, map);
-      }
+      await this.options.cache.setBlob(cacheKeys.map, map);
     }
 
     let info = {
@@ -861,23 +784,14 @@ export default class PackagerRunner {
   }
 
   static getContentKey(cacheKey: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/content`;
-    }
     return hashString(`${cacheKey}:content`);
   }
 
   static getMapKey(cacheKey: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/map`;
-    }
     return hashString(`${cacheKey}:map`);
   }
 
   static getInfoKey(cacheKey: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/info`;
-    }
     return hashString(`${cacheKey}:info`);
   }
 }

package/src/RequestTracker.ts

@@ -2,7 +2,7 @@ import invariant, {AssertionError} from 'assert';
 import path from 'path';
 
 import {deserialize, serialize} from '@atlaspack/build-cache';
-import {LMDBLiteCache, Cache} from '@atlaspack/cache';
+import {Cache} from '@atlaspack/cache';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {ContentGraph} from '@atlaspack/graph';
 import type {
@@ -12,7 +12,7 @@ import type {
   SerializedContentGraph,
   Graph,
 } from '@atlaspack/graph';
-import logger, {instrument} from '@atlaspack/logger';
+import logger from '@atlaspack/logger';
 import {hashString} from '@atlaspack/rust';
 import type {Async, EnvMap} from '@atlaspack/types';
 import {
@@ -1315,13 +1315,11 @@ export default class RequestTracker {
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      if (!getFeatureFlag('cachePerformanceImprovements')) {
-        invariant(this.options.cache.hasLargeBlob(key));
-      }
+      invariant(this.options.cache.hasLargeBlob(key));
 
-      let cachedResult: T = getFeatureFlag('cachePerformanceImprovements')
-        ? nullthrows(await this.options.cache.get<T>(key))
-        : deserialize(await this.options.cache.getLargeBlob(key));
+      let cachedResult: T = deserialize(
+        await this.options.cache.getLargeBlob(key),
+      );
       node.result = cachedResult;
       return cachedResult;
     }
@@ -1559,40 +1557,15 @@ export default class RequestTracker {
   }
 
   async writeToCache(signal?: AbortSignal) {
-    const options = this.options;
-    async function runCacheImprovements<T>(
-      newPath: (cache: LMDBLiteCache) => Promise<T>,
-      oldPath: () => Promise<T>,
-    ): Promise<T> {
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        invariant(options.cache instanceof LMDBLiteCache);
-        const result = await newPath(options.cache);
-        return result;
-      } else {
-        const result = await oldPath();
-        return result;
-      }
-    }
-
     let cacheKey = getCacheKey(this.options);
-    let requestGraphKey = getFeatureFlag('cachePerformanceImprovements')
-      ? `${cacheKey}/RequestGraph`
-      : `requestGraph-${cacheKey}`;
-    let snapshotKey = getFeatureFlag('cachePerformanceImprovements')
-      ? `${cacheKey}/snapshot`
-      : `snapshot-${cacheKey}`;
+    let requestGraphKey = `requestGraph-${cacheKey}`;
+    let snapshotKey = `snapshot-${cacheKey}`;
 
     if (this.options.shouldDisableCache) {
       return;
     }
 
     let total = 0;
-    await runCacheImprovements(
-      async (cache) => {
-        await cache.getNativeRef().startWriteTransaction();
-      },
-      () => Promise.resolve(),
-    );
     try {
       report({
         type: 'cache',
@@ -1602,7 +1575,7 @@ export default class RequestTracker {
       });
 
       if (getFeatureFlag('environmentDeduplication')) {
-        await writeEnvironmentsToCache(options.cache);
+        await writeEnvironmentsToCache(this.options.cache);
       }
 
       let serialisedGraph = this.graph.serialize();
@@ -1618,27 +1591,14 @@ export default class RequestTracker {
           throw new Error('Serialization was aborted');
         }
 
-        await runCacheImprovements(
-          (cache) => {
-            instrument(
-              `RequestTracker::writeToCache::cache.put(${key})`,
-              () => {
-                cache.getNativeRef().putNoConfirm(key, serialize(contents));
-              },
-            );
-            return Promise.resolve();
-          },
-          async () => {
-            await this.options.cache.setLargeBlob(
-              key,
-              serialize(contents),
-              signal
-                ? {
-                    signal: signal,
-                  }
-                : undefined,
-            );
-          },
+        await this.options.cache.setLargeBlob(
+          key,
+          serialize(contents),
+          signal
+            ? {
+                signal: signal,
+              }
+            : undefined,
         );
 
         total += 1;
@@ -1720,18 +1680,6 @@ export default class RequestTracker {
         nodes: undefined,
       });
 
-      await runCacheImprovements(
-        () =>
-          serialiseAndSet(`${cacheKey}/cache_metadata`, {
-            version: ATLASPACK_VERSION,
-            entries: this.options.entries,
-            mode: this.options.mode,
-            shouldBuildLazily: this.options.shouldBuildLazily,
-            watchBackend: this.options.watchBackend,
-          }),
-        () => Promise.resolve(),
-      );
-
       let opts = getWatcherOptions(this.options);
       let snapshotPath = path.join(this.options.cacheDir, snapshotKey + '.txt');
 
@@ -1743,13 +1691,6 @@ export default class RequestTracker {
     } catch (err: any) {
       // If we have aborted, ignore the error and continue
       if (!signal?.aborted) throw err;
-    } finally {
-      await runCacheImprovements(
-        async (cache) => {
-          await cache.getNativeRef().commitWriteTransaction();
-        },
-        () => Promise.resolve(),
-      );
     }
 
     report({type: 'cache', phase: 'end', total, size: this.graph.nodes.length});
@@ -1783,18 +1724,6 @@ export function getWatcherOptions({
 }
 
 function getCacheKey(options: AtlaspackOptions) {
-  if (getFeatureFlag('cachePerformanceImprovements')) {
-    const hash = hashString(
-      `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${
-        options.mode
-      }:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${
-        options.watchBackend ?? ''
-      }`,
-    );
-
-    return `RequestTracker/${ATLASPACK_VERSION}/${hash}`;
-  }
-
   return hashString(
     `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${
       options.shouldBuildLazily ? 'lazy' : 'eager'
@@ -1803,10 +1732,6 @@ function getCacheKey(options: AtlaspackOptions) {
 }
 
 function getRequestGraphNodeKey(index: number, cacheKey: string) {
-  if (getFeatureFlag('cachePerformanceImprovements')) {
-    return `${cacheKey}/RequestGraph/nodes/${index}`;
-  }
-
   return `requestGraph-nodes-${index}-${cacheKey}`;
 }
 
@@ -1823,15 +1748,9 @@ export async function readAndDeserializeRequestGraph(
   let bufferLength = 0;
 
   const getAndDeserialize = async (key: string) => {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const buffer = await cache.getBlob(key);
-      bufferLength += Buffer.byteLength(buffer);
-      return deserialize(buffer);
-    } else {
-      const buffer = await cache.getLargeBlob(key);
-      bufferLength += Buffer.byteLength(buffer);
-      return deserialize(buffer);
-    }
+    const buffer = await cache.getLargeBlob(key);
+    bufferLength += Buffer.byteLength(buffer);
+    return deserialize(buffer);
   };
 
   let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
@@ -1867,14 +1786,10 @@ async function loadRequestGraph(
   }
 
   let cacheKey = getCacheKey(options);
-  let requestGraphKey = getFeatureFlag('cachePerformanceImprovements')
-    ? `${cacheKey}/RequestGraph`
-    : `requestGraph-${cacheKey}`;
+  let requestGraphKey = `requestGraph-${cacheKey}`;
 
   let timeout;
-  const snapshotKey = getFeatureFlag('cachePerformanceImprovements')
-    ? `${cacheKey}/snapshot`
-    : `snapshot-${cacheKey}`;
+  const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
   const commonMeta = {
@@ -1901,9 +1816,8 @@ async function loadRequestGraph(
     await loadEnvironmentsFromCache(options.cache);
   }
 
-  const hasRequestGraphInCache = getFeatureFlag('cachePerformanceImprovements')
-    ? await options.cache.has(requestGraphKey)
-    : await options.cache.hasLargeBlob(requestGraphKey);
+  const hasRequestGraphInCache =
+    await options.cache.hasLargeBlob(requestGraphKey);
 
   if (hasRequestGraphInCache) {
     try {

package/src/TargetDescriptor.schema.ts

@@ -121,6 +121,9 @@ export const PACKAGE_DESCRIPTOR_SCHEMA: SchemaObject = {
         type: 'string',
       },
     },
+    inlineRequires: {
+      type: 'boolean',
+    },
   },
   additionalProperties: false,
 };

package/src/UncommittedAsset.ts

@@ -28,12 +28,7 @@ import {ATLASPACK_VERSION} from './constants';
 import {createAsset, createAssetIdFromOptions} from './assetUtils';
 import {BundleBehaviorNames} from './types';
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
-import {
-  ProjectPath,
-  fromProjectPath,
-  fromProjectPathRelative,
-} from './projectPath';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {ProjectPath, fromProjectPath} from './projectPath';
 import {fromEnvironmentId} from './EnvironmentManager';
 
 type UncommittedAssetOptions = {
@@ -308,11 +303,6 @@ export default class UncommittedAsset {
   }
 
   getCacheKey(key: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const filePath = fromProjectPathRelative(this.value.filePath);
-      return `Asset/${ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
-    }
-
     return hashString(ATLASPACK_VERSION + key + this.value.id);
   }
 

package/src/applyRuntimes.ts

@@ -505,7 +505,9 @@ function reconcileNewRuntimes<TResult extends RequestResult>(
     name: 'Runtimes',
     assetGroups,
     optionsRef,
-    skipSymbolProp: getFeatureFlag('skipRuntimeSymbolProp'),
+    skipSymbolProp:
+      getFeatureFlag('skipRuntimeSymbolProp') ||
+      getFeatureFlag('rustSymbolTracker'),
   });
 
   // rebuild the graph

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -6,10 +6,12 @@ import {
   atlaspackNapiCompleteSession,
   atlaspackNapiLoadBundleGraph,
   atlaspackNapiPackage,
+  atlaspackNapiUpdateBundleGraph,
   AtlaspackNapi,
   Lmdb,
   AtlaspackNapiOptions,
   CacheStats,
+  PackageOptions,
 } from '@atlaspack/rust';
 import {NapiWorkerPool} from './NapiWorkerPool';
 import ThrowableDiagnostic, {Diagnostic} from '@atlaspack/diagnostic';
@@ -119,12 +121,26 @@ export class AtlaspackV3 {
     ) as Promise<void>;
   }
 
+  updateBundleGraph(
+    bundleGraph: BundleGraph,
+    changedAssetIds: string[],
+  ): Promise<void> {
+    const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+    return atlaspackNapiUpdateBundleGraph(
+      this._atlaspack_napi,
+      nodesJson,
+    ) as Promise<void>;
+  }
+
   package(
     bundleId: string,
+    options?: PackageOptions,
   ): Promise<[RunPackagerRunnerResult, Diagnostic | null]> {
-    return atlaspackNapiPackage(this._atlaspack_napi, bundleId) as Promise<
-      [RunPackagerRunnerResult, Diagnostic | null]
-    >;
+    return atlaspackNapiPackage(
+      this._atlaspack_napi,
+      bundleId,
+      options,
+    ) as Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
   }
 
   async respondToFsEvents(events: Array<Event>): Promise<boolean> {

package/src/requests/AssetGraphRequest.ts

@@ -18,7 +18,6 @@ import logger from '@atlaspack/logger';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {PromiseQueue, setEqual} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -85,10 +84,12 @@ export default function createAssetGraphRequest(
       let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
-      assetGraphRequest.assetGraph.setDisableIncrementalBundling(
+      if (
         !input.options.shouldBundleIncrementally ||
-          input.options.mode === 'production',
-      );
+        input.options.mode === 'production'
+      ) {
+        assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
+      }
 
       if (
         !input.options.shouldBundleIncrementally ||
@@ -171,21 +172,12 @@ export class AssetGraphBuilder {
     this.lazyExcludes = lazyExcludes ?? [];
     this.skipSymbolProp = input.skipSymbolProp ?? false;
 
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const key = hashString(
+    this.cacheKey =
+      hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
           options.mode
         }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      );
-      this.cacheKey = `AssetGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
-    } else {
-      this.cacheKey =
-        hashString(
-          `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
-            options.mode
-          }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-        ) + '-AssetGraph';
-    }
+      ) + '-AssetGraph';
 
     this.isSingleChangeRebuild =
       api
@@ -535,7 +527,6 @@ export class AssetGraphBuilder {
 
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
-        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -590,12 +581,10 @@ export class AssetGraphBuilder {
             invariant(otherAsset.type === 'asset');
             if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
               this.assetGraph.safeToIncrementallyBundle = false;
-              this.assetGraph.setNeedsBundling();
             }
           } else {
             // adding a new entry or dependency
             this.assetGraph.safeToIncrementallyBundle = false;
-            this.assetGraph.setNeedsBundling();
           }
         }
         this.changedAssets.set(asset.id, asset);
@@ -604,7 +593,6 @@ export class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
-      this.assetGraph.setNeedsBundling();
     }
 
     this.isSingleChangeRebuild = false;