@adobe/data 0.2.1 → 0.2.3

package/src/cache/functions/hashing/json-to-hash.ts

@@ -1,29 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { stringToHash } from "./string-to-hash.js";
-
-/**
- * Converts a JSON object to a hash using SHA-256.
- */
-export async function jsonToHash(value: unknown): Promise<string> {
-  return stringToHash(JSON.stringify(value));
-}

package/src/cache/functions/hashing/string-to-hash.ts

@@ -1,38 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { bufferToHash } from "./buffer-to-hash.js";
-
-function stringToArrayBuffer(value: string): ArrayBuffer {
-  const buf = new ArrayBuffer(value.length * 2);
-  const view = new Uint16Array(buf);
-  for (let i = 0, strLen = value.length; i < strLen; i++) {
-    view[i] = value.charCodeAt(i);
-  }
-  return buf;
-}
-
-/**
- * Converts a string to a hash using SHA-256.
- */
-export async function stringToHash(value: string): Promise<string> {
-  return bufferToHash(stringToArrayBuffer(value));
-}

package/src/cache/functions/index.ts

@@ -1,27 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-
-export * from "./hashing/index.js";
-export * from "./memoize.js";
-export * from "./prevent-parallel-execution.js";
-export * from "./async-data-function.js";
-export * from "./get-cached.js";

package/src/cache/functions/memoize.ts

@@ -1,55 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-
-import { preventParallelExecution } from "./prevent-parallel-execution.js";
-import { AsyncDataFunction } from "./async-data-function.js";
-
-import { type Data } from "../../data.js";
-import { getDataCache } from "../index.js";
-
-/**
- * Uses datacache to store results so we can avoid expensive recomputations of the same input.
- * This function also uses preventParallelExecution to prevent multiple executions of the same function at the same time with the same arguments.
- * @param fn The function to memoize by storing results in the DataCache.
- * @param version The version of this function. If the function changes this must also change
- * to avoid returning stale results from an older version of the function.
- * @param name The name of this function which should be application unique to avoid hash collisions.
- * @returns A function with the same signature but memoized results.
- */
-export function memoize<In extends Array<Data>, Out extends Data>(
-  uniqueNameAndVersion: string,
-  fn: AsyncDataFunction<In, Out>
-): AsyncDataFunction<In, Out> {
-  // synchronize the function to prevent executing same requests simultaneously.
-  fn = preventParallelExecution(fn);
-  const cache = getDataCache(uniqueNameAndVersion);
-  const memoized = async (...args: Array<Data>): Promise<Data> => {
-    const cachedResult = await cache.match(args);
-    if (cachedResult !== undefined) {
-      return cachedResult;
-    }
-    const result = await fn(...(args as In));
-    await cache.put(args, result);
-    return result;
-  };
-  return memoized as unknown as AsyncDataFunction<In, Out>;
-}

package/src/cache/functions/prevent-parallel-execution.ts

@@ -1,50 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { type AsyncDataFunction } from "./async-data-function.js";
-
-import { type Data } from "../../data.js";
-
-/**
- * Returns an async function which can NOT be executed simultaneously with the same arguments.
- * Any attempt to call again while a prior call with same args is executing will return the first promise.
- * Once a promise completes, then a new call with same args could occur.
- */
-export function preventParallelExecution<In extends Array<unknown>, Out>(
-  fn: AsyncDataFunction<In, Out>
-): AsyncDataFunction<In, Out> {
-  const executing = new Map<string, Promise<Out>>();
-  const synchronized = async (...args: Array<Data>): Promise<Out> => {
-    const key = JSON.stringify(args);
-    let promise = executing.get(key);
-    if (!promise) {
-      promise = fn(...(args as In));
-      executing.set(key, promise);
-    }
-    try {
-      return await promise;
-    } finally {
-      // we delete the key after execution to prevent memory leak.
-      executing.delete(key);
-    }
-  };
-  return synchronized as unknown as AsyncDataFunction<In, Out>;
-}

package/src/cache/get-persistent-cache.ts

@@ -1,62 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import type { AsyncCache, AsyncCacheWithKeys } from "./async-cache.js";
-import { createFallbackAsyncCache } from "./fallback-async-cache.js";
-import { createManagedAsyncCache } from "./managed-async-cache.js";
-import { createMemoryAsyncCache } from "./memory-async-cache.js";
-
-/**
- * Gets a persistent async cache.
- * @param name the namespace name for the cache.
- */
-async function getUnmanagedPersistentCache(
-  name: string
-): Promise<AsyncCacheWithKeys<Request, Response>> {
-  return globalThis.caches.open(name) as unknown as Promise<
-    AsyncCacheWithKeys<Request, Response>
-  >;
-}
-
-/**
- * Gets a managed persistent cache using both fast memory layer and slower storage layer.
- * @param name The namespace for this persistent cache, used to isolate cache storage.
- * @param maximumMemoryEntries
- * @param maximumStorageEntries
- * @returns
- */
-export async function getManagedPersistentCache(
-  name: string,
-  options: {
-    maximumMemoryEntries: number;
-    maximumStorageEntries: number;
-  }
-): Promise<AsyncCache<Request, Response>> {
-  const memoryCache = createManagedAsyncCache(
-    createMemoryAsyncCache(),
-    options.maximumMemoryEntries
-  );
-  const storageCache = createManagedAsyncCache(
-    await getUnmanagedPersistentCache(name),
-    options.maximumStorageEntries
-  );
-  return createFallbackAsyncCache(memoryCache, storageCache);
-}

package/src/cache/index.ts

@@ -1,31 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-
-export {
-  type BlobStore,
-  type BlobRef,
-  blobStore,
-  isBlobRef,
-  BlobRefSchema,
-} from "./blob-store.js";
-export { getDataCache, type DataCache } from "./data-cache.js";
-export * from "./functions/index.js";

package/src/cache/managed-array.ts

@@ -1,243 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { MemoryAllocator } from "./memory-allocator.js";
-import { FromSchema, Schema } from "../schema/index.js";
-import { TypedArray, TypedArrayConstructor } from "../internal/typed-array/index.js";
-import { Data } from "../index.js";
-
-export interface NativeArray<T> {
-  readonly length: number;
-  [n: number]: T;
-}
-
-/**
- * Represents an abstraction over Arrays, numeric TypedArrays and
- * TypedArrays which contain tightly packed linear memory structures.
- */
-export interface ManagedArray<T> {
-  get(index: number): T;
-  set(index: number, value: T): void;
-  readonly native?: NativeArray<T>;
-  readonly constant: boolean;
-
-  ensureCapacity(capacity: number): void;
-  slice(from: number, length: number): Array<T>;
-  move(from: number, to: number): void;
-
-  toJSON(length: number, allowEncoding?: boolean): Data;
-  fromJSON(data: Data, length: number): void;
-}
-
-function createManagedConstantArray<T>(value: T): ManagedArray<T> {
-  return {
-    constant: true,
-    get(_index: number): T {
-      return value;
-    },
-    set(_index: number, _value: T): void { },
-    move(_from: number, _to: number): void { },
-    slice(_from: number, _length: number): Array<T> {
-      return [value];
-    },
-    ensureCapacity(_capacity: number) { },
-    toJSON(_length: number) {
-      return value as Data;
-    },
-    fromJSON(data: Data) {
-      if (data !== value) {
-        throw new Error(`Cannot set constant array to ${data}`);
-      }
-    },
-  };
-}
-
-function createManagedBasicArray<T>(): ManagedArray<T> {
-  const array: T[] = [];
-  return {
-    constant: false,
-    native: array,
-    get: (index: number) => array[index],
-    set: (index: number, value: T) => (array[index] = value),
-    move: (from: number, to: number) => (array[to] = array[from]),
-    ensureCapacity: (_capacity: number) => { },
-    slice: (from: number, length: number) => array.slice(from, from + length),
-    toJSON(length: number) {
-      return array.slice(0, length) as Data;
-    },
-    fromJSON(data: Data) {
-      if (!Array.isArray(data)) {
-        throw new Error(`Cannot set array to ${data}`);
-      }
-      array.length = 0;
-      array.push(...data as T[]);
-    },
-  };
-}
-
-function binaryEncode(subarray: TypedArray): string {
-  return btoa(
-    String.fromCharCode(
-      ...new Uint8Array(
-        subarray.buffer,
-        subarray.byteOffset,
-        subarray.byteLength
-      )
-    )
-  );
-}
-
-function binaryDecode(
-  data: string,
-  length: number,
-  ctor: TypedArrayConstructor
-): TypedArray {
-  const binaryString = atob(data);
-  const byteArray = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    byteArray[i] = binaryString.charCodeAt(i);
-  }
-  return new ctor(byteArray.buffer, byteArray.byteOffset, length);
-}
-
-function createManagedTypedArray(
-  ctor: TypedArrayConstructor,
-  allocator: MemoryAllocator
-): ManagedArray<number> {
-  let capacity = 16;
-  let array = allocator.allocate(ctor, capacity);
-  //  when the main wasm memory is resized, we need to refresh the array.
-  allocator.needsRefresh(() => {
-    array = allocator.refresh(array);
-  });
-
-  const grow = (newCapacity?: number) => {
-    if (newCapacity && newCapacity > capacity) {
-      array = allocator.refresh(array);
-      const oldArray = array;
-      const growthFactor = 2;
-      capacity = Math.max(newCapacity, capacity * growthFactor);
-      const newArray = allocator.allocate(ctor, capacity);
-      newArray.set(array);
-      array = newArray;
-      allocator.release(oldArray);
-    }
-  };
-  const result = {
-    constant: false,
-    get native() {
-      return array;
-    },
-    get(index: number) {
-      return array[index];
-    },
-    set(index: number, value: number): void {
-      // if (index >= capacity) {
-      //   grow();
-      // }
-      array[index] = value;
-    },
-    move(from: number, to: number): void {
-      array[to] = array[from];
-    },
-    slice(start: number, end: number) {
-      return [...array.subarray(start, end)];
-    },
-    ensureCapacity(newCapacity: number) {
-      grow(newCapacity);
-    },
-    toJSON(length: number, allowEncoding = true) {
-      const subarray = array.subarray(0, length);
-      if (!allowEncoding) {
-        return Array.from(subarray);
-      }
-      const jsonString = JSON.stringify(Array.from(subarray));
-      const binaryString = binaryEncode(subarray);
-      return binaryString.length < jsonString.length
-        ? binaryString
-        : Array.from(subarray);
-    },
-    fromJSON(data: Data, length: number) {
-      if (typeof data === "string") {
-        const decodedArray = binaryDecode(data, length, ctor);
-        if (decodedArray.length > capacity) {
-          grow(decodedArray.length);
-        }
-        array.set(decodedArray);
-      } else {
-        if (!Array.isArray(data)) {
-          throw new Error(`Cannot set array to ${data}`);
-        }
-        if (data.length > capacity) {
-          grow(data.length);
-        }
-        array.set(data as number[]);
-      }
-    },
-  };
-  return result;
-}
-
-export function createManagedArray<S extends Schema>(
-  s: S,
-  allocator: MemoryAllocator
-): ManagedArray<FromSchema<S>> {
-  if (s.const !== undefined) {
-    return createManagedConstantArray(s.const) as ManagedArray<FromSchema<S>>;
-  }
-  if (s.type === "number") {
-    if (s.precision === 1) {
-      return createManagedTypedArray(Float32Array, allocator) as ManagedArray<
-        FromSchema<S>
-      >;
-    }
-    // default to double precision float
-    return createManagedTypedArray(Float64Array, allocator) as ManagedArray<
-      FromSchema<S>
-    >;
-  }
-  if (
-    s.type === "integer" &&
-    s.minimum !== undefined
-  ) {
-    if (s.minimum >= 0) {
-      if (s.maximum) {
-        // unsigned integers
-        if (s.maximum <= 0xff) {
-          return createManagedTypedArray(Uint8Array, allocator) as ManagedArray<
-            FromSchema<S>
-          >;
-        }
-        if (s.maximum <= 0xffff) {
-          return createManagedTypedArray(Uint16Array, allocator) as ManagedArray<
-            FromSchema<S>
-          >;
-        }
-        if (s.maximum <= 0xffffffff) {
-          return createManagedTypedArray(Uint32Array, allocator) as ManagedArray<
-            FromSchema<S>
-          >;
-        }
-      }
-    }
-  }
-  return createManagedBasicArray();
-}

package/src/cache/managed-async-cache.browser.test.ts

@@ -1,53 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { createManagedAsyncCache } from "./managed-async-cache.js";
-import { createMemoryAsyncCache } from "./memory-async-cache.js";
-import { describe, expect, it } from "vitest";
-
-describe("ManagedAsyncCache", () => {
-  it("should retain new data but evict old data", async () => {
-    const optimum = 4;
-    const maximumEntries = optimum * 2;
-    const cache = createManagedAsyncCache(createMemoryAsyncCache(), optimum);
-    const count = 100;
-    for (let i = 0; i < count; i++) {
-      await cache.put(new Request(`key:${i}`), new Response(`value:${i}`));
-    }
-
-    // make sure we don't exceed maximum keys
-    const keyCount = await cache.getKeyCountForTesting();
-    //  should not store more than maximum keys
-    expect(keyCount <= maximumEntries).toBe(true);
-
-    // make the last N requests still available.
-    for (let k = 0; k < optimum; k++) {
-      const i = count - 1 - k;
-      const value = await cache.match(new Request(`key:${i}`));
-      expect(value instanceof Response).toBe(true);
-    }
-
-    //  old keys should return undefined
-    expect(await cache.match(new Request(`key:0`))).toBe(undefined);
-    expect(await cache.match(new Request(`key:1`))).toBe(undefined);
-    expect(await cache.match(new Request(`key:2`))).toBe(undefined);
-  });
-});

package/src/cache/managed-async-cache.ts

@@ -1,78 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import type { AsyncCache, AsyncCacheWithKeys } from "./async-cache.js";
-
-const CREATED_HEADER = "ManagedAsyncCache.Created";
-
-export function createManagedAsyncCache(
-  cache: AsyncCacheWithKeys<Request, Response>,
-  optimumEntries: number
-): AsyncCache<Request, Response> & {
-  getKeyCountForTesting(): Promise<number>;
-} {
-  const maximumEntries = optimumEntries * 2;
-  let putCount = 0;
-
-  const maybeManageCacheOnPut = async () => {
-    if (putCount++ % optimumEntries === 0) {
-      let keys = [...(await cache.keys())];
-      if (keys.length >= maximumEntries) {
-        // sort by created. ISO date strings are comparable by date
-        keys = keys.sort((a, b) => {
-          const aheader = a.headers.get(CREATED_HEADER);
-          const bheader = b.headers.get(CREATED_HEADER);
-          if (!aheader || !bheader) {
-            return 0;
-          }
-          return aheader.localeCompare(bheader);
-        });
-        while (keys.length > optimumEntries) {
-          const key = keys.shift();
-          if (key) {
-            await cache.delete(key);
-          }
-        }
-      }
-    }
-  };
-
-  return {
-    async put(key: Request, value: Response): Promise<void> {
-      // add a created header as metadata to the request
-      key.headers.set(CREATED_HEADER, new Date().toISOString());
-      await cache.put(key, value);
-      await maybeManageCacheOnPut();
-    },
-
-    async match(key: Request): Promise<Response | undefined> {
-      return cache.match(key);
-    },
-
-    async delete(key: Request): Promise<void> {
-      await cache.delete(key);
-    },
-
-    async getKeyCountForTesting(): Promise<number> {
-      return (await cache.keys()).length;
-    },
-  };
-}