@haneullabs/utils 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# @haneullabs/utils
+
+## 0.2.0
+
+### Minor Changes
+
+- ea1ac70: Update dependencies and improve support for typescript 5.9
+
+## 0.1.1
+
+### Patch Changes
+
+- 1c4a82d: update links in package.json
+
+## 0.1.0
+
+### Minor Changes
+
+- a00522b: Add dataloader
+
+## 0.0.1
+
+### Patch Changes
+
+- bb7c03a: Update dependencies

package/README.md

@@ -0,0 +1,5 @@
+# SDK Utils
+
+This is package contains utils shared across `@haneullabs/*` sdks. It is not intended to be consumed
+directly. Changes in this package will be undocumented, and may contain breaking changes at any
+time.

package/dist/cjs/b58.d.ts

@@ -0,0 +1,2 @@
+export declare const toBase58: (buffer: Uint8Array) => string;
+export declare const fromBase58: (str: string) => Uint8Array<ArrayBuffer>;

package/dist/cjs/b58.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var b58_exports = {};
+__export(b58_exports, {
+  fromBase58: () => fromBase58,
+  toBase58: () => toBase58
+});
+module.exports = __toCommonJS(b58_exports);
+var import_base = require("@scure/base");
+const toBase58 = (buffer) => import_base.base58.encode(buffer);
+const fromBase58 = (str) => import_base.base58.decode(str);
+//# sourceMappingURL=b58.js.map

package/dist/cjs/b58.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/b58.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { base58 } from '@scure/base';\n\nexport const toBase58 = (buffer: Uint8Array) => base58.encode(buffer);\nexport const fromBase58 = (str: string) => base58.decode(str) as Uint8Array<ArrayBuffer>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,kBAAuB;AAEhB,MAAM,WAAW,CAAC,WAAuB,mBAAO,OAAO,MAAM;AAC7D,MAAM,aAAa,CAAC,QAAgB,mBAAO,OAAO,GAAG;",
+  "names": []
+}

package/dist/cjs/b64.d.ts

@@ -0,0 +1,2 @@
+export declare function fromBase64(base64String: string): Uint8Array<ArrayBuffer>;
+export declare function toBase64(bytes: Uint8Array): string;

package/dist/cjs/b64.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var b64_exports = {};
+__export(b64_exports, {
+  fromBase64: () => fromBase64,
+  toBase64: () => toBase64
+});
+module.exports = __toCommonJS(b64_exports);
+function fromBase64(base64String) {
+  return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+}
+const CHUNK_SIZE = 8192;
+function toBase64(bytes) {
+  if (bytes.length < CHUNK_SIZE) {
+    return btoa(String.fromCharCode(...bytes));
+  }
+  let output = "";
+  for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.slice(i, i + CHUNK_SIZE);
+    output += String.fromCharCode(...chunk);
+  }
+  return btoa(output);
+}
+//# sourceMappingURL=b64.js.map

package/dist/cjs/b64.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/b64.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport function fromBase64(base64String: string): Uint8Array<ArrayBuffer> {\n\treturn Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));\n}\n\nconst CHUNK_SIZE = 8192;\nexport function toBase64(bytes: Uint8Array): string {\n\t// Special-case the simple case for speed's sake.\n\tif (bytes.length < CHUNK_SIZE) {\n\t\treturn btoa(String.fromCharCode(...bytes));\n\t}\n\n\tlet output = '';\n\tfor (var i = 0; i < bytes.length; i += CHUNK_SIZE) {\n\t\tconst chunk = bytes.slice(i, i + CHUNK_SIZE);\n\t\toutput += String.fromCharCode(...chunk);\n\t}\n\n\treturn btoa(output);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,WAAW,cAA+C;AACzE,SAAO,WAAW,KAAK,KAAK,YAAY,GAAG,CAAC,SAAS,KAAK,WAAW,CAAC,CAAC;AACxE;AAEA,MAAM,aAAa;AACZ,SAAS,SAAS,OAA2B;AAEnD,MAAI,MAAM,SAAS,YAAY;AAC9B,WAAO,KAAK,OAAO,aAAa,GAAG,KAAK,CAAC;AAAA,EAC1C;AAEA,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,YAAY;AAClD,UAAM,QAAQ,MAAM,MAAM,GAAG,IAAI,UAAU;AAC3C,cAAU,OAAO,aAAa,GAAG,KAAK;AAAA,EACvC;AAEA,SAAO,KAAK,MAAM;AACnB;",
+  "names": []
+}

package/dist/cjs/chunk.d.ts

@@ -0,0 +1 @@
+export declare function chunk<T>(array: readonly T[], size: number): T[][];

package/dist/cjs/chunk.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_exports = {};
+__export(chunk_exports, {
+  chunk: () => chunk
+});
+module.exports = __toCommonJS(chunk_exports);
+function chunk(array, size) {
+  return Array.from({ length: Math.ceil(array.length / size) }, (_, i) => {
+    return array.slice(i * size, (i + 1) * size);
+  });
+}
+//# sourceMappingURL=chunk.js.map

package/dist/cjs/chunk.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/chunk.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nexport function chunk<T>(array: readonly T[], size: number): T[][] {\n\treturn Array.from({ length: Math.ceil(array.length / size) }, (_, i) => {\n\t\treturn array.slice(i * size, (i + 1) * size);\n\t});\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,MAAS,OAAqB,MAAqB;AAClE,SAAO,MAAM,KAAK,EAAE,QAAQ,KAAK,KAAK,MAAM,SAAS,IAAI,EAAE,GAAG,CAAC,GAAG,MAAM;AACvE,WAAO,MAAM,MAAM,IAAI,OAAO,IAAI,KAAK,IAAI;AAAA,EAC5C,CAAC;AACF;",
+  "names": []
+}

package/dist/cjs/dataloader.d.ts

@@ -0,0 +1,129 @@
+/** Copied from https://github.com/graphql/dataloader/blob/a10773043d41a56bde4219c155fcf5633e6c9bcb/src/index.js */
+/**
+ * A `DataLoader` creates a public API for loading data from a particular
+ * data back-end with unique keys such as the `id` column of a SQL table or
+ * document name in a MongoDB database, given a batch loading function.
+ *
+ * Each `DataLoader` instance contains a unique memoized cache. Use caution when
+ * used in long-lived applications or those which serve many users with
+ * different access permissions and consider creating a new instance per
+ * web request.
+ */
+export declare class DataLoader<K, V, C = K> {
+    constructor(batchLoadFn: DataLoader.BatchLoadFn<K, V>, options?: DataLoader.Options<K, V, C>);
+    _batchLoadFn: DataLoader.BatchLoadFn<K, V>;
+    _maxBatchSize: number;
+    _batchScheduleFn: (cb: () => void) => void;
+    _cacheKeyFn: (key: K) => C;
+    _cacheMap: DataLoader.CacheMap<C, Promise<V>> | null;
+    _batch: Batch<K, V> | null;
+    /**
+     * Loads a key, returning a `Promise` for the value represented by that key.
+     */
+    load(key: K): Promise<V>;
+    /**
+     * Loads multiple keys, promising an array of values:
+     *
+     *     var [ a, b ] = await myLoader.loadMany([ 'a', 'b' ]);
+     *
+     * This is similar to the more verbose:
+     *
+     *     var [ a, b ] = await Promise.all([
+     *       myLoader.load('a'),
+     *       myLoader.load('b')
+     *     ]);
+     *
+     * However it is different in the case where any load fails. Where
+     * Promise.all() would reject, loadMany() always resolves, however each result
+     * is either a value or an Error instance.
+     *
+     *     var [ a, b, c ] = await myLoader.loadMany([ 'a', 'b', 'badkey' ]);
+     *     // c instanceof Error
+     *
+     */
+    loadMany(keys: ReadonlyArray<K>): Promise<Array<V | Error>>;
+    /**
+     * Clears the value at `key` from the cache, if it exists. Returns itself for
+     * method chaining.
+     */
+    clear(key: K): this;
+    /**
+     * Clears the entire cache. To be used when some event results in unknown
+     * invalidations across this particular `DataLoader`. Returns itself for
+     * method chaining.
+     */
+    clearAll(): this;
+    /**
+     * Adds the provided key and value to the cache. If the key already
+     * exists, no change is made. Returns itself for method chaining.
+     *
+     * To prime the cache with an error at a key, provide an Error instance.
+     */
+    prime(key: K, value: V | Promise<V> | Error): this;
+    /**
+     * The name given to this `DataLoader` instance. Useful for APM tools.
+     *
+     * Is `null` if not set in the constructor.
+     */
+    name: string | null;
+}
+type Batch<K, V> = {
+    hasDispatched: boolean;
+    keys: Array<K>;
+    callbacks: Array<{
+        resolve: (value: V) => void;
+        reject: (error: Error) => void;
+    }>;
+    cacheHits?: Array<() => void>;
+};
+export declare namespace DataLoader {
+    type CacheMap<K, V> = {
+        get(key: K): V | void;
+        set(key: K, value: V): any;
+        delete(key: K): any;
+        clear(): any;
+    };
+    type BatchLoadFn<K, V> = (keys: ReadonlyArray<K>) => PromiseLike<ArrayLike<V | Error>>;
+    type Options<K, V, C = K> = {
+        /**
+         * Default `true`. Set to `false` to disable batching, invoking
+         * `batchLoadFn` with a single load key. This is equivalent to setting
+         * `maxBatchSize` to `1`.
+         */
+        batch?: boolean;
+        /**
+         * Default `Infinity`. Limits the number of items that get passed in to the
+         * `batchLoadFn`. May be set to `1` to disable batching.
+         */
+        maxBatchSize?: number;
+        /**
+         * Default see https://github.com/graphql/dataloader#batch-scheduling.
+         * A function to schedule the later execution of a batch. The function is
+         * expected to call the provided callback in the immediate future.
+         */
+        batchScheduleFn?: (callback: () => void) => void;
+        /**
+         * Default `true`. Set to `false` to disable memoization caching, creating a
+         * new Promise and new key in the `batchLoadFn` for every load of the same
+         * key. This is equivalent to setting `cacheMap` to `null`.
+         */
+        cache?: boolean;
+        /**
+         * Default `key => key`. Produces cache key for a given load key. Useful
+         * when keys are objects and two objects should be considered equivalent.
+         */
+        cacheKeyFn?: (key: K) => C;
+        /**
+         * Default `new Map()`. Instance of `Map` (or an object with a similar API)
+         * to be used as cache. May be set to `null` to disable caching.
+         */
+        cacheMap?: CacheMap<C, Promise<V>> | null;
+        /**
+         * The name given to this `DataLoader` instance. Useful for APM tools.
+         *
+         * Is `null` if not set in the constructor.
+         */
+        name?: string | null;
+    };
+}
+export {};

package/dist/cjs/dataloader.js

@@ -0,0 +1,318 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dataloader_exports = {};
+__export(dataloader_exports, {
+  DataLoader: () => DataLoader
+});
+module.exports = __toCommonJS(dataloader_exports);
+class DataLoader {
+  constructor(batchLoadFn, options) {
+    if (typeof batchLoadFn !== "function") {
+      throw new TypeError(
+        `DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but got: ${batchLoadFn}.`
+      );
+    }
+    this._batchLoadFn = batchLoadFn;
+    this._maxBatchSize = getValidMaxBatchSize(options);
+    this._batchScheduleFn = getValidBatchScheduleFn(options);
+    this._cacheKeyFn = getValidCacheKeyFn(options);
+    this._cacheMap = getValidCacheMap(options);
+    this._batch = null;
+    this.name = getValidName(options);
+  }
+  /**
+   * Loads a key, returning a `Promise` for the value represented by that key.
+   */
+  load(key) {
+    if (key === null || key === void 0) {
+      throw new TypeError(
+        `The loader.load() function must be called with a value, but got: ${String(key)}.`
+      );
+    }
+    const batch = getCurrentBatch(this);
+    const cacheMap = this._cacheMap;
+    let cacheKey;
+    if (cacheMap) {
+      cacheKey = this._cacheKeyFn(key);
+      const cachedPromise = cacheMap.get(cacheKey);
+      if (cachedPromise) {
+        const cacheHits = batch.cacheHits || (batch.cacheHits = []);
+        return new Promise((resolve) => {
+          cacheHits.push(() => {
+            resolve(cachedPromise);
+          });
+        });
+      }
+    }
+    batch.keys.push(key);
+    const promise = new Promise((resolve, reject) => {
+      batch.callbacks.push({ resolve, reject });
+    });
+    if (cacheMap) {
+      cacheMap.set(cacheKey, promise);
+    }
+    return promise;
+  }
+  /**
+   * Loads multiple keys, promising an array of values:
+   *
+   *     var [ a, b ] = await myLoader.loadMany([ 'a', 'b' ]);
+   *
+   * This is similar to the more verbose:
+   *
+   *     var [ a, b ] = await Promise.all([
+   *       myLoader.load('a'),
+   *       myLoader.load('b')
+   *     ]);
+   *
+   * However it is different in the case where any load fails. Where
+   * Promise.all() would reject, loadMany() always resolves, however each result
+   * is either a value or an Error instance.
+   *
+   *     var [ a, b, c ] = await myLoader.loadMany([ 'a', 'b', 'badkey' ]);
+   *     // c instanceof Error
+   *
+   */
+  loadMany(keys) {
+    if (!isArrayLike(keys)) {
+      throw new TypeError(
+        `The loader.loadMany() function must be called with Array<key>, but got: ${keys}.`
+      );
+    }
+    const loadPromises = [];
+    for (let i = 0; i < keys.length; i++) {
+      loadPromises.push(this.load(keys[i]).catch((error) => error));
+    }
+    return Promise.all(loadPromises);
+  }
+  /**
+   * Clears the value at `key` from the cache, if it exists. Returns itself for
+   * method chaining.
+   */
+  clear(key) {
+    const cacheMap = this._cacheMap;
+    if (cacheMap) {
+      const cacheKey = this._cacheKeyFn(key);
+      cacheMap.delete(cacheKey);
+    }
+    return this;
+  }
+  /**
+   * Clears the entire cache. To be used when some event results in unknown
+   * invalidations across this particular `DataLoader`. Returns itself for
+   * method chaining.
+   */
+  clearAll() {
+    const cacheMap = this._cacheMap;
+    if (cacheMap) {
+      cacheMap.clear();
+    }
+    return this;
+  }
+  /**
+   * Adds the provided key and value to the cache. If the key already
+   * exists, no change is made. Returns itself for method chaining.
+   *
+   * To prime the cache with an error at a key, provide an Error instance.
+   */
+  prime(key, value) {
+    const cacheMap = this._cacheMap;
+    if (cacheMap) {
+      const cacheKey = this._cacheKeyFn(key);
+      if (cacheMap.get(cacheKey) === void 0) {
+        let promise;
+        if (value instanceof Error) {
+          promise = Promise.reject(value);
+          promise.catch(() => {
+          });
+        } else {
+          promise = Promise.resolve(value);
+        }
+        cacheMap.set(cacheKey, promise);
+      }
+    }
+    return this;
+  }
+}
+const enqueuePostPromiseJob = (
+  // @ts-ignore
+  typeof process === "object" && typeof process.nextTick === "function" ? function(fn) {
+    if (!resolvedPromise) {
+      resolvedPromise = Promise.resolve();
+    }
+    resolvedPromise.then(() => {
+      process.nextTick(fn);
+    });
+  } : (
+    // @ts-ignore
+    typeof setImmediate === "function" ? function(fn) {
+      setImmediate(fn);
+    } : function(fn) {
+      setTimeout(fn);
+    }
+  )
+);
+let resolvedPromise;
+function getCurrentBatch(loader) {
+  const existingBatch = loader._batch;
+  if (existingBatch !== null && !existingBatch.hasDispatched && existingBatch.keys.length < loader._maxBatchSize) {
+    return existingBatch;
+  }
+  const newBatch = { hasDispatched: false, keys: [], callbacks: [] };
+  loader._batch = newBatch;
+  loader._batchScheduleFn(() => {
+    dispatchBatch(loader, newBatch);
+  });
+  return newBatch;
+}
+function dispatchBatch(loader, batch) {
+  batch.hasDispatched = true;
+  if (batch.keys.length === 0) {
+    resolveCacheHits(batch);
+    return;
+  }
+  let batchPromise;
+  try {
+    batchPromise = loader._batchLoadFn(batch.keys);
+  } catch (e) {
+    return failedDispatch(
+      loader,
+      batch,
+      new TypeError(
+        `DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function errored synchronously: ${String(e)}.`
+      )
+    );
+  }
+  if (!batchPromise || typeof batchPromise.then !== "function") {
+    return failedDispatch(
+      loader,
+      batch,
+      new TypeError(
+        `DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise: ${String(batchPromise)}.`
+      )
+    );
+  }
+  Promise.resolve(batchPromise).then((values) => {
+    if (!isArrayLike(values)) {
+      throw new TypeError(
+        `DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise of an Array: ${String(values)}.`
+      );
+    }
+    if (values.length !== batch.keys.length) {
+      throw new TypeError(
+        `DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise of an Array of the same length as the Array of keys.
+
+Keys:
+${String(batch.keys)}
+
+Values:
+${String(values)}`
+      );
+    }
+    resolveCacheHits(batch);
+    for (let i = 0; i < batch.callbacks.length; i++) {
+      const value = values[i];
+      if (value instanceof Error) {
+        batch.callbacks[i].reject(value);
+      } else {
+        batch.callbacks[i].resolve(value);
+      }
+    }
+  }).catch((error) => {
+    failedDispatch(loader, batch, error);
+  });
+}
+function failedDispatch(loader, batch, error) {
+  resolveCacheHits(batch);
+  for (let i = 0; i < batch.keys.length; i++) {
+    loader.clear(batch.keys[i]);
+    batch.callbacks[i].reject(error);
+  }
+}
+function resolveCacheHits(batch) {
+  if (batch.cacheHits) {
+    for (let i = 0; i < batch.cacheHits.length; i++) {
+      batch.cacheHits[i]();
+    }
+  }
+}
+function getValidMaxBatchSize(options) {
+  const shouldBatch = !options || options.batch !== false;
+  if (!shouldBatch) {
+    return 1;
+  }
+  const maxBatchSize = options && options.maxBatchSize;
+  if (maxBatchSize === void 0) {
+    return Infinity;
+  }
+  if (typeof maxBatchSize !== "number" || maxBatchSize < 1) {
+    throw new TypeError(`maxBatchSize must be a positive number: ${maxBatchSize}`);
+  }
+  return maxBatchSize;
+}
+function getValidBatchScheduleFn(options) {
+  const batchScheduleFn = options && options.batchScheduleFn;
+  if (batchScheduleFn === void 0) {
+    return enqueuePostPromiseJob;
+  }
+  if (typeof batchScheduleFn !== "function") {
+    throw new TypeError(`batchScheduleFn must be a function: ${batchScheduleFn}`);
+  }
+  return batchScheduleFn;
+}
+function getValidCacheKeyFn(options) {
+  const cacheKeyFn = options && options.cacheKeyFn;
+  if (cacheKeyFn === void 0) {
+    return (key) => key;
+  }
+  if (typeof cacheKeyFn !== "function") {
+    throw new TypeError(`cacheKeyFn must be a function: ${cacheKeyFn}`);
+  }
+  return cacheKeyFn;
+}
+function getValidCacheMap(options) {
+  const shouldCache = !options || options.cache !== false;
+  if (!shouldCache) {
+    return null;
+  }
+  const cacheMap = options && options.cacheMap;
+  if (cacheMap === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (cacheMap !== null) {
+    const cacheFunctions = ["get", "set", "delete", "clear"];
+    const missingFunctions = cacheFunctions.filter(
+      (fnName) => cacheMap && typeof cacheMap[fnName] !== "function"
+    );
+    if (missingFunctions.length !== 0) {
+      throw new TypeError("Custom cacheMap missing methods: " + missingFunctions.join(", "));
+    }
+  }
+  return cacheMap;
+}
+function getValidName(options) {
+  if (options && options.name) {
+    return options.name;
+  }
+  return null;
+}
+function isArrayLike(x) {
+  return typeof x === "object" && x !== null && "length" in x && typeof x.length === "number" && (x.length === 0 || x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1));
+}
+//# sourceMappingURL=dataloader.js.map