@shopify/flash-list 2.0.0-alpha.8 → 2.0.0-rc.1

package/dist/recyclerview/RecycleKeyManager.d.ts

@@ -1,82 +0,0 @@
-export interface RecycleKeyManager {
-    /**
-     * Retrieves a unique key for an item type, maintaining a separate pool for each type.
-     * If a stableId is provided and exists, returns the associated key.
-     * Otherwise, generates a new key or reuses one from the pool.
-     * @param itemType - The type/category of the item (e.g., 'header', 'product', 'footer')
-     * @param stableId - Optional unique identifier for stable item tracking
-     * @param currentKey - Optional current key to maintain if it exists in the pool
-     * @returns A unique key for the item
-     */
-    getKey: (itemType: string, stableId: string, currentKey?: string) => string;
-    /**
-     * Recycles a key back into its item type's pool when the associated view is no longer visible.
-     * This allows the key to be reused for new items of the same type.
-     * @param key - The key to be recycled back into the pool
-     */
-    recycleKey: (key: string) => void;
-    /**
-     * Checks if a key is currently available in the recycling pool (not in use).
-     * @param key - The key to check
-     * @returns True if the key is available in the pool, false otherwise
-     */
-    hasKeyInPool: (key: string) => boolean;
-    /**
-     * Clears all recycled keys from the pool, resetting the recycling system.
-     * This is useful when the list needs to be completely reset.
-     */
-    clearPool: () => void;
-}
-export declare class RecycleKeyManagerImpl implements RecycleKeyManager {
-    private maxItems;
-    private keyPools;
-    private keyMap;
-    private stableIdMap;
-    private keyCounter;
-    /**
-     * Creates a new RecycleKeyManager with a specified maximum number of items.
-     * @param maxItems - Maximum number of unique keys that can be active simultaneously.
-     *                   Defaults to Number.MAX_SAFE_INTEGER if not specified.
-     */
-    constructor(maxItems?: number);
-    /**
-     * Gets a key for the specified item type, prioritizing stable ID associations.
-     * If a stable ID exists, returns its associated key. Otherwise, either reuses
-     * a key from the pool or generates a new one.
-     * @param itemType - The type/category of the item
-     * @param stableId - Optional unique identifier for stable item tracking
-     * @param currentKey - Optional current key to maintain if it exists in the pool
-     * @returns A unique key for the item
-     */
-    getKey(itemType: string, stableId: string, currentKey?: string): string;
-    /**
-     * Recycles a key by adding it back to its item type's pool and cleaning up
-     * associated mappings. This should be called when a view is no longer visible.
-     * @param key - The key to be recycled
-     */
-    recycleKey(key: string): void;
-    /**
-     * Checks if a key is currently available in the recycling pool.
-     * @param key - The key to check
-     * @returns True if the key is available in the pool, false otherwise
-     */
-    hasKeyInPool(key: string): boolean;
-    /**
-     * Clears all recycled keys from the pool, effectively resetting the recycling system.
-     * This operation does not affect currently active keys.
-     */
-    clearPool(): void;
-    /**
-     * Generates a unique sequential key using an internal counter.
-     * @returns A unique key as a string
-     */
-    private generateKey;
-    /**
-     * Ensures the total number of active keys doesn't exceed the maximum limit.
-     * If the limit is exceeded, recycles the oldest keys until within bounds.
-     * Note: This operation may impact performance when dealing with large lists.
-     * TODO: Check performance impact of this
-     */
-    private ensurePoolSize;
-}
-//# sourceMappingURL=RecycleKeyManager.d.ts.map

package/dist/recyclerview/RecycleKeyManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RecycleKeyManager.d.ts","sourceRoot":"","sources":["../../src/recyclerview/RecycleKeyManager.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;OAQG;IACH,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAE5E;;;;OAIG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAElC;;;;OAIG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAEvC;;;OAGG;IACH,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,qBAAa,qBAAsB,YAAW,iBAAiB;IAE7D,OAAO,CAAC,QAAQ,CAAS;IAGzB,OAAO,CAAC,QAAQ,CAA2B;IAG3C,OAAO,CAAC,MAAM,CAAuD;IAGrE,OAAO,CAAC,WAAW,CAAsB;IAGzC,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;OAIG;gBACS,QAAQ,GAAE,MAAgC;IAQtD;;;;;;;;OAQG;IACI,MAAM,CACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM;IAsCT;;;;OAIG;IACI,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAwBpC;;;;OAIG;IACI,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC;;;OAGG;IACI,SAAS;IAIhB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;CAWvB"}

package/dist/recyclerview/RecycleKeyManager.js

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecycleKeyManagerImpl = void 0;
-var tslib_1 = require("tslib");
-var RecycleKeyManagerImpl = /** @class */ (function () {
-    /**
-     * Creates a new RecycleKeyManager with a specified maximum number of items.
-     * @param maxItems - Maximum number of unique keys that can be active simultaneously.
-     *                   Defaults to Number.MAX_SAFE_INTEGER if not specified.
-     */
-    function RecycleKeyManagerImpl(maxItems) {
-        if (maxItems === void 0) { maxItems = Number.MAX_SAFE_INTEGER; }
-        this.maxItems = maxItems;
-        this.keyPools = new Map();
-        this.keyMap = new Map();
-        this.stableIdMap = new Map();
-        this.keyCounter = 0;
-    }
-    /**
-     * Gets a key for the specified item type, prioritizing stable ID associations.
-     * If a stable ID exists, returns its associated key. Otherwise, either reuses
-     * a key from the pool or generates a new one.
-     * @param itemType - The type/category of the item
-     * @param stableId - Optional unique identifier for stable item tracking
-     * @param currentKey - Optional current key to maintain if it exists in the pool
-     * @returns A unique key for the item
-     */
-    RecycleKeyManagerImpl.prototype.getKey = function (itemType, stableId, currentKey) {
-        // Return existing key if stableId is already mapped
-        if (stableId && this.stableIdMap.has(stableId)) {
-            return this.stableIdMap.get(stableId);
-        }
-        // Get or create the pool for this item type
-        var pool = this.keyPools.get(itemType);
-        if (!pool) {
-            pool = new Set();
-            this.keyPools.set(itemType, pool);
-        }
-        var key;
-        // Reuse existing key from pool if available
-        if (pool.size > 0) {
-            key =
-                currentKey && pool.has(currentKey)
-                    ? currentKey
-                    : pool.values().next().value;
-            pool.delete(key);
-        }
-        else {
-            // Generate new key if pool is empty
-            key = this.generateKey();
-        }
-        // Update mappings with new key information
-        this.keyMap.set(key, { itemType: itemType, stableId: stableId });
-        if (stableId) {
-            this.stableIdMap.set(stableId, key);
-        }
-        // Ensure we don't exceed the maximum number of active keys
-        this.ensurePoolSize();
-        return key;
-    };
-    /**
-     * Recycles a key by adding it back to its item type's pool and cleaning up
-     * associated mappings. This should be called when a view is no longer visible.
-     * @param key - The key to be recycled
-     */
-    RecycleKeyManagerImpl.prototype.recycleKey = function (key) {
-        var keyInfo = this.keyMap.get(key);
-        if (!keyInfo) {
-            return;
-        }
-        var itemType = keyInfo.itemType, stableId = keyInfo.stableId;
-        // Clean up stable ID mapping if it exists
-        if (stableId) {
-            this.stableIdMap.delete(stableId);
-        }
-        // Add key back to its type's pool
-        var pool = this.keyPools.get(itemType);
-        if (!pool) {
-            pool = new Set();
-            this.keyPools.set(itemType, pool);
-        }
-        pool.add(key);
-        this.keyMap.delete(key);
-    };
-    /**
-     * Checks if a key is currently available in the recycling pool.
-     * @param key - The key to check
-     * @returns True if the key is available in the pool, false otherwise
-     */
-    RecycleKeyManagerImpl.prototype.hasKeyInPool = function (key) {
-        return !this.keyMap.has(key);
-    };
-    /**
-     * Clears all recycled keys from the pool, effectively resetting the recycling system.
-     * This operation does not affect currently active keys.
-     */
-    RecycleKeyManagerImpl.prototype.clearPool = function () {
-        this.keyPools.clear();
-    };
-    /**
-     * Generates a unique sequential key using an internal counter.
-     * @returns A unique key as a string
-     */
-    RecycleKeyManagerImpl.prototype.generateKey = function () {
-        return (this.keyCounter++).toString();
-    };
-    /**
-     * Ensures the total number of active keys doesn't exceed the maximum limit.
-     * If the limit is exceeded, recycles the oldest keys until within bounds.
-     * Note: This operation may impact performance when dealing with large lists.
-     * TODO: Check performance impact of this
-     */
-    RecycleKeyManagerImpl.prototype.ensurePoolSize = function () {
-        var e_1, _a;
-        if (this.keyMap.size <= this.maxItems)
-            return;
-        var keysToRecycle = Array.from(this.keyMap.keys()).slice(0, this.keyMap.size - this.maxItems);
-        try {
-            for (var keysToRecycle_1 = tslib_1.__values(keysToRecycle), keysToRecycle_1_1 = keysToRecycle_1.next(); !keysToRecycle_1_1.done; keysToRecycle_1_1 = keysToRecycle_1.next()) {
-                var key = keysToRecycle_1_1.value;
-                this.recycleKey(key);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (keysToRecycle_1_1 && !keysToRecycle_1_1.done && (_a = keysToRecycle_1.return)) _a.call(keysToRecycle_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    return RecycleKeyManagerImpl;
-}());
-exports.RecycleKeyManagerImpl = RecycleKeyManagerImpl;
-//# sourceMappingURL=RecycleKeyManager.js.map

package/dist/recyclerview/RecycleKeyManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"RecycleKeyManager.js","sourceRoot":"","sources":["../../src/recyclerview/RecycleKeyManager.ts"],"names":[],"mappings":"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"}

package/src/__tests__/RecycleKeyManager.test.ts

@@ -1,254 +0,0 @@
-import { RecycleKeyManagerImpl } from "../recyclerview/RecycleKeyManager";
-
-describe("RecycleKeyManagerImpl", () => {
-  let keyManager: RecycleKeyManagerImpl;
-
-  beforeEach(() => {
-    // Initialize a new manager before each test
-    keyManager = new RecycleKeyManagerImpl();
-  });
-
-  describe("constructor", () => {
-    it("should initialize with default maxItems", () => {
-      // Test default maxItems value (implicitly tested via other methods)
-      // We can potentially expose maxItems for testing or test its effect
-      expect(keyManager).toBeDefined(); // Basic check
-    });
-
-    it("should initialize with specified maxItems", () => {
-      const specificMaxItems = 10;
-      keyManager = new RecycleKeyManagerImpl(specificMaxItems);
-      // Test the effect of maxItems limit later in getKey tests
-      expect(keyManager).toBeDefined(); // Basic check
-    });
-  });
-
-  describe("getKey", () => {
-    it("should generate a new key for a new item type without stableId", () => {
-      const key = keyManager.getKey("typeA", "item1");
-      expect(key).toBeDefined();
-      expect(typeof key).toBe("string");
-      expect(keyManager.hasKeyInPool(key)).toBe(false);
-    });
-
-    it("should generate a different key for a different item type", () => {
-      const keyA = keyManager.getKey("typeA", "item1");
-      const keyB = keyManager.getKey("typeB", "item2");
-      expect(keyA).not.toEqual(keyB);
-      expect(keyManager.hasKeyInPool(keyA)).toBe(false);
-      expect(keyManager.hasKeyInPool(keyB)).toBe(false);
-    });
-
-    it("should generate sequential keys when pool is empty", () => {
-      const key1 = keyManager.getKey("typeA", "item1");
-      const key2 = keyManager.getKey("typeA", "item2");
-      expect(parseInt(key2, 10)).toBe(parseInt(key1, 10) + 1);
-    });
-
-    it("should return the existing key for a known stableId", () => {
-      const stableId = "stable1";
-      const key1 = keyManager.getKey("typeA", stableId);
-      const key2 = keyManager.getKey("typeA", stableId);
-      const key3 = keyManager.getKey("typeB", stableId); // Different type, same stableId
-      expect(key2).toEqual(key1);
-      expect(key3).toEqual(key1); // Should still return the key associated with the stableId
-      expect(keyManager.hasKeyInPool(key1)).toBe(false);
-    });
-
-    it("should reuse a key from the pool for the same item type", () => {
-      const key1 = keyManager.getKey("typeA", "item1");
-      keyManager.recycleKey(key1);
-      const key2 = keyManager.getKey("typeA", "item2");
-      expect(key2).toEqual(key1); // Should reuse the recycled key
-      expect(keyManager.hasKeyInPool(key1)).toBe(false);
-    });
-
-    it("should reuse the specified currentKey if it exists in the pool", () => {
-      const key1 = keyManager.getKey("typeA", "item1");
-      const key2 = keyManager.getKey("typeA", "item2");
-      keyManager.recycleKey(key1);
-      keyManager.recycleKey(key2);
-
-      const reusedKey = keyManager.getKey("typeA", "item3", key1);
-      expect(reusedKey).toEqual(key1);
-      expect(keyManager.hasKeyInPool(key1)).toBe(false);
-      // key2 should still be in the pool
-      expect(keyManager.hasKeyInPool(key2)).toBe(true);
-    });
-
-    it("should reuse any key from the pool if currentKey does not exist", () => {
-      const key1 = keyManager.getKey("typeA", "item1");
-      const key2 = keyManager.getKey("typeA", "item2");
-      keyManager.recycleKey(key1);
-      keyManager.recycleKey(key2);
-
-      const nonExistentKey = "nonExistentKey";
-      const reusedKey = keyManager.getKey("typeA", "item3", nonExistentKey);
-
-      // It should have reused either key1 or key2
-      expect([key1, key2]).toContain(reusedKey);
-      expect(keyManager.hasKeyInPool(reusedKey)).toBe(false);
-    });
-
-    it("should prioritize stableId over pool reuse", () => {
-      const stableId = "stable1";
-      const key1 = keyManager.getKey("typeA", stableId); // Assign key1 to stable1
-      const key2 = keyManager.getKey("typeA", "item2");
-      keyManager.recycleKey(key2); // Put key2 in the pool
-
-      // Request key for stable1 again
-      const key3 = keyManager.getKey("typeA", stableId);
-      expect(key3).toEqual(key1); // Should return key1 associated with stableId
-      expect(keyManager.hasKeyInPool(key1)).toBe(false);
-      // key2 should still be in the pool
-      expect(keyManager.hasKeyInPool(key2)).toBe(true);
-    });
-
-    it("should assign stableId to a reused key", () => {
-      const key1 = keyManager.getKey("typeA", "item1");
-      keyManager.recycleKey(key1);
-
-      const stableId = "stableReuse";
-      const reusedKey = keyManager.getKey("typeA", stableId); // Reuse key1 and assign stableId
-      expect(reusedKey).toEqual(key1);
-
-      // Verify stableId mapping
-      const keyForStableId = keyManager.getKey("typeA", stableId);
-      expect(keyForStableId).toEqual(key1);
-    });
-
-    it("should handle ensurePoolSize when maxItems is exceeded", () => {
-      const maxItems = 2;
-      keyManager = new RecycleKeyManagerImpl(maxItems);
-
-      const key1 = keyManager.getKey("typeA", "item1"); // Active: {key1}
-      const key2 = keyManager.getKey("typeA", "item2"); // Active: {key1, key2}
-      expect(keyManager.hasKeyInPool(key1)).toBe(false);
-      expect(keyManager.hasKeyInPool(key2)).toBe(false);
-
-      // This should trigger ensurePoolSize and recycle key1 (oldest)
-      const key3 = keyManager.getKey("typeA", "item3"); // Active: {key2, key3}
-
-      expect(keyManager.hasKeyInPool(key1)).toBe(true); // key1 should be recycled
-      expect(keyManager.hasKeyInPool(key2)).toBe(false);
-      expect(keyManager.hasKeyInPool(key3)).toBe(false);
-
-      // This should trigger ensurePoolSize and recycle key2
-      const key4 = keyManager.getKey("typeA", "item4"); // Active: {key3, key4}
-      expect(keyManager.hasKeyInPool(key2)).toBe(true); // key2 should be recycled
-      expect(keyManager.hasKeyInPool(key3)).toBe(false);
-      expect(keyManager.hasKeyInPool(key4)).toBe(false);
-    });
-  });
-
-  describe("recycleKey", () => {
-    it("should add the key back to the correct pool", () => {
-      const keyA = keyManager.getKey("typeA", "item1");
-      const keyB = keyManager.getKey("typeB", "item2");
-
-      expect(keyManager.hasKeyInPool(keyA)).toBe(false);
-      expect(keyManager.hasKeyInPool(keyB)).toBe(false);
-
-      keyManager.recycleKey(keyA);
-      expect(keyManager.hasKeyInPool(keyA)).toBe(true);
-      expect(keyManager.hasKeyInPool(keyB)).toBe(false); // keyB should remain active
-
-      // Verify reuse from correct pool
-      const reusedKeyA = keyManager.getKey("typeA", "item3");
-      expect(reusedKeyA).toEqual(keyA);
-    });
-
-    it("should do nothing if the key does not exist or is already recycled", () => {
-      const key = keyManager.getKey("typeA", "item1");
-      keyManager.recycleKey(key); // Recycle it once
-
-      // Get current state (how many keys active, how many in pool)
-      // We need internal access or specific methods to check pool size directly.
-      // Let's assume internal state is correct after first recycle.
-
-      keyManager.recycleKey(key); // Try recycling again
-      keyManager.recycleKey("nonExistentKey"); // Try recycling non-existent key
-
-      // Verify state hasn't changed unexpectedly
-      expect(keyManager.hasKeyInPool(key)).toBe(true); // Still in pool
-      const newKey = keyManager.getKey("typeA", "item2");
-      expect(newKey).toEqual(key); // Should still reuse the original key
-    });
-  });
-
-  describe("hasKeyInPool", () => {
-    it("should return false for an active key", () => {
-      const key = keyManager.getKey("typeA", "item1");
-      expect(keyManager.hasKeyInPool(key)).toBe(false);
-    });
-
-    it("should return true for a recycled key", () => {
-      const key = keyManager.getKey("typeA", "item1");
-      keyManager.recycleKey(key);
-      expect(keyManager.hasKeyInPool(key)).toBe(true);
-    });
-
-    it("should return true for a key that was never generated", () => {
-      expect(keyManager.hasKeyInPool("nonExistentKey")).toBe(true);
-    });
-  });
-
-  describe("clearPool", () => {
-    it("should clear all keys from all pools", () => {
-      const keyA1 = keyManager.getKey("typeA", "item1");
-      const keyA2 = keyManager.getKey("typeA", "item2");
-      const keyB1 = keyManager.getKey("typeB", "item3");
-
-      keyManager.recycleKey(keyA1);
-      keyManager.recycleKey(keyB1);
-
-      expect(keyManager.hasKeyInPool(keyA1)).toBe(true);
-      expect(keyManager.hasKeyInPool(keyA2)).toBe(false); // Still active
-      expect(keyManager.hasKeyInPool(keyB1)).toBe(true);
-
-      keyManager.clearPool();
-
-      expect(keyManager.hasKeyInPool(keyA1)).toBe(true); // Still not active
-      expect(keyManager.hasKeyInPool(keyB1)).toBe(true); // Still not active
-      expect(keyManager.hasKeyInPool(keyA2)).toBe(false); // Active keys remain
-
-      // Getting new keys should generate new ones, not reuse cleared ones
-      const newKeyA = keyManager.getKey("typeA", "item4");
-      const newKeyB = keyManager.getKey("typeB", "item5");
-
-      expect(newKeyA).not.toEqual(keyA1);
-      expect(newKeyB).not.toEqual(keyB1);
-      // Depending on implementation, newKeyA might be keyA1 if keyCounter wasn't reset
-      // Check if key reuse happens after clearPool -> it shouldn't reuse from the *pool*
-      const keyA3 = keyManager.getKey("typeA", "item5"); // Generate another A key
-      keyManager.recycleKey(keyA3); // Recycle it
-      keyManager.clearPool(); // Clear pools again
-      keyManager.getKey("typeA", "item6"); // Get a new key
-      expect(keyManager.hasKeyInPool(keyA3)).toBe(true); // keyA3 is not active
-      // keyA4 should be newly generated, not reused from the cleared pool
-      // Note: Due to sequential key generation, it *might* match a previous key numerically
-      // but the crucial part is it wasn't reused *from the pool*.
-    });
-
-    it("should not affect active keys or stableId mappings", () => {
-      const stableId = "stableClear";
-      const keyA = keyManager.getKey("typeA", stableId);
-      const keyB = keyManager.getKey("typeB", "item2");
-      keyManager.recycleKey(keyB); // Put keyB in pool
-
-      expect(keyManager.hasKeyInPool(keyA)).toBe(false);
-      expect(keyManager.hasKeyInPool(keyB)).toBe(true);
-      expect(keyManager.getKey("typeA", stableId)).toEqual(keyA); // Check stableId mapping
-
-      keyManager.clearPool();
-
-      expect(keyManager.hasKeyInPool(keyA)).toBe(false); // keyA still active
-      expect(keyManager.hasKeyInPool(keyB)).toBe(true); // keyB still considered "in pool" (i.e., not active)
-      expect(keyManager.getKey("typeA", stableId)).toEqual(keyA); // StableId mapping persists
-
-      // Trying to get a key of type B should generate a new one
-      const newKeyB = keyManager.getKey("typeB", "item3");
-      expect(newKeyB).not.toEqual(keyB); // Because pool was cleared
-    });
-  });
-});

package/src/recyclerview/RecycleKeyManager.ts

@@ -1,185 +0,0 @@
-export interface RecycleKeyManager {
-  /**
-   * Retrieves a unique key for an item type, maintaining a separate pool for each type.
-   * If a stableId is provided and exists, returns the associated key.
-   * Otherwise, generates a new key or reuses one from the pool.
-   * @param itemType - The type/category of the item (e.g., 'header', 'product', 'footer')
-   * @param stableId - Optional unique identifier for stable item tracking
-   * @param currentKey - Optional current key to maintain if it exists in the pool
-   * @returns A unique key for the item
-   */
-  getKey: (itemType: string, stableId: string, currentKey?: string) => string;
-
-  /**
-   * Recycles a key back into its item type's pool when the associated view is no longer visible.
-   * This allows the key to be reused for new items of the same type.
-   * @param key - The key to be recycled back into the pool
-   */
-  recycleKey: (key: string) => void;
-
-  /**
-   * Checks if a key is currently available in the recycling pool (not in use).
-   * @param key - The key to check
-   * @returns True if the key is available in the pool, false otherwise
-   */
-  hasKeyInPool: (key: string) => boolean;
-
-  /**
-   * Clears all recycled keys from the pool, resetting the recycling system.
-   * This is useful when the list needs to be completely reset.
-   */
-  clearPool: () => void;
-}
-
-export class RecycleKeyManagerImpl implements RecycleKeyManager {
-  // Maximum number of unique keys that can be active at any time
-  private maxItems: number;
-
-  // Stores pools of recycled keys for each item type
-  private keyPools: Map<string, Set<string>>;
-
-  // Maps active keys to their metadata (item type and stable ID)
-  private keyMap: Map<string, { itemType: string; stableId?: string }>;
-
-  // Maps stable IDs to their corresponding keys for quick lookups
-  private stableIdMap: Map<string, string>;
-
-  // Counter for generating unique sequential keys
-  private keyCounter: number;
-
-  /**
-   * Creates a new RecycleKeyManager with a specified maximum number of items.
-   * @param maxItems - Maximum number of unique keys that can be active simultaneously.
-   *                   Defaults to Number.MAX_SAFE_INTEGER if not specified.
-   */
-  constructor(maxItems: number = Number.MAX_SAFE_INTEGER) {
-    this.maxItems = maxItems;
-    this.keyPools = new Map();
-    this.keyMap = new Map();
-    this.stableIdMap = new Map();
-    this.keyCounter = 0;
-  }
-
-  /**
-   * Gets a key for the specified item type, prioritizing stable ID associations.
-   * If a stable ID exists, returns its associated key. Otherwise, either reuses
-   * a key from the pool or generates a new one.
-   * @param itemType - The type/category of the item
-   * @param stableId - Optional unique identifier for stable item tracking
-   * @param currentKey - Optional current key to maintain if it exists in the pool
-   * @returns A unique key for the item
-   */
-  public getKey(
-    itemType: string,
-    stableId: string,
-    currentKey?: string
-  ): string {
-    // Return existing key if stableId is already mapped
-    if (stableId && this.stableIdMap.has(stableId)) {
-      return this.stableIdMap.get(stableId)!;
-    }
-
-    // Get or create the pool for this item type
-    let pool = this.keyPools.get(itemType);
-    if (!pool) {
-      pool = new Set();
-      this.keyPools.set(itemType, pool);
-    }
-
-    let key: string;
-    // Reuse existing key from pool if available
-    if (pool.size > 0) {
-      key =
-        currentKey && pool.has(currentKey)
-          ? currentKey
-          : pool.values().next().value;
-      pool.delete(key);
-    } else {
-      // Generate new key if pool is empty
-      key = this.generateKey();
-    }
-
-    // Update mappings with new key information
-    this.keyMap.set(key, { itemType, stableId });
-    if (stableId) {
-      this.stableIdMap.set(stableId, key);
-    }
-
-    // Ensure we don't exceed the maximum number of active keys
-    this.ensurePoolSize();
-
-    return key;
-  }
-
-  /**
-   * Recycles a key by adding it back to its item type's pool and cleaning up
-   * associated mappings. This should be called when a view is no longer visible.
-   * @param key - The key to be recycled
-   */
-  public recycleKey(key: string): void {
-    const keyInfo = this.keyMap.get(key);
-
-    if (!keyInfo) {
-      return;
-    }
-
-    const { itemType, stableId } = keyInfo;
-    // Clean up stable ID mapping if it exists
-    if (stableId) {
-      this.stableIdMap.delete(stableId);
-    }
-
-    // Add key back to its type's pool
-    let pool = this.keyPools.get(itemType);
-    if (!pool) {
-      pool = new Set();
-      this.keyPools.set(itemType, pool);
-    }
-
-    pool.add(key);
-    this.keyMap.delete(key);
-  }
-
-  /**
-   * Checks if a key is currently available in the recycling pool.
-   * @param key - The key to check
-   * @returns True if the key is available in the pool, false otherwise
-   */
-  public hasKeyInPool(key: string): boolean {
-    return !this.keyMap.has(key);
-  }
-
-  /**
-   * Clears all recycled keys from the pool, effectively resetting the recycling system.
-   * This operation does not affect currently active keys.
-   */
-  public clearPool() {
-    this.keyPools.clear();
-  }
-
-  /**
-   * Generates a unique sequential key using an internal counter.
-   * @returns A unique key as a string
-   */
-  private generateKey(): string {
-    return (this.keyCounter++).toString();
-  }
-
-  /**
-   * Ensures the total number of active keys doesn't exceed the maximum limit.
-   * If the limit is exceeded, recycles the oldest keys until within bounds.
-   * Note: This operation may impact performance when dealing with large lists.
-   * TODO: Check performance impact of this
-   */
-  private ensurePoolSize(): void {
-    if (this.keyMap.size <= this.maxItems) return;
-
-    const keysToRecycle = Array.from(this.keyMap.keys()).slice(
-      0,
-      this.keyMap.size - this.maxItems
-    );
-    for (const key of keysToRecycle) {
-      this.recycleKey(key);
-    }
-  }
-}