@mmstack/primitives 19.2.3 → 19.3.0

package/lib/sensors/sensor.d.ts

@@ -1,8 +1,85 @@
-import { Signal } from '@angular/core';
-import { MousePositionOptions, MousePositionSignal } from './mouse-position';
-import { NetworkStatusSignal } from './network-status';
-import { ScrollPositionOptions, ScrollPositionSignal } from './scroll-position';
-import { WindowSizeOptions, WindowSizeSignal } from './window-size';
+import { type ElementRef, type Signal } from '@angular/core';
+import { type ElementSizeOptions as BaseElementSizeOptions, type ElementSizeSignal } from './element-size';
+import { type ElementVisibilityOptions as BaseElementVisibilityOptions, type ElementVisibilitySignal } from './element-visibility';
+import { type MousePositionOptions, type MousePositionSignal } from './mouse-position';
+import { type NetworkStatusSignal } from './network-status';
+import { type ScrollPositionOptions, type ScrollPositionSignal } from './scroll-position';
+import { type WindowSizeOptions, type WindowSizeSignal } from './window-size';
+type SensorTypedOptions = {
+    elementVisibility: {
+        opt: BaseElementVisibilityOptions & {
+            target?: ElementRef<Element> | Element | Signal<ElementRef<Element> | Element | null>;
+        };
+        returnType: ElementVisibilitySignal;
+    };
+    elementSize: {
+        opt: BaseElementSizeOptions & {
+            target?: ElementRef<Element> | Element | Signal<ElementRef<Element> | Element | null>;
+        };
+        returnType: ElementSizeSignal;
+    };
+    mousePosition: {
+        opt: MousePositionOptions;
+        returnType: MousePositionSignal;
+    };
+    networkStatus: {
+        opt: {
+            debugName?: string;
+        };
+        returnType: NetworkStatusSignal;
+    };
+    pageVisibility: {
+        opt: {
+            debugName?: string;
+        };
+        returnType: Signal<DocumentVisibilityState>;
+    };
+    darkMode: {
+        opt: {
+            debugName?: string;
+        };
+        returnType: Signal<boolean>;
+    };
+    reducedMotion: {
+        opt: {
+            debugName?: string;
+        };
+        returnType: Signal<boolean>;
+    };
+    scrollPosition: {
+        opt: ScrollPositionOptions;
+        returnType: ScrollPositionSignal;
+    };
+    windowSize: {
+        opt: WindowSizeOptions;
+        returnType: WindowSizeSignal;
+    };
+    mediaQuery: {
+        opt: {
+            query: string;
+            debugName?: string;
+        };
+        returnType: Signal<boolean>;
+    };
+};
+/**
+ * Creates a sensor signal that the elements visiblity within the viewport
+ * @param type Must be `'elementVisibility'`.
+ * @param options Optional configuration IntersectionObserver & target.
+ * @returns A `ElementVisibilitySignal` that tracks whether the Element is intersected.
+ * @see {elementVisibility} for detailed documentation and examples.
+ * @example const pos = sensor('elementVisibility');
+ */
+export declare function sensor(type: 'elementVisibility', options?: SensorTypedOptions['elementVisibility']['opt']): ElementVisibilitySignal;
+/**
+ * Creates a sensor signal that tracks the element's size dimensions.
+ * @param type Must be `'elementSize'`.
+ * @param options Optional configuration ResizeObserver & target.
+ * @returns A `ElementSizeSignal` that tracks the element's size ({ width, height }).
+ * @see {elementSize} for detailed documentation and examples.
+ * @example const size = sensor('elementSize');
+ */
+export declare function sensor(type: 'elementSize', options?: SensorTypedOptions['elementSize']['opt']): ElementSizeSignal;
 /**
  * Creates a sensor signal that tracks the mouse cursor's position.
  * @param type Must be `'mousePosition'`.
@@ -11,7 +88,7 @@ import { WindowSizeOptions, WindowSizeSignal } from './window-size';
  * @see {mousePosition} for detailed documentation and examples.
  * @example const pos = sensor('mousePosition', { coordinateSpace: 'page', throttle: 50 });
  */
-export declare function sensor(type: 'mousePosition', options?: MousePositionOptions): MousePositionSignal;
+export declare function sensor(type: 'mousePosition', options?: SensorTypedOptions['mousePosition']['opt']): MousePositionSignal;
 /**
  * Creates a sensor signal that tracks the browser's online/offline status.
  * @param type Must be `'networkStatus'`.
@@ -20,9 +97,7 @@ export declare function sensor(type: 'mousePosition', options?: MousePositionOpt
  * @see {networkStatus} for detailed documentation and examples.
  * @example const onlineStatus = sensor('networkStatus');
  */
-export declare function sensor(type: 'networkStatus', options?: {
-    debugName?: string;
-}): NetworkStatusSignal;
+export declare function sensor(type: 'networkStatus', options?: SensorTypedOptions['networkStatus']['opt']): NetworkStatusSignal;
 /**
  * Creates a sensor signal that tracks the page's visibility state (e.g., 'visible', 'hidden').
  * @param type Must be `'pageVisibility'`.
@@ -31,31 +106,34 @@ export declare function sensor(type: 'networkStatus', options?: {
  * @see {pageVisibility} for detailed documentation and examples.
  * @example const visibility = sensor('pageVisibility');
  */
-export declare function sensor(type: 'pageVisibility', options?: {
-    debugName?: string;
-}): Signal<DocumentVisibilityState>;
+export declare function sensor(type: 'pageVisibility', options?: SensorTypedOptions['pageVisibility']['opt']): Signal<DocumentVisibilityState>;
 /**
  * Creates a sensor signal that tracks the user's OS/browser preference for a dark color scheme.
- * @param type Must be `'dark-mode'`.
+ * @param type Must be `'darkMode'`.
  * @param options Optional configuration, currently only `debugName`.
  * @returns A `Signal<boolean>` which is `true` if a dark theme is preferred.
  * @see {prefersDarkMode} for detailed documentation and examples.
  * @example const isDarkMode = sensor('dark-mode');
  */
-export declare function sensor(type: 'dark-mode', options?: {
-    debugName?: string;
-}): Signal<boolean>;
+export declare function sensor(type: 'darkMode' | 'dark-mode', options?: SensorTypedOptions['darkMode']['opt']): Signal<boolean>;
 /**
  * Creates a sensor signal that tracks the user's OS/browser preference for reduced motion.
- * @param type Must be `'reduced-motion'`.
+ * @param type Must be `'reducedMotion'`.
  * @param options Optional configuration, currently only `debugName`.
  * @returns A `Signal<boolean>` which is `true` if reduced motion is preferred.
  * @see {prefersReducedMotion} for detailed documentation and examples.
  * @example const wantsReducedMotion = sensor('reduced-motion');
  */
-export declare function sensor(type: 'reduced-motion', options?: {
-    debugName?: string;
-}): Signal<boolean>;
+export declare function sensor(type: 'reducedMotion' | 'reduced-motion', options?: SensorTypedOptions['reducedMotion']['opt']): Signal<boolean>;
+/**
+ * Creates a sensor signal that tracks the provided media query.
+ * @param type Must be `'mediaQuery'`.
+ * @param options Optional configuration for the media query sensor, including `query` and `debugName`.
+ * @returns A `Signal<boolean>` which is `true` if the media query currently matches.
+ * @see {mediaQuery} for detailed documentation and examples.
+ * @example const isDesktop = sensor('mediaQuery', { query: '(min-width: 1024px)' });
+ */
+export declare function sensor(type: 'mediaQuery', options?: SensorTypedOptions['mediaQuery']['opt']): Signal<boolean>;
 /**
  * Creates a sensor signal that tracks the browser window's inner dimensions (width and height).
  * @param type Must be `'windowSize'`.
@@ -64,7 +142,7 @@ export declare function sensor(type: 'reduced-motion', options?: {
  * @see {windowSize} for detailed documentation and examples.
  * @example const size = sensor('windowSize', { throttle: 200 });
  */
-export declare function sensor(type: 'windowSize', options?: WindowSizeOptions): WindowSizeSignal;
+export declare function sensor(type: 'windowSize', options?: SensorTypedOptions['windowSize']['opt']): WindowSizeSignal;
 /**
  * Creates a sensor signal that tracks the scroll position (x, y) of the window or a specified element.
  * @param type Must be `'scrollPosition'`.
@@ -73,4 +151,12 @@ export declare function sensor(type: 'windowSize', options?: WindowSizeOptions):
  * @see {scrollPosition} for detailed documentation and examples.
  * @example const pageScroll = sensor('scrollPosition', { throttle: 150 });
  */
-export declare function sensor(type: 'scrollPosition', options?: ScrollPositionOptions): ScrollPositionSignal;
+export declare function sensor(type: 'scrollPosition', options?: SensorTypedOptions['scrollPosition']['opt']): ScrollPositionSignal;
+type SensorsOptions<TKey extends keyof SensorTypedOptions> = {
+    [K in TKey]: SensorTypedOptions[K]['opt'];
+};
+type Sensors<TKey extends keyof SensorTypedOptions> = {
+    [K in TKey]: SensorTypedOptions[K]['returnType'];
+};
+export declare function sensors<const TType extends keyof SensorTypedOptions>(track: TType[], opt?: SensorsOptions<TType>): Sensors<TType>;
+export {};

package/lib/sensors/window-size.d.ts

@@ -1,4 +1,4 @@
-import { Signal } from '@angular/core';
+import { type Signal } from '@angular/core';
 /**
  * Represents the dimensions of the window.
  */

package/lib/store.d.ts

@@ -0,0 +1,58 @@
+import { Injector, type CreateSignalOptions, type Signal, type WritableSignal } from '@angular/core';
+import { type MutableSignal } from './mutable';
+type BaseType = string | number | boolean | symbol | undefined | null | Function | Date | RegExp;
+type Key = string | number;
+type AnyRecord = Record<Key, any>;
+/**
+ * @internal
+ * Validates whether a value is a Signal Store.
+ */
+export declare function isStore<T>(value: unknown): value is SignalStore<T>;
+type SignalArrayStore<T extends any[]> = Signal<T> & {
+    readonly [index: number]: SignalStore<T[number]>;
+    readonly length: Signal<number>;
+    [Symbol.iterator](): Iterator<SignalStore<T[number]>>;
+};
+type WritableArrayStore<T extends any[]> = WritableSignal<T> & {
+    readonly asReadonlyStore: () => SignalArrayStore<T>;
+    readonly [index: number]: WritableSignalStore<T[number]>;
+    readonly length: Signal<number>;
+    [Symbol.iterator](): Iterator<WritableSignalStore<T[number]>>;
+};
+type MutableArrayStore<T extends any[]> = MutableSignal<T> & {
+    readonly asReadonlyStore: () => SignalArrayStore<T>;
+    readonly [index: number]: MutableSignalStore<T[number]>;
+    readonly length: Signal<number>;
+    [Symbol.iterator](): Iterator<MutableSignalStore<T[number]>>;
+};
+export type SignalStore<T> = Signal<T> & (NonNullable<T> extends BaseType ? unknown : NonNullable<T> extends Array<any> ? SignalArrayStore<NonNullable<T>> : Readonly<{
+    [K in keyof Required<T>]: SignalStore<NonNullable<T>[K]>;
+}>);
+export type WritableSignalStore<T> = WritableSignal<T> & {
+    readonly asReadonlyStore: () => SignalStore<T>;
+} & (NonNullable<T> extends BaseType ? unknown : NonNullable<T> extends Array<any> ? WritableArrayStore<NonNullable<T>> : Readonly<{
+    [K in keyof Required<T>]: WritableSignalStore<NonNullable<T>[K]>;
+}>);
+export type MutableSignalStore<T> = MutableSignal<T> & {
+    readonly asReadonlyStore: () => SignalStore<T>;
+} & (NonNullable<T> extends BaseType ? unknown : NonNullable<T> extends Array<any> ? MutableArrayStore<NonNullable<T>> : Readonly<{
+    [K in keyof Required<T>]: MutableSignalStore<NonNullable<T>[K]>;
+}>);
+export declare function toStore<T extends AnyRecord>(source: MutableSignal<T>, injector?: Injector): MutableSignalStore<T>;
+export declare function toStore<T extends AnyRecord>(source: WritableSignal<T>, injector?: Injector): WritableSignalStore<T>;
+export declare function toStore<T extends AnyRecord>(source: Signal<T>, injector?: Injector): SignalStore<T>;
+/**
+ * Creates a WritableSignalStore from a value.
+ * @see {@link toStore}
+ */
+export declare function store<T extends AnyRecord>(value: T, opt?: CreateSignalOptions<T> & {
+    injector?: Injector;
+}): WritableSignalStore<T>;
+/**
+ * Creates a MutableSignalStore from a value.
+ * @see {@link toStore}
+ */
+export declare function mutableStore<T extends AnyRecord>(value: T, opt?: CreateSignalOptions<T> & {
+    injector?: Injector;
+}): MutableSignalStore<T>;
+export {};

package/lib/stored.d.ts

@@ -1,4 +1,4 @@
-import { Signal, type CreateSignalOptions, type WritableSignal } from '@angular/core';
+import { type CreateSignalOptions, type Signal, type WritableSignal } from '@angular/core';
 /**
  * Interface for storage mechanisms compatible with the `stored` signal.
  * Matches the essential parts of the `Storage` interface (`localStorage`, `sessionStorage`).
@@ -61,6 +61,10 @@ export type CreateStoredOptions<T> = CreateSignalOptions<T> & {
      * If 'true', the signal will remove the old key from storage when the key changes, defaults to `false`.
      */
     cleanupOldKey?: boolean;
+    /**
+     * Optional validator, which is called on load of value. Store will be set to fallback if value is false
+     */
+    validate?: (value: T) => boolean;
 };
 /**
  * A specialized `WritableSignal` returned by the `stored()` function.
@@ -132,5 +136,5 @@ export type StoredSignal<T> = WritableSignal<T> & {
  * }
  * ```
  */
-export declare function stored<T>(fallback: T, { key, store: providedStore, serialize, deserialize, syncTabs, equal, onKeyChange, cleanupOldKey, ...rest }: CreateStoredOptions<T>): StoredSignal<T>;
+export declare function stored<T>(fallback: T, { key, store: providedStore, serialize, deserialize, syncTabs, equal, onKeyChange, cleanupOldKey, validate, ...rest }: CreateStoredOptions<T>): StoredSignal<T>;
 export {};

package/lib/tabSync.d.ts

@@ -0,0 +1,56 @@
+import { type WritableSignal } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class MessageBus {
+    private readonly channel;
+    private readonly listeners;
+    subscribe<T>(id: string, listener: (data: T) => void): {
+        unsub: () => void;
+        post: (value: T) => void;
+    };
+    private unsubscribe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageBus, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageBus>;
+}
+export declare function generateDeterministicID(): string;
+type SyncSignalOptions = {
+    id?: string;
+};
+/**
+ * Synchronizes a WritableSignal across browser tabs using BroadcastChannel API.
+ *
+ * Creates a shared signal that automatically syncs its value between all tabs
+ * of the same application. When the signal is updated in one tab, all other
+ * tabs will receive the new value automatically.
+ *
+ * @template T - The type of the WritableSignal
+ * @param sig - The WritableSignal to synchronize across tabs
+ * @param opt - Optional configuration object
+ * @param opt.id - Explicit channel ID for synchronization. If not provided,
+ *                 a deterministic ID is generated based on the call site.
+ *                 Use explicit IDs in production for reliability.
+ *
+ * @returns The same WritableSignal instance, now synchronized across tabs
+ *
+ * @throws {Error} When deterministic ID generation fails and no explicit ID is provided
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - auto-generates channel ID from call site
+ * const theme = tabSync(signal('dark'));
+ *
+ * // With explicit ID (recommended for production)
+ * const userPrefs = tabSync(signal({ lang: 'en' }), { id: 'user-preferences' });
+ *
+ * // Changes in one tab will sync to all other tabs
+ * theme.set('light'); // All tabs will update to 'light'
+ * ```
+ *
+ * @remarks
+ * - Only works in browser environments (returns original signal on server)
+ * - Uses a single BroadcastChannel for all synchronized signals
+ * - Automatically cleans up listeners when the injection context is destroyed
+ * - Initial signal value after sync setup is not broadcasted to prevent loops
+ *
+ */
+export declare function tabSync<T extends WritableSignal<any>>(sig: T, opt?: SyncSignalOptions): T;
+export {};

package/lib/throttled.d.ts

@@ -1,5 +1,5 @@
 import { type CreateSignalOptions, DestroyRef, type WritableSignal } from '@angular/core';
-import { DebouncedSignal } from './debounced';
+import { type DebouncedSignal } from './debounced';
 /**
  * Options for creating a throttled writable signal.
  * Extends Angular's `CreateSignalOptions` with a throttle time setting.

package/lib/to-writable.d.ts

@@ -1,4 +1,4 @@
-import { Signal, WritableSignal } from '@angular/core';
+import { type CreateSignalOptions, type Signal, type WritableSignal } from '@angular/core';
 /**
  * Converts a read-only `Signal` into a `WritableSignal` by providing custom `set` and, optionally, `update` functions.
  * This can be useful for creating controlled write access to a signal that is otherwise read-only.
@@ -27,4 +27,11 @@ import { Signal, WritableSignal } from '@angular/core';
  *
  * writableSignal.set(5); // sets value of originalValue.a to 5 & triggers all signals
  */
-export declare function toWritable<T>(signal: Signal<T>, set: (value: T) => void, update?: (updater: (value: T) => T) => void): WritableSignal<T>;
+export declare function toWritable<T>(source: Signal<T>, set: (value: T) => void, update?: (updater: (value: T) => T) => void, opt?: CreateSignalOptions<T> & {
+    /**
+     * If `true` (the default), the returned signal will be a computed signal that depends on the source signal.
+     * If `false`, the returned signal will be a direct wrapper around the source signal without creating a new computed signal.
+     * @default true
+     */
+    pure?: boolean;
+}): WritableSignal<T>;

package/lib/until.d.ts

@@ -1,4 +1,4 @@
-import { DestroyRef, Injector, Signal } from '@angular/core';
+import { DestroyRef, Injector, type Signal } from '@angular/core';
 export type UntilOptions = {
     /**
      * Optional timeout in milliseconds. If the condition is not met
@@ -14,38 +14,43 @@ export type UntilOptions = {
     injector?: Injector;
 };
 /**
- * Creates a Promise that resolves when a signal's value satisfies a given predicate.
+ * Creates a Promise that resolves when a signal's value satisfies a type predicate.
  *
- * This is useful for imperatively waiting for a reactive state to change,
- * for example, in tests or to orchestrate complex asynchronous operations.
+ * This overload is used when the predicate function is a type guard (e.g., `(v): v is MyType`).
+ * The returned promise will resolve with the narrowed type.
  *
- * @template T The type of the signal's value.
+ * @template T The base type of the signal's value.
+ * @template U The narrowed type asserted by the predicate.
  * @param sourceSignal The signal to observe.
- * @param predicate A function that takes the signal's value and returns `true` if the condition is met.
+ * @param predicate A type guard function that returns `true` if the value is of type `U`.
  * @param options Optional configuration for timeout and explicit destruction.
- * @returns A Promise that resolves with the signal's value when the predicate is true,
- * or rejects on timeout or context destruction.
+ * @returns A Promise that resolves with the signal's value, narrowed to type `U`.
  *
  * @example
  * ```ts
- * const count = signal(0);
+ * const event = signal<Event | null>(null);
  *
- * async function waitForCount() {
- * console.log('Waiting for count to be >= 3...');
- * try {
- * const finalCount = await until(count, c => c >= 3, { timeout: 5000 });
- * console.log(`Count reached: ${finalCount}`);
- * } catch (e: any) { // Ensure 'e' is typed if you access properties like e.message
- * console.error(e.message); // e.g., "until: Timeout after 5000ms."
- * }
+ * // The returned promise is `Promise<MouseEvent>`
+ * const mouseEventPromise = until(event, (e): e is MouseEvent => e instanceof MouseEvent);
+ *
+ * async function logMouseEvent() {
+ * const me = await mouseEventPromise;
+ * console.log(me.clientX); // `me` is correctly typed as MouseEvent
  * }
+ * ```
+ */
+export declare function until<T, U extends T>(sourceSignal: Signal<T>, predicate: (value: T) => value is U, options?: UntilOptions): Promise<U>;
+/**
+ * Creates a Promise that resolves when a signal's value satisfies a given predicate.
  *
- * // Simulate updates
- * setTimeout(() => count.set(1), 500);
- * setTimeout(() => count.set(2), 1000);
- * setTimeout(() => count.set(3), 1500);
+ * This is useful for imperatively waiting for a reactive state to change,
+ * for example, in tests or to orchestrate complex asynchronous operations.
  *
- * waitForCount();
- * ```
+ * @template T The type of the signal's value.
+ * @param sourceSignal The signal to observe.
+ * @param predicate A function that takes the signal's value and returns `true` if the condition is met.
+ * @param options Optional configuration for timeout and explicit destruction.
+ * @returns A Promise that resolves with the signal's value when the predicate is true,
+ * or rejects on timeout or context destruction.
  */
 export declare function until<T>(sourceSignal: Signal<T>, predicate: (value: T) => boolean, options?: UntilOptions): Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/primitives",
-  "version": "19.2.3",
+  "version": "19.3.0",
   "keywords": [
     "angular",
     "signals",
@@ -14,13 +14,9 @@
     "url": "https://github.com/mihajm/mmstack"
   },
   "homepage": "https://github.com/mihajm/mmstack/blob/master/packages/primitives",
-  "dependencies": {
-    "@mmstack/object": "^19.2.0",
-    "tslib": "^2.3.0"
-  },
   "peerDependencies": {
-    "@angular/core": "~19.2.3",
-    "@angular/common": "~19.2.3"
+    "@angular/core": ">=19 <20",
+    "@angular/common": ">=19 <20"
   },
   "sideEffects": false,
   "module": "fesm2022/mmstack-primitives.mjs",
@@ -33,5 +29,8 @@
       "types": "./index.d.ts",
       "default": "./fesm2022/mmstack-primitives.mjs"
     }
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
   }
 }

package/lib/map-array.d.ts

@@ -1,61 +0,0 @@
-import { type CreateSignalOptions, type Signal } from '@angular/core';
-/**
- * Reactively maps items from a source array (or signal of an array) using a provided mapping function.
- *
- * This function serves a similar purpose to SolidJS's `mapArray` by providing stability
- * for mapped items. It receives a source function returning an array (or a Signal<T[]>)
- * and a mapping function.
- *
- * For each item in the source array, it creates a stable `computed` signal representing
- * that item's value at its current index. This stable signal (`Signal<T>`) is passed
- * to the mapping function. This ensures that downstream computations or components
- * depending on the mapped result only re-render or re-calculate for the specific items
- * that have changed, or when items are added/removed, rather than re-evaluating everything
- * when the source array reference changes but items remain the same.
- *
- * It efficiently handles changes in the source array's length by reusing existing mapped
- * results when possible, slicing when the array shrinks, and appending new mapped items
- * when it grows.
- *
- * @template T The type of items in the source array.
- * @template U The type of items in the resulting mapped array.
- *
- * @param source A function returning the source array `T[]`, or a `Signal<T[]>` itself.
- * The `mapArray` function will reactively update based on changes to this source.
- * @param map The mapping function. It is called for each item in the source array.
- * It receives:
- * - `value`: A stable `Signal<T>` representing the item at the current index.
- * Use this signal within your mapping logic if you need reactivity
- * tied to the specific item's value changes.
- * - `index`: The number index of the item in the array.
- * It should return the mapped value `U`.
- * @param [opt] Optional `CreateSignalOptions<T>`. These options are passed directly
- * to the `computed` signal created for each individual item (`Signal<T>`).
- * This allows specifying options like a custom `equal` function for item comparison.
- *
- * @returns A `Signal<U[]>` containing the mapped array. This signal updates whenever
- * the source array changes (either length or the values of its items).
- *
- * @example
- * ```ts
- * const sourceItems = signal([
- * { id: 1, name: 'Apple' },
- * { id: 2, name: 'Banana' }
- * ]);
- *
- * const mappedItems = mapArray(
- * sourceItems,
- * (itemSignal, index) => {
- * // itemSignal is stable for a given item based on its index.
- * // We create a computed here to react to changes in the item's name.
- *  return computed(() => `${index}: ${itemSignal().name.toUpperCase()}`);
- * },
- * // Example optional options (e.g., custom equality for item signals)
- * { equal: (a, b) => a.id === b.id && a.name === b.name }
- * );
- * ```
- * @remarks
- * This function achieves its high performance by leveraging the new `linkedSignal`
- * API from Angular, which allows for efficient memoization and reuse of array items.
- */
-export declare function mapArray<T, U>(source: () => T[], map: (value: Signal<T>, index: number) => U, opt?: CreateSignalOptions<T>): Signal<U[]>;