@atlaspack/build-cache 2.13.3-canary.56 → 2.13.3-canary.560

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/{buildCache.js → buildCache.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 const buildCaches: Array<Map<any, any>> = [];
 
 export function createBuildCache<K, V>(): Map<K, V> {

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './buildCache';
+export * from './serializer';
+export * from './serializerCore';

package/src/{serializer.js → serializer.ts}

@@ -1,9 +1,15 @@
-// @flow
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
 import {createBuildCache} from './buildCache';
+import {LargeMap} from './LargeMap';
 import {serializeRaw, deserializeRaw} from './serializerCore';
 
 export {serializeRaw, deserializeRaw} from './serializerCore';
 
+// flow-to-ts helpers
+export type Class<T> = new (...args: any[]) => T;
+// /flow-to-ts helpers
+
 const nameToCtor: Map<string, Class<any>> = new Map();
 const ctorToName: Map<Class<any>, string> = new Map();
 
@@ -49,7 +55,7 @@ function shallowCopy(object: any) {
   return object;
 }
 
-function isBuffer(object) {
+function isBuffer(object: any) {
   return (
     object.buffer instanceof ArrayBuffer ||
     (typeof SharedArrayBuffer !== 'undefined' &&
@@ -57,13 +63,25 @@ function isBuffer(object) {
   );
 }
 
-function shouldContinueMapping(value) {
+function shouldContinueMapping(value: any) {
   return value && typeof value === 'object' && value.$$raw !== true;
 }
 
-function mapObject(object: any, fn: (val: any) => any, preOrder = false): any {
-  let cache = new Map();
-  let memo = new Map();
+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 {
+  // 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
@@ -211,8 +229,8 @@ export function restoreDeserializedObject(object: any): any {
         );
       }
 
-      if (typeof ctor.deserialize === 'function') {
-        return ctor.deserialize(value.value);
+      if (typeof (ctor as any).deserialize === 'function') {
+        return (ctor as any).deserialize(value.value);
       }
 
       value = value.value;
@@ -223,7 +241,7 @@ export function restoreDeserializedObject(object: any): any {
   });
 }
 
-const serializeCache = createBuildCache();
+const serializeCache = createBuildCache<any, Buffer>();
 
 export function serialize(object: any): Buffer {
   let cached = serializeCache.get(object);

package/src/serializerCore.ts

@@ -0,0 +1,4 @@
+import v8 from 'v8';
+
+export let serializeRaw: (arg1?: any) => Buffer = v8.serialize;
+export let deserializeRaw: (arg1: Buffer) => any = v8.deserialize;

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/test/{serializer.test.js → serializer.test.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import assert from 'assert';
 import sinon from 'sinon';
 
@@ -151,8 +149,8 @@ describe('serializer', () => {
 
   it('should serialize a cyclic class', () => {
     class Foo {
-      x: ?Foo;
-      constructor(x: ?Foo) {
+      x: Foo | null | undefined;
+      constructor(x?: Foo | null) {
         this.x = x;
       }
     }
@@ -193,8 +191,8 @@ describe('serializer', () => {
 
   it('should serialize a cyclic class and copy on write', () => {
     class Foo {
-      x: ?Foo;
-      constructor(x: ?Foo) {
+      x: Foo | null | undefined;
+      constructor(x?: Foo | null) {
         this.x = x;
       }
     }
@@ -257,7 +255,7 @@ describe('serializer', () => {
     class Outer {
       inner: Inner;
 
-      constructor(inner) {
+      constructor(inner: any) {
         this.inner = inner;
       }
 
@@ -272,7 +270,7 @@ describe('serializer', () => {
     class Inner {
       x: number;
 
-      constructor(x) {
+      constructor(x: any) {
         this.x = x;
       }
 

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../feature-flags/tsconfig.json"
+    }
+  ]
+}