@cognite/signal-utils 1.0.1 → 1.48535.0

package/dist/core/signal.d.ts

@@ -1,88 +1,88 @@
 declare const signalSymbol: unique symbol;
 /**
- * Represents a readonly signal that can be used to get the current value.
- *
- * @template T - The type of the signal value.
- */
+* Represents a readonly signal that can be used to get the current value.
+*
+* @template T - The type of the signal value.
+*/
 export type ReadonlySignal<T> = {
-    (): T;
-    /**
-     * Let you peek the signal value without taking dependency on the signal.
-     * Peeking is useful in scenarios where you want to read the value, but not update on value changes.
-     *
-     * @returns The current signal value.
-     */
-    peek(): T;
-    /**
-     * Subscribes to value changes. The provided function will be called once initially with the current value.
-     * @param fn The provided function will be invoked with a single argument, the newest signal value.
-     * @returns A function to unsubscribe.
-     */
-    subscribe: (fn: Subscriber<T>) => Unsubscribe;
+	(): T;
+	/**
+	* Let you peek the signal value without taking dependency on the signal.
+	* Peeking is useful in scenarios where you want to read the value, but not update on value changes.
+	*
+	* @returns The current signal value.
+	*/
+	peek(): T;
+	/**
+	* Subscribes to value changes. The provided function will be called once initially with the current value.
+	* @param fn The provided function will be invoked with a single argument, the newest signal value.
+	* @returns A function to unsubscribe.
+	*/
+	subscribe: (fn: Subscriber<T>) => Unsubscribe;
 };
 export type Subscriber<T> = (value: T) => void;
 export type Unsubscribe = VoidFunction;
 /**
- * Represents a signal that can be used to get and set the current value.
- *
- * @template T - The type of the signal value.
- */
+* Represents a signal that can be used to get and set the current value.
+*
+* @template T - The type of the signal value.
+*/
 export type Signal<T> = ReadonlySignal<T> & {
-    (value: T): void;
-    [signalSymbol]?: boolean;
+	(value: T): void;
+	[signalSymbol]?: boolean;
 };
 /**
- * Creates a new signal with an optional initial value.
- *
- * A signal is a reactive primitive that holds a value and can be used to track changes to that value.
- * The signal can be read by calling it as a function, and it can be updated by calling it with a new value.
- * The `peek` method can be used to read the current value without taking dependency on it.
- *
- * @template T - The type of the signal value.
- * @param {T} [value] - The initial value of the signal.
- * @returns {Signal<T | undefined> | Signal<T>} - The created signal.
- *
- * @example
- * ```ts
- * // Create a signal with an initial value
- * const mySignal = signal(42); // Will have the type Signal<number>
- * console.log(mySignal()); // 42
- * mySignal(43);
- * console.log(mySignal()); // 43
- * ```
- *
- * @example
- * ```ts
- * // Create a signal without an initial value
- * const mySignal = signal<string>(); // Will have the type Signal<string | undefined>
- * console.log(mySignal()); // undefined
- * mySignal('hello');
- * console.log(mySignal()); // 'hello'
- * ```
- *
- * @example
- * ```ts
- * // Peek the value without creating a dependency
- * const mySignal = signal(42);
- * mySignal.peek(); // 42
- * ```
- *
- * @example
- * ```ts
- * // Subscribe to value changes
- * const mySignal = signal(42);
- * mySignal.subscribe(console.log); // Logs 42
- * mySignal(43); // Logs 43
- * ```
- */
+* Creates a new signal with an optional initial value.
+*
+* A signal is a reactive primitive that holds a value and can be used to track changes to that value.
+* The signal can be read by calling it as a function, and it can be updated by calling it with a new value.
+* The `peek` method can be used to read the current value without taking dependency on it.
+*
+* @template T - The type of the signal value.
+* @param {T} [value] - The initial value of the signal.
+* @returns {Signal<T | undefined> | Signal<T>} - The created signal.
+*
+* @example
+* ```ts
+* // Create a signal with an initial value
+* const mySignal = signal(42); // Will have the type Signal<number>
+* console.log(mySignal()); // 42
+* mySignal(43);
+* console.log(mySignal()); // 43
+* ```
+*
+* @example
+* ```ts
+* // Create a signal without an initial value
+* const mySignal = signal<string>(); // Will have the type Signal<string | undefined>
+* console.log(mySignal()); // undefined
+* mySignal('hello');
+* console.log(mySignal()); // 'hello'
+* ```
+*
+* @example
+* ```ts
+* // Peek the value without creating a dependency
+* const mySignal = signal(42);
+* mySignal.peek(); // 42
+* ```
+*
+* @example
+* ```ts
+* // Subscribe to value changes
+* const mySignal = signal(42);
+* mySignal.subscribe(console.log); // Logs 42
+* mySignal(43); // Logs 43
+* ```
+*/
 export declare function signal<T>(): Signal<T | undefined>;
 export declare function signal<T>(value: T): Signal<T>;
 /**
- * Checks if the given value is a Signal.
- *
- * @template T - The value type of the signal.
- * @param value - The value to check.
- * @returns A boolean indicating whether the value is a Signal.
- */
+* Checks if the given value is a Signal.
+*
+* @template T - The value type of the signal.
+* @param value - The value to check.
+* @returns A boolean indicating whether the value is a Signal.
+*/
 export declare function isSignal<T>(value: unknown): value is Signal<T>;
 export {};

package/dist/core/signal.js

@@ -1,19 +1,27 @@
-import { signal as e } from "@preact/signals-core";
-//#region libs/shared/signal-utils/src/core/signal.ts
-var t = Symbol("signal");
-function n(n) {
-	let r = e(n);
-	function i(e) {
-		if (arguments.length === 1) {
-			r.value = e;
-			return;
-		}
-		return r.value;
-	}
-	return i[t] = !0, i.peek = () => r.peek(), i.subscribe = (e) => r.subscribe(e), i;
+import { signal as preactSignal } from "@preact/signals-core";
+const signalSymbol = Symbol('signal');
+export function signal(value) {
+    const innerSignal = preactSignal(value);
+    function fn(newValue) {
+        if (arguments.length === 1) {
+            innerSignal.value = newValue;
+            return;
+        }
+        return innerSignal.value;
+    }
+    fn[signalSymbol] = true;
+    fn.peek = ()=>innerSignal.peek();
+    fn.subscribe = (fn)=>innerSignal.subscribe(fn);
+    return fn;
 }
-function r(e) {
-	return typeof e == "function" && t in e;
+/**
+ * Checks if the given value is a Signal.
+ *
+ * @template T - The value type of the signal.
+ * @param value - The value to check.
+ * @returns A boolean indicating whether the value is a Signal.
+ */ export function isSignal(value) {
+    return typeof value === 'function' && signalSymbol in value;
 }
-//#endregion
-export { r as isSignal, n as signal };
+
+//# sourceMappingURL=signal.js.map

package/dist/core/signal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/signal.ts"],"sourcesContent":["import { signal as preactSignal } from '@preact/signals-core';\n\nconst signalSymbol: unique symbol = Symbol('signal');\n\n/**\n * Represents a readonly signal that can be used to get the current value.\n *\n * @template T - The type of the signal value.\n */\nexport type ReadonlySignal<T> = {\n  (): T;\n  /**\n   * Let you peek the signal value without taking dependency on the signal.\n   * Peeking is useful in scenarios where you want to read the value, but not update on value changes.\n   *\n   * @returns The current signal value.\n   */\n  peek(): T;\n  /**\n   * Subscribes to value changes. The provided function will be called once initially with the current value.\n   * @param fn The provided function will be invoked with a single argument, the newest signal value.\n   * @returns A function to unsubscribe.\n   */\n  subscribe: (fn: Subscriber<T>) => Unsubscribe;\n};\n\nexport type Subscriber<T> = (value: T) => void;\nexport type Unsubscribe = VoidFunction;\n\n/**\n * Represents a signal that can be used to get and set the current value.\n *\n * @template T - The type of the signal value.\n */\nexport type Signal<T> = ReadonlySignal<T> & {\n  (value: T): void;\n  [signalSymbol]?: boolean;\n};\n\n/**\n * Creates a new signal with an optional initial value.\n *\n * A signal is a reactive primitive that holds a value and can be used to track changes to that value.\n * The signal can be read by calling it as a function, and it can be updated by calling it with a new value.\n * The `peek` method can be used to read the current value without taking dependency on it.\n *\n * @template T - The type of the signal value.\n * @param {T} [value] - The initial value of the signal.\n * @returns {Signal<T | undefined> | Signal<T>} - The created signal.\n *\n * @example\n * ```ts\n * // Create a signal with an initial value\n * const mySignal = signal(42); // Will have the type Signal<number>\n * console.log(mySignal()); // 42\n * mySignal(43);\n * console.log(mySignal()); // 43\n * ```\n *\n * @example\n * ```ts\n * // Create a signal without an initial value\n * const mySignal = signal<string>(); // Will have the type Signal<string | undefined>\n * console.log(mySignal()); // undefined\n * mySignal('hello');\n * console.log(mySignal()); // 'hello'\n * ```\n *\n * @example\n * ```ts\n * // Peek the value without creating a dependency\n * const mySignal = signal(42);\n * mySignal.peek(); // 42\n * ```\n *\n * @example\n * ```ts\n * // Subscribe to value changes\n * const mySignal = signal(42);\n * mySignal.subscribe(console.log); // Logs 42\n * mySignal(43); // Logs 43\n * ```\n */\nexport function signal<T>(): Signal<T | undefined>;\nexport function signal<T>(value: T): Signal<T>;\nexport function signal<T>(value?: T): Signal<T | undefined> | Signal<T> {\n  const innerSignal = preactSignal(value as T);\n\n  function fn(): T; // Getter\n  function fn(newValue: T): void; // Setter\n  function fn(newValue?: T): T | void {\n    if (arguments.length === 1) {\n      innerSignal.value = newValue as T;\n      return;\n    }\n    return innerSignal.value;\n  }\n\n  fn[signalSymbol] = true;\n  fn.peek = (): T => innerSignal.peek();\n  fn.subscribe = (fn: Subscriber<T>): Unsubscribe => innerSignal.subscribe(fn);\n\n  return fn;\n}\n\n/**\n * Checks if the given value is a Signal.\n *\n * @template T - The value type of the signal.\n * @param value - The value to check.\n * @returns A boolean indicating whether the value is a Signal.\n */\nexport function isSignal<T>(value: unknown): value is Signal<T> {\n  return typeof value === 'function' && signalSymbol in value;\n}\n"],"names":["signal","preactSignal","signalSymbol","Symbol","value","innerSignal","fn","newValue","arguments","length","peek","subscribe","isSignal"],"mappings":"AAAA,SAASA,UAAUC,YAAY,QAAQ,uBAAuB;AAE9D,MAAMC,eAA8BC,OAAO;AAmF3C,OAAO,SAASH,OAAUI,KAAS;IACjC,MAAMC,cAAcJ,aAAaG;IAIjC,SAASE,GAAGC,QAAY;QACtB,IAAIC,UAAUC,MAAM,KAAK,GAAG;YAC1BJ,YAAYD,KAAK,GAAGG;YACpB;QACF;QACA,OAAOF,YAAYD,KAAK;IAC1B;IAEAE,EAAE,CAACJ,aAAa,GAAG;IACnBI,GAAGI,IAAI,GAAG,IAASL,YAAYK,IAAI;IACnCJ,GAAGK,SAAS,GAAG,CAACL,KAAmCD,YAAYM,SAAS,CAACL;IAEzE,OAAOA;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASM,SAAYR,KAAc;IACxC,OAAO,OAAOA,UAAU,cAAcF,gBAAgBE;AACxD"}

package/dist/core/untracked.d.ts

@@ -1,28 +1,28 @@
 /**
- * Calls the provided function, without taking dependency on any signals called within it.
- * @param fn
- * @returns The value returned from `fn`.
- *
- * @example
- * ```ts
- * const signalA = signal('A');
- * const signalB = signal('B');
- *
- * function someFunction() {
- *   console.log(signalB());
- * }
- *
- * effect(() => {
- *   console.log(signalA());
- *   untracked(someFunction);
- * })
- * // A & B is logged
- *
- * signalA('A2');
- * // A2 & B is logged
- *
- * signalB('B2');
- * // Nothing is logged as we didn't take a dependency on signalB
- * ```
- */
+* Calls the provided function, without taking dependency on any signals called within it.
+* @param fn
+* @returns The value returned from `fn`.
+*
+* @example
+* ```ts
+* const signalA = signal('A');
+* const signalB = signal('B');
+*
+* function someFunction() {
+*   console.log(signalB());
+* }
+*
+* effect(() => {
+*   console.log(signalA());
+*   untracked(someFunction);
+* })
+* // A & B is logged
+*
+* signalA('A2');
+* // A2 & B is logged
+*
+* signalB('B2');
+* // Nothing is logged as we didn't take a dependency on signalB
+* ```
+*/
 export declare function untracked<T>(fn: () => T): T;

package/dist/core/untracked.js

@@ -1,7 +1,32 @@
-import { untracked as e } from "@preact/signals-core";
-//#region libs/shared/signal-utils/src/core/untracked.ts
-function t(t) {
-	return e(t);
+import { untracked as preactUntracked } from "@preact/signals-core";
+/**
+ * Calls the provided function, without taking dependency on any signals called within it.
+ * @param fn
+ * @returns The value returned from `fn`.
+ *
+ * @example
+ * ```ts
+ * const signalA = signal('A');
+ * const signalB = signal('B');
+ *
+ * function someFunction() {
+ *   console.log(signalB());
+ * }
+ *
+ * effect(() => {
+ *   console.log(signalA());
+ *   untracked(someFunction);
+ * })
+ * // A & B is logged
+ *
+ * signalA('A2');
+ * // A2 & B is logged
+ *
+ * signalB('B2');
+ * // Nothing is logged as we didn't take a dependency on signalB
+ * ```
+ */ export function untracked(fn) {
+    return preactUntracked(fn);
 }
-//#endregion
-export { t as untracked };
+
+//# sourceMappingURL=untracked.js.map

package/dist/core/untracked.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/untracked.ts"],"sourcesContent":["import { untracked as preactUntracked } from '@preact/signals-core';\n\n/**\n * Calls the provided function, without taking dependency on any signals called within it.\n * @param fn\n * @returns The value returned from `fn`.\n *\n * @example\n * ```ts\n * const signalA = signal('A');\n * const signalB = signal('B');\n *\n * function someFunction() {\n *   console.log(signalB());\n * }\n *\n * effect(() => {\n *   console.log(signalA());\n *   untracked(someFunction);\n * })\n * // A & B is logged\n *\n * signalA('A2');\n * // A2 & B is logged\n *\n * signalB('B2');\n * // Nothing is logged as we didn't take a dependency on signalB\n * ```\n */\nexport function untracked<T>(fn: () => T): T {\n  return preactUntracked(fn);\n}\n"],"names":["untracked","preactUntracked","fn"],"mappings":"AAAA,SAASA,aAAaC,eAAe,QAAQ,uBAAuB;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GACD,OAAO,SAASD,UAAaE,EAAW;IACtC,OAAOD,gBAAgBC;AACzB"}

package/dist/extensions/fragmentSignal.d.ts

@@ -1,89 +1,89 @@
-import { Signal } from '../core/signal';
+import type { Signal } from "../core/signal";
 export type FragmentSignal<T> = Signal<T> & {
-    dispose: () => void;
+	dispose: () => void;
 };
 /**
- * Creates a signal that synchronizes its value with the URL hash fragment.
- *
- * This function creates a reactive signal that automatically reads from and writes to
- * the URL hash fragment (the part after `#`). When the signal value changes, the URL
- * hash is updated. When the URL hash changes (e.g., via browser navigation), the
- * signal value is updated accordingly.
- *
- * @template T - The type of the value stored in the signal
- *
- * @param key - The parameter name to use in the URL hash fragment
- * @param defaultValue - The default value to use when the URL parameter is not present
- * @param serialize - Optional function to serialize the value to a string. Defaults to `JSON.stringify`
- * @param deserialize - Optional function to deserialize a string to a value. Defaults to `JSON.parse`
- *
- * @returns A signal that synchronizes with the URL hash fragment, including a `dispose()` method to clean up event listeners
- *
- * @example
- * ```ts
- * // Basic usage with a default value
- * const pageSignal = fragmentSignal('page', 1);
- *
- * // Read the current value
- * console.log(pageSignal()); // 1 (or value from URL if present)
- *
- * // Update the value (also updates URL to #page=2)
- * pageSignal(2);
- *
- * // Clear the value (removes from URL and resets to default)
- * pageSignal(null);
- *
- * // Clean up when done
- * pageSignal.dispose();
- * ```
- *
- * @example
- * ```ts
- * // Usage without default value (signal will be undefined if not in URL)
- * const optionalSignal = fragmentSignal<string>('filter');
- *
- * console.log(optionalSignal()); // undefined (if not in URL)
- * optionalSignal('active'); // Sets URL to #filter=active
- * optionalSignal(undefined); // Removes from URL
- * ```
- *
- * @example
- * ```ts
- * // Custom serialization for complex objects
- * interface Filter {
- *   category: string;
- *   priceRange: [number, number];
- * }
- *
- * const filterSignal = fragmentSignal<Filter>(
- *   'filter',
- *   { category: 'all', priceRange: [0, 100] },
- *   (filter) => btoa(JSON.stringify(filter)), // Base64 encode
- *   (str) => JSON.parse(atob(str)) // Base64 decode
- * );
- * ```
- *
- * @example
- * ```ts
- * // Multiple fragment signals can coexist
- * const searchSignal = fragmentSignal('q', '');
- * const sortSignal = fragmentSignal('sort', 'name');
- *
- * searchSignal('react');
- * sortSignal('date');
- * // URL becomes: #q=react&sort=date
- * ```
- *
- * @remarks
- * - The signal automatically listens to `hashchange` events and updates accordingly
- * - Setting the signal to `null` or `undefined` resets the parameter to the default value.
- *   If it is initialized without a default value, then it will remove the hash key from the URL.
- * - The URL hash uses `URLSearchParams` format for encoding multiple parameters
- * - The signal persists across page reloads as long as the URL hash remains
- * - Call `dispose()` on the returned signal to remove the `hashchange` event listener when no longer needed
- * - Two overloads are available:
- *   1. With default value: `fragmentSignal(key, defaultValue, serialize?, deserialize?)` - returns `Signal<T>`
- *   2. Without default value: `fragmentSignal(key, serialize?, deserialize?)` - returns `Signal<T | undefined>`
- */
+* Creates a signal that synchronizes its value with the URL hash fragment.
+*
+* This function creates a reactive signal that automatically reads from and writes to
+* the URL hash fragment (the part after `#`). When the signal value changes, the URL
+* hash is updated. When the URL hash changes (e.g., via browser navigation), the
+* signal value is updated accordingly.
+*
+* @template T - The type of the value stored in the signal
+*
+* @param key - The parameter name to use in the URL hash fragment
+* @param defaultValue - The default value to use when the URL parameter is not present
+* @param serialize - Optional function to serialize the value to a string. Defaults to `JSON.stringify`
+* @param deserialize - Optional function to deserialize a string to a value. Defaults to `JSON.parse`
+*
+* @returns A signal that synchronizes with the URL hash fragment, including a `dispose()` method to clean up event listeners
+*
+* @example
+* ```ts
+* // Basic usage with a default value
+* const pageSignal = fragmentSignal('page', 1);
+*
+* // Read the current value
+* console.log(pageSignal()); // 1 (or value from URL if present)
+*
+* // Update the value (also updates URL to #page=2)
+* pageSignal(2);
+*
+* // Clear the value (removes from URL and resets to default)
+* pageSignal(null);
+*
+* // Clean up when done
+* pageSignal.dispose();
+* ```
+*
+* @example
+* ```ts
+* // Usage without default value (signal will be undefined if not in URL)
+* const optionalSignal = fragmentSignal<string>('filter');
+*
+* console.log(optionalSignal()); // undefined (if not in URL)
+* optionalSignal('active'); // Sets URL to #filter=active
+* optionalSignal(undefined); // Removes from URL
+* ```
+*
+* @example
+* ```ts
+* // Custom serialization for complex objects
+* interface Filter {
+*   category: string;
+*   priceRange: [number, number];
+* }
+*
+* const filterSignal = fragmentSignal<Filter>(
+*   'filter',
+*   { category: 'all', priceRange: [0, 100] },
+*   (filter) => btoa(JSON.stringify(filter)), // Base64 encode
+*   (str) => JSON.parse(atob(str)) // Base64 decode
+* );
+* ```
+*
+* @example
+* ```ts
+* // Multiple fragment signals can coexist
+* const searchSignal = fragmentSignal('q', '');
+* const sortSignal = fragmentSignal('sort', 'name');
+*
+* searchSignal('react');
+* sortSignal('date');
+* // URL becomes: #q=react&sort=date
+* ```
+*
+* @remarks
+* - The signal automatically listens to `hashchange` events and updates accordingly
+* - Setting the signal to `null` or `undefined` resets the parameter to the default value.
+*   If it is initialized without a default value, then it will remove the hash key from the URL.
+* - The URL hash uses `URLSearchParams` format for encoding multiple parameters
+* - The signal persists across page reloads as long as the URL hash remains
+* - Call `dispose()` on the returned signal to remove the `hashchange` event listener when no longer needed
+* - Two overloads are available:
+*   1. With default value: `fragmentSignal(key, defaultValue, serialize?, deserialize?)` - returns `Signal<T>`
+*   2. Without default value: `fragmentSignal(key, serialize?, deserialize?)` - returns `Signal<T | undefined>`
+*/
 export declare function fragmentSignal<T extends NonNullable<unknown>>(key: string, defaultValue: T, serialize?: (value: T) => string, deserialize?: (hashString: string) => T): FragmentSignal<T>;
 export declare function fragmentSignal<T>(key: string, serialize?: (value: T) => string, deserialize?: (hashString: string) => T): FragmentSignal<T | undefined | null>;

package/dist/extensions/fragmentSignal.js

@@ -1,21 +1,39 @@
-import { signal as e } from "../core/signal.js";
-//#region libs/shared/signal-utils/src/extensions/fragmentSignal.ts
-function t(t, n, r = JSON.stringify, i = JSON.parse) {
-	let a = u().get(t), o = a === null ? n : i(a), s = e(o), c = new AbortController();
-	window.addEventListener("hashchange", () => {
-		let e = u().get(t), r = e === null ? n : i(e);
-		s(r);
-	}, { signal: c.signal });
-	let l = new Proxy(s, { apply: function(e, n, i) {
-		if (i.length === 0) return Reflect.apply(e, n, i);
-		let a = u(), o = i[0];
-		return o == null ? a.delete(t) : a.set(t, r(o)), window.location.hash = a.toString(), o;
-	} });
-	return Object.assign(l, { dispose: () => c.abort() });
-	function u() {
-		let e = window.location.hash.substring(1);
-		return new URLSearchParams(e);
-	}
+import { signal } from "../core/signal.js";
+export function fragmentSignal(key, defaultValue, serialize = JSON.stringify, deserialize = JSON.parse) {
+    const urlParam = getHashParams().get(key);
+    const defaultSignalValue = urlParam !== null ? deserialize(urlParam) : defaultValue;
+    const backingSignal = signal(defaultSignalValue);
+    const abortController = new AbortController();
+    window.addEventListener('hashchange', ()=>{
+        const urlParam = getHashParams().get(key);
+        const newValue = urlParam !== null ? deserialize(urlParam) : defaultValue;
+        backingSignal(newValue);
+    }, {
+        signal: abortController.signal
+    });
+    const proxySignal = new Proxy(backingSignal, {
+        apply: function(target, thisArg, argList) {
+            if (argList.length === 0) {
+                return Reflect.apply(target, thisArg, argList);
+            }
+            const newHashParams = getHashParams();
+            const value = argList[0];
+            if (value === undefined || value === null) {
+                newHashParams.delete(key);
+            } else {
+                newHashParams.set(key, serialize(value));
+            }
+            window.location.hash = newHashParams.toString();
+            return value;
+        }
+    });
+    return Object.assign(proxySignal, {
+        dispose: ()=>abortController.abort()
+    });
+    function getHashParams() {
+        const currentHashString = window.location.hash.substring(1);
+        return new URLSearchParams(currentHashString);
+    }
 }
-//#endregion
-export { t as fragmentSignal };
+
+//# sourceMappingURL=fragmentSignal.js.map

package/dist/extensions/fragmentSignal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/extensions/fragmentSignal.ts"],"sourcesContent":["import type { Signal } from '../core/signal';\nimport { signal } from '../core/signal';\n\nexport type FragmentSignal<T> = Signal<T> & {\n  dispose: () => void;\n};\n\n/**\n * Creates a signal that synchronizes its value with the URL hash fragment.\n *\n * This function creates a reactive signal that automatically reads from and writes to\n * the URL hash fragment (the part after `#`). When the signal value changes, the URL\n * hash is updated. When the URL hash changes (e.g., via browser navigation), the\n * signal value is updated accordingly.\n *\n * @template T - The type of the value stored in the signal\n *\n * @param key - The parameter name to use in the URL hash fragment\n * @param defaultValue - The default value to use when the URL parameter is not present\n * @param serialize - Optional function to serialize the value to a string. Defaults to `JSON.stringify`\n * @param deserialize - Optional function to deserialize a string to a value. Defaults to `JSON.parse`\n *\n * @returns A signal that synchronizes with the URL hash fragment, including a `dispose()` method to clean up event listeners\n *\n * @example\n * ```ts\n * // Basic usage with a default value\n * const pageSignal = fragmentSignal('page', 1);\n *\n * // Read the current value\n * console.log(pageSignal()); // 1 (or value from URL if present)\n *\n * // Update the value (also updates URL to #page=2)\n * pageSignal(2);\n *\n * // Clear the value (removes from URL and resets to default)\n * pageSignal(null);\n *\n * // Clean up when done\n * pageSignal.dispose();\n * ```\n *\n * @example\n * ```ts\n * // Usage without default value (signal will be undefined if not in URL)\n * const optionalSignal = fragmentSignal<string>('filter');\n *\n * console.log(optionalSignal()); // undefined (if not in URL)\n * optionalSignal('active'); // Sets URL to #filter=active\n * optionalSignal(undefined); // Removes from URL\n * ```\n *\n * @example\n * ```ts\n * // Custom serialization for complex objects\n * interface Filter {\n *   category: string;\n *   priceRange: [number, number];\n * }\n *\n * const filterSignal = fragmentSignal<Filter>(\n *   'filter',\n *   { category: 'all', priceRange: [0, 100] },\n *   (filter) => btoa(JSON.stringify(filter)), // Base64 encode\n *   (str) => JSON.parse(atob(str)) // Base64 decode\n * );\n * ```\n *\n * @example\n * ```ts\n * // Multiple fragment signals can coexist\n * const searchSignal = fragmentSignal('q', '');\n * const sortSignal = fragmentSignal('sort', 'name');\n *\n * searchSignal('react');\n * sortSignal('date');\n * // URL becomes: #q=react&sort=date\n * ```\n *\n * @remarks\n * - The signal automatically listens to `hashchange` events and updates accordingly\n * - Setting the signal to `null` or `undefined` resets the parameter to the default value.\n *   If it is initialized without a default value, then it will remove the hash key from the URL.\n * - The URL hash uses `URLSearchParams` format for encoding multiple parameters\n * - The signal persists across page reloads as long as the URL hash remains\n * - Call `dispose()` on the returned signal to remove the `hashchange` event listener when no longer needed\n * - Two overloads are available:\n *   1. With default value: `fragmentSignal(key, defaultValue, serialize?, deserialize?)` - returns `Signal<T>`\n *   2. Without default value: `fragmentSignal(key, serialize?, deserialize?)` - returns `Signal<T | undefined>`\n */\nexport function fragmentSignal<T extends NonNullable<unknown>>(\n  key: string,\n  defaultValue: T,\n  serialize?: (value: T) => string,\n  deserialize?: (hashString: string) => T\n): FragmentSignal<T>;\nexport function fragmentSignal<T>(\n  key: string,\n  serialize?: (value: T) => string,\n  deserialize?: (hashString: string) => T\n): FragmentSignal<T | undefined | null>;\nexport function fragmentSignal<T>(\n  key: string,\n  defaultValue?: T,\n  serialize: (value: T) => string = JSON.stringify,\n  deserialize: (hashString: string) => T = JSON.parse\n): FragmentSignal<T | undefined> {\n  const urlParam = getHashParams().get(key);\n  const defaultSignalValue =\n    urlParam !== null ? deserialize(urlParam) : defaultValue;\n  const backingSignal = signal(defaultSignalValue);\n\n  const abortController = new AbortController();\n\n  window.addEventListener(\n    'hashchange',\n    () => {\n      const urlParam = getHashParams().get(key);\n      const newValue = urlParam !== null ? deserialize(urlParam) : defaultValue;\n      backingSignal(newValue);\n    },\n    {\n      signal: abortController.signal,\n    }\n  );\n\n  const proxySignal = new Proxy(backingSignal, {\n    apply: function (target, thisArg, argList): unknown {\n      if (argList.length === 0) {\n        return Reflect.apply(target, thisArg, argList);\n      }\n      const newHashParams = getHashParams();\n      const value = argList[0];\n      if (value === undefined || value === null) {\n        newHashParams.delete(key);\n      } else {\n        newHashParams.set(key, serialize(value));\n      }\n      window.location.hash = newHashParams.toString();\n      return value;\n    },\n  });\n\n  return Object.assign(proxySignal, {\n    dispose: () => abortController.abort(),\n  });\n\n  function getHashParams(): URLSearchParams {\n    const currentHashString = window.location.hash.substring(1);\n    return new URLSearchParams(currentHashString);\n  }\n}\n"],"names":["signal","fragmentSignal","key","defaultValue","serialize","JSON","stringify","deserialize","parse","urlParam","getHashParams","get","defaultSignalValue","backingSignal","abortController","AbortController","window","addEventListener","newValue","proxySignal","Proxy","apply","target","thisArg","argList","length","Reflect","newHashParams","value","undefined","delete","set","location","hash","toString","Object","assign","dispose","abort","currentHashString","substring","URLSearchParams"],"mappings":"AACA,SAASA,MAAM,QAAQ,oBAAiB;AAoGxC,OAAO,SAASC,eACdC,GAAW,EACXC,YAAgB,EAChBC,YAAkCC,KAAKC,SAAS,EAChDC,cAAyCF,KAAKG,KAAK;IAEnD,MAAMC,WAAWC,gBAAgBC,GAAG,CAACT;IACrC,MAAMU,qBACJH,aAAa,OAAOF,YAAYE,YAAYN;IAC9C,MAAMU,gBAAgBb,OAAOY;IAE7B,MAAME,kBAAkB,IAAIC;IAE5BC,OAAOC,gBAAgB,CACrB,cACA;QACE,MAAMR,WAAWC,gBAAgBC,GAAG,CAACT;QACrC,MAAMgB,WAAWT,aAAa,OAAOF,YAAYE,YAAYN;QAC7DU,cAAcK;IAChB,GACA;QACElB,QAAQc,gBAAgBd,MAAM;IAChC;IAGF,MAAMmB,cAAc,IAAIC,MAAMP,eAAe;QAC3CQ,OAAO,SAAUC,MAAM,EAAEC,OAAO,EAAEC,OAAO;YACvC,IAAIA,QAAQC,MAAM,KAAK,GAAG;gBACxB,OAAOC,QAAQL,KAAK,CAACC,QAAQC,SAASC;YACxC;YACA,MAAMG,gBAAgBjB;YACtB,MAAMkB,QAAQJ,OAAO,CAAC,EAAE;YACxB,IAAII,UAAUC,aAAaD,UAAU,MAAM;gBACzCD,cAAcG,MAAM,CAAC5B;YACvB,OAAO;gBACLyB,cAAcI,GAAG,CAAC7B,KAAKE,UAAUwB;YACnC;YACAZ,OAAOgB,QAAQ,CAACC,IAAI,GAAGN,cAAcO,QAAQ;YAC7C,OAAON;QACT;IACF;IAEA,OAAOO,OAAOC,MAAM,CAACjB,aAAa;QAChCkB,SAAS,IAAMvB,gBAAgBwB,KAAK;IACtC;IAEA,SAAS5B;QACP,MAAM6B,oBAAoBvB,OAAOgB,QAAQ,CAACC,IAAI,CAACO,SAAS,CAAC;QACzD,OAAO,IAAIC,gBAAgBF;IAC7B;AACF"}

package/dist/extensions.d.ts

@@ -1 +1 @@
-export { fragmentSignal, type FragmentSignal, } from './extensions/fragmentSignal';
+export { fragmentSignal, type FragmentSignal } from "./extensions/fragmentSignal";

package/dist/extensions.js

@@ -1,2 +1,3 @@
-import { fragmentSignal as e } from "./extensions/fragmentSignal.js";
-export { e as fragmentSignal };
+export { fragmentSignal } from "./extensions/fragmentSignal.js";
+
+//# sourceMappingURL=extensions.js.map

package/dist/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extensions.ts"],"sourcesContent":["export {\n  fragmentSignal,\n  type FragmentSignal,\n} from './extensions/fragmentSignal';\n"],"names":["fragmentSignal"],"mappings":"AAAA,SACEA,cAAc,QAET,iCAA8B"}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-export { arraySignal, isArraySignal } from './core/array-signal';
-export { batch } from './core/batch';
-export { computed } from './core/computed';
-export { debouncedComputed } from './misc/debounced-computed';
-export { effect } from './core/effect';
-export { signal, isSignal } from './core/signal';
-export { untracked } from './core/untracked';
-export type { ArraySignal, ReadonlyArraySignal } from './core/array-signal';
-export type { DebouncedComputed } from './misc/debounced-computed';
-export type { Signal, ReadonlySignal } from './core/signal';
+export { arraySignal, isArraySignal } from "./core/array-signal";
+export { batch } from "./core/batch";
+export { computed } from "./core/computed";
+export { debouncedComputed } from "./misc/debounced-computed";
+export { effect } from "./core/effect";
+export { signal, isSignal } from "./core/signal";
+export { untracked } from "./core/untracked";
+export type { ArraySignal, ReadonlyArraySignal } from "./core/array-signal";
+export type { DebouncedComputed } from "./misc/debounced-computed";
+export type { Signal, ReadonlySignal } from "./core/signal";

package/dist/index.js

@@ -1,8 +1,9 @@
-import { isSignal as e, signal as t } from "./core/signal.js";
-import { arraySignal as n, isArraySignal as r } from "./core/array-signal.js";
-import { batch as i } from "./core/batch.js";
-import { computed as a } from "./core/computed.js";
-import { effect as o } from "./core/effect.js";
-import { debouncedComputed as s } from "./misc/debounced-computed.js";
-import { untracked as c } from "./core/untracked.js";
-export { n as arraySignal, i as batch, a as computed, s as debouncedComputed, o as effect, r as isArraySignal, e as isSignal, t as signal, c as untracked };
+export { arraySignal, isArraySignal } from "./core/array-signal.js";
+export { batch } from "./core/batch.js";
+export { computed } from "./core/computed.js";
+export { debouncedComputed } from "./misc/debounced-computed.js";
+export { effect } from "./core/effect.js";
+export { signal, isSignal } from "./core/signal.js";
+export { untracked } from "./core/untracked.js";
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { arraySignal, isArraySignal } from './core/array-signal';\nexport { batch } from './core/batch';\nexport { computed } from './core/computed';\nexport { debouncedComputed } from './misc/debounced-computed';\nexport { effect } from './core/effect';\nexport { signal, isSignal } from './core/signal';\nexport { untracked } from './core/untracked';\nexport type { ArraySignal, ReadonlyArraySignal } from './core/array-signal';\nexport type { DebouncedComputed } from './misc/debounced-computed';\nexport type { Signal, ReadonlySignal } from './core/signal';\n"],"names":["arraySignal","isArraySignal","batch","computed","debouncedComputed","effect","signal","isSignal","untracked"],"mappings":"AAAA,SAASA,WAAW,EAAEC,aAAa,QAAQ,yBAAsB;AACjE,SAASC,KAAK,QAAQ,kBAAe;AACrC,SAASC,QAAQ,QAAQ,qBAAkB;AAC3C,SAASC,iBAAiB,QAAQ,+BAA4B;AAC9D,SAASC,MAAM,QAAQ,mBAAgB;AACvC,SAASC,MAAM,EAAEC,QAAQ,QAAQ,mBAAgB;AACjD,SAASC,SAAS,QAAQ,sBAAmB"}