@atlaspack/core 2.17.3 → 2.17.4

package/lib/public/BundleGraph.js

@@ -32,6 +32,13 @@ var _Dependency = _interopRequireWildcard(require("./Dependency"));
 var _Target = require("./Target");
 var _utils = require("../utils");
 var _BundleGroup = _interopRequireWildcard(require("./BundleGroup"));
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -263,11 +270,20 @@ class BundleGraph {
       }
       for (let bundle of bundles) {
         const conditions = bundleConditions.get(bundle.id) ?? new Map();
-        conditions.set(cond.key, {
-          bundle,
-          ifTrueBundles,
-          ifFalseBundles
-        });
+        const currentCondition = conditions.get(cond.key);
+        if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingReporterSameConditionFix')) {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles: [...((currentCondition === null || currentCondition === void 0 ? void 0 : currentCondition.ifTrueBundles) ?? []), ...ifTrueBundles],
+            ifFalseBundles: [...((currentCondition === null || currentCondition === void 0 ? void 0 : currentCondition.ifFalseBundles) ?? []), ...ifFalseBundles]
+          });
+        } else {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles,
+            ifFalseBundles
+          });
+        }
         bundleConditions.set(bundle.id, conditions);
       }
     }

package/lib/public/Config.js

@@ -27,6 +27,13 @@ function _utils() {
 }
 var _Environment = _interopRequireDefault(require("./Environment"));
 var _projectPath = require("../projectPath");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const internalConfigToConfig = new (_utils().DefaultWeakMap)(() => new WeakMap());
 class PublicConfig {
@@ -126,6 +133,27 @@ class PublicConfig {
         };
       }
     }
+    if ((0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation')) {
+      const configKey = options === null || options === void 0 ? void 0 : options.configKey;
+      if (configKey != null) {
+        for (let fileName of fileNames) {
+          let config = await this.getConfigFrom(searchPath, [fileName], {
+            exclude: true
+          });
+          if (config && config.contents[configKey]) {
+            // Invalidate only when the package key changes
+            this.invalidateOnConfigKeyChange(config.filePath, configKey);
+            return {
+              contents: config.contents[configKey],
+              filePath: config.filePath
+            };
+          }
+        }
+
+        // fall through so that file above invalidations are registered
+      }
+    }
+
     if (fileNames.length === 0) {
       return null;
     }

package/lib/requests/AssetGraphRequest.js

@@ -26,6 +26,13 @@ function _nullthrows() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _utils() {
   const data = require("@atlaspack/utils");
   _utils = function () {
@@ -116,7 +123,12 @@ class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+      this.cacheKey = `AssetGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
+    }
     this.isSingleChangeRebuild = api.getInvalidSubRequests().filter(req => req.requestType === 'asset_request').length === 1;
     this.queue = new (_utils().PromiseQueue)();
     assetGraph.onNodeRemoved = nodeId => {

package/lib/requests/BundleGraphRequest.js

@@ -32,6 +32,13 @@ function _logger() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
   _diagnostic = function () {
@@ -225,7 +232,12 @@ class BundlerRunner {
     this.devDepRequests = new Map();
     this.configs = new Map();
     this.pluginOptions = new _PluginOptions.default((0, _utils2.optionsProxy)(this.options, api.invalidateOnOptionChange));
-    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+      this.cacheKey = `BundleGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
+    }
   }
   async loadConfigs() {
     // Load all configs up front so we can use them in the cache key

package/lib/requests/WriteBundleRequest.js

@@ -61,6 +61,13 @@ function _profiler() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -145,8 +152,10 @@ async function run({
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
   await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline && (await options.cache.has(mapKey))) {
-    await writeFiles((0, _utils().blobToStream)(await options.cache.getBlob(mapKey)), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+  const hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
+  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+    await writeFiles((0, _utils().blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,

package/lib/resolveOptions.js

@@ -144,8 +144,10 @@ async function resolveOptions(initialOptions) {
       return initialOptions.cache;
     }
     const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3');
-    if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
-      return new (_cache().FSCache)(outputFS, cacheDir);
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
+        return new (_cache().FSCache)(outputFS, cacheDir);
+      }
     }
     return new (_cache().LMDBLiteCache)(cacheDir);
   }();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.17.3",
+  "version": "2.17.4",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,20 +23,20 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.3",
-    "@atlaspack/cache": "3.2.3",
+    "@atlaspack/cache": "3.2.4",
     "@atlaspack/diagnostic": "2.14.1",
     "@atlaspack/events": "2.14.1",
-    "@atlaspack/feature-flags": "2.15.1",
-    "@atlaspack/fs": "2.15.3",
-    "@atlaspack/graph": "3.4.6",
-    "@atlaspack/logger": "2.14.8",
-    "@atlaspack/package-manager": "2.14.8",
-    "@atlaspack/plugin": "2.14.8",
-    "@atlaspack/profiler": "2.14.6",
-    "@atlaspack/rust": "3.3.3",
-    "@atlaspack/types": "2.14.8",
-    "@atlaspack/utils": "2.14.8",
-    "@atlaspack/workers": "2.14.8",
+    "@atlaspack/feature-flags": "2.16.0",
+    "@atlaspack/fs": "2.15.4",
+    "@atlaspack/graph": "3.4.7",
+    "@atlaspack/logger": "2.14.9",
+    "@atlaspack/package-manager": "2.14.9",
+    "@atlaspack/plugin": "2.14.9",
+    "@atlaspack/profiler": "2.14.7",
+    "@atlaspack/rust": "3.3.4",
+    "@atlaspack/types": "2.14.9",
+    "@atlaspack/utils": "2.14.9",
+    "@atlaspack/workers": "2.14.9",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",

package/src/Atlaspack.js

@@ -533,10 +533,11 @@ export default class Atlaspack {
           nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
         }
 
-        let isInvalid = await this.#requestTracker.respondToFSEvents(
-          events,
-          Number.POSITIVE_INFINITY,
-        );
+        let {didInvalidate: isInvalid} =
+          await this.#requestTracker.respondToFSEvents(
+            events,
+            Number.POSITIVE_INFINITY,
+          );
 
         if (
           (nativeInvalid || isInvalid) &&

package/src/PackagerRunner.js

@@ -63,6 +63,7 @@ import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type Opts = {|
   config: AtlaspackConfig,
@@ -658,6 +659,21 @@ 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 +
@@ -700,20 +716,27 @@ export default class PackagerRunner {
     let mapKey = PackagerRunner.getMapKey(cacheKey);
 
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists =
-      isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = getFeatureFlag('cachePerformanceImprovements')
+      ? isLargeBlob
+      : isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = await this.options.cache.has(mapKey);
+    let mapExists = getFeatureFlag('cachePerformanceImprovements')
+      ? await this.options.cache.hasLargeBlob(mapKey)
+      : await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(await this.options.cache.getBlob(mapKey))
+        ? blobToStream(
+            getFeatureFlag('cachePerformanceImprovements')
+              ? await this.options.cache.getLargeBlob(mapKey)
+              : await this.options.cache.getBlob(mapKey),
+          )
         : null,
     };
   }
@@ -727,11 +750,14 @@ export default class PackagerRunner {
     let size = 0;
     let hash;
     let hashReferences = [];
-    let isLargeBlob = false;
+    let isLargeBlob = getFeatureFlag('cachePerformanceImprovements');
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      isLargeBlob = true;
+      if (!getFeatureFlag('cachePerformanceImprovements')) {
+        isLargeBlob = true;
+      }
+
       let boundaryStr = '';
       let h = new Hash();
       await this.options.cache.setStream(
@@ -754,17 +780,32 @@ export default class PackagerRunner {
       size = buffer.byteLength;
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, buffer);
+      }
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, contents);
+      }
     }
 
     if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.map, map);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.map, map);
+      }
     }
+
     let info = {
       type,
       size,
@@ -773,19 +814,29 @@ export default class PackagerRunner {
       cacheKeys,
       isLargeBlob,
     };
+
     await this.options.cache.set(cacheKeys.info, info);
     return info;
   }
 
   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`);
   }
 }