@cognite/underscore 1.0.0

package/dist/math.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determines if a number is even.
+ *
+ * @param value - The number to check.
+ * @returns `true` if the number is even, otherwise `false`.
+ */
+export declare function isEven(value: number): boolean;
+/**
+ * Determines if a number is odd.
+ *
+ * @param value - The number to check.
+ * @returns `true` if the number is odd, otherwise `false`.
+ */
+export declare function isOdd(value: number): boolean;

package/dist/math.js

@@ -0,0 +1,9 @@
+//#region libs/shared/underscore/src/math.ts
+function e(e) {
+	return e % 2 == 0;
+}
+function t(t) {
+	return !e(t);
+}
+//#endregion
+export { e as isEven, t as isOdd };

package/dist/random.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generates a random string of the specified length using alphanumeric characters.
+ *
+ * @param {number} length - The length of the random string to generate. Must be greater than 0.
+ * @returns {string} A random string of the specified length.
+ * @throws {Error} If the length is less than 1.
+ */
+export declare function randomString(length: number): string;
+/**
+ * Returns a random element from the given array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array from which to select a random element.
+ * @returns {T} A random element from the array.
+ */
+export declare function randomElement<T>(array: readonly T[]): T;
+/**
+ * Returns a random integer between minInclusive and maxExclusive.
+ *
+ * @param minInclusive
+ * @param maxExclusive
+ * @returns
+ */
+export declare function randomInteger(minInclusive: number, maxExclusive: number): number;
+/**
+ * Generates a random float within the given range [min, max).
+ *
+ * @param {number} minInclusive - The minimum value (inclusive).
+ * @param {number} maxExclusive - The maximum value (exclusive).
+ * @returns {number} A random float within the range [min, max).
+ */
+export declare function randomFloat(minInclusive: number, maxExclusive: number): number;

package/dist/random.js

@@ -0,0 +1,22 @@
+import { repeat as e } from "./repeat.js";
+//#region libs/shared/underscore/src/random.ts
+function t(t) {
+	if (t < 1) throw Error("Length must be greater than 0");
+	let r = [..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"], i = "";
+	return e(() => {
+		i += n(r);
+	}, t), i;
+}
+function n(e) {
+	return e[r(0, e.length)];
+}
+function r(e, t) {
+	if (e >= t) throw Error("The `minInclusive` value must be less than the `maxExclusive` value.");
+	return Math.floor(Math.random() * (t - e)) + e;
+}
+function i(e, t) {
+	if (e >= t) throw Error("The `minInclusive` value must be less than the `maxExclusive` value.");
+	return Math.random() * (t - e) + e;
+}
+//#endregion
+export { n as randomElement, i as randomFloat, r as randomInteger, t as randomString };

package/dist/react/use-debounce.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hook that debounces a value by a specified delay.
+ *
+ * The returned value will only update after the specified delay has passed
+ * since the last change to the input value. This is useful for reducing
+ * the frequency of expensive operations triggered by rapidly changing values.
+ *
+ * @param value - The value to debounce
+ * @param delayInMs - The delay in milliseconds
+ * @returns The debounced value
+ *
+ * @example
+ * ```tsx
+ * const [searchTerm, setSearchTerm] = useState('');
+ * const debouncedSearchTerm = useDebounce(searchTerm, 300);
+ *
+ * // API call only triggers when user stops typing for 300ms
+ * useEffect(() => {
+ *   searchApi(debouncedSearchTerm);
+ * }, [debouncedSearchTerm]);
+ * ```
+ */
+export declare function useDebounce<T>(value: T, delayInMs: number): T;

package/dist/react/use-debounce.js

@@ -0,0 +1,15 @@
+import { useEffect as e, useState as t } from "react";
+//#region libs/shared/underscore/src/react/use-debounce.ts
+function n(n, r) {
+	let [i, a] = t(n);
+	return e(() => {
+		let e = setTimeout(() => {
+			a(n);
+		}, r);
+		return () => {
+			clearTimeout(e);
+		};
+	}, [n, r]), i;
+}
+//#endregion
+export { n as useDebounce };

package/dist/react/use-derived-promise.d.ts

@@ -0,0 +1,34 @@
+type UseDerivedPromiseResult<T> = {
+    data: T | undefined;
+    error: Error | undefined;
+    isLoading: true;
+} | {
+    data: T;
+    error: undefined;
+    isLoading: false;
+} | {
+    data: undefined;
+    error: Error;
+    isLoading: false;
+};
+/**
+ * A custom React hook that executes a promise function whenever its dependencies change.
+ * It manages the loading state, error handling, and the result of the promise.
+ *
+ * @param promiseFn - A function that returns a promise.
+ * @param deps - An array of dependencies that trigger the promise execution when changed.
+ * @returns An object containing the data, loading state, and error from the promise execution.
+ *
+ * @example
+ * // Usage inside a React component
+ * const { data: user, error, isLoading } = useDerivedPromise(
+ *   () => getUserFromId(userId),
+ *   [userId]
+ * );
+ *
+ * if (isLoading) return <div>Loading...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * return <div>User: {user.name}</div>;
+ */
+export declare function useDerivedPromise<T>(promiseFn: () => Promise<T>, deps: React.DependencyList): UseDerivedPromiseResult<T>;
+export {};

package/dist/react/use-derived-promise.js

@@ -0,0 +1,34 @@
+import { useEffect as e, useState as t } from "react";
+//#region libs/shared/underscore/src/react/use-derived-promise.ts
+function n(n, r) {
+	let [i, a] = t(void 0), [o, s] = t(!0), [c, l] = t(void 0);
+	return e(() => {
+		let e = !0;
+		return s(!0), (async () => {
+			try {
+				let t = await n();
+				e && a(t);
+			} catch (t) {
+				e && l(t instanceof Error ? t : Error(String(t)));
+			} finally {
+				e && s(!1);
+			}
+		})(), () => {
+			e = !1;
+		};
+	}, r), o ? {
+		data: i,
+		error: c,
+		isLoading: !0
+	} : c ? {
+		data: void 0,
+		error: c,
+		isLoading: !1
+	} : {
+		data: i,
+		error: void 0,
+		isLoading: !1
+	};
+}
+//#endregion
+export { n as useDerivedPromise };

package/dist/react/use-stable-sync-external-store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A wrapper around React's `useSyncExternalStore` that returns a referentially
+ * stable value from a mutable data source.
+ *
+ * This hook uses structural cloning and deep equality checks to keep returning
+ * the same reference for the same value, making it safe to use with dependency
+ * arrays in other hooks.
+ *
+ * This is performance-sensitive and should be used with small slices of data.
+ *
+ * @template T - structurally-cloneable data type from your store
+ *
+ * @param subscribe - A function that subscribes to the external store and
+ *   returns an unsubscribe function. Called with a callback that should be
+ *   invoked whenever the store changes. Should be memoized.
+ * @param getSnapshot - A function that retrieves the current value from the
+ *   external store. Must be a pure function and can be called multiple times
+ *   per render. Must return a structurally-cloneable value. Does not need to be
+ *   memoized.
+ *
+ * @returns The current value from the store, with referential stability
+ *   guaranteed when the value content hasn't changed.
+ *
+ * @see [React
+ * useSyncExternalStore](https://react.dev/reference/react/useSyncExternalStore)
+ */
+export declare function useStableSyncExternalStore<T>(subscribe: (callback: VoidFunction) => VoidFunction, getSnapshot: () => T): T;

package/dist/react/use-stable-sync-external-store.js

@@ -0,0 +1,12 @@
+import { isEqual as e } from "lodash-es";
+import { useRef as t, useSyncExternalStore as n } from "react";
+//#region libs/shared/underscore/src/react/use-stable-sync-external-store.ts
+function r(r, i) {
+	let a = t(null);
+	return n(r, () => {
+		let t = i(), n = structuredClone(t), r = a.current;
+		return r !== null && e(r, n) ? r : (a.current = n, n);
+	});
+}
+//#endregion
+export { r as useStableSyncExternalStore };

package/dist/react.d.ts

@@ -0,0 +1,3 @@
+export { useDebounce } from './react/use-debounce';
+export { useDerivedPromise } from './react/use-derived-promise';
+export { useStableSyncExternalStore } from './react/use-stable-sync-external-store';

package/dist/react.js

@@ -0,0 +1,4 @@
+import { useDebounce as e } from "./react/use-debounce.js";
+import { useDerivedPromise as t } from "./react/use-derived-promise.js";
+import { useStableSyncExternalStore as n } from "./react/use-stable-sync-external-store.js";
+export { e as useDebounce, t as useDerivedPromise, n as useStableSyncExternalStore };

package/dist/repeat.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Repeats the execution of a given function a specified number of times.
+ *
+ * @param fn - The function to be executed repeatedly.
+ * @param times - The number of times to execute the function.
+ */
+export declare function repeat(fn: VoidFunction, times: number): void;

package/dist/repeat.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/repeat.ts
+function e(e, t) {
+	for (let n = 0; n < t; ++n) e();
+}
+//#endregion
+export { e as repeat };

package/dist/retry-async.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Retries an operation a configurable number of times.
+ *
+ * The flow is as follows:
+ * 1. Call the `operation` function.
+ * 2. If it resolves, return the resolved value.
+ * 3. If it throws an error, check if we should retry (based on `maxAttempts` and `shouldRetry`).
+ * 4. If we should retry, calculate the delay using `delayInMsCalculator`, call `onAttemptFail`, wait for that duration, and then repeat from step 1.
+ * 5. If we shouldn't retry (either because we've exhausted attempts or `shouldRetry` returned false), re-throw the error.
+ *
+ * By default, we use exponential backoff with jitter for delays between attempts.
+ *
+ * @param operation The function to execute and retry.
+ * @param config Configuration for the retry mechanism.
+ * @returns A Promise that resolves with the result of the successful operation.
+ * @throws Will throw if, and only if, all retry attempts failed. Only the last exception from `operation` will be re-thrown.
+ *
+ * @example
+ * ```ts
+ * // Basic usage: retry a function that may fail
+ * await retryAsync(() => {
+ *   if (Math.random() < 0.7) throw new Error('Transient error');
+ *   return 'success';
+ * });
+ * ```
+ *
+ * * @example
+ * ```ts
+ * try {
+ *   return retryAsync(() => fetchAllUsers());
+ * } catch (err) {
+ *   console.error('Failed to fetch users after several attempts:', err);
+ *   notifyUser('Failed to fetch users. Please try again later.');
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Custom retry logic and delay
+ * await retryAsync(
+ *   async () => myFetch('https://api.example.com/data'),
+ *   {
+ *     maxAttempts: 10,
+ *     shouldRetry: (error) => error instanceof NetworkError,
+ *     delayInMsCalculator: (attempt) => 100 * attempt,
+ *     onAttemptFail: (error, attempt, delay) => {
+ *       console.warn(`Attempt ${attempt} failed (waiting ${delay}ms):`, error);
+ *     },
+ *   }
+ * );
+ * ```
+ */
+export declare function retryAsync<T>(operation: () => T | Promise<T>, options?: RetryAsyncOptions): Promise<T>;
+/**
+ * Configuration options for {@link retryAsync}.
+ */
+export type RetryAsyncOptions = {
+    /**
+     * The maximum number of attempts to make, including the initial one.
+     * Must be in the range [1, 100].
+     * @default 5
+     */
+    maxAttempts?: number;
+    /**
+     * A function to determine if the thrown error should trigger a retry.
+     *
+     * If this function returns `true`, a retry will be performed (up to `maxAttempts`).
+     * If it returns `false`, the error will be immediately thrown and not retried.
+     * @default (error) => true // Retries on any error.
+     * @returns Whether to retry based on the provided error.
+     */
+    shouldRetry?: (error: unknown) => boolean;
+    /**
+     * An optional callback executed after a failed attempt, but before the next delay.
+     *
+     * Useful for logging or metrics.
+     * @param error The error that caused the failure.
+     * @param attempt The current failed attempt number (1, 2, 3, etc.).
+     * @param delayInMs The calculated delay before the next attempt.
+     */
+    onAttemptFail?: (error: unknown, attempt: number, delayInMs: number) => void;
+    /**
+     * The function that calculates the delay (in milliseconds) before the
+     * next attempt.
+     *
+     * It takes the current attempt number (starting at 1) and returns the delay.
+     * @default Delay calculated using the {@link exponentialBackoffWithJitter} function.
+     *
+     * @returns The delay in milliseconds before the next attempt.
+     */
+    delayInMsCalculator?: (attempt: number) => number;
+};

package/dist/retry-async.js

@@ -0,0 +1,18 @@
+import { exponentialBackoffWithJitter as e } from "./exponential-backoff-with-jitter.js";
+import { sleep as t } from "./sleep.js";
+//#region libs/shared/underscore/src/retry-async.ts
+async function n(n, r = {}) {
+	let i = r.maxAttempts ?? 5, a = r.shouldRetry ?? (() => !0), o = r.onAttemptFail, s = r.delayInMsCalculator ?? e;
+	if (i < 1) throw Error("`maxAttempts` must be 1 or greater");
+	if (i > 100) throw Error("`maxAttempts` must be 100 or less");
+	let c = 1;
+	for (;;) try {
+		return await n();
+	} catch (e) {
+		if (c >= i || !a(e)) throw e;
+		let n = s(c);
+		o?.(e, c, n), await t(n), c++;
+	}
+}
+//#endregion
+export { n as retryAsync };

package/dist/sleep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Pauses the execution for a specified duration.
+ *
+ * @param durationInMs - The duration to sleep in milliseconds.
+ * @returns A promise that resolves after the specified duration.
+ */
+export declare function sleep(durationInMs: number): Promise<void>;

package/dist/sleep.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/sleep.ts
+function e(e) {
+	return new Promise((t) => setTimeout(t, e));
+}
+//#endregion
+export { e as sleep };

package/dist/string.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Capitalizes the first letter of the given string.
+ *
+ * @param str - The string to capitalize.
+ * @returns The input string with the first letter capitalized.
+ *
+ * @example
+ * ```ts
+ * capitalizeFirstLetter('hello'); // returns 'Hello'
+ * ```
+ */
+export declare function capitalizeFirstLetter(str: string): string;
+/**
+ * Converts a kebab-case string to PascalCase.
+ *
+ * @param str - The kebab-case string to convert.
+ * @returns The converted PascalCase string.
+ *
+ * @example
+ * ```ts
+ * kebabToPascalCase('kebab-case-string'); // returns 'KebabCaseString'
+ * ```
+ */
+export declare function kebabToPascalCase(str: string): string;
+/**
+ * Converts a given string to kebab-case (dash-case).
+ *
+ * @param str - The input string to be converted.
+ * @returns The kebab-case version of the input string.
+ *
+ * @example
+ * ```ts
+ * toKebabCase('HelloWorld'); // Returns 'hello-world'
+ * toKebabCase('hello_world'); // Returns 'hello-world'
+ * toKebabCase('hello world'); // Returns 'hello-world'
+ * toKebabCase('Hello World_Test'); // Returns 'hello-world-test'
+ * toKebabCase('special$Char'); // Returns 'special$-char'
+ * ```
+ *
+ * */
+export declare function toKebabCase(str: string): string;

package/dist/string.js

@@ -0,0 +1,12 @@
+//#region libs/shared/underscore/src/string.ts
+function e(e) {
+	return e.charAt(0).toUpperCase() + e.slice(1);
+}
+function t(e) {
+	return e.replace(/-./g, (e) => e.charAt(1).toUpperCase()).replace(/^\w/, (e) => e.toUpperCase());
+}
+function n(e) {
+	return e.replace(/([a-z])([0-9])/gi, "$1-$2").replace(/([0-9])([a-zA-Z])/g, "$1-$2").replace(/([a-z0-9$])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+//#endregion
+export { e as capitalizeFirstLetter, t as kebabToPascalCase, n as toKebabCase };

package/dist/structMap/index.d.ts

@@ -0,0 +1,3 @@
+export { StructMap } from './structMap';
+export type { KeySerializer } from './types';
+export { stableStringify } from './stableStringify';

package/dist/structMap/stableStringify.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Stringifies any value using JSON.stringify under the hood, but treating certain cases differently.
+ * - Objects - Properties are sorted alphabetically to ensure stable output
+ * - Non-object values - plain JSON.stringify
+ * - Functions, symbols, undefined - removed during serialization
+ *
+ * @param value - A value to serialize into a string
+ * @returns Stringified version of the provided value
+ * @throws Throws when BigInt value is encountered at any point or a circular dependency is detected
+ *
+ * @example
+ * ```ts
+ * const fileId = { externalId: 'file-1', space: 's1' };
+ * const fileIdReversed = { space: 's1', externalId: 'file-1' };
+ *
+ * console.log(stableStringify(fileId) === stableStringify(fileIdReversed)); // true
+ *
+ * const user = { name: 'Bob', age: 35, pets: ['Felix', 'Alex'] };
+ *
+ * console.log(stableStringify(user)); // {"age":35,"name":"Bob","pets":["Felix","Alex"] }
+ * ```
+ */
+export declare function stableStringify(value: unknown): string | undefined;

package/dist/structMap/stableStringify.js

@@ -0,0 +1,24 @@
+//#region libs/shared/underscore/src/structMap/stableStringify.ts
+function e(e) {
+	let n = /* @__PURE__ */ new WeakSet();
+	function r(e) {
+		if (t(e)) return;
+		if (typeof e != "object" || !e) return JSON.stringify(e);
+		if (n.has(e)) throw TypeError("Converting circular structure to JSON");
+		if (n.add(e), "toJSON" in e && typeof e.toJSON == "function") return r(e.toJSON());
+		if (Array.isArray(e)) return `[${e.map((e) => r(e) ?? "null").join(",")}]`;
+		let i = e, a = Object.keys(i).sort(), o = [];
+		for (let e of a) {
+			let n = i[e];
+			t(n) || o.push(`${JSON.stringify(e)}:${r(n)}`);
+		}
+		return `{${o.join(",")}}`;
+	}
+	return r(e);
+}
+function t(e) {
+	if (typeof e == "bigint") throw TypeError("Do not know how to serialize a BigInt");
+	return typeof e == "function" || typeof e == "symbol" || e === void 0;
+}
+//#endregion
+export { e as stableStringify };

package/dist/structMap/structMap.d.ts

@@ -0,0 +1,110 @@
+import { KeySerializer } from './types';
+/**
+ * Custom data structure that builds on top of the native `Map` class.
+ * Unlike `Map`, it enables proper usage of objects as keys by comparing them structurally, instead of by reference.
+ * By default, objects are serialized using `stableStringify` function to ensure consistent key representation.
+ *
+ * @template K - Type of keys in the StructMap
+ * @template V - Type of values in the StructMap
+ * @param entries - Initial key-value pairs to populate the StructMap
+ * @param serializer - Custom serializer to convert keys to strings and back
+ *
+ * @example
+ * ```ts
+ * // Basic case with a Data Modeling-like scenario
+ *
+ * // Simplified list of DM-like objects
+ * const dmFiles = [
+ *   { externalId: 'f1', space: 's1', properties: { name: 'file-1' } },
+ *   { externalId: 'f2', space: 's1', properties: { name: 'file-2' } },
+ * ];
+ *
+ * // To create a map, we first need entries - a list of [key, value] pairs
+ * const fileEntries = dmFiles.map((file) => [
+ *   { externalId: file.externalId, space: file.space }, // This object will be a key for each entry
+ *   file, // Each file object will be a value in the map
+ * ]);
+ *
+ * const filesMap = new StructMap(fileEntries);
+ *
+ * // Set new values
+ * const newFile = { externalId: 'f3', space: 's2', properties: { name: 'file-3' } };
+ *
+ * filesMap.set({ externalId: 'f3', space: 's2' }, newFile);
+ *
+ * // Get an existing value
+ * const file = filesMap.get({ space: 's2', externalId: 'f3' }); // By default, order of object properties is ignored
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using a custom key serializer
+ *
+ * // Custom serializer that lowercases keys and values
+ * const lowerCaseSerializer: KeySerializer<PreferencesKey> = {
+ *   serialize: (key) =>
+ *     JSON.stringify({
+ *       user: key.user.toLowerCase(),
+ *       setting: key.setting.toLowerCase(),
+ *     }),
+ *   deserialize: (keyString) => JSON.parse(keyString),
+ * };
+ *
+ * // Create a StructMap with our custom serializer
+ * const preferences = new StructMap<PreferencesKey, string>([], lowerCaseSerializer);
+ *
+ * // Store preferences
+ * preferences.set({ user: 'Alice', setting: 'Theme' }, 'dark');
+ * preferences.set({ user: 'Bob', setting: 'Theme' }, 'light');
+ *
+ * // Retrieve values with keys of any casing
+ * console.log(preferences.get({ user: 'alice', setting: 'theme' })); // dark
+ * console.log(preferences.get({ user: 'BOB', setting: 'THEME' })); // light
+ * ```
+ */
+export declare class StructMap<K extends object, V> {
+    private map;
+    private serializer;
+    constructor(entries?: Iterable<[K, V]>, serializer?: KeySerializer<K>);
+    /**
+     * Returns the number of elements in the map.
+     */
+    get size(): number;
+    /**
+     * Removes all elements from the map.
+     */
+    clear: () => void;
+    /**
+     * Removes an element associated with the given key and returns true if element existed, false otherwise.
+     */
+    delete: (key: K) => boolean;
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map..
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     */
+    forEach: (callbackFn: (value: V, key: K, map: StructMap<K, V>) => void) => void;
+    /**
+     * Returns an element associated with the given key, or undefined if the key doesn't exist.
+     */
+    get: (key: K) => V | undefined;
+    /**
+     * Checks if an element with the given key exists in the map.
+     */
+    has: (key: K) => boolean;
+    /**
+     * Returns an iterable of keys in the map.
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+     * @returns this
+     */
+    set: (key: K, value: V) => this;
+    /**
+     * Returns an iterable of values in the map.
+     */
+    values: () => IterableIterator<V>;
+}

package/dist/structMap/structMap.js

@@ -0,0 +1,29 @@
+import { stableStringify as e } from "./stableStringify.js";
+//#region libs/shared/underscore/src/structMap/structMap.ts
+var t = class {
+	constructor(e = [], t = n()) {
+		this.map = /* @__PURE__ */ new Map(), this.clear = () => this.map.clear(), this.delete = (e) => this.map.delete(this.serializer.serialize(e)), this.forEach = (e) => {
+			this.map.forEach((t, n) => {
+				e(t, this.serializer.deserialize(n), this);
+			});
+		}, this.get = (e) => this.map.get(this.serializer.serialize(e)), this.has = (e) => this.map.has(this.serializer.serialize(e)), this.set = (e, t) => (this.map.set(this.serializer.serialize(e), t), this), this.values = () => this.map.values(), this.serializer = t;
+		for (let [t, n] of e) this.set(t, n);
+	}
+	get size() {
+		return this.map.size;
+	}
+	*entries() {
+		for (let [e, t] of this.map.entries()) yield [this.serializer.deserialize(e), t];
+	}
+	*keys() {
+		for (let e of this.map.keys()) yield this.serializer.deserialize(e);
+	}
+};
+function n() {
+	return {
+		serialize: (t) => String(e(t)),
+		deserialize: JSON.parse
+	};
+}
+//#endregion
+export { t as StructMap };

package/dist/structMap/testUtils.d.ts

@@ -0,0 +1,17 @@
+export type DmsId = {
+    externalId: string;
+    space: string;
+};
+export type MockCogniteFile = DmsId & {
+    createdTime: number;
+    lastUpdatedTime: number;
+    name: string;
+};
+/**
+ * Streamlines creation of a DM CogniteFile-like mock instance by hiding unnecessary details and providing smart defaults.
+ */
+export declare function createMockCogniteFile({ externalId, space, name, createdTime, lastUpdatedTime, }?: Partial<MockCogniteFile>): MockCogniteFile;
+/** Helper to convert a DM-like object to a DmsId. */
+export declare function toDmsId<T extends DmsId>(item: T): DmsId;
+/** Helper to convert a list of DM-like items to a list of initial entries for StructMap. */
+export declare function toDmsIdEntries<T extends DmsId>(items: T[]): [DmsId, T][];

package/dist/structMap/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Holds functions to serialize a key into a string and deserialize the string back into its original form.
+ */
+export type KeySerializer<K> = {
+    serialize(key: K): string;
+    deserialize(keyString: string): K;
+};