@cognite/underscore 1.0.1 → 1.48535.0

package/dist/structMap/stableStringify.js

@@ -1,24 +1,71 @@
-//#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);
+/**
+ * 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 function stableStringify(value) {
+    const seen = new WeakSet();
+    // Implementing stringify logic in an inner function in order to keep track of seen objects across recursive calls
+    function internalStringify(val) {
+        if (isInvalidJson(val)) return;
+        // Non-object values can be stringified in a simple way
+        if (val === null || typeof val !== 'object') {
+            return JSON.stringify(val);
+        }
+        // Check if the current array or object has been encountered before to avoid circular references
+        if (seen.has(val)) {
+            throw new TypeError('Converting circular structure to JSON');
+        }
+        seen.add(val);
+        // Use toJSON for objects that have it, like Date
+        if ('toJSON' in val && typeof val.toJSON === 'function') {
+            return internalStringify(val.toJSON());
+        }
+        // Stringify array items recursively and join into a string
+        if (Array.isArray(val)) {
+            const normalizedItems = val.map((item)=>{
+                var _internalStringify;
+                return (_internalStringify = internalStringify(item)) !== null && _internalStringify !== void 0 ? _internalStringify : 'null' // JSON.stringify turns undefined into 'null' in arrays
+                ;
+            });
+            return `[${normalizedItems.join(',')}]`;
+        }
+        // Stringify objects recursively and join into a string
+        const obj = val;
+        const sortedKeys = Object.keys(obj).sort();
+        const keyValuePairs = [];
+        for (const key of sortedKeys){
+            const keyValue = obj[key];
+            // JSON.stringify ignores keys with invalid values
+            if (isInvalidJson(keyValue)) continue;
+            keyValuePairs.push(`${JSON.stringify(key)}:${internalStringify(keyValue)}`);
+        }
+        return `{${keyValuePairs.join(',')}}`;
+    }
+    return internalStringify(value);
 }
-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;
+function isInvalidJson(value) {
+    if (typeof value === 'bigint') {
+        // Throw for BigInt like native JSON.stringify
+        throw new TypeError('Do not know how to serialize a BigInt');
+    }
+    return typeof value === 'function' || typeof value === 'symbol' || typeof value === 'undefined';
 }
-//#endregion
-export { e as stableStringify };
+
+//# sourceMappingURL=stableStringify.js.map

package/dist/structMap/stableStringify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/structMap/stableStringify.ts"],"sourcesContent":["/**\n * Stringifies any value using JSON.stringify under the hood, but treating certain cases differently.\n * - Objects - Properties are sorted alphabetically to ensure stable output\n * - Non-object values - plain JSON.stringify\n * - Functions, symbols, undefined - removed during serialization\n *\n * @param value - A value to serialize into a string\n * @returns Stringified version of the provided value\n * @throws Throws when BigInt value is encountered at any point or a circular dependency is detected\n *\n * @example\n * ```ts\n * const fileId = { externalId: 'file-1', space: 's1' };\n * const fileIdReversed = { space: 's1', externalId: 'file-1' };\n *\n * console.log(stableStringify(fileId) === stableStringify(fileIdReversed)); // true\n *\n * const user = { name: 'Bob', age: 35, pets: ['Felix', 'Alex'] };\n *\n * console.log(stableStringify(user)); // {\"age\":35,\"name\":\"Bob\",\"pets\":[\"Felix\",\"Alex\"] }\n * ```\n */\nexport function stableStringify(value: unknown): string | undefined {\n  const seen = new WeakSet();\n\n  // Implementing stringify logic in an inner function in order to keep track of seen objects across recursive calls\n  function internalStringify(val: unknown): string | undefined {\n    if (isInvalidJson(val)) return;\n\n    // Non-object values can be stringified in a simple way\n    if (val === null || typeof val !== 'object') {\n      return JSON.stringify(val);\n    }\n\n    // Check if the current array or object has been encountered before to avoid circular references\n    if (seen.has(val)) {\n      throw new TypeError('Converting circular structure to JSON');\n    }\n    seen.add(val);\n\n    // Use toJSON for objects that have it, like Date\n    if ('toJSON' in val && typeof val.toJSON === 'function') {\n      return internalStringify(val.toJSON());\n    }\n\n    // Stringify array items recursively and join into a string\n    if (Array.isArray(val)) {\n      const normalizedItems = val.map(\n        (item) => internalStringify(item) ?? 'null' // JSON.stringify turns undefined into 'null' in arrays\n      );\n\n      return `[${normalizedItems.join(',')}]`;\n    }\n\n    // Stringify objects recursively and join into a string\n    const obj = val as Record<string, unknown>;\n    const sortedKeys = Object.keys(obj).sort();\n    const keyValuePairs: string[] = [];\n\n    for (const key of sortedKeys) {\n      const keyValue: unknown = obj[key];\n\n      // JSON.stringify ignores keys with invalid values\n      if (isInvalidJson(keyValue)) continue;\n\n      keyValuePairs.push(\n        `${JSON.stringify(key)}:${internalStringify(keyValue)}`\n      );\n    }\n\n    return `{${keyValuePairs.join(',')}}`;\n  }\n\n  return internalStringify(value);\n}\n\nfunction isInvalidJson(value: unknown): boolean {\n  if (typeof value === 'bigint') {\n    // Throw for BigInt like native JSON.stringify\n    throw new TypeError('Do not know how to serialize a BigInt');\n  }\n\n  return (\n    typeof value === 'function' ||\n    typeof value === 'symbol' ||\n    typeof value === 'undefined'\n  );\n}\n"],"names":["stableStringify","value","seen","WeakSet","internalStringify","val","isInvalidJson","JSON","stringify","has","TypeError","add","toJSON","Array","isArray","normalizedItems","map","item","join","obj","sortedKeys","Object","keys","sort","keyValuePairs","key","keyValue","push"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASA,gBAAgBC,KAAc;IAC5C,MAAMC,OAAO,IAAIC;IAEjB,kHAAkH;IAClH,SAASC,kBAAkBC,GAAY;QACrC,IAAIC,cAAcD,MAAM;QAExB,uDAAuD;QACvD,IAAIA,QAAQ,QAAQ,OAAOA,QAAQ,UAAU;YAC3C,OAAOE,KAAKC,SAAS,CAACH;QACxB;QAEA,gGAAgG;QAChG,IAAIH,KAAKO,GAAG,CAACJ,MAAM;YACjB,MAAM,IAAIK,UAAU;QACtB;QACAR,KAAKS,GAAG,CAACN;QAET,iDAAiD;QACjD,IAAI,YAAYA,OAAO,OAAOA,IAAIO,MAAM,KAAK,YAAY;YACvD,OAAOR,kBAAkBC,IAAIO,MAAM;QACrC;QAEA,2DAA2D;QAC3D,IAAIC,MAAMC,OAAO,CAACT,MAAM;YACtB,MAAMU,kBAAkBV,IAAIW,GAAG,CAC7B,CAACC;oBAASb;wBAAAA,qBAAAA,kBAAkBa,mBAAlBb,gCAAAA,qBAA2B,OAAO,uDAAuD;;;YAGrG,OAAO,CAAC,CAAC,EAAEW,gBAAgBG,IAAI,CAAC,KAAK,CAAC,CAAC;QACzC;QAEA,uDAAuD;QACvD,MAAMC,MAAMd;QACZ,MAAMe,aAAaC,OAAOC,IAAI,CAACH,KAAKI,IAAI;QACxC,MAAMC,gBAA0B,EAAE;QAElC,KAAK,MAAMC,OAAOL,WAAY;YAC5B,MAAMM,WAAoBP,GAAG,CAACM,IAAI;YAElC,kDAAkD;YAClD,IAAInB,cAAcoB,WAAW;YAE7BF,cAAcG,IAAI,CAChB,GAAGpB,KAAKC,SAAS,CAACiB,KAAK,CAAC,EAAErB,kBAAkBsB,WAAW;QAE3D;QAEA,OAAO,CAAC,CAAC,EAAEF,cAAcN,IAAI,CAAC,KAAK,CAAC,CAAC;IACvC;IAEA,OAAOd,kBAAkBH;AAC3B;AAEA,SAASK,cAAcL,KAAc;IACnC,IAAI,OAAOA,UAAU,UAAU;QAC7B,8CAA8C;QAC9C,MAAM,IAAIS,UAAU;IACtB;IAEA,OACE,OAAOT,UAAU,cACjB,OAAOA,UAAU,YACjB,OAAOA,UAAU;AAErB"}

package/dist/structMap/structMap.d.ts

@@ -1,110 +1,113 @@
-import { KeySerializer } from './types';
+import type { 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>;
+* 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

@@ -1,29 +1,132 @@
-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
-	};
+import { stableStringify } from "./stableStringify.js";
+/**
+ * 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 class StructMap {
+    /**
+   * Returns the number of elements in the map.
+   */ get size() {
+        return this.map.size;
+    }
+    /**
+   * Returns an iterable of key, value pairs for every entry in the map..
+   */ *entries() {
+        for (const [key, value] of this.map.entries()){
+            yield [
+                this.serializer.deserialize(key),
+                value
+            ];
+        }
+    }
+    /**
+   * Returns an iterable of keys in the map.
+   */ *keys() {
+        for (const key of this.map.keys()){
+            yield this.serializer.deserialize(key);
+        }
+    }
+    constructor(entries = [], serializer = getDefaultSerializer()){
+        this.map = new Map();
+        /**
+   * Removes all elements from the map.
+   */ this.clear = ()=>this.map.clear();
+        /**
+   * Removes an element associated with the given key and returns true if element existed, false otherwise.
+   */ this.delete = (key)=>this.map.delete(this.serializer.serialize(key));
+        /**
+   * Executes a provided function once per each key/value pair in the Map, in insertion order.
+   */ this.forEach = (callbackFn)=>{
+            this.map.forEach((value, keyString)=>{
+                const key = this.serializer.deserialize(keyString);
+                callbackFn(value, key, this);
+            });
+        };
+        /**
+   * Returns an element associated with the given key, or undefined if the key doesn't exist.
+   */ this.get = (key)=>this.map.get(this.serializer.serialize(key));
+        /**
+   * Checks if an element with the given key exists in the map.
+   */ this.has = (key)=>this.map.has(this.serializer.serialize(key));
+        /**
+   * 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
+   */ this.set = (key, value)=>{
+            this.map.set(this.serializer.serialize(key), value);
+            return this;
+        };
+        /**
+   * Returns an iterable of values in the map.
+   */ this.values = ()=>this.map.values();
+        this.serializer = serializer;
+        for (const [key, value] of entries){
+            this.set(key, value);
+        }
+    }
 }
-//#endregion
-export { t as StructMap };
+function getDefaultSerializer() {
+    return {
+        serialize: (key)=>String(stableStringify(key)),
+        deserialize: JSON.parse
+    };
+}
+
+//# sourceMappingURL=structMap.js.map

package/dist/structMap/structMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/structMap/structMap.ts"],"sourcesContent":["import { stableStringify } from './stableStringify';\nimport type { KeySerializer } from './types';\n\n/**\n * Custom data structure that builds on top of the native `Map` class.\n * Unlike `Map`, it enables proper usage of objects as keys by comparing them structurally, instead of by reference.\n * By default, objects are serialized using `stableStringify` function to ensure consistent key representation.\n *\n * @template K - Type of keys in the StructMap\n * @template V - Type of values in the StructMap\n * @param entries - Initial key-value pairs to populate the StructMap\n * @param serializer - Custom serializer to convert keys to strings and back\n *\n * @example\n * ```ts\n * // Basic case with a Data Modeling-like scenario\n *\n * // Simplified list of DM-like objects\n * const dmFiles = [\n *   { externalId: 'f1', space: 's1', properties: { name: 'file-1' } },\n *   { externalId: 'f2', space: 's1', properties: { name: 'file-2' } },\n * ];\n *\n * // To create a map, we first need entries - a list of [key, value] pairs\n * const fileEntries = dmFiles.map((file) => [\n *   { externalId: file.externalId, space: file.space }, // This object will be a key for each entry\n *   file, // Each file object will be a value in the map\n * ]);\n *\n * const filesMap = new StructMap(fileEntries);\n *\n * // Set new values\n * const newFile = { externalId: 'f3', space: 's2', properties: { name: 'file-3' } };\n *\n * filesMap.set({ externalId: 'f3', space: 's2' }, newFile);\n *\n * // Get an existing value\n * const file = filesMap.get({ space: 's2', externalId: 'f3' }); // By default, order of object properties is ignored\n * ```\n *\n * @example\n * ```ts\n * // Using a custom key serializer\n *\n * // Custom serializer that lowercases keys and values\n * const lowerCaseSerializer: KeySerializer<PreferencesKey> = {\n *   serialize: (key) =>\n *     JSON.stringify({\n *       user: key.user.toLowerCase(),\n *       setting: key.setting.toLowerCase(),\n *     }),\n *   deserialize: (keyString) => JSON.parse(keyString),\n * };\n *\n * // Create a StructMap with our custom serializer\n * const preferences = new StructMap<PreferencesKey, string>([], lowerCaseSerializer);\n *\n * // Store preferences\n * preferences.set({ user: 'Alice', setting: 'Theme' }, 'dark');\n * preferences.set({ user: 'Bob', setting: 'Theme' }, 'light');\n *\n * // Retrieve values with keys of any casing\n * console.log(preferences.get({ user: 'alice', setting: 'theme' })); // dark\n * console.log(preferences.get({ user: 'BOB', setting: 'THEME' })); // light\n * ```\n */\nexport class StructMap<K extends object, V> {\n  private map = new Map<string, V>();\n  private serializer: KeySerializer<K>;\n\n  public constructor(\n    entries: Iterable<[K, V]> = [],\n    serializer: KeySerializer<K> = getDefaultSerializer<K>()\n  ) {\n    this.serializer = serializer;\n    for (const [key, value] of entries) {\n      this.set(key, value);\n    }\n  }\n\n  /**\n   * Returns the number of elements in the map.\n   */\n  public get size(): number {\n    return this.map.size;\n  }\n\n  /**\n   * Removes all elements from the map.\n   */\n  public clear = (): void => this.map.clear();\n\n  /**\n   * Removes an element associated with the given key and returns true if element existed, false otherwise.\n   */\n  public delete = (key: K): boolean =>\n    this.map.delete(this.serializer.serialize(key));\n\n  /**\n   * Returns an iterable of key, value pairs for every entry in the map..\n   */\n  public *entries(): IterableIterator<[K, V]> {\n    for (const [key, value] of this.map.entries()) {\n      yield [this.serializer.deserialize(key), value];\n    }\n  }\n\n  /**\n   * Executes a provided function once per each key/value pair in the Map, in insertion order.\n   */\n  public forEach = (\n    callbackFn: (value: V, key: K, map: StructMap<K, V>) => void\n  ): void => {\n    this.map.forEach((value, keyString) => {\n      const key = this.serializer.deserialize(keyString);\n      callbackFn(value, key, this);\n    });\n  };\n\n  /**\n   * Returns an element associated with the given key, or undefined if the key doesn't exist.\n   */\n  public get = (key: K): V | undefined =>\n    this.map.get(this.serializer.serialize(key));\n\n  /**\n   * Checks if an element with the given key exists in the map.\n   */\n  public has = (key: K): boolean =>\n    this.map.has(this.serializer.serialize(key));\n\n  /**\n   * Returns an iterable of keys in the map.\n   */\n  public *keys(): IterableIterator<K> {\n    for (const key of this.map.keys()) {\n      yield this.serializer.deserialize(key);\n    }\n  }\n\n  /**\n   * 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.\n   * @returns this\n   */\n  public set = (key: K, value: V): this => {\n    this.map.set(this.serializer.serialize(key), value);\n    return this;\n  };\n\n  /**\n   * Returns an iterable of values in the map.\n   */\n  public values = (): IterableIterator<V> => this.map.values();\n}\n\nfunction getDefaultSerializer<K>(): KeySerializer<K> {\n  return {\n    serialize: (key: K) => String(stableStringify(key)),\n    deserialize: JSON.parse,\n  };\n}\n"],"names":["stableStringify","StructMap","size","map","entries","key","value","serializer","deserialize","keys","getDefaultSerializer","Map","clear","delete","serialize","forEach","callbackFn","keyString","get","has","set","values","String","JSON","parse"],"mappings":"AAAA,SAASA,eAAe,QAAQ,uBAAoB;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DC,GACD,OAAO,MAAMC;IAcX;;GAEC,GACD,IAAWC,OAAe;QACxB,OAAO,IAAI,CAACC,GAAG,CAACD,IAAI;IACtB;IAaA;;GAEC,GACD,CAAQE,UAAoC;QAC1C,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAI,IAAI,CAACH,GAAG,CAACC,OAAO,GAAI;YAC7C,MAAM;gBAAC,IAAI,CAACG,UAAU,CAACC,WAAW,CAACH;gBAAMC;aAAM;QACjD;IACF;IA0BA;;GAEC,GACD,CAAQG,OAA4B;QAClC,KAAK,MAAMJ,OAAO,IAAI,CAACF,GAAG,CAACM,IAAI,GAAI;YACjC,MAAM,IAAI,CAACF,UAAU,CAACC,WAAW,CAACH;QACpC;IACF;IApEA,YACED,UAA4B,EAAE,EAC9BG,aAA+BG,sBAAyB,CACxD;aANMP,MAAM,IAAIQ;QAoBlB;;GAEC,QACMC,QAAQ,IAAY,IAAI,CAACT,GAAG,CAACS,KAAK;QAEzC;;GAEC,QACMC,SAAS,CAACR,MACf,IAAI,CAACF,GAAG,CAACU,MAAM,CAAC,IAAI,CAACN,UAAU,CAACO,SAAS,CAACT;QAW5C;;GAEC,QACMU,UAAU,CACfC;YAEA,IAAI,CAACb,GAAG,CAACY,OAAO,CAAC,CAACT,OAAOW;gBACvB,MAAMZ,MAAM,IAAI,CAACE,UAAU,CAACC,WAAW,CAACS;gBACxCD,WAAWV,OAAOD,KAAK,IAAI;YAC7B;QACF;QAEA;;GAEC,QACMa,MAAM,CAACb,MACZ,IAAI,CAACF,GAAG,CAACe,GAAG,CAAC,IAAI,CAACX,UAAU,CAACO,SAAS,CAACT;QAEzC;;GAEC,QACMc,MAAM,CAACd,MACZ,IAAI,CAACF,GAAG,CAACgB,GAAG,CAAC,IAAI,CAACZ,UAAU,CAACO,SAAS,CAACT;QAWzC;;;GAGC,QACMe,MAAM,CAACf,KAAQC;YACpB,IAAI,CAACH,GAAG,CAACiB,GAAG,CAAC,IAAI,CAACb,UAAU,CAACO,SAAS,CAACT,MAAMC;YAC7C,OAAO,IAAI;QACb;QAEA;;GAEC,QACMe,SAAS,IAA2B,IAAI,CAAClB,GAAG,CAACkB,MAAM;QA9ExD,IAAI,CAACd,UAAU,GAAGA;QAClB,KAAK,MAAM,CAACF,KAAKC,MAAM,IAAIF,QAAS;YAClC,IAAI,CAACgB,GAAG,CAACf,KAAKC;QAChB;IACF;AA2EF;AAEA,SAASI;IACP,OAAO;QACLI,WAAW,CAACT,MAAWiB,OAAOtB,gBAAgBK;QAC9CG,aAAae,KAAKC,KAAK;IACzB;AACF"}

package/dist/structMap/testUtils.d.ts

@@ -1,16 +1,16 @@
 export type DmsId = {
-    externalId: string;
-    space: string;
+	externalId: string;
+	space: string;
 };
 export type MockCogniteFile = DmsId & {
-    createdTime: number;
-    lastUpdatedTime: number;
-    name: string;
+	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;
+* 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. */

package/dist/structMap/testUtils.js

@@ -0,0 +1,26 @@
+import { randomString } from "../random.js";
+/**
+ * Streamlines creation of a DM CogniteFile-like mock instance by hiding unnecessary details and providing smart defaults.
+ */ export function createMockCogniteFile({ externalId = randomString(32), space = randomString(32), name = randomString(32), createdTime = Date.now(), lastUpdatedTime = Date.now() } = {}) {
+    return {
+        externalId,
+        space,
+        name,
+        createdTime,
+        lastUpdatedTime
+    };
+}
+/** Helper to convert a DM-like object to a DmsId. */ export function toDmsId(item) {
+    return {
+        externalId: item.externalId,
+        space: item.space
+    };
+}
+/** Helper to convert a list of DM-like items to a list of initial entries for StructMap. */ export function toDmsIdEntries(items) {
+    return items.map((it)=>[
+            toDmsId(it),
+            it
+        ]);
+}
+
+//# sourceMappingURL=testUtils.js.map

package/dist/structMap/testUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/structMap/testUtils.ts"],"sourcesContent":["import { randomString } from '../random';\n\nexport type DmsId = {\n  externalId: string;\n  space: string;\n};\n\nexport type MockCogniteFile = DmsId & {\n  createdTime: number;\n  lastUpdatedTime: number;\n  name: string;\n};\n\n/**\n * Streamlines creation of a DM CogniteFile-like mock instance by hiding unnecessary details and providing smart defaults.\n */\nexport function createMockCogniteFile({\n  externalId = randomString(32),\n  space = randomString(32),\n  name = randomString(32),\n  createdTime = Date.now(),\n  lastUpdatedTime = Date.now(),\n}: Partial<MockCogniteFile> = {}): MockCogniteFile {\n  return {\n    externalId,\n    space,\n    name,\n    createdTime,\n    lastUpdatedTime,\n  };\n}\n\n/** Helper to convert a DM-like object to a DmsId. */\nexport function toDmsId<T extends DmsId>(item: T): DmsId {\n  return {\n    externalId: item.externalId,\n    space: item.space,\n  };\n}\n\n/** Helper to convert a list of DM-like items to a list of initial entries for StructMap. */\nexport function toDmsIdEntries<T extends DmsId>(items: T[]): [DmsId, T][] {\n  return items.map((it) => [toDmsId(it), it]);\n}\n"],"names":["randomString","createMockCogniteFile","externalId","space","name","createdTime","Date","now","lastUpdatedTime","toDmsId","item","toDmsIdEntries","items","map","it"],"mappings":"AAAA,SAASA,YAAY,QAAQ,eAAY;AAazC;;CAEC,GACD,OAAO,SAASC,sBAAsB,EACpCC,aAAaF,aAAa,GAAG,EAC7BG,QAAQH,aAAa,GAAG,EACxBI,OAAOJ,aAAa,GAAG,EACvBK,cAAcC,KAAKC,GAAG,EAAE,EACxBC,kBAAkBF,KAAKC,GAAG,EAAE,EACH,GAAG,CAAC,CAAC;IAC9B,OAAO;QACLL;QACAC;QACAC;QACAC;QACAG;IACF;AACF;AAEA,mDAAmD,GACnD,OAAO,SAASC,QAAyBC,IAAO;IAC9C,OAAO;QACLR,YAAYQ,KAAKR,UAAU;QAC3BC,OAAOO,KAAKP,KAAK;IACnB;AACF;AAEA,0FAA0F,GAC1F,OAAO,SAASQ,eAAgCC,KAAU;IACxD,OAAOA,MAAMC,GAAG,CAAC,CAACC,KAAO;YAACL,QAAQK;YAAKA;SAAG;AAC5C"}

package/dist/structMap/types.d.ts

@@ -1,7 +1,7 @@
 /**
- * Holds functions to serialize a key into a string and deserialize the string back into its original form.
- */
+* 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;
+	serialize(key: K): string;
+	deserialize(keyString: string): K;
 };

package/dist/structMap/types.js

@@ -0,0 +1,5 @@
+/**
+ * Holds functions to serialize a key into a string and deserialize the string back into its original form.
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/structMap/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/structMap/types.ts"],"sourcesContent":["/**\n * Holds functions to serialize a key into a string and deserialize the string back into its original form.\n */\nexport type KeySerializer<K> = {\n  serialize(key: K): string;\n  deserialize(keyString: string): K;\n};\n"],"names":[],"mappings":"AAAA;;CAEC,GACD,WAGE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/underscore",
-  "version": "1.0.1",
+  "version": "1.48535.0",
   "description": "A collection of useful plain TypeScript utility functions.",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -22,8 +22,6 @@
     "dist"
   ],
   "devDependencies": {
-    "@nx/devkit": "22.7.8",
-    "@nx/eslint-plugin": "22.7.8",
     "@testing-library/react": "16.0.1",
     "@types/lodash-es": "^4.17.12",
     "@types/react": "18.3.14",
@@ -34,12 +32,17 @@
     "typedoc": "^0.27.6",
     "typedoc-plugin-markdown": "^4.4.1",
     "typescript": "6.0.3",
-    "vite": "8.2.2",
+    "vite": "8.2.4",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "lodash-es": "^4.18.1",
     "react": "^18.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cognitedata/infrastructure.git",
+    "directory": "lib/ts/shared/underscore"
   }
 }