@cognite/signal-utils 1.0.1 → 1.48411.0

package/README.md

@@ -45,9 +45,9 @@ import { signal, computed } from '@cognite/signal-utils';
 
 const myNumber = signal(42);
 const double = computed(() => myNumber() * 2);
-double() // 84
+double(); // 84
 myNumber(43);
-double() // 86
+double(); // 86
 ```
 
 ### `effect(fn)`
@@ -57,7 +57,7 @@ import { signal, effect } from '@cognite/signal-utils';
 
 const mySignal = signal(42);
 effect(() => {
- console.log(mySignal());
+  console.log(mySignal());
 });
 // 42 is logged
 mySignal(43);
@@ -66,11 +66,12 @@ mySignal(43);
 // Cleanup
 effect(() => {
   addEventListener('click', handler);
-  return () => { removeEventListener('click', handler); };
+  return () => {
+    removeEventListener('click', handler);
+  };
 });
 ```
 
-
 ### `batch(fn)`
 
 ```ts
@@ -106,7 +107,7 @@ function someFunction() {
 effect(() => {
   console.log(signalA());
   untracked(someFunction);
-})
+});
 // A & B is logged
 
 signalA('A2');

package/dist/core/array-signal.d.ts

@@ -1,61 +1,61 @@
-import { ReadonlySignal, Signal } from './signal';
+import type { ReadonlySignal, Signal } from "./signal";
 declare const arraySignalSymbol: unique symbol;
 export type ReadonlyArraySignal<T> = ReadonlySignal<readonly T[]>;
 export type ArraySignal<T> = Signal<readonly T[]> & {
-    push(...values: T[]): void;
-    insertAt(index: number, value: T): void;
-    remove(value: T): void;
-    removeAt(index: number): void;
-    swap(i: number, j: number): void;
-    clear(): void;
-    [arraySignalSymbol]: boolean;
+	push(...values: T[]): void;
+	insertAt(index: number, value: T): void;
+	remove(value: T): void;
+	removeAt(index: number): void;
+	swap(i: number, j: number): void;
+	clear(): void;
+	[arraySignalSymbol]: boolean;
 };
 /**
- * Creates an `ArraySignal` which is a reactive signal for an array of values.
- *
- * @template T - The type of elements in the array.
- * @param {readonly T[]} [value=[]] - The initial value of the array.
- * @returns {ArraySignal<T>} A reactive signal for the array.
- *
- * @example
- * ```ts
- * const myArraySignal = arraySignal([1, 2, 3]);
- *
- * // Getter
- * const currentArray = myArraySignal();
- *
- * // Setter
- * myArraySignal([4, 5, 6]);
- *
- * // Push new values
- * myArraySignal.push(7, 8);
- *
- * // Insert value at specific index
- * myArraySignal.insertAt(1, 9);
- *
- * // Remove specific value
- * myArraySignal.remove(2);
- *
- * // Remove value at specific index
- * myArraySignal.removeAt(0);
- *
- * // Swap values at two indices
- * myArraySignal.swap(0, 1);
- *
- * // Clear the array
- * myArraySignal.clear();
- *
- * // Peek the current value without taking a dependency
- * const peekedArray = myArraySignal.peek();
- * ```
- */
+* Creates an `ArraySignal` which is a reactive signal for an array of values.
+*
+* @template T - The type of elements in the array.
+* @param {readonly T[]} [value=[]] - The initial value of the array.
+* @returns {ArraySignal<T>} A reactive signal for the array.
+*
+* @example
+* ```ts
+* const myArraySignal = arraySignal([1, 2, 3]);
+*
+* // Getter
+* const currentArray = myArraySignal();
+*
+* // Setter
+* myArraySignal([4, 5, 6]);
+*
+* // Push new values
+* myArraySignal.push(7, 8);
+*
+* // Insert value at specific index
+* myArraySignal.insertAt(1, 9);
+*
+* // Remove specific value
+* myArraySignal.remove(2);
+*
+* // Remove value at specific index
+* myArraySignal.removeAt(0);
+*
+* // Swap values at two indices
+* myArraySignal.swap(0, 1);
+*
+* // Clear the array
+* myArraySignal.clear();
+*
+* // Peek the current value without taking a dependency
+* const peekedArray = myArraySignal.peek();
+* ```
+*/
 export declare function arraySignal<T>(value?: readonly T[]): ArraySignal<T>;
 /**
- * Checks if the given value is an ArraySignal.
- *
- * @template T - The type of elements in the array signal.
- * @param value - The value to check.
- * @returns A boolean indicating whether the value is an ArraySignal.
- */
+* Checks if the given value is an ArraySignal.
+*
+* @template T - The type of elements in the array signal.
+* @param value - The value to check.
+* @returns A boolean indicating whether the value is an ArraySignal.
+*/
 export declare function isArraySignal<T>(value: unknown): value is ArraySignal<T>;
 export {};

package/dist/core/array-signal.js

@@ -1,36 +1,107 @@
-import { insertAt as e, remove as t, removeAt as n, swap as r } from "../utils/arrays.js";
-import { signal as i } from "./signal.js";
-//#region libs/shared/signal-utils/src/core/array-signal.ts
-var a = Symbol("ArraySignal");
-function o(o = []) {
-	let s = i([...o]);
-	function c(e) {
-		if (arguments.length === 1) {
-			s([...e]);
-			return;
-		}
-		return s();
-	}
-	return c[a] = !0, c.push = (...e) => {
-		s([...s.peek(), ...e]);
-	}, c.insertAt = (t, n) => {
-		let r = [...s.peek()];
-		e(r, t, n), s(r);
-	}, c.remove = (e) => {
-		let n = [...s.peek()];
-		t(n, e), s(n);
-	}, c.removeAt = (e) => {
-		let t = [...s.peek()];
-		n(t, e), s(t);
-	}, c.swap = (e, t) => {
-		let n = [...s.peek()];
-		r(n, e, t), s(n);
-	}, c.clear = () => {
-		s([]);
-	}, c.peek = () => s.peek(), c.subscribe = (e) => s.subscribe(e), c;
+import { insertAt, remove, removeAt, swap } from "../utils/arrays.js";
+import { signal } from "./signal.js";
+const arraySignalSymbol = Symbol('ArraySignal');
+/**
+ * Creates an `ArraySignal` which is a reactive signal for an array of values.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} [value=[]] - The initial value of the array.
+ * @returns {ArraySignal<T>} A reactive signal for the array.
+ *
+ * @example
+ * ```ts
+ * const myArraySignal = arraySignal([1, 2, 3]);
+ *
+ * // Getter
+ * const currentArray = myArraySignal();
+ *
+ * // Setter
+ * myArraySignal([4, 5, 6]);
+ *
+ * // Push new values
+ * myArraySignal.push(7, 8);
+ *
+ * // Insert value at specific index
+ * myArraySignal.insertAt(1, 9);
+ *
+ * // Remove specific value
+ * myArraySignal.remove(2);
+ *
+ * // Remove value at specific index
+ * myArraySignal.removeAt(0);
+ *
+ * // Swap values at two indices
+ * myArraySignal.swap(0, 1);
+ *
+ * // Clear the array
+ * myArraySignal.clear();
+ *
+ * // Peek the current value without taking a dependency
+ * const peekedArray = myArraySignal.peek();
+ * ```
+ */ export function arraySignal(value = []) {
+    const innerSignal = signal([
+        ...value
+    ]);
+    function fn(newValue) {
+        if (arguments.length === 1) {
+            innerSignal([
+                ...newValue
+            ]);
+            return;
+        }
+        return innerSignal();
+    }
+    fn[arraySignalSymbol] = true;
+    fn.push = (...values)=>{
+        innerSignal([
+            ...innerSignal.peek(),
+            ...values
+        ]);
+    };
+    fn.insertAt = (index, value)=>{
+        const values = [
+            ...innerSignal.peek()
+        ];
+        insertAt(values, index, value);
+        innerSignal(values);
+    };
+    fn.remove = (value)=>{
+        const values = [
+            ...innerSignal.peek()
+        ];
+        remove(values, value);
+        innerSignal(values);
+    };
+    fn.removeAt = (index)=>{
+        const values = [
+            ...innerSignal.peek()
+        ];
+        removeAt(values, index);
+        innerSignal(values);
+    };
+    fn.swap = (i, j)=>{
+        const values = [
+            ...innerSignal.peek()
+        ];
+        swap(values, i, j);
+        innerSignal(values);
+    };
+    fn.clear = ()=>{
+        innerSignal([]);
+    };
+    fn.peek = ()=>innerSignal.peek();
+    fn.subscribe = (fn)=>innerSignal.subscribe(fn);
+    return fn;
 }
-function s(e) {
-	return typeof e == "function" && a in e;
+/**
+ * Checks if the given value is an ArraySignal.
+ *
+ * @template T - The type of elements in the array signal.
+ * @param value - The value to check.
+ * @returns A boolean indicating whether the value is an ArraySignal.
+ */ export function isArraySignal(value) {
+    return typeof value === 'function' && arraySignalSymbol in value;
 }
-//#endregion
-export { o as arraySignal, s as isArraySignal };
+
+//# sourceMappingURL=array-signal.js.map

package/dist/core/array-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/array-signal.ts"],"sourcesContent":["import { insertAt, remove, removeAt, swap } from '../utils/arrays';\n\nimport type { ReadonlySignal, Signal, Subscriber, Unsubscribe } from './signal';\nimport { signal } from './signal';\n\nconst arraySignalSymbol: unique symbol = Symbol('ArraySignal');\n\nexport type ReadonlyArraySignal<T> = ReadonlySignal<readonly T[]>;\n\nexport type ArraySignal<T> = Signal<readonly T[]> & {\n  push(...values: T[]): void;\n  insertAt(index: number, value: T): void;\n  remove(value: T): void;\n  removeAt(index: number): void;\n  swap(i: number, j: number): void;\n  clear(): void;\n  [arraySignalSymbol]: boolean;\n};\n\n/**\n * Creates an `ArraySignal` which is a reactive signal for an array of values.\n *\n * @template T - The type of elements in the array.\n * @param {readonly T[]} [value=[]] - The initial value of the array.\n * @returns {ArraySignal<T>} A reactive signal for the array.\n *\n * @example\n * ```ts\n * const myArraySignal = arraySignal([1, 2, 3]);\n *\n * // Getter\n * const currentArray = myArraySignal();\n *\n * // Setter\n * myArraySignal([4, 5, 6]);\n *\n * // Push new values\n * myArraySignal.push(7, 8);\n *\n * // Insert value at specific index\n * myArraySignal.insertAt(1, 9);\n *\n * // Remove specific value\n * myArraySignal.remove(2);\n *\n * // Remove value at specific index\n * myArraySignal.removeAt(0);\n *\n * // Swap values at two indices\n * myArraySignal.swap(0, 1);\n *\n * // Clear the array\n * myArraySignal.clear();\n *\n * // Peek the current value without taking a dependency\n * const peekedArray = myArraySignal.peek();\n * ```\n */\nexport function arraySignal<T>(value: readonly T[] = []): ArraySignal<T> {\n  const innerSignal = signal([...value] as readonly T[]);\n\n  function fn(): readonly T[]; // Getter\n  function fn(newValue: readonly T[]): void; // Setter\n  function fn(newValue?: readonly T[]): readonly T[] | void {\n    if (arguments.length === 1) {\n      innerSignal([...(newValue as [])]);\n      return;\n    }\n    return innerSignal();\n  }\n\n  fn[arraySignalSymbol] = true;\n\n  fn.push = (...values: T[]): void => {\n    innerSignal([...innerSignal.peek(), ...values]);\n  };\n\n  fn.insertAt = (index: number, value: T): void => {\n    const values = [...innerSignal.peek()];\n    insertAt(values, index, value);\n    innerSignal(values);\n  };\n\n  fn.remove = (value: T): void => {\n    const values = [...innerSignal.peek()];\n    remove(values, value);\n    innerSignal(values);\n  };\n\n  fn.removeAt = (index: number): void => {\n    const values = [...innerSignal.peek()];\n    removeAt(values, index);\n    innerSignal(values);\n  };\n\n  fn.swap = (i: number, j: number): void => {\n    const values = [...innerSignal.peek()];\n    swap(values, i, j);\n    innerSignal(values);\n  };\n\n  fn.clear = (): void => {\n    innerSignal([]);\n  };\n\n  fn.peek = (): readonly T[] => innerSignal.peek();\n  fn.subscribe = (fn: Subscriber<readonly T[]>): Unsubscribe =>\n    innerSignal.subscribe(fn);\n\n  return fn;\n}\n\n/**\n * Checks if the given value is an ArraySignal.\n *\n * @template T - The type of elements in the array signal.\n * @param value - The value to check.\n * @returns A boolean indicating whether the value is an ArraySignal.\n */\nexport function isArraySignal<T>(value: unknown): value is ArraySignal<T> {\n  return typeof value === 'function' && arraySignalSymbol in value;\n}\n"],"names":["insertAt","remove","removeAt","swap","signal","arraySignalSymbol","Symbol","arraySignal","value","innerSignal","fn","newValue","arguments","length","push","values","peek","index","i","j","clear","subscribe","isArraySignal"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,IAAI,QAAQ,qBAAkB;AAGnE,SAASC,MAAM,QAAQ,cAAW;AAElC,MAAMC,oBAAmCC,OAAO;AAchD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCC,GACD,OAAO,SAASC,YAAeC,QAAsB,EAAE;IACrD,MAAMC,cAAcL,OAAO;WAAII;KAAM;IAIrC,SAASE,GAAGC,QAAuB;QACjC,IAAIC,UAAUC,MAAM,KAAK,GAAG;YAC1BJ,YAAY;mBAAKE;aAAgB;YACjC;QACF;QACA,OAAOF;IACT;IAEAC,EAAE,CAACL,kBAAkB,GAAG;IAExBK,GAAGI,IAAI,GAAG,CAAC,GAAGC;QACZN,YAAY;eAAIA,YAAYO,IAAI;eAAOD;SAAO;IAChD;IAEAL,GAAGV,QAAQ,GAAG,CAACiB,OAAeT;QAC5B,MAAMO,SAAS;eAAIN,YAAYO,IAAI;SAAG;QACtChB,SAASe,QAAQE,OAAOT;QACxBC,YAAYM;IACd;IAEAL,GAAGT,MAAM,GAAG,CAACO;QACX,MAAMO,SAAS;eAAIN,YAAYO,IAAI;SAAG;QACtCf,OAAOc,QAAQP;QACfC,YAAYM;IACd;IAEAL,GAAGR,QAAQ,GAAG,CAACe;QACb,MAAMF,SAAS;eAAIN,YAAYO,IAAI;SAAG;QACtCd,SAASa,QAAQE;QACjBR,YAAYM;IACd;IAEAL,GAAGP,IAAI,GAAG,CAACe,GAAWC;QACpB,MAAMJ,SAAS;eAAIN,YAAYO,IAAI;SAAG;QACtCb,KAAKY,QAAQG,GAAGC;QAChBV,YAAYM;IACd;IAEAL,GAAGU,KAAK,GAAG;QACTX,YAAY,EAAE;IAChB;IAEAC,GAAGM,IAAI,GAAG,IAAoBP,YAAYO,IAAI;IAC9CN,GAAGW,SAAS,GAAG,CAACX,KACdD,YAAYY,SAAS,CAACX;IAExB,OAAOA;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASY,cAAiBd,KAAc;IAC7C,OAAO,OAAOA,UAAU,cAAcH,qBAAqBG;AAC7D"}

package/dist/core/batch.d.ts

@@ -1,23 +1,23 @@
 /**
- * Executes a function within a batch, ensuring that signal updates are batched together (atomic operation).
- *
- * @param fn - The function to be executed within the batch.
- *
- * @example
- * ```ts
- * const givenName = signal('Jane');
- * const familyName = signal('Doe');
- * const fullName = computed(() => givenName() + ' ' + familyName());
- *
- * effect(() => console.log(fullName()));
- * // "Jane Doe" logged
- *
- * // Combines both signal writes into one atomic update.
- * batch(() => {
- *   givenName('Foo');
- *   familyName('Bar');
- * });
- * // "Foo Bar" logged
- * ```
- */
+* Executes a function within a batch, ensuring that signal updates are batched together (atomic operation).
+*
+* @param fn - The function to be executed within the batch.
+*
+* @example
+* ```ts
+* const givenName = signal('Jane');
+* const familyName = signal('Doe');
+* const fullName = computed(() => givenName() + ' ' + familyName());
+*
+* effect(() => console.log(fullName()));
+* // "Jane Doe" logged
+*
+* // Combines both signal writes into one atomic update.
+* batch(() => {
+*   givenName('Foo');
+*   familyName('Bar');
+* });
+* // "Foo Bar" logged
+* ```
+*/
 export declare function batch(fn: VoidFunction): void;

package/dist/core/batch.js

@@ -1,7 +1,27 @@
-import { batch as e } from "@preact/signals-core";
-//#region libs/shared/signal-utils/src/core/batch.ts
-function t(t) {
-	e(t);
+import { batch as preactBatch } from "@preact/signals-core";
+/**
+ * Executes a function within a batch, ensuring that signal updates are batched together (atomic operation).
+ *
+ * @param fn - The function to be executed within the batch.
+ *
+ * @example
+ * ```ts
+ * const givenName = signal('Jane');
+ * const familyName = signal('Doe');
+ * const fullName = computed(() => givenName() + ' ' + familyName());
+ *
+ * effect(() => console.log(fullName()));
+ * // "Jane Doe" logged
+ *
+ * // Combines both signal writes into one atomic update.
+ * batch(() => {
+ *   givenName('Foo');
+ *   familyName('Bar');
+ * });
+ * // "Foo Bar" logged
+ * ```
+ */ export function batch(fn) {
+    preactBatch(fn);
 }
-//#endregion
-export { t as batch };
+
+//# sourceMappingURL=batch.js.map

package/dist/core/batch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/batch.ts"],"sourcesContent":["import { batch as preactBatch } from '@preact/signals-core';\n\n/**\n * Executes a function within a batch, ensuring that signal updates are batched together (atomic operation).\n *\n * @param fn - The function to be executed within the batch.\n *\n * @example\n * ```ts\n * const givenName = signal('Jane');\n * const familyName = signal('Doe');\n * const fullName = computed(() => givenName() + ' ' + familyName());\n *\n * effect(() => console.log(fullName()));\n * // \"Jane Doe\" logged\n *\n * // Combines both signal writes into one atomic update.\n * batch(() => {\n *   givenName('Foo');\n *   familyName('Bar');\n * });\n * // \"Foo Bar\" logged\n * ```\n */\nexport function batch(fn: VoidFunction): void {\n  preactBatch(fn);\n}\n"],"names":["batch","preactBatch","fn"],"mappings":"AAAA,SAASA,SAASC,WAAW,QAAQ,uBAAuB;AAE5D;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,SAASD,MAAME,EAAgB;IACpCD,YAAYC;AACd"}

package/dist/core/computed.d.ts

@@ -1,19 +1,19 @@
-import { ReadonlySignal } from './signal';
+import type { ReadonlySignal } from "./signal";
 /**
- * Creates a computed signal that derives its value from the provided function.
- *
- * @template T - The type of the value returned by the computed function.
- * @param {() => T} fn - A function that returns the value for the computed signal.
- * @returns {ReadonlySignal<T>} A readonly signal that provides the computed value.
- *
- * @example
- * ```ts
- * const myNumber = signal(42);
- * const double = computed(() => myNumber() * 2);
- * double() // 84
- *
- * myNumber(43);
- * double() // 86
- * ```
- */
+* Creates a computed signal that derives its value from the provided function.
+*
+* @template T - The type of the value returned by the computed function.
+* @param {() => T} fn - A function that returns the value for the computed signal.
+* @returns {ReadonlySignal<T>} A readonly signal that provides the computed value.
+*
+* @example
+* ```ts
+* const myNumber = signal(42);
+* const double = computed(() => myNumber() * 2);
+* double() // 84
+*
+* myNumber(43);
+* double() // 86
+* ```
+*/
 export declare function computed<T>(fn: () => T): ReadonlySignal<T>;

package/dist/core/computed.js

@@ -1,11 +1,28 @@
-import { computed as e } from "@preact/signals-core";
-//#region libs/shared/signal-utils/src/core/computed.ts
-function t(t) {
-	let n = e(t);
-	function r() {
-		return n.value;
-	}
-	return r.peek = () => n.peek(), r.subscribe = (e) => n.subscribe(e), r;
+import { computed as preactComputed } from "@preact/signals-core";
+/**
+ * Creates a computed signal that derives its value from the provided function.
+ *
+ * @template T - The type of the value returned by the computed function.
+ * @param {() => T} fn - A function that returns the value for the computed signal.
+ * @returns {ReadonlySignal<T>} A readonly signal that provides the computed value.
+ *
+ * @example
+ * ```ts
+ * const myNumber = signal(42);
+ * const double = computed(() => myNumber() * 2);
+ * double() // 84
+ *
+ * myNumber(43);
+ * double() // 86
+ * ```
+ */ export function computed(fn) {
+    const innerComputed = preactComputed(fn);
+    function comp() {
+        return innerComputed.value;
+    }
+    comp.peek = ()=>innerComputed.peek();
+    comp.subscribe = (fn)=>innerComputed.subscribe(fn);
+    return comp;
 }
-//#endregion
-export { t as computed };
+
+//# sourceMappingURL=computed.js.map

package/dist/core/computed.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/computed.ts"],"sourcesContent":["import { computed as preactComputed } from '@preact/signals-core';\n\nimport type { ReadonlySignal, Subscriber, Unsubscribe } from './signal';\n\n/**\n * Creates a computed signal that derives its value from the provided function.\n *\n * @template T - The type of the value returned by the computed function.\n * @param {() => T} fn - A function that returns the value for the computed signal.\n * @returns {ReadonlySignal<T>} A readonly signal that provides the computed value.\n *\n * @example\n * ```ts\n * const myNumber = signal(42);\n * const double = computed(() => myNumber() * 2);\n * double() // 84\n *\n * myNumber(43);\n * double() // 86\n * ```\n */\nexport function computed<T>(fn: () => T): ReadonlySignal<T> {\n  const innerComputed = preactComputed(fn);\n  function comp(): T {\n    return innerComputed.value;\n  }\n  comp.peek = (): T => innerComputed.peek();\n  comp.subscribe = (fn: Subscriber<T>): Unsubscribe =>\n    innerComputed.subscribe(fn);\n  return comp;\n}\n"],"names":["computed","preactComputed","fn","innerComputed","comp","value","peek","subscribe"],"mappings":"AAAA,SAASA,YAAYC,cAAc,QAAQ,uBAAuB;AAIlE;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASD,SAAYE,EAAW;IACrC,MAAMC,gBAAgBF,eAAeC;IACrC,SAASE;QACP,OAAOD,cAAcE,KAAK;IAC5B;IACAD,KAAKE,IAAI,GAAG,IAASH,cAAcG,IAAI;IACvCF,KAAKG,SAAS,GAAG,CAACL,KAChBC,cAAcI,SAAS,CAACL;IAC1B,OAAOE;AACT"}

package/dist/core/effect.d.ts

@@ -1,33 +1,33 @@
 /**
- * Calls the provided function, first initially, and when a signal dependency changes.
- *
- * The provided function can optionally return a cleanup function that will run only once.
- * It will run when the effect is disposed or right before the next invocation of provided function.
- *
- * @param fn
- * @returns A method to dispose the effect.
- *
- * @example
- * ```ts
- * const mySignal = signal(42);
- * effect(() => {
- *  console.log(mySignal());
- * });
- * // 42 is logged
- *
- * mySignal(43);
- * // 43 is logged
- * ```
- *
- * @example
- * ```ts
- * // Cleanup
- * effect(() => {
- *   addEventListener('click', handler);
- *   return () => { removeEventListener('click', handler); };
- * });
- * ```
- */
+* Calls the provided function, first initially, and when a signal dependency changes.
+*
+* The provided function can optionally return a cleanup function that will run only once.
+* It will run when the effect is disposed or right before the next invocation of provided function.
+*
+* @param fn
+* @returns A method to dispose the effect.
+*
+* @example
+* ```ts
+* const mySignal = signal(42);
+* effect(() => {
+*  console.log(mySignal());
+* });
+* // 42 is logged
+*
+* mySignal(43);
+* // 43 is logged
+* ```
+*
+* @example
+* ```ts
+* // Cleanup
+* effect(() => {
+*   addEventListener('click', handler);
+*   return () => { removeEventListener('click', handler); };
+* });
+* ```
+*/
 export declare function effect(fn: EffectFn): Dispose;
 type Dispose = VoidFunction;
 type EffectFn = () => void | Dispose;

package/dist/core/effect.js

@@ -1,7 +1,35 @@
-import { effect as e } from "@preact/signals-core";
-//#region libs/shared/signal-utils/src/core/effect.ts
-function t(t) {
-	return e(t);
+import { effect as preactEffect } from "@preact/signals-core";
+/**
+ * Calls the provided function, first initially, and when a signal dependency changes.
+ *
+ * The provided function can optionally return a cleanup function that will run only once.
+ * It will run when the effect is disposed or right before the next invocation of provided function.
+ *
+ * @param fn
+ * @returns A method to dispose the effect.
+ *
+ * @example
+ * ```ts
+ * const mySignal = signal(42);
+ * effect(() => {
+ *  console.log(mySignal());
+ * });
+ * // 42 is logged
+ *
+ * mySignal(43);
+ * // 43 is logged
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Cleanup
+ * effect(() => {
+ *   addEventListener('click', handler);
+ *   return () => { removeEventListener('click', handler); };
+ * });
+ * ```
+ */ export function effect(fn) {
+    return preactEffect(fn);
 }
-//#endregion
-export { t as effect };
+
+//# sourceMappingURL=effect.js.map

package/dist/core/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/effect.ts"],"sourcesContent":["import { effect as preactEffect } from '@preact/signals-core';\n\n/**\n * Calls the provided function, first initially, and when a signal dependency changes.\n *\n * The provided function can optionally return a cleanup function that will run only once.\n * It will run when the effect is disposed or right before the next invocation of provided function.\n *\n * @param fn\n * @returns A method to dispose the effect.\n *\n * @example\n * ```ts\n * const mySignal = signal(42);\n * effect(() => {\n *  console.log(mySignal());\n * });\n * // 42 is logged\n *\n * mySignal(43);\n * // 43 is logged\n * ```\n *\n * @example\n * ```ts\n * // Cleanup\n * effect(() => {\n *   addEventListener('click', handler);\n *   return () => { removeEventListener('click', handler); };\n * });\n * ```\n */\nexport function effect(fn: EffectFn): Dispose {\n  return preactEffect(fn);\n}\n\ntype Dispose = VoidFunction;\ntype EffectFn = () => void | Dispose;\n"],"names":["effect","preactEffect","fn"],"mappings":"AAAA,SAASA,UAAUC,YAAY,QAAQ,uBAAuB;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BC,GACD,OAAO,SAASD,OAAOE,EAAY;IACjC,OAAOD,aAAaC;AACtB"}