@cognite/signal-utils 1.0.1 → 1.48411.0

package/dist/misc/debounced-computed.d.ts

@@ -1,25 +1,25 @@
-import { ReadonlySignal } from '../core/signal';
+import type { ReadonlySignal } from "../core/signal";
 /**
- * Represents a debounced computed value.
- *
- * @template T - The type of the computed value.
- *
- * @property {ReadonlySignal<T>} value - The debounced computed value.
- * @property {VoidFunction} dispose - A function to dispose updates to the computed value.
- */
+* Represents a debounced computed value.
+*
+* @template T - The type of the computed value.
+*
+* @property {ReadonlySignal<T>} value - The debounced computed value.
+* @property {VoidFunction} dispose - A function to dispose updates to the computed value.
+*/
 export type DebouncedComputed<T> = {
-    value: ReadonlySignal<T>;
-    dispose: VoidFunction;
+	value: ReadonlySignal<T>;
+	dispose: VoidFunction;
 };
 /**
- * Creates a debounced computed value based on the provided function.
- * The value will be set immediately, and debounce thereafter. This means the computed value will be updated at a maximum
- * frequency of once every `delayInMs` milliseconds.
- *
- * @template T - The type of the computed value.
- * @param {() => T} func - The function that returns the computed value.
- * @param {number} [delayInMs] - The minimum amount of time that must pass between between each value update. If not provided, a default delay will be used.
- * @param {boolean} [immediate=false] - If true, the function will be called at the start of the wait period, rather than the end.
- * @returns {DebouncedComputed<T>} An object containing the debounced computed value and a dispose function.
- */
+* Creates a debounced computed value based on the provided function.
+* The value will be set immediately, and debounce thereafter. This means the computed value will be updated at a maximum
+* frequency of once every `delayInMs` milliseconds.
+*
+* @template T - The type of the computed value.
+* @param {() => T} func - The function that returns the computed value.
+* @param {number} [delayInMs] - The minimum amount of time that must pass between between each value update. If not provided, a default delay will be used.
+* @param {boolean} [immediate=false] - If true, the function will be called at the start of the wait period, rather than the end.
+* @returns {DebouncedComputed<T>} An object containing the debounced computed value and a dispose function.
+*/
 export declare function debouncedComputed<T>(func: () => T, delayInMs?: number, immediate?: boolean): DebouncedComputed<T>;

package/dist/misc/debounced-computed.js

@@ -1,17 +1,38 @@
-import { signal as e } from "../core/signal.js";
-import { computed as t } from "../core/computed.js";
-import { effect as n } from "../core/effect.js";
-import { debounce as r } from "../utils/debounce.js";
-//#region libs/shared/signal-utils/src/misc/debounced-computed.ts
-function i(i, a, o = !1) {
-	let s = !1, c = e(void 0), l = r(c, a, o), u = t(i), d = n(() => {
-		let e = u();
-		s ? l(e) : (c(e), s = !0);
-	});
-	return {
-		value: t(() => c()),
-		dispose: d
-	};
+import { computed } from "../core/computed.js";
+import { effect } from "../core/effect.js";
+import { signal } from "../core/signal.js";
+import { debounce } from "../utils/debounce.js";
+/**
+ * Creates a debounced computed value based on the provided function.
+ * The value will be set immediately, and debounce thereafter. This means the computed value will be updated at a maximum
+ * frequency of once every `delayInMs` milliseconds.
+ *
+ * @template T - The type of the computed value.
+ * @param {() => T} func - The function that returns the computed value.
+ * @param {number} [delayInMs] - The minimum amount of time that must pass between between each value update. If not provided, a default delay will be used.
+ * @param {boolean} [immediate=false] - If true, the function will be called at the start of the wait period, rather than the end.
+ * @returns {DebouncedComputed<T>} An object containing the debounced computed value and a dispose function.
+ */ export function debouncedComputed(func, delayInMs, immediate = false) {
+    let isInitialized = false;
+    let innerValue = signal(undefined); // We set the initial value in the effect
+    const updateInnerValue = debounce(innerValue, delayInMs, immediate);
+    const inputComputed = computed(func);
+    const dispose = effect(()=>{
+        const newValue = inputComputed();
+        if (!isInitialized) {
+            // We want to set the value immediately on the first run.
+            // No debounce is applied here.
+            innerValue(newValue);
+            isInitialized = true;
+        } else {
+            updateInnerValue(newValue);
+        }
+    });
+    const value = computed(()=>innerValue());
+    return {
+        value,
+        dispose
+    };
 }
-//#endregion
-export { i as debouncedComputed };
+
+//# sourceMappingURL=debounced-computed.js.map

package/dist/misc/debounced-computed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/misc/debounced-computed.ts"],"sourcesContent":["import { computed } from '../core/computed';\nimport { effect } from '../core/effect';\nimport type { ReadonlySignal } from '../core/signal';\nimport { signal } from '../core/signal';\nimport { debounce } from '../utils/debounce';\n\n/**\n * Represents a debounced computed value.\n *\n * @template T - The type of the computed value.\n *\n * @property {ReadonlySignal<T>} value - The debounced computed value.\n * @property {VoidFunction} dispose - A function to dispose updates to the computed value.\n */\nexport type DebouncedComputed<T> = {\n  value: ReadonlySignal<T>;\n  dispose: VoidFunction;\n};\n\n/**\n * Creates a debounced computed value based on the provided function.\n * The value will be set immediately, and debounce thereafter. This means the computed value will be updated at a maximum\n * frequency of once every `delayInMs` milliseconds.\n *\n * @template T - The type of the computed value.\n * @param {() => T} func - The function that returns the computed value.\n * @param {number} [delayInMs] - The minimum amount of time that must pass between between each value update. If not provided, a default delay will be used.\n * @param {boolean} [immediate=false] - If true, the function will be called at the start of the wait period, rather than the end.\n * @returns {DebouncedComputed<T>} An object containing the debounced computed value and a dispose function.\n */\nexport function debouncedComputed<T>(\n  func: () => T,\n  delayInMs?: number,\n  immediate: boolean = false\n): DebouncedComputed<T> {\n  let isInitialized = false;\n  let innerValue = signal(undefined as T); // We set the initial value in the effect\n  const updateInnerValue = debounce(innerValue, delayInMs, immediate);\n  const inputComputed = computed(func);\n\n  const dispose = effect(() => {\n    const newValue = inputComputed();\n    if (!isInitialized) {\n      // We want to set the value immediately on the first run.\n      // No debounce is applied here.\n      innerValue(newValue);\n      isInitialized = true;\n    } else {\n      updateInnerValue(newValue);\n    }\n  });\n\n  const value = computed(() => innerValue());\n  return { value, dispose };\n}\n"],"names":["computed","effect","signal","debounce","debouncedComputed","func","delayInMs","immediate","isInitialized","innerValue","undefined","updateInnerValue","inputComputed","dispose","newValue","value"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,sBAAmB;AAC5C,SAASC,MAAM,QAAQ,oBAAiB;AAExC,SAASC,MAAM,QAAQ,oBAAiB;AACxC,SAASC,QAAQ,QAAQ,uBAAoB;AAe7C;;;;;;;;;;CAUC,GACD,OAAO,SAASC,kBACdC,IAAa,EACbC,SAAkB,EAClBC,YAAqB,KAAK;IAE1B,IAAIC,gBAAgB;IACpB,IAAIC,aAAaP,OAAOQ,YAAiB,yCAAyC;IAClF,MAAMC,mBAAmBR,SAASM,YAAYH,WAAWC;IACzD,MAAMK,gBAAgBZ,SAASK;IAE/B,MAAMQ,UAAUZ,OAAO;QACrB,MAAMa,WAAWF;QACjB,IAAI,CAACJ,eAAe;YAClB,yDAAyD;YACzD,+BAA+B;YAC/BC,WAAWK;YACXN,gBAAgB;QAClB,OAAO;YACLG,iBAAiBG;QACnB;IACF;IAEA,MAAMC,QAAQf,SAAS,IAAMS;IAC7B,OAAO;QAAEM;QAAOF;IAAQ;AAC1B"}

package/dist/react/use-signal-value.d.ts

@@ -1,9 +1,9 @@
-import { ReadonlySignal } from '../core/signal';
+import type { ReadonlySignal } from "../core/signal";
 /**
- * A custom hook that returns the signal's value and keeps the value up-to-date.
- *
- * @template T - The type of the value held by the signal.
- * @param {ReadonlySignal<T>} signal - The signal.
- * @returns {T} - The current value of the signal.
- */
+* A custom hook that returns the signal's value and keeps the value up-to-date.
+*
+* @template T - The type of the value held by the signal.
+* @param {ReadonlySignal<T>} signal - The signal.
+* @returns {T} - The current value of the signal.
+*/
 export declare function useSignalValue<T>(signal: ReadonlySignal<T>): T;

package/dist/react/use-signal-value.js

@@ -1,7 +1,12 @@
-import { useSyncExternalStore as e } from "react";
-//#region libs/shared/signal-utils/src/react/use-signal-value.ts
-function t(t) {
-	return e(t.subscribe, t.peek);
+import { useSyncExternalStore } from "react";
+/**
+ * A custom hook that returns the signal's value and keeps the value up-to-date.
+ *
+ * @template T - The type of the value held by the signal.
+ * @param {ReadonlySignal<T>} signal - The signal.
+ * @returns {T} - The current value of the signal.
+ */ export function useSignalValue(signal) {
+    return useSyncExternalStore(signal.subscribe, signal.peek);
 }
-//#endregion
-export { t as useSignalValue };
+
+//# sourceMappingURL=use-signal-value.js.map

package/dist/react/use-signal-value.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/use-signal-value.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\n\nimport type { ReadonlySignal } from '../core/signal';\n\n/**\n * A custom hook that returns the signal's value and keeps the value up-to-date.\n *\n * @template T - The type of the value held by the signal.\n * @param {ReadonlySignal<T>} signal - The signal.\n * @returns {T} - The current value of the signal.\n */\nexport function useSignalValue<T>(signal: ReadonlySignal<T>): T {\n  return useSyncExternalStore(signal.subscribe, signal.peek);\n}\n"],"names":["useSyncExternalStore","useSignalValue","signal","subscribe","peek"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,QAAQ;AAI7C;;;;;;CAMC,GACD,OAAO,SAASC,eAAkBC,MAAyB;IACzD,OAAOF,qBAAqBE,OAAOC,SAAS,EAAED,OAAOE,IAAI;AAC3D"}

package/dist/react.d.ts

@@ -1 +1 @@
-export { useSignalValue } from './react/use-signal-value';
+export { useSignalValue } from "./react/use-signal-value";

package/dist/react.js

@@ -1,2 +1,3 @@
-import { useSignalValue as e } from "./react/use-signal-value.js";
-export { e as useSignalValue };
+export { useSignalValue } from "./react/use-signal-value.js";
+
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react.ts"],"sourcesContent":["export { useSignalValue } from './react/use-signal-value';\n"],"names":["useSignalValue"],"mappings":"AAAA,SAASA,cAAc,QAAQ,8BAA2B"}

package/dist/utils/arrays.d.ts

@@ -1,30 +1,30 @@
 /**
- * Inserts an element at a specific index in the array.
- *
- * @param array
- * @param index
- * @param item
- */
+* Inserts an element at a specific index in the array.
+*
+* @param array
+* @param index
+* @param item
+*/
 export declare function insertAt<T>(array: T[], index: number, item: T): void;
 /**
- * Removes an element from the array.
- *
- * @param array
- * @param item
- */
+* Removes an element from the array.
+*
+* @param array
+* @param item
+*/
 export declare function remove<T>(array: T[], item: T): void;
 /**
- * Removes an element at the index from the array.
- *
- * @param array
- * @param item
- */
+* Removes an element at the index from the array.
+*
+* @param array
+* @param item
+*/
 export declare function removeAt(array: unknown[], index: number): void;
 /**
- * Swaps two elements in the array on index `i` and `j`.
- *
- * @param array
- * @param i
- * @param j
- */
+* Swaps two elements in the array on index `i` and `j`.
+*
+* @param array
+* @param i
+* @param j
+*/
 export declare function swap(array: unknown[], i: number, j: number): void;

package/dist/utils/arrays.js

@@ -1,17 +1,45 @@
-//#region libs/shared/signal-utils/src/utils/arrays.ts
-function e(e, t, n) {
-	e.splice(t, 0, n);
+/**
+ * Inserts an element at a specific index in the array.
+ *
+ * @param array
+ * @param index
+ * @param item
+ */ export function insertAt(array, index, item) {
+    array.splice(index, 0, item);
 }
-function t(e, t) {
-	let r = e.indexOf(t);
-	r !== -1 && n(e, r);
+/**
+ * Removes an element from the array.
+ *
+ * @param array
+ * @param item
+ */ export function remove(array, item) {
+    const index = array.indexOf(item);
+    if (index !== -1) {
+        removeAt(array, index);
+    }
 }
-function n(e, t) {
-	e.splice(t, 1);
+/**
+ * Removes an element at the index from the array.
+ *
+ * @param array
+ * @param item
+ */ export function removeAt(array, index) {
+    array.splice(index, 1);
 }
-function r(e, t, n) {
-	if (t < 0 || n < 0 || t >= e.length || n >= e.length) throw Error("Index out of bounds");
-	[e[t], e[n]] = [e[n], e[t]];
+/**
+ * Swaps two elements in the array on index `i` and `j`.
+ *
+ * @param array
+ * @param i
+ * @param j
+ */ export function swap(array, i, j) {
+    if (i < 0 || j < 0 || i >= array.length || j >= array.length) {
+        throw new Error('Index out of bounds');
+    }
+    [array[i], array[j]] = [
+        array[j],
+        array[i]
+    ];
 }
-//#endregion
-export { e as insertAt, t as remove, n as removeAt, r as swap };
+
+//# sourceMappingURL=arrays.js.map

package/dist/utils/arrays.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/arrays.ts"],"sourcesContent":["/**\n * Inserts an element at a specific index in the array.\n *\n * @param array\n * @param index\n * @param item\n */\nexport function insertAt<T>(array: T[], index: number, item: T): void {\n  array.splice(index, 0, item);\n}\n\n/**\n * Removes an element from the array.\n *\n * @param array\n * @param item\n */\nexport function remove<T>(array: T[], item: T): void {\n  const index = array.indexOf(item);\n  if (index !== -1) {\n    removeAt(array, index);\n  }\n}\n\n/**\n * Removes an element at the index from the array.\n *\n * @param array\n * @param item\n */\nexport function removeAt(array: unknown[], index: number): void {\n  array.splice(index, 1);\n}\n\n/**\n * Swaps two elements in the array on index `i` and `j`.\n *\n * @param array\n * @param i\n * @param j\n */\nexport function swap(array: unknown[], i: number, j: number): void {\n  if (i < 0 || j < 0 || i >= array.length || j >= array.length) {\n    throw new Error('Index out of bounds');\n  }\n  [array[i], array[j]] = [array[j], array[i]];\n}\n"],"names":["insertAt","array","index","item","splice","remove","indexOf","removeAt","swap","i","j","length","Error"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,SAAYC,KAAU,EAAEC,KAAa,EAAEC,IAAO;IAC5DF,MAAMG,MAAM,CAACF,OAAO,GAAGC;AACzB;AAEA;;;;;CAKC,GACD,OAAO,SAASE,OAAUJ,KAAU,EAAEE,IAAO;IAC3C,MAAMD,QAAQD,MAAMK,OAAO,CAACH;IAC5B,IAAID,UAAU,CAAC,GAAG;QAChBK,SAASN,OAAOC;IAClB;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASK,SAASN,KAAgB,EAAEC,KAAa;IACtDD,MAAMG,MAAM,CAACF,OAAO;AACtB;AAEA;;;;;;CAMC,GACD,OAAO,SAASM,KAAKP,KAAgB,EAAEQ,CAAS,EAAEC,CAAS;IACzD,IAAID,IAAI,KAAKC,IAAI,KAAKD,KAAKR,MAAMU,MAAM,IAAID,KAAKT,MAAMU,MAAM,EAAE;QAC5D,MAAM,IAAIC,MAAM;IAClB;IACA,CAACX,KAAK,CAACQ,EAAE,EAAER,KAAK,CAACS,EAAE,CAAC,GAAG;QAACT,KAAK,CAACS,EAAE;QAAET,KAAK,CAACQ,EAAE;KAAC;AAC7C"}

package/dist/utils/debounce.d.ts

@@ -1,10 +1,10 @@
 /**
- * Wraps a function in a debounce function that will only execute
- * the provided function at a maximum frequency of once every `delayInMs` milliseconds.
- *
- * @param callback The function to debounce.
- * @param delayInMs The minimum amount of time that must pass between calls to the function.
- * @param immediate If true, the function will be called at the start of the wait period, rather than the end.
- * @returns
- */
+* Wraps a function in a debounce function that will only execute
+* the provided function at a maximum frequency of once every `delayInMs` milliseconds.
+*
+* @param callback The function to debounce.
+* @param delayInMs The minimum amount of time that must pass between calls to the function.
+* @param immediate If true, the function will be called at the start of the wait period, rather than the end.
+* @returns
+*/
 export declare function debounce<T extends (...args: any[]) => void>(callback: T, delayInMs?: number, immediate?: boolean): <U>(this: U, ...args: Parameters<typeof callback>) => void;

package/dist/utils/debounce.js

@@ -1,12 +1,31 @@
-//#region libs/shared/signal-utils/src/utils/debounce.ts
-function e(e, t = 250, n = !1) {
-	let r = null;
-	return function(...i) {
-		let a = () => {
-			r = null, n || e.apply(this, i);
-		}, o = n && r === null;
-		r !== null && clearTimeout(r), r = setTimeout(a, t), o && e.apply(this, i);
-	};
+// https://stackoverflow.com/questions/72205837/safe-type-debounce-function-in-typescript
+/**
+ * Wraps a function in a debounce function that will only execute
+ * the provided function at a maximum frequency of once every `delayInMs` milliseconds.
+ *
+ * @param callback The function to debounce.
+ * @param delayInMs The minimum amount of time that must pass between calls to the function.
+ * @param immediate If true, the function will be called at the start of the wait period, rather than the end.
+ * @returns
+ */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function debounce(callback, delayInMs = 250, immediate = false) {
+    let timeout = null;
+    return function(...args) {
+        const later = ()=>{
+            timeout = null;
+            if (!immediate) {
+                callback.apply(this, args);
+            }
+        };
+        const callNow = immediate && timeout === null;
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(later, delayInMs);
+        if (callNow) {
+            callback.apply(this, args);
+        }
+    };
 }
-//#endregion
-export { e as debounce };
+
+//# sourceMappingURL=debounce.js.map

package/dist/utils/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/debounce.ts"],"sourcesContent":["// https://stackoverflow.com/questions/72205837/safe-type-debounce-function-in-typescript\n\n/**\n * Wraps a function in a debounce function that will only execute\n * the provided function at a maximum frequency of once every `delayInMs` milliseconds.\n *\n * @param callback The function to debounce.\n * @param delayInMs The minimum amount of time that must pass between calls to the function.\n * @param immediate If true, the function will be called at the start of the wait period, rather than the end.\n * @returns\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function debounce<T extends (...args: any[]) => void>(\n  callback: T,\n  delayInMs: number = 250,\n  immediate = false\n) {\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  return function <U>(this: U, ...args: Parameters<typeof callback>): void {\n    const later = (): void => {\n      timeout = null;\n      if (!immediate) {\n        callback.apply(this, args);\n      }\n    };\n    const callNow = immediate && timeout === null;\n    if (timeout !== null) {\n      clearTimeout(timeout);\n    }\n    timeout = setTimeout(later, delayInMs);\n    if (callNow) {\n      callback.apply(this, args);\n    }\n  };\n}\n"],"names":["debounce","callback","delayInMs","immediate","timeout","args","later","apply","callNow","clearTimeout","setTimeout"],"mappings":"AAAA,yFAAyF;AAEzF;;;;;;;;CAQC,GACD,8DAA8D;AAC9D,OAAO,SAASA,SACdC,QAAW,EACXC,YAAoB,GAAG,EACvBC,YAAY,KAAK;IAEjB,IAAIC,UAAgD;IACpD,OAAO,SAAsB,GAAGC,IAAiC;QAC/D,MAAMC,QAAQ;YACZF,UAAU;YACV,IAAI,CAACD,WAAW;gBACdF,SAASM,KAAK,CAAC,IAAI,EAAEF;YACvB;QACF;QACA,MAAMG,UAAUL,aAAaC,YAAY;QACzC,IAAIA,YAAY,MAAM;YACpBK,aAAaL;QACf;QACAA,UAAUM,WAAWJ,OAAOJ;QAC5B,IAAIM,SAAS;YACXP,SAASM,KAAK,CAAC,IAAI,EAAEF;QACvB;IACF;AACF"}

package/dist/utils/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. It should not take any arguments and should not return any value.
- * @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. It should not take any arguments and should not return any value.
+* @param times - The number of times to execute the function.
+*/
 export declare function repeat(fn: VoidFunction, times: number): void;

package/dist/utils/repeat.js

@@ -0,0 +1,12 @@
+/**
+ * Repeats the execution of a given function a specified number of times.
+ *
+ * @param fn - The function to be executed repeatedly. It should not take any arguments and should not return any value.
+ * @param times - The number of times to execute the function.
+ */ export function repeat(fn, times) {
+    for(let i = 0; i < times; i++){
+        fn();
+    }
+}
+
+//# sourceMappingURL=repeat.js.map

package/dist/utils/repeat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/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. It should not take any arguments and should not return any value.\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,OAAOC,IAAK;QAC9BF;IACF;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/signal-utils",
-  "version": "1.0.1",
+  "version": "1.48411.0",
   "description": "A thin, framework-agnostic wrapper around Preact Signals for reactive state management.",
   "license": "Apache-2.0",
   "type": "module",
@@ -29,15 +29,19 @@
     "@preact/signals-core": "^1.8.0"
   },
   "devDependencies": {
-    "@nx/eslint-plugin": "22.7.8",
     "@testing-library/react": "16.0.1",
     "@types/react": "18.3.14",
     "@vitejs/plugin-react": "^5.2.0",
     "react": "^18.3.1",
-    "vite": "8.2.2",
+    "vite": "8.2.4",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "react": "^18.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cognitedata/infrastructure.git",
+    "directory": "lib/ts/shared/signal-utils"
   }
 }