@atlaspack/build-cache 2.13.3-canary.48 → 2.13.3-canary.481

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # @atlaspack/build-cache
 
+## 2.13.11
+
+### Patch Changes
+
+- Updated dependencies [[`1815c2c`](https://github.com/atlassian-labs/atlaspack/commit/1815c2ce48e32f4df97ccdd668fd650fc79d1051)]:
+  - @atlaspack/feature-flags@2.29.1
+
+## 2.13.10
+
+### Patch Changes
+
+- Updated dependencies [[`349b19c`](https://github.com/atlassian-labs/atlaspack/commit/349b19c3aca2ccb1ffb5cdcdc74890f4b62228be)]:
+  - @atlaspack/feature-flags@2.29.0
+
+## 2.13.9
+
+### Patch Changes
+
+- Updated dependencies [[`8826fd0`](https://github.com/atlassian-labs/atlaspack/commit/8826fd02c29c9c67cf0c80da41f424257fbdef93)]:
+  - @atlaspack/feature-flags@2.28.0
+
+## 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
+
+- [#785](https://github.com/atlassian-labs/atlaspack/pull/785) [`0e7dd5e`](https://github.com/atlassian-labs/atlaspack/commit/0e7dd5ec6fbe05aa9e0bb5775a9d0975f206a922) Thanks [@matt-koko](https://github.com/matt-koko)! - We need to re-publish every package in Atlaspack with the corrected types field.
+
+## 2.13.5
+
+### Patch Changes
+
+- [#742](https://github.com/atlassian-labs/atlaspack/pull/742) [`ee040bb`](https://github.com/atlassian-labs/atlaspack/commit/ee040bb6428f29b57d892ddd8107e29077d08ffd) Thanks [@yamadapc](https://github.com/yamadapc)! - Internal changes and bug fixes to environmentDeduplication flag
+
+## 2.13.4
+
+### Patch Changes
+
+- [#720](https://github.com/atlassian-labs/atlaspack/pull/720) [`d2fd849`](https://github.com/atlassian-labs/atlaspack/commit/d2fd849770fe6305e9c694bd97b1bd905abd9d94) Thanks [@alshdavid](https://github.com/alshdavid)! - Migrate to TypeScript
+
 ## 2.13.3
 
 ### 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/buildCache.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildCache = createBuildCache;
+exports.clearBuildCaches = clearBuildCaches;
+const buildCaches = [];
+function createBuildCache() {
+    let cache = new Map();
+    buildCaches.push(cache);
+    return cache;
+}
+function clearBuildCaches() {
+    for (let cache of buildCaches) {
+        cache.clear();
+    }
+}

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./buildCache"), exports);
+__exportStar(require("./serializer"), exports);
+__exportStar(require("./serializerCore"), exports);

package/dist/serializer.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeRaw = exports.serializeRaw = void 0;
+exports.registerSerializableClass = registerSerializableClass;
+exports.unregisterSerializableClass = unregisterSerializableClass;
+exports.prepareForSerialization = prepareForSerialization;
+exports.restoreDeserializedObject = restoreDeserializedObject;
+exports.serialize = serialize;
+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; } });
+Object.defineProperty(exports, "deserializeRaw", { enumerable: true, get: function () { return serializerCore_2.deserializeRaw; } });
+// /flow-to-ts helpers
+const nameToCtor = new Map();
+const ctorToName = new Map();
+function registerSerializableClass(name, ctor) {
+    if (ctorToName.has(ctor)) {
+        throw new Error('Class already registered with serializer');
+    }
+    nameToCtor.set(name, ctor);
+    ctorToName.set(ctor, name);
+}
+function unregisterSerializableClass(name, ctor) {
+    if (nameToCtor.get(name) === ctor) {
+        nameToCtor.delete(name);
+    }
+    if (ctorToName.get(ctor) === name) {
+        ctorToName.delete(ctor);
+    }
+}
+function shallowCopy(object) {
+    if (object && typeof object === 'object') {
+        if (Array.isArray(object)) {
+            return [...object];
+        }
+        if (object instanceof Map) {
+            return new Map(object);
+        }
+        if (object instanceof Set) {
+            return new Set(object);
+        }
+        return Object.create(Object.getPrototypeOf(object), Object.getOwnPropertyDescriptors(object));
+    }
+    return object;
+}
+function isBuffer(object) {
+    return (object.buffer instanceof ArrayBuffer ||
+        (typeof SharedArrayBuffer !== 'undefined' &&
+            object.buffer instanceof SharedArrayBuffer));
+}
+function shouldContinueMapping(value) {
+    return value && typeof value === 'object' && value.$$raw !== true;
+}
+function mapObject(object, fn, preOrder = false) {
+    // 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.
+    let memoizedFn = (val) => {
+        let res = memo.get(val);
+        if (res == null) {
+            res = fn(val);
+            memo.set(val, res);
+        }
+        return res;
+    };
+    let walk = (object, shouldCopy = false) => {
+        // Check the cache first, both for performance and cycle detection.
+        if (cache.has(object)) {
+            return cache.get(object);
+        }
+        let result = object;
+        cache.set(object, result);
+        let processKey = (key, value) => {
+            let newValue = value;
+            if (preOrder && value && typeof value === 'object') {
+                newValue = memoizedFn(value);
+            }
+            // Recursively walk the children
+            if (preOrder
+                ? shouldContinueMapping(newValue)
+                : newValue &&
+                    typeof newValue === 'object' &&
+                    shouldContinueMapping(object)) {
+                newValue = walk(newValue, newValue === value);
+            }
+            if (!preOrder && newValue && typeof newValue === 'object') {
+                newValue = memoizedFn(newValue);
+            }
+            if (newValue !== value) {
+                // Copy on write. We only need to do this when serializing, not deserializing.
+                if (object === result && preOrder && shouldCopy) {
+                    result = shallowCopy(object);
+                    cache.set(object, result);
+                }
+                // Replace the key with the new value
+                if (result instanceof Map) {
+                    result.set(key, newValue);
+                }
+                else if (result instanceof Set) {
+                    let _result = result; // For Flow
+                    // TODO: do we care about iteration order??
+                    _result.delete(value);
+                    _result.add(newValue);
+                }
+                else {
+                    result[key] = newValue;
+                }
+            }
+        };
+        // Iterate in various ways depending on type.
+        if (Array.isArray(object)) {
+            for (let i = 0; i < object.length; i++) {
+                processKey(i, object[i]);
+            }
+        }
+        else if (object instanceof Map || object instanceof Set) {
+            for (let [key, val] of object.entries()) {
+                processKey(key, val);
+            }
+        }
+        else if (!isBuffer(object)) {
+            for (let key in object) {
+                processKey(key, object[key]);
+            }
+        }
+        return result;
+    };
+    let mapped = memoizedFn(object);
+    if (preOrder
+        ? shouldContinueMapping(mapped)
+        : mapped && typeof mapped === 'object' && shouldContinueMapping(object)) {
+        return walk(mapped, mapped === object);
+    }
+    return mapped;
+}
+function prepareForSerialization(object) {
+    if (object?.$$raw) {
+        return object;
+    }
+    return mapObject(object, (value) => {
+        // Add a $$type property with the name of this class, if any is registered.
+        if (value &&
+            typeof value === 'object' &&
+            typeof value.constructor === 'function') {
+            let type = ctorToName.get(value.constructor);
+            if (type != null) {
+                let serialized = value;
+                let raw = false;
+                if (value && typeof value.serialize === 'function') {
+                    // If the object has a serialize method, call it
+                    serialized = value.serialize();
+                    raw = (serialized && serialized.$$raw) ?? true;
+                    if (serialized) {
+                        delete serialized.$$raw;
+                    }
+                }
+                return {
+                    $$type: type,
+                    $$raw: raw,
+                    value: { ...serialized },
+                };
+            }
+        }
+        return value;
+    }, true);
+}
+function restoreDeserializedObject(object) {
+    return mapObject(object, (value) => {
+        // If the value has a $$type property, use it to restore the object type
+        if (value && value.$$type) {
+            let ctor = nameToCtor.get(value.$$type);
+            if (ctor == null) {
+                throw new Error(`Expected constructor ${value.$$type} to be registered with serializer to deserialize`);
+            }
+            if (typeof ctor.deserialize === 'function') {
+                return ctor.deserialize(value.value);
+            }
+            value = value.value;
+            Object.setPrototypeOf(value, ctor.prototype);
+        }
+        return value;
+    });
+}
+const serializeCache = (0, buildCache_1.createBuildCache)();
+function serialize(object) {
+    let cached = serializeCache.get(object);
+    if (cached) {
+        return cached;
+    }
+    let mapped = prepareForSerialization(object);
+    return (0, serializerCore_1.serializeRaw)(mapped);
+}
+function deserialize(buffer) {
+    let obj = (0, serializerCore_1.deserializeRaw)(buffer);
+    return restoreDeserializedObject(obj);
+}
+function cacheSerializedObject(object, buffer) {
+    serializeCache.set(object, buffer || serialize(object));
+}
+function deserializeToCache(buffer) {
+    let deserialized = deserialize(buffer);
+    serializeCache.set(deserialized, buffer);
+    return deserialized;
+}
+function removeSerializedObjectFromCache(object) {
+    serializeCache.delete(object);
+}

package/dist/serializerCore.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeRaw = exports.serializeRaw = void 0;
+const v8_1 = __importDefault(require("v8"));
+exports.serializeRaw = v8_1.default.serialize;
+exports.deserializeRaw = v8_1.default.deserialize;

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,8 +24,20 @@ 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
+
+// /flow-to-ts helpers
+
 const nameToCtor = new Map();
 const ctorToName = new Map();
 function registerSerializableClass(name, ctor) {
@@ -65,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/lib/types/buildCache.d.ts

@@ -0,0 +1,2 @@
+export declare function createBuildCache<K, V>(): Map<K, V>;
+export declare function clearBuildCaches(): void;

package/{src/index.js → lib/types/index.d.ts}

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

package/lib/types/serializer.d.ts

@@ -0,0 +1,11 @@
+export { serializeRaw, deserializeRaw } from './serializerCore';
+export type Class<T> = new (...args: any[]) => T;
+export declare function registerSerializableClass(name: string, ctor: Class<any>): void;
+export declare function unregisterSerializableClass(name: string, ctor: Class<any>): void;
+export declare function prepareForSerialization(object: any): any;
+export declare function restoreDeserializedObject(object: any): any;
+export declare function serialize(object: any): Buffer;
+export declare function deserialize(buffer: Buffer): any;
+export declare function cacheSerializedObject(object: any, buffer?: Buffer): void;
+export declare function deserializeToCache(buffer: Buffer): any;
+export declare function removeSerializedObjectFromCache(object: any): void;

package/lib/types/serializerCore.d.ts

@@ -0,0 +1,2 @@
+export declare let serializeRaw: (arg1?: any) => Buffer;
+export declare let deserializeRaw: (arg1: Buffer) => any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaspack/build-cache",
   "description": "Serialize and deserialize data structures to a build cache",
-  "version": "2.13.3-canary.48+f8b0cd29d",
+  "version": "2.13.3-canary.481+221f28644",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -11,10 +11,17 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
-  "gitHead": "f8b0cd29d020072681cbb52d958553d0813b6460"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "dependencies": {
+    "@atlaspack/feature-flags": "2.14.1-canary.481+221f28644"
+  },
+  "gitHead": "221f28644f5b2314645595facac076b49503345d"
+}

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';