@atlaspack/build-cache 2.13.7-dev-swc44-53cdb819f.0 → 2.13.8

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaspack/build-cache
 
+## 2.13.8
+
+### Patch Changes
+
+- Updated dependencies [[`f33f9c4`](https://github.com/atlassian-labs/atlaspack/commit/f33f9c48dd24b319df352d197e4a83cbb1b053bc), [`e15fb6c`](https://github.com/atlassian-labs/atlaspack/commit/e15fb6c885c6354c6c02283de35ce18abc8c9e18)]:
+  - @atlaspack/feature-flags@2.27.7
+
+## 2.13.7
+
+### Patch Changes
+
+- [#960](https://github.com/atlassian-labs/atlaspack/pull/960) [`565bab3`](https://github.com/atlassian-labs/atlaspack/commit/565bab3771cc334659d873cabff4cdfac0860cc7) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add LargeMap to work around Node 24's Map size limit in build cache serializer.
+
+  This change is behind the `useLargeMapInBuildCache` feature flag.
+
+- Updated dependencies [[`c31090c`](https://github.com/atlassian-labs/atlaspack/commit/c31090c9025f35d3fa8561b42dca170853a32e6f), [`565bab3`](https://github.com/atlassian-labs/atlaspack/commit/565bab3771cc334659d873cabff4cdfac0860cc7)]:
+  - @atlaspack/feature-flags@2.27.6
+
 ## 2.13.6
 
 ### Patch Changes

package/dist/LargeMap.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LargeMap = void 0;
+/**
+ * A Map implementation that can exceed Node 24's Map size limit.
+ *
+ * LargeMap works around the Maximum maps size limit by using multiple internal Maps,
+ * creating a new one when the current Map reaches the size limit.
+ *
+ * This is a minimal implementation supporting only has/get/set - intended as a
+ * temporary solution until we no longer need large JS serialization
+ */
+class LargeMap {
+    constructor(maxSize = Math.pow(2, 23)) {
+        this.lastMap = new Map();
+        this.maps = [this.lastMap];
+        this.singleMap = true;
+        this.maxSize = maxSize;
+    }
+    set(key, value) {
+        // Update existing key if found
+        if (!this.singleMap) {
+            for (let map of this.maps) {
+                if (map.has(key)) {
+                    map.set(key, value);
+                    return this;
+                }
+            }
+        }
+        // Otherwise, add to last map
+        if (this.lastMap.size >= this.maxSize) {
+            this.lastMap = new Map();
+            this.maps.push(this.lastMap);
+            this.singleMap = false;
+        }
+        this.lastMap.set(key, value);
+        return this;
+    }
+    get(key) {
+        if (this.singleMap) {
+            return this.lastMap.get(key);
+        }
+        for (let map of this.maps) {
+            if (map.has(key)) {
+                return map.get(key);
+            }
+        }
+        return undefined;
+    }
+    has(key) {
+        for (let map of this.maps) {
+            if (map.has(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.LargeMap = LargeMap;

package/dist/serializer.js

@@ -10,7 +10,9 @@ exports.deserialize = deserialize;
 exports.cacheSerializedObject = cacheSerializedObject;
 exports.deserializeToCache = deserializeToCache;
 exports.removeSerializedObjectFromCache = removeSerializedObjectFromCache;
+const feature_flags_1 = require("@atlaspack/feature-flags");
 const buildCache_1 = require("./buildCache");
+const LargeMap_1 = require("./LargeMap");
 const serializerCore_1 = require("./serializerCore");
 var serializerCore_2 = require("./serializerCore");
 Object.defineProperty(exports, "serializeRaw", { enumerable: true, get: function () { return serializerCore_2.serializeRaw; } });
@@ -57,8 +59,14 @@ function shouldContinueMapping(value) {
     return value && typeof value === 'object' && value.$$raw !== true;
 }
 function mapObject(object, fn, preOrder = false) {
-    let cache = new Map();
-    let memo = new Map();
+    // Use LargeMap to work around Node 24's Map size limit
+    // when the feature flag is enabled
+    let cache = (0, feature_flags_1.getFeatureFlag)('useLargeMapInBuildCache')
+        ? new LargeMap_1.LargeMap()
+        : new Map();
+    let memo = (0, feature_flags_1.getFeatureFlag)('useLargeMapInBuildCache')
+        ? new LargeMap_1.LargeMap()
+        : new Map();
     // Memoize the passed function to ensure it always returns the exact same
     // output by reference for the same input. This is important to maintain
     // reference integrity when deserializing rather than cloning.

package/lib/LargeMap.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LargeMap = void 0;
+/**
+ * A Map implementation that can exceed Node 24's Map size limit.
+ *
+ * LargeMap works around the Maximum maps size limit by using multiple internal Maps,
+ * creating a new one when the current Map reaches the size limit.
+ *
+ * This is a minimal implementation supporting only has/get/set - intended as a
+ * temporary solution until we no longer need large JS serialization
+ */
+class LargeMap {
+  constructor(maxSize = Math.pow(2, 23)) {
+    this.lastMap = new Map();
+    this.maps = [this.lastMap];
+    this.singleMap = true;
+    this.maxSize = maxSize;
+  }
+  set(key, value) {
+    // Update existing key if found
+    if (!this.singleMap) {
+      for (let map of this.maps) {
+        if (map.has(key)) {
+          map.set(key, value);
+          return this;
+        }
+      }
+    }
+
+    // Otherwise, add to last map
+    if (this.lastMap.size >= this.maxSize) {
+      this.lastMap = new Map();
+      this.maps.push(this.lastMap);
+      this.singleMap = false;
+    }
+    this.lastMap.set(key, value);
+    return this;
+  }
+  get(key) {
+    if (this.singleMap) {
+      return this.lastMap.get(key);
+    }
+    for (let map of this.maps) {
+      if (map.has(key)) {
+        return map.get(key);
+      }
+    }
+    return undefined;
+  }
+  has(key) {
+    for (let map of this.maps) {
+      if (map.has(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+exports.LargeMap = LargeMap;

package/lib/serializer.js

@@ -24,7 +24,15 @@ Object.defineProperty(exports, "serializeRaw", {
   }
 });
 exports.unregisterSerializableClass = unregisterSerializableClass;
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 var _buildCache = require("./buildCache");
+var _LargeMap = require("./LargeMap");
 var _serializerCore = require("./serializerCore");
 // flow-to-ts helpers
 
@@ -69,8 +77,10 @@ function shouldContinueMapping(value) {
   return value && typeof value === 'object' && value.$$raw !== true;
 }
 function mapObject(object, fn, preOrder = false) {
-  let cache = new Map();
-  let memo = new Map();
+  // Use LargeMap to work around Node 24's Map size limit
+  // when the feature flag is enabled
+  let cache = (0, _featureFlags().getFeatureFlag)('useLargeMapInBuildCache') ? new _LargeMap.LargeMap() : new Map();
+  let memo = (0, _featureFlags().getFeatureFlag)('useLargeMapInBuildCache') ? new _LargeMap.LargeMap() : new Map();
 
   // Memoize the passed function to ensure it always returns the exact same
   // output by reference for the same input. This is important to maintain

package/lib/types/LargeMap.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A Map implementation that can exceed Node 24's Map size limit.
+ *
+ * LargeMap works around the Maximum maps size limit by using multiple internal Maps,
+ * creating a new one when the current Map reaches the size limit.
+ *
+ * This is a minimal implementation supporting only has/get/set - intended as a
+ * temporary solution until we no longer need large JS serialization
+ */
+export declare class LargeMap<K, V> {
+    maps: Map<K, V>[];
+    maxSize: number;
+    singleMap: boolean;
+    lastMap: Map<K, V>;
+    constructor(maxSize?: number);
+    set(key: K, value: V): this;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaspack/build-cache",
   "description": "Serialize and deserialize data structures to a build cache",
-  "version": "2.13.7-dev-swc44-53cdb819f.0",
+  "version": "2.13.8",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -20,5 +20,7 @@
   "scripts": {
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
-  "gitHead": "53cdb819f1739c63fb7dc9769cdd64352c097f9a"
+  "dependencies": {
+    "@atlaspack/feature-flags": "2.27.7"
+  }
 }

package/src/LargeMap.ts

@@ -0,0 +1,67 @@
+/**
+ * A Map implementation that can exceed Node 24's Map size limit.
+ *
+ * LargeMap works around the Maximum maps size limit by using multiple internal Maps,
+ * creating a new one when the current Map reaches the size limit.
+ *
+ * This is a minimal implementation supporting only has/get/set - intended as a
+ * temporary solution until we no longer need large JS serialization
+ */
+export class LargeMap<K, V> {
+  maps: Map<K, V>[];
+  maxSize: number;
+  singleMap: boolean;
+  lastMap: Map<K, V>;
+
+  constructor(maxSize: number = Math.pow(2, 23)) {
+    this.lastMap = new Map();
+    this.maps = [this.lastMap];
+    this.singleMap = true;
+    this.maxSize = maxSize;
+  }
+
+  set(key: K, value: V): this {
+    // Update existing key if found
+    if (!this.singleMap) {
+      for (let map of this.maps) {
+        if (map.has(key)) {
+          map.set(key, value);
+          return this;
+        }
+      }
+    }
+
+    // Otherwise, add to last map
+    if (this.lastMap.size >= this.maxSize) {
+      this.lastMap = new Map();
+      this.maps.push(this.lastMap);
+      this.singleMap = false;
+    }
+
+    this.lastMap.set(key, value);
+
+    return this;
+  }
+
+  get(key: K): V | undefined {
+    if (this.singleMap) {
+      return this.lastMap.get(key);
+    }
+
+    for (let map of this.maps) {
+      if (map.has(key)) {
+        return map.get(key);
+      }
+    }
+    return undefined;
+  }
+
+  has(key: K): boolean {
+    for (let map of this.maps) {
+      if (map.has(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/src/serializer.ts

@@ -1,4 +1,7 @@
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
 import {createBuildCache} from './buildCache';
+import {LargeMap} from './LargeMap';
 import {serializeRaw, deserializeRaw} from './serializerCore';
 
 export {serializeRaw, deserializeRaw} from './serializerCore';
@@ -64,9 +67,21 @@ function shouldContinueMapping(value: any) {
   return value && typeof value === 'object' && value.$$raw !== true;
 }
 
+interface MapLike<K, V> {
+  get(key: K): V | undefined;
+  set(key: K, value: V): unknown;
+  has(key: K): boolean;
+}
+
 function mapObject(object: any, fn: (val?: any) => any, preOrder = false): any {
-  let cache = new Map();
-  let memo = new Map();
+  // Use LargeMap to work around Node 24's Map size limit
+  // when the feature flag is enabled
+  let cache: MapLike<any, any> = getFeatureFlag('useLargeMapInBuildCache')
+    ? new LargeMap<any, any>()
+    : new Map<any, any>();
+  let memo: MapLike<any, any> = getFeatureFlag('useLargeMapInBuildCache')
+    ? new LargeMap<any, any>()
+    : new Map<any, any>();
 
   // Memoize the passed function to ensure it always returns the exact same
   // output by reference for the same input. This is important to maintain

package/test/LargeMap.test.ts

@@ -0,0 +1,151 @@
+import assert from 'assert';
+import {LargeMap} from '../src/LargeMap';
+
+describe('LargeMap', () => {
+  describe('basic operations', () => {
+    it('should set and get values', () => {
+      const map = new LargeMap<string, number>();
+      map.set('a', 1);
+      map.set('b', 2);
+
+      assert.equal(map.get('a'), 1);
+      assert.equal(map.get('b'), 2);
+    });
+
+    it('should return undefined for missing keys', () => {
+      const map = new LargeMap<string, number>();
+      assert.equal(map.get('missing'), undefined);
+    });
+
+    it('should check if key exists with has()', () => {
+      const map = new LargeMap<string, number>();
+      map.set('a', 1);
+
+      assert.equal(map.has('a'), true);
+      assert.equal(map.has('b'), false);
+    });
+
+    it('should update existing key in single map', () => {
+      const map = new LargeMap<string, number>();
+      map.set('a', 1);
+      map.set('a', 2);
+
+      assert.equal(map.get('a'), 2);
+    });
+
+    it('should return this from set() for chaining', () => {
+      const map = new LargeMap<string, number>();
+      const result = map.set('a', 1).set('b', 2).set('c', 3);
+
+      assert.equal(result, map);
+      assert.equal(map.get('a'), 1);
+      assert.equal(map.get('b'), 2);
+      assert.equal(map.get('c'), 3);
+    });
+  });
+
+  describe('multiple internal maps', () => {
+    it('should create new internal map when maxSize is reached', () => {
+      const map = new LargeMap<number, number>(3); // Small maxSize for testing
+
+      map.set(1, 1);
+      map.set(2, 2);
+      map.set(3, 3);
+      assert.equal(map.maps.length, 1);
+
+      map.set(4, 4); // Should trigger new internal map
+      assert.equal(map.maps.length, 2);
+
+      map.set(5, 5);
+      map.set(6, 6);
+      assert.equal(map.maps.length, 2);
+
+      map.set(7, 7); // Should trigger another new internal map
+      assert.equal(map.maps.length, 3);
+    });
+
+    it('should find values across multiple internal maps', () => {
+      const map = new LargeMap<number, string>(2);
+
+      map.set(1, 'one');
+      map.set(2, 'two');
+      map.set(3, 'three');
+      map.set(4, 'four');
+      map.set(5, 'five');
+
+      assert.equal(map.get(1), 'one');
+      assert.equal(map.get(2), 'two');
+      assert.equal(map.get(3), 'three');
+      assert.equal(map.get(4), 'four');
+      assert.equal(map.get(5), 'five');
+    });
+
+    it('should check has() across multiple internal maps', () => {
+      const map = new LargeMap<number, string>(2);
+
+      map.set(1, 'one');
+      map.set(2, 'two');
+      map.set(3, 'three');
+
+      assert.equal(map.has(1), true);
+      assert.equal(map.has(2), true);
+      assert.equal(map.has(3), true);
+      assert.equal(map.has(4), false);
+    });
+
+    it('should update existing key in earlier internal map', () => {
+      const map = new LargeMap<number, string>(2);
+
+      map.set(1, 'one');
+      map.set(2, 'two');
+      map.set(3, 'three'); // Goes to second map
+
+      // Update key in first map
+      map.set(1, 'ONE');
+
+      assert.equal(map.get(1), 'ONE');
+      assert.equal(map.maps.length, 2); // Should not create new map
+    });
+  });
+
+  describe('type handling', () => {
+    it('should work with object keys', () => {
+      const map = new LargeMap<object, string>();
+      const key1 = {id: 1};
+      const key2 = {id: 2};
+
+      map.set(key1, 'first');
+      map.set(key2, 'second');
+
+      assert.equal(map.get(key1), 'first');
+      assert.equal(map.get(key2), 'second');
+      assert.equal(map.get({id: 1}), undefined); // Different reference
+    });
+
+    it('should work with null and undefined values', () => {
+      const map = new LargeMap<string, any>();
+
+      map.set('null', null);
+      map.set('undefined', undefined);
+
+      assert.equal(map.get('null'), null);
+      assert.equal(map.get('undefined'), undefined);
+      assert.equal(map.has('null'), true);
+      assert.equal(map.has('undefined'), true);
+    });
+
+    it('should work with various key types', () => {
+      const map = new LargeMap<any, string>();
+
+      map.set(1, 'number');
+      map.set('str', 'string');
+      map.set(true, 'boolean');
+      map.set(null, 'null');
+
+      assert.equal(map.get(1), 'number');
+      assert.equal(map.get('str'), 'string');
+      assert.equal(map.get(true), 'boolean');
+      assert.equal(map.get(null), 'null');
+    });
+  });
+});

package/tsconfig.json

@@ -3,5 +3,10 @@
   "include": ["src"],
   "compilerOptions": {
     "composite": true
-  }
+  },
+  "references": [
+    {
+      "path": "../feature-flags/tsconfig.json"
+    }
+  ]
 }