@cognite/underscore 1.0.1 → 1.48411.0

package/dist/random.js

@@ -1,22 +1,56 @@
-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;
+import { repeat } from "./repeat.js";
+/**
+ * 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 function randomString(length) {
+    if (length < 1) {
+        throw new Error('Length must be greater than 0');
+    }
+    const validCharacters = [
+        ...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+    ];
+    let result = '';
+    repeat(()=>{
+        result += randomElement(validCharacters);
+    }, length);
+    return result;
 }
-function n(e) {
-	return e[r(0, e.length)];
+/**
+ * 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 function randomElement(array) {
+    const index = randomInteger(0, array.length);
+    return array[index];
 }
-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;
+/**
+ * Returns a random integer between minInclusive and maxExclusive.
+ *
+ * @param minInclusive
+ * @param maxExclusive
+ * @returns
+ */ export function randomInteger(minInclusive, maxExclusive) {
+    if (minInclusive >= maxExclusive) {
+        throw new Error('The `minInclusive` value must be less than the `maxExclusive` value.');
+    }
+    return Math.floor(Math.random() * (maxExclusive - minInclusive)) + minInclusive;
 }
-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;
+/**
+ * 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 function randomFloat(minInclusive, maxExclusive) {
+    if (minInclusive >= maxExclusive) {
+        throw new Error('The `minInclusive` value must be less than the `maxExclusive` value.');
+    }
+    return Math.random() * (maxExclusive - minInclusive) + minInclusive;
 }
-//#endregion
-export { n as randomElement, i as randomFloat, r as randomInteger, t as randomString };
+
+//# sourceMappingURL=random.js.map

package/dist/random.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/random.ts"],"sourcesContent":["import { repeat } from './repeat';\n\n/**\n * Generates a random string of the specified length using alphanumeric characters.\n *\n * @param {number} length - The length of the random string to generate. Must be greater than 0.\n * @returns {string} A random string of the specified length.\n * @throws {Error} If the length is less than 1.\n */\nexport function randomString(length: number): string {\n  if (length < 1) {\n    throw new Error('Length must be greater than 0');\n  }\n  const validCharacters = [\n    ...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',\n  ];\n  let result = '';\n  repeat(() => {\n    result += randomElement(validCharacters);\n  }, length);\n  return result;\n}\n\n/**\n * Returns a random element from the given array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array from which to select a random element.\n * @returns {T} A random element from the array.\n */\nexport function randomElement<T>(array: readonly T[]): T {\n  const index = randomInteger(0, array.length);\n  return array[index];\n}\n\n/**\n * Returns a random integer between minInclusive and maxExclusive.\n *\n * @param minInclusive\n * @param maxExclusive\n * @returns\n */\nexport function randomInteger(\n  minInclusive: number,\n  maxExclusive: number\n): number {\n  if (minInclusive >= maxExclusive) {\n    throw new Error(\n      'The `minInclusive` value must be less than the `maxExclusive` value.'\n    );\n  }\n  return (\n    Math.floor(Math.random() * (maxExclusive - minInclusive)) + minInclusive\n  );\n}\n\n/**\n * Generates a random float within the given range [min, max).\n *\n * @param {number} minInclusive - The minimum value (inclusive).\n * @param {number} maxExclusive - The maximum value (exclusive).\n * @returns {number} A random float within the range [min, max).\n */\nexport function randomFloat(\n  minInclusive: number,\n  maxExclusive: number\n): number {\n  if (minInclusive >= maxExclusive) {\n    throw new Error(\n      'The `minInclusive` value must be less than the `maxExclusive` value.'\n    );\n  }\n  return Math.random() * (maxExclusive - minInclusive) + minInclusive;\n}\n"],"names":["repeat","randomString","length","Error","validCharacters","result","randomElement","array","index","randomInteger","minInclusive","maxExclusive","Math","floor","random","randomFloat"],"mappings":"AAAA,SAASA,MAAM,QAAQ,cAAW;AAElC;;;;;;CAMC,GACD,OAAO,SAASC,aAAaC,MAAc;IACzC,IAAIA,SAAS,GAAG;QACd,MAAM,IAAIC,MAAM;IAClB;IACA,MAAMC,kBAAkB;WACnB;KACJ;IACD,IAAIC,SAAS;IACbL,OAAO;QACLK,UAAUC,cAAcF;IAC1B,GAAGF;IACH,OAAOG;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,cAAiBC,KAAmB;IAClD,MAAMC,QAAQC,cAAc,GAAGF,MAAML,MAAM;IAC3C,OAAOK,KAAK,CAACC,MAAM;AACrB;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,cACdC,YAAoB,EACpBC,YAAoB;IAEpB,IAAID,gBAAgBC,cAAc;QAChC,MAAM,IAAIR,MACR;IAEJ;IACA,OACES,KAAKC,KAAK,CAACD,KAAKE,MAAM,KAAMH,CAAAA,eAAeD,YAAW,KAAMA;AAEhE;AAEA;;;;;;CAMC,GACD,OAAO,SAASK,YACdL,YAAoB,EACpBC,YAAoB;IAEpB,IAAID,gBAAgBC,cAAc;QAChC,MAAM,IAAIR,MACR;IAEJ;IACA,OAAOS,KAAKE,MAAM,KAAMH,CAAAA,eAAeD,YAAW,IAAKA;AACzD"}

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

@@ -1,23 +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]);
- * ```
- */
+* 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

@@ -1,15 +1,40 @@
-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;
+import { useEffect, useState } from "react";
+/**
+ * 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 function useDebounce(value, delayInMs) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(()=>{
+        const handler = setTimeout(()=>{
+            setDebouncedValue(value);
+        }, delayInMs);
+        // Cancel the timeout if value changes (also on delayInMs change or unmount)
+        return ()=>{
+            clearTimeout(handler);
+        };
+    }, [
+        value,
+        delayInMs
+    ]);
+    return debouncedValue;
 }
-//#endregion
-export { n as useDebounce };
+
+//# sourceMappingURL=use-debounce.js.map

package/dist/react/use-debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/use-debounce.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * Hook that debounces a value by a specified delay.\n *\n * The returned value will only update after the specified delay has passed\n * since the last change to the input value. This is useful for reducing\n * the frequency of expensive operations triggered by rapidly changing values.\n *\n * @param value - The value to debounce\n * @param delayInMs - The delay in milliseconds\n * @returns The debounced value\n *\n * @example\n * ```tsx\n * const [searchTerm, setSearchTerm] = useState('');\n * const debouncedSearchTerm = useDebounce(searchTerm, 300);\n *\n * // API call only triggers when user stops typing for 300ms\n * useEffect(() => {\n *   searchApi(debouncedSearchTerm);\n * }, [debouncedSearchTerm]);\n * ```\n */\nexport function useDebounce<T>(value: T, delayInMs: number): T {\n  const [debouncedValue, setDebouncedValue] = useState(value);\n\n  useEffect(() => {\n    const handler = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delayInMs);\n\n    // Cancel the timeout if value changes (also on delayInMs change or unmount)\n    return (): void => {\n      clearTimeout(handler);\n    };\n  }, [value, delayInMs]);\n\n  return debouncedValue;\n}\n"],"names":["useEffect","useState","useDebounce","value","delayInMs","debouncedValue","setDebouncedValue","handler","setTimeout","clearTimeout"],"mappings":"AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,QAAQ;AAE5C;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASC,YAAeC,KAAQ,EAAEC,SAAiB;IACxD,MAAM,CAACC,gBAAgBC,kBAAkB,GAAGL,SAASE;IAErDH,UAAU;QACR,MAAMO,UAAUC,WAAW;YACzBF,kBAAkBH;QACpB,GAAGC;QAEH,4EAA4E;QAC5E,OAAO;YACLK,aAAaF;QACf;IACF,GAAG;QAACJ;QAAOC;KAAU;IAErB,OAAOC;AACT"}

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

@@ -1,34 +1,33 @@
-type UseDerivedPromiseResult<T> = {
-    data: T | undefined;
-    error: Error | undefined;
-    isLoading: true;
+export type UseDerivedPromiseResult<T> = {
+	data: T | undefined;
+	error: Error | undefined;
+	isLoading: true;
 } | {
-    data: T;
-    error: undefined;
-    isLoading: false;
+	data: T;
+	error: undefined;
+	isLoading: false;
 } | {
-    data: undefined;
-    error: Error;
-    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>;
- */
+* 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

@@ -1,34 +1,71 @@
-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
-	};
+/* eslint-disable @eslint-react/hooks-extra/no-direct-set-state-in-use-effect */ import { useEffect, useState } from "react";
+/**
+ * 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 function useDerivedPromise(promiseFn, deps) {
+    const [data, setData] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(undefined);
+    useEffect(()=>{
+        let isActive = true;
+        // If a dependency changes, reset loading state
+        setIsLoading(true);
+        const executePromise = async ()=>{
+            try {
+                const result = await promiseFn();
+                if (isActive) {
+                    setData(result);
+                }
+            } catch (err) {
+                if (isActive) {
+                    setError(err instanceof Error ? err : new Error(String(err)));
+                }
+            } finally{
+                if (isActive) {
+                    setIsLoading(false);
+                }
+            }
+        };
+        executePromise();
+        return ()=>{
+            isActive = false;
+        };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps); // Effect re-runs only when these dependencies change
+    if (isLoading) {
+        return {
+            data,
+            error,
+            isLoading: true
+        };
+    }
+    if (error) {
+        return {
+            data: undefined,
+            error,
+            isLoading: false
+        };
+    }
+    return {
+        data: data,
+        error: undefined,
+        isLoading: false
+    };
 }
-//#endregion
-export { n as useDerivedPromise };
+
+//# sourceMappingURL=use-derived-promise.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/use-derived-promise.ts"],"sourcesContent":["/* eslint-disable @eslint-react/hooks-extra/no-direct-set-state-in-use-effect */\nimport { useEffect, useState } from 'react';\n\nexport type UseDerivedPromiseResult<T> =\n  // Loading state\n  | {\n      data: T | undefined;\n      error: Error | undefined;\n      isLoading: true;\n    }\n  // Resolved state\n  | {\n      data: T;\n      error: undefined;\n      isLoading: false;\n    }\n  // Rejected state\n  | {\n      data: undefined;\n      error: Error;\n      isLoading: false;\n    };\n\n/**\n * A custom React hook that executes a promise function whenever its dependencies change.\n * It manages the loading state, error handling, and the result of the promise.\n *\n * @param promiseFn - A function that returns a promise.\n * @param deps - An array of dependencies that trigger the promise execution when changed.\n * @returns An object containing the data, loading state, and error from the promise execution.\n *\n * @example\n * // Usage inside a React component\n * const { data: user, error, isLoading } = useDerivedPromise(\n *   () => getUserFromId(userId),\n *   [userId]\n * );\n *\n * if (isLoading) return <div>Loading...</div>;\n * if (error) return <div>Error: {error.message}</div>;\n * return <div>User: {user.name}</div>;\n */\nexport function useDerivedPromise<T>(\n  promiseFn: () => Promise<T>,\n  deps: React.DependencyList\n): UseDerivedPromiseResult<T> {\n  const [data, setData] = useState<T | undefined>(undefined);\n  const [isLoading, setIsLoading] = useState<boolean>(true);\n  const [error, setError] = useState<Error | undefined>(undefined);\n\n  useEffect(() => {\n    let isActive = true;\n\n    // If a dependency changes, reset loading state\n    setIsLoading(true);\n\n    const executePromise = async (): Promise<void> => {\n      try {\n        const result = await promiseFn();\n        if (isActive) {\n          setData(result);\n        }\n      } catch (err) {\n        if (isActive) {\n          setError(err instanceof Error ? err : new Error(String(err)));\n        }\n      } finally {\n        if (isActive) {\n          setIsLoading(false);\n        }\n      }\n    };\n\n    executePromise();\n\n    return (): void => {\n      isActive = false;\n    };\n\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps); // Effect re-runs only when these dependencies change\n\n  if (isLoading) {\n    return { data, error, isLoading: true };\n  }\n  if (error) {\n    return { data: undefined, error, isLoading: false };\n  }\n  return { data: data as T, error: undefined, isLoading: false };\n}\n"],"names":["useEffect","useState","useDerivedPromise","promiseFn","deps","data","setData","undefined","isLoading","setIsLoading","error","setError","isActive","executePromise","result","err","Error","String"],"mappings":"AAAA,8EAA8E,GAC9E,SAASA,SAAS,EAAEC,QAAQ,QAAQ,QAAQ;AAsB5C;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,kBACdC,SAA2B,EAC3BC,IAA0B;IAE1B,MAAM,CAACC,MAAMC,QAAQ,GAAGL,SAAwBM;IAChD,MAAM,CAACC,WAAWC,aAAa,GAAGR,SAAkB;IACpD,MAAM,CAACS,OAAOC,SAAS,GAAGV,SAA4BM;IAEtDP,UAAU;QACR,IAAIY,WAAW;QAEf,+CAA+C;QAC/CH,aAAa;QAEb,MAAMI,iBAAiB;YACrB,IAAI;gBACF,MAAMC,SAAS,MAAMX;gBACrB,IAAIS,UAAU;oBACZN,QAAQQ;gBACV;YACF,EAAE,OAAOC,KAAK;gBACZ,IAAIH,UAAU;oBACZD,SAASI,eAAeC,QAAQD,MAAM,IAAIC,MAAMC,OAAOF;gBACzD;YACF,SAAU;gBACR,IAAIH,UAAU;oBACZH,aAAa;gBACf;YACF;QACF;QAEAI;QAEA,OAAO;YACLD,WAAW;QACb;IAEA,uDAAuD;IACzD,GAAGR,OAAO,qDAAqD;IAE/D,IAAII,WAAW;QACb,OAAO;YAAEH;YAAMK;YAAOF,WAAW;QAAK;IACxC;IACA,IAAIE,OAAO;QACT,OAAO;YAAEL,MAAME;YAAWG;YAAOF,WAAW;QAAM;IACpD;IACA,OAAO;QAAEH,MAAMA;QAAWK,OAAOH;QAAWC,WAAW;IAAM;AAC/D"}

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

@@ -1,27 +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)
- */
+* 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

@@ -1,12 +1,53 @@
-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);
-	});
+import { useRef, useSyncExternalStore } from "react";
+import { isEqual } from "lodash-es";
+/**
+ * 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 function useStableSyncExternalStore(subscribe, getSnapshot) {
+    // Store the previous value to compare against for referential stability
+    const prevValueRef = useRef(null);
+    // Wrap the snapshot getter to add cloning and deep equality comparison.
+    // useSyncExternalStore does not benefit from memoizing this function,
+    // performance instead relies on consumers leveraging the returned stable
+    // reference in their own memoization.
+    const wrappedGetSnapshot = ()=>{
+        // Get the raw value from the snapshot function
+        const rawValue = getSnapshot();
+        // Clone the value to ensure immutability and to compare with previous value
+        const clonedValue = structuredClone(rawValue);
+        // Check if the value is equal to the previous value
+        const prevValue = prevValueRef.current;
+        if (prevValue !== null && isEqual(prevValue, clonedValue)) {
+            // Return the previous reference to maintain referential identity
+            return prevValue;
+        }
+        // Update the memoized value and return the new one
+        prevValueRef.current = clonedValue;
+        return clonedValue;
+    };
+    return useSyncExternalStore(subscribe, wrappedGetSnapshot);
 }
-//#endregion
-export { r as useStableSyncExternalStore };
+
+//# sourceMappingURL=use-stable-sync-external-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/use-stable-sync-external-store.ts"],"sourcesContent":["import { useRef, useSyncExternalStore } from 'react';\n\nimport { isEqual } from 'lodash-es';\n\n/**\n * A wrapper around React's `useSyncExternalStore` that returns a referentially\n * stable value from a mutable data source.\n *\n * This hook uses structural cloning and deep equality checks to keep returning\n * the same reference for the same value, making it safe to use with dependency\n * arrays in other hooks.\n *\n * This is performance-sensitive and should be used with small slices of data.\n *\n * @template T - structurally-cloneable data type from your store\n *\n * @param subscribe - A function that subscribes to the external store and\n *   returns an unsubscribe function. Called with a callback that should be\n *   invoked whenever the store changes. Should be memoized.\n * @param getSnapshot - A function that retrieves the current value from the\n *   external store. Must be a pure function and can be called multiple times\n *   per render. Must return a structurally-cloneable value. Does not need to be\n *   memoized.\n *\n * @returns The current value from the store, with referential stability\n *   guaranteed when the value content hasn't changed.\n *\n * @see [React\n * useSyncExternalStore](https://react.dev/reference/react/useSyncExternalStore)\n */\nexport function useStableSyncExternalStore<T>(\n  subscribe: (callback: VoidFunction) => VoidFunction,\n  getSnapshot: () => T\n): T {\n  // Store the previous value to compare against for referential stability\n  const prevValueRef = useRef<T | null>(null);\n\n  // Wrap the snapshot getter to add cloning and deep equality comparison.\n  // useSyncExternalStore does not benefit from memoizing this function,\n  // performance instead relies on consumers leveraging the returned stable\n  // reference in their own memoization.\n  const wrappedGetSnapshot = (): T => {\n    // Get the raw value from the snapshot function\n    const rawValue = getSnapshot();\n\n    // Clone the value to ensure immutability and to compare with previous value\n    const clonedValue = structuredClone(rawValue);\n\n    // Check if the value is equal to the previous value\n    const prevValue = prevValueRef.current;\n    if (prevValue !== null && isEqual(prevValue, clonedValue)) {\n      // Return the previous reference to maintain referential identity\n      return prevValue;\n    }\n\n    // Update the memoized value and return the new one\n    prevValueRef.current = clonedValue;\n    return clonedValue;\n  };\n\n  return useSyncExternalStore(subscribe, wrappedGetSnapshot);\n}\n"],"names":["useRef","useSyncExternalStore","isEqual","useStableSyncExternalStore","subscribe","getSnapshot","prevValueRef","wrappedGetSnapshot","rawValue","clonedValue","structuredClone","prevValue","current"],"mappings":"AAAA,SAASA,MAAM,EAAEC,oBAAoB,QAAQ,QAAQ;AAErD,SAASC,OAAO,QAAQ,YAAY;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,SAASC,2BACdC,SAAmD,EACnDC,WAAoB;IAEpB,wEAAwE;IACxE,MAAMC,eAAeN,OAAiB;IAEtC,wEAAwE;IACxE,sEAAsE;IACtE,yEAAyE;IACzE,sCAAsC;IACtC,MAAMO,qBAAqB;QACzB,+CAA+C;QAC/C,MAAMC,WAAWH;QAEjB,4EAA4E;QAC5E,MAAMI,cAAcC,gBAAgBF;QAEpC,oDAAoD;QACpD,MAAMG,YAAYL,aAAaM,OAAO;QACtC,IAAID,cAAc,QAAQT,QAAQS,WAAWF,cAAc;YACzD,iEAAiE;YACjE,OAAOE;QACT;QAEA,mDAAmD;QACnDL,aAAaM,OAAO,GAAGH;QACvB,OAAOA;IACT;IAEA,OAAOR,qBAAqBG,WAAWG;AACzC"}

package/dist/react.d.ts

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

package/dist/react.js

@@ -1,4 +1,5 @@
-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 };
+export { useDebounce } from "./react/use-debounce.js";
+export { useDerivedPromise } from "./react/use-derived-promise.js";
+export { useStableSyncExternalStore } from "./react/use-stable-sync-external-store.js";
+
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react.ts"],"sourcesContent":["export { useDebounce } from './react/use-debounce';\nexport {\n  useDerivedPromise,\n  type UseDerivedPromiseResult,\n} from './react/use-derived-promise';\nexport { useStableSyncExternalStore } from './react/use-stable-sync-external-store';\n"],"names":["useDebounce","useDerivedPromise","useStableSyncExternalStore"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAAuB;AACnD,SACEC,iBAAiB,QAEZ,iCAA8B;AACrC,SAASC,0BAA0B,QAAQ,4CAAyC"}

package/dist/repeat.d.ts

@@ -1,7 +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.
- */
+* 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

@@ -1,6 +1,12 @@
-//#region libs/shared/underscore/src/repeat.ts
-function e(e, t) {
-	for (let n = 0; n < t; ++n) e();
+/**
+ * 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 function repeat(fn, times) {
+    for(let i = 0; i < times; ++i){
+        fn();
+    }
 }
-//#endregion
-export { e as repeat };
+
+//# sourceMappingURL=repeat.js.map

package/dist/repeat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/repeat.ts"],"sourcesContent":["/**\n * Repeats the execution of a given function a specified number of times.\n *\n * @param fn - The function to be executed repeatedly.\n * @param times - The number of times to execute the function.\n */\nexport function repeat(fn: VoidFunction, times: number): void {\n  for (let i = 0; i < times; ++i) {\n    fn();\n  }\n}\n"],"names":["repeat","fn","times","i"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,SAASA,OAAOC,EAAgB,EAAEC,KAAa;IACpD,IAAK,IAAIC,IAAI,GAAGA,IAAID,OAAO,EAAEC,EAAG;QAC9BF;IACF;AACF"}