@signality/core 0.0.1-alpha.2

package/browser/input-modality/index.d.ts

@@ -0,0 +1,26 @@
+import { type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export type InputModality = 'keyboard' | 'mouse' | 'touch' | null;
+/**
+ * Reactively track the user's current input method (keyboard, mouse, or touch).
+ *
+ * @param options - Optional configuration including injector
+ * @returns A signal containing the current input modality: `'keyboard'`, `'mouse'`, `'touch'`, or `null`
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div [class.keyboard]="modality() === 'keyboard'">
+ *       <p>Current input: {{ modality() ?? 'none' }}</p>
+ *       <button>Button with conditional focus ring</button>
+ *     </div>
+ *   `
+ * })
+ * export class ModalityComponent {
+ *   readonly modality = inputModality();
+ * }
+ * ```
+ */
+export declare function inputModality(options?: WithInjector): Signal<InputModality>;
+export declare const INPUT_MODALITY: import("@angular/core").ProviderToken<Signal<InputModality>>;

package/browser/listener/index.d.ts

@@ -0,0 +1,61 @@
+import type { MaybeElementSignal, MaybeSignal, WithInjector } from '@signality/core/types';
+export type ListenerOptions = WithInjector;
+export interface ListenerRef {
+    readonly destroy: () => void;
+}
+export interface ListenerFunction {
+    <E extends keyof WindowEventMap>(target: Window, event: MaybeSignal<E>, handler: (this: Window, e: WindowEventMap[E]) => any, options?: ListenerOptions): ListenerRef;
+    <E extends keyof DocumentEventMap>(target: Document, event: MaybeSignal<E>, handler: (this: Document, e: DocumentEventMap[E]) => any, options?: ListenerOptions): ListenerRef;
+    <E extends keyof ShadowRootEventMap>(target: MaybeSignal<ShadowRoot>, event: MaybeSignal<E>, handler: (this: ShadowRoot, e: ShadowRootEventMap[E]) => any, options?: ListenerOptions): ListenerRef;
+    <T extends HTMLElement, E extends keyof HTMLElementEventMap>(target: MaybeElementSignal<T>, event: MaybeSignal<E>, handler: (this: T, e: HTMLElementEventMap[E]) => any, options?: ListenerOptions): ListenerRef;
+    <T extends SVGElement, E extends keyof SVGElementEventMap>(target: MaybeElementSignal<T>, event: MaybeSignal<E>, handler: (this: T, e: SVGElementEventMap[E]) => any, options?: ListenerOptions): ListenerRef;
+    <Names extends string>(target: MaybeSignal<InferEventTarget<Names>>, event: MaybeSignal<Names>, handler: (e: Event) => void, options?: ListenerOptions): ListenerRef;
+    <EventType = Event>(target: MaybeSignal<EventTarget> | MaybeElementSignal<Element>, event: MaybeSignal<string>, handler: GeneralEventListener<EventType>, options?: ListenerOptions): ListenerRef;
+    readonly capture: ListenerFunction;
+    readonly passive: ListenerFunction;
+    readonly once: ListenerFunction;
+    readonly stop: ListenerFunction;
+    readonly prevent: ListenerFunction;
+    readonly self: ListenerFunction;
+}
+/**
+ * Signal-based wrapper around the [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) method.
+ *
+ * @param target - Event target
+ * @param event - Event type name
+ * @param handler - Event handler function
+ * @param options - Optional listener configuration
+ * @returns A ListenerRef that can be used to destroy the listener
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `<button #btn>Click me</button>`,
+ * })
+ * class ListenerComponent {
+ *   readonly btn = viewChild<ElementRef>('btn');
+ *
+ *   constructor() {
+ *     listener.capture.prevent(this.btn, 'click', event => {
+ *       console.log('Button clicked!', event);
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare const listener: ListenerFunction;
+/**
+ * By default, `listener()` registers event listeners after the render cycle completes
+ * to ensure DOM elements exist. However, global targets (window, document, navigator.*, etc.)
+ * are not tied to the render cycle. Use `setupSync()` to wrap listener calls when you need to prevent
+ * race conditions where a global event is dispatched before Angular completes its scheduled rendering tasks.
+ */
+export declare function setupSync<T>(listenerFactoryExecFn: () => T): T;
+interface InferEventTarget<Events> {
+    readonly addEventListener: (event: Events, fn?: any, options?: any) => any;
+    readonly removeEventListener: (event: Events, fn?: any, options?: any) => any;
+}
+interface GeneralEventListener<E = Event> {
+    (e: E): void;
+}
+export {};

package/browser/media-query/index.d.ts

@@ -0,0 +1,36 @@
+import { type CreateSignalOptions, type Signal } from '@angular/core';
+import { type Union } from '@signality/core/internal';
+import type { MaybeSignal, WithInjector } from '@signality/core/types';
+export interface MediaQueryOptions extends CreateSignalOptions<boolean>, WithInjector {
+    /**
+     * Initial value for SSR.
+     * @default false
+     */
+    readonly initialValue?: boolean;
+}
+/**
+ * Reactive wrapper around the [Window.matchMedia](https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia) method.
+ *
+ * @param query - CSS media query string (can be a signal)
+ * @param options - Optional configuration
+ * @returns A signal that is true when the media query matches
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (prefersDark()) {
+ *       <p>Dark mode is preferred</p>
+ *     } @else {
+ *       <p>Light mode is preferred</p>
+ *     }
+ *   `
+ * })
+ * class ThemeComponent {
+ *   readonly prefersDark = mediaQuery('(prefers-color-scheme: dark)');
+ * }
+ * ```
+ */
+export declare function mediaQuery(query: MaybeSignal<Union<MediaQueryFeature, string>>, options?: MediaQueryOptions): Signal<boolean>;
+type MediaQueryFeature = `(any-hover: ${'none' | 'hover'})` | `(any-pointer: ${'none' | 'coarse' | 'fine'})` | `(aspect-ratio: ${string})` | `(color: ${string})` | `(color-gamut: ${'srgb' | 'p3' | 'rec2020'})` | `(color-index: ${string})` | `(device-aspect-ratio: ${string})` | `(device-height: ${string})` | `(device-posture: ${'flat' | 'folded' | 'continuous'})` | `(device-width: ${string})` | `(display-mode: ${'fullscreen' | 'standalone' | 'minimal-ui' | 'browser' | 'picture-in-picture' | 'window-controls-overlay'})` | `(dynamic-range: ${'standard' | 'high'})` | `(forced-colors: ${'none' | 'active'})` | `(grid: ${'0' | '1'})` | `(height: ${string})` | `(hover: ${'none' | 'hover'})` | `(inverted-colors: ${'none' | 'inverted'})` | `(monochrome: ${string})` | `(orientation: ${'portrait' | 'landscape'})` | `(overflow-block: ${'none' | 'scroll' | 'optional-paged' | 'paged'})` | `(overflow-inline: ${'none' | 'scroll'})` | `(pointer: ${'none' | 'coarse' | 'fine'})` | `(prefers-color-scheme: ${'light' | 'dark' | 'no-preference'})` | `(prefers-contrast: ${'no-preference' | 'more' | 'less' | 'custom'})` | `(prefers-reduced-data: ${'no-preference' | 'reduce'})` | `(prefers-reduced-motion: ${'no-preference' | 'reduce'})` | `(prefers-reduced-transparency: ${'no-preference' | 'reduce'})` | `(resolution: ${string})` | `(scan: ${'progressive' | 'interlace'})` | `(scripting: ${'none' | 'initial-only' | 'enabled'})` | `(shape: ${'rect' | 'round'})` | `(update: ${'none' | 'slow' | 'fast'})` | `(video-dynamic-range: ${'standard' | 'high'})` | `(width: ${string})` | `(min-width: ${string})` | `(max-width: ${string})` | `(min-height: ${string})` | `(max-height: ${string})` | `(min-aspect-ratio: ${string})` | `(max-aspect-ratio: ${string})` | `(min-resolution: ${string})` | `(max-resolution: ${string})` | `(min-color: ${string})` | `(max-color: ${string})` | `(min-color-index: ${string})` | `(max-color-index: ${string})` | `(min-monochrome: ${string})` | `(max-monochrome: ${string})`;
+export {};

package/browser/network/index.d.ts

@@ -0,0 +1,44 @@
+import { type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export type EffectiveConnectionType = 'slow-2g' | '2g' | '3g' | '4g';
+export type ConnectionType = 'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'none' | 'other' | 'unknown';
+export type NetworkOptions = WithInjector;
+export interface NetworkRef {
+    /** Whether Network Information API is supported */
+    readonly isSupported: Signal<boolean>;
+    /** Whether the browser is online */
+    readonly isOnline: Signal<boolean>;
+    /** Effective connection type */
+    readonly effectiveType: Signal<EffectiveConnectionType | undefined>;
+    /** Downlink speed in Mbps */
+    readonly downlink: Signal<number | undefined>;
+    /** Round-trip time in ms */
+    readonly rtt: Signal<number | undefined>;
+    /** Whether user has data saver enabled */
+    readonly saveData: Signal<boolean>;
+    /** Connection type (wifi, cellular, etc.) */
+    readonly type: Signal<ConnectionType | undefined>;
+}
+/**
+ * Signal-based wrapper around the Network Information API and online/offline events.
+ *
+ * @param options - Optional configuration including injector
+ * @returns A NetworkRef with network status signals
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <p>{{ net.isOnline() ? 'Online' : 'Offline' }}</p>
+ *     @if (net.effectiveType()) {
+ *       <p>Connection: {{ net.effectiveType() }}</p>
+ *     }
+ *   `
+ * })
+ * class NetworkComponent {
+ *   readonly net = network();
+ * }
+ * ```
+ */
+export declare function network(options?: NetworkOptions): NetworkRef;
+export declare const NETWORK: import("@angular/core").ProviderToken<NetworkRef>;

package/browser/online/index.d.ts

@@ -0,0 +1,27 @@
+import { type CreateSignalOptions, type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export type OnlineOptions = CreateSignalOptions<boolean> & WithInjector;
+/**
+ * Reactive wrapper around the [Navigator.onLine](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/onLine) property.
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the current online status (`true` for online, `false` for offline)
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (isOnline()) {
+ *       <p>You're online</p>
+ *     } @else {
+ *       <p>You're offline</p>
+ *     }
+ *   `
+ * })
+ * class NetworkStatusComponent {
+ *   readonly isOnline = online();
+ * }
+ * ```
+ */
+export declare function online(options?: OnlineOptions): Signal<boolean>;
+export declare const ONLINE: import("@angular/core").ProviderToken<Signal<boolean>>;

package/browser/page-visibility/index.d.ts

@@ -0,0 +1,27 @@
+import { type CreateSignalOptions, type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export type PageVisibilityOptions = CreateSignalOptions<DocumentVisibilityState> & WithInjector;
+/**
+ * Signal-based wrapper around the [Page Visibility API](https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API).
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the current DocumentVisibilityState ('visible' or 'hidden')
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (visibility() === 'hidden') {
+ *       <p>Page is hidden</p>
+ *     } @else {
+ *       <p>Page is visible</p>
+ *     }
+ *   `
+ * })
+ * class VisibilityComponent {
+ *   readonly visibility = pageVisibility();
+ * }
+ * ```
+ */
+export declare function pageVisibility(options?: PageVisibilityOptions): Signal<DocumentVisibilityState>;
+export declare const PAGE_VISIBILITY: import("@angular/core").ProviderToken<Signal<DocumentVisibilityState>>;

package/browser/picture-in-picture/index.d.ts

@@ -0,0 +1,42 @@
+import { type Signal } from '@angular/core';
+import type { MaybeElementSignal, WithInjector } from '@signality/core/types';
+export type PictureInPictureOptions = WithInjector;
+export interface PictureInPictureRef {
+    /** Whether Picture-in-Picture API is supported */
+    readonly isSupported: Signal<boolean>;
+    /** Whether Picture-in-Picture is active */
+    readonly isActive: Signal<boolean>;
+    /** Enter Picture-in-Picture mode */
+    readonly enter: () => Promise<void>;
+    /** Exit Picture-in-Picture mode */
+    readonly exit: () => Promise<void>;
+    /** Toggle Picture-in-Picture mode */
+    readonly toggle: () => Promise<void>;
+}
+/**
+ * Signal-based wrapper around the [Picture-in-Picture API](https://developer.mozilla.org/en-US/docs/Web/API/Picture-in-Picture_API).
+ *
+ * Automatically exits Picture-in-Picture when the target element is disconnected from the DOM.
+ *
+ * @param target - Video element
+ * @param options - Optional configuration
+ * @returns A {@link PictureInPictureRef} with `isSupported`, `isActive` signals and `enter`/`exit`/`toggle` methods
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (pip.isSupported()) {
+ *       <video #video src="video.mp4"></video>
+ *       <button (click)="pip.toggle()">Toggle PiP</button>
+ *       <p>Active: {{ pip.isActive() }}</p>
+ *     }
+ *   `
+ * })
+ * class PiPComponent {
+ *   readonly video = viewChild<HTMLVideoElement>('video');
+ *   readonly pip = pictureInPicture(this.video);
+ * }
+ * ```
+ */
+export declare function pictureInPicture(target: MaybeElementSignal<HTMLVideoElement>, options?: PictureInPictureOptions): PictureInPictureRef;

package/browser/pointer-lock-element/index.d.ts

@@ -0,0 +1,22 @@
+import { type CreateSignalOptions, type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export type PointerLockElementOptions = CreateSignalOptions<Element | null> & WithInjector;
+/**
+ * Reactive wrapper around the [Pointer Lock API](https://developer.mozilla.org/en-US/docs/Web/API/Pointer_Lock_API).
+ * Returns a signal that tracks the element that currently has pointer lock.
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the element with pointer lock, or `null` if no element has lock
+ *
+ * @example
+ * ```typescript
+ * const lockedElement = pointerLockElement();
+ *
+ * effect(() => {
+ *   if (lockedElement()) {
+ *     console.log('Pointer locked on:', lockedElement());
+ *   }
+ * });
+ * ```
+ */
+export declare function pointerLockElement(options?: PointerLockElementOptions): Signal<Element | null>;

package/browser/screen-orientation/index.d.ts

@@ -0,0 +1,29 @@
+import { type CreateSignalOptions, type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export interface ScreenOrientationOptions extends CreateSignalOptions<OrientationType>, WithInjector {
+    /**
+     * Initial value for SSR.
+     * @default 'portrait-primary'
+     */
+    readonly initialValue?: OrientationType;
+}
+/**
+ * Reactive wrapper around the [Screen Orientation API](https://developer.mozilla.org/en-US/docs/Web/API/Screen_Orientation_API).
+ * Returns a signal that tracks the current screen orientation.
+ *
+ * @param options - Optional configuration including signal options and injector
+ * @returns A signal containing the current orientation type (`'portrait-primary'`, `'portrait-secondary'`, `'landscape-primary'`, or `'landscape-secondary'`)
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <p>Orientation: {{ orientation() }}</p>
+ *   `
+ * })
+ * class OrientationComponent {
+ *   readonly orientation = screenOrientation();
+ * }
+ * ```
+ */
+export declare function screenOrientation(options?: ScreenOrientationOptions): Signal<OrientationType>;

package/browser/speech-recognition/index.d.ts

@@ -0,0 +1,77 @@
+import { type Signal } from '@angular/core';
+import type { MaybeSignal, WithInjector } from '@signality/core/types';
+export interface SpeechRecognitionOptions extends WithInjector {
+    /**
+     * Language for speech recognition.
+     * @default 'en-US'
+     */
+    readonly lang?: MaybeSignal<string>;
+    /**
+     * Whether to return interim results.
+     * @default false
+     */
+    readonly interimResults?: boolean;
+    /**
+     * Whether to continue recognition after speech ends.
+     * @default false
+     */
+    readonly continuous?: boolean;
+    /**
+     * Maximum number of alternative transcripts.
+     * @default 1
+     */
+    readonly maxAlternatives?: number;
+}
+export interface SpeechRecognitionRef {
+    /** Whether Speech Recognition API is supported */
+    readonly isSupported: Signal<boolean>;
+    /** Whether recognition is currently active */
+    readonly isListening: Signal<boolean>;
+    /** Final transcript text */
+    readonly text: Signal<string>;
+    /** Interim transcript text */
+    readonly interimText: Signal<string>;
+    /** Error if recognition failed */
+    readonly error: Signal<SpeechRecognitionErrorEvent | Error | null>;
+    /** Start speech recognition */
+    readonly start: () => void;
+    /** Stop speech recognition */
+    readonly stop: () => void;
+    /** Abort speech recognition */
+    readonly abort: () => void;
+}
+/**
+ * Signal-based wrapper around the [Speech Recognition API](https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition).
+ *
+ * @param options - Optional configuration
+ * @returns A SpeechRecognitionRef with isSupported, isListening, text, interimText, error signals and control methods
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (recognition.isSupported()) {
+ *       <button (click)="toggleRecognition()">
+ *         {{ recognition.isListening() ? 'Stop' : 'Start' }} Recording
+ *       </button>
+ *       <p>{{ recognition.text() }}</p>
+ *       @if (recognition.interimText()) {
+ *         <p><em>{{ recognition.interimText() }}</em></p>
+ *       }
+ *     }
+ *   `
+ * })
+ * class SpeechComponent {
+ *   readonly recognition = speechRecognition();
+ *
+ *   toggleRecognition() {
+ *     if (this.recognition.isListening()) {
+ *       this.recognition.stop();
+ *     } else {
+ *       this.recognition.start();
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function speechRecognition(options?: SpeechRecognitionOptions): SpeechRecognitionRef;

package/browser/speech-synthesis/index.d.ts

@@ -0,0 +1,76 @@
+import { type Signal } from '@angular/core';
+import type { WithInjector } from '@signality/core/types';
+export interface SpeechSynthesisSpeakOptions {
+    /** Text to speak */
+    readonly text: string;
+    /** Language code (e.g., 'en-US') */
+    readonly lang?: string;
+    /** Speech rate (0.1 to 10) */
+    readonly rate?: number;
+    /** Speech pitch (0 to 2) */
+    readonly pitch?: number;
+    /** Speech volume (0 to 1) */
+    readonly volume?: number;
+    /** Voice to use */
+    readonly voice?: SpeechSynthesisVoice;
+}
+export interface SpeechSynthesisOptions extends WithInjector {
+    /** Default language */
+    readonly lang?: string;
+    /** Default speech rate */
+    readonly rate?: number;
+    /** Default pitch */
+    readonly pitch?: number;
+    /** Default volume */
+    readonly volume?: number;
+    /** Default voice */
+    readonly voice?: SpeechSynthesisVoice;
+}
+export interface SpeechSynthesisRef {
+    /** Whether Speech Synthesis API is supported */
+    readonly isSupported: Signal<boolean>;
+    /** Whether speech is currently playing */
+    readonly isSpeaking: Signal<boolean>;
+    /** Whether speech is currently paused */
+    readonly isPaused: Signal<boolean>;
+    /** Available voices */
+    readonly voices: Signal<SpeechSynthesisVoice[]>;
+    /** Current speaking text */
+    readonly currentText: Signal<string>;
+    /** Speak text */
+    readonly speak: (text: string, options?: Partial<SpeechSynthesisSpeakOptions>) => void;
+    /** Stop speaking */
+    readonly stop: () => void;
+    /** Pause speaking */
+    readonly pause: () => void;
+    /** Resume speaking */
+    readonly resume: () => void;
+}
+/**
+ * Signal-based wrapper around the [Speech Synthesis API](https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis).
+ *
+ * @param options - Optional configuration
+ * @returns A SpeechSynthesisRef with isSupported, isSpeaking, isPaused, voices signals and control methods
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (synthesis.isSupported()) {
+ *       <button (click)="speakText()" [disabled]="synthesis.isSpeaking()">
+ *         {{ synthesis.isSpeaking() ? 'Speaking...' : 'Speak' }}
+ *       </button>
+ *       <button (click)="synthesis.stop()">Stop</button>
+ *     }
+ *   `
+ * })
+ * class TextToSpeechComponent {
+ *   readonly synthesis = speechSynthesis();
+ *
+ *   speakText() {
+ *     this.synthesis.speak('Hello, world!');
+ *   }
+ * }
+ * ```
+ */
+export declare function speechSynthesis(options?: SpeechSynthesisOptions): SpeechSynthesisRef;

package/browser/storage/index.d.ts

@@ -0,0 +1,142 @@
+import { type CreateSignalOptions, type WritableSignal } from '@angular/core';
+import type { MaybeSignal, WithInjector } from '@signality/core/types';
+export interface StorageOptions<T> extends CreateSignalOptions<T>, WithInjector {
+    /**
+     * Storage type to use.
+     * @default 'local'
+     */
+    readonly type?: 'local' | 'session';
+    /**
+     * Custom serializer for read/write operations.
+     *
+     * If not provided, the serializer is automatically inferred from the initial value type:
+     * - `string` → pass-through (no transformation)
+     * - `number` → handles Infinity, -Infinity, NaN
+     * - `boolean` → strict true/false conversion
+     * - `bigint` → string representation
+     * - `Date` → ISO 8601 format
+     * - `Map` → JSON array of entries
+     * - `Set` → JSON array
+     * - `object/array` → JSON serialization
+     *
+     * @example
+     * ```typescript
+     * // Use built-in serializers
+     * import { Serializers } from '@signality/core';
+     *
+     * const counter = storage('count', 0, {
+     *   serializer: Serializers.number,
+     * });
+     *
+     * // or create a custom serializer
+     * const userSettings = storage('settings', defaultSettings, {
+     *   serializer: {
+     *     write: (v) => JSON.stringify(v),
+     *     read: (s) => ({ ...defaultSettings, ...JSON.parse(s) }),
+     *   },
+     * });
+     * ```
+     */
+    readonly serializer?: Serializer<T>;
+    /**
+     * Merge resolver function when reading from storage.
+     *
+     * Receives stored value and default value, returns the final value.
+     * Default: shallow merge for objects ({ ...initialValue, ...stored })
+     *
+     * Useful for handling schema migrations when default has new properties.
+     *
+     * @example
+     * ```typescript
+     * const settings = storage('settings', { theme: 'dark', fontSize: 14 }, {
+     *   mergeResolver: (stored, initial) => ({ ...initial, ...stored }),
+     * });
+     *
+     * // Or with custom merge
+     * const settings = storage('settings', defaultSettings, {
+     *   mergeResolver: (stored, initial) => deepMerge(stored, initial),
+     * });
+     * ```
+     */
+    readonly mergeResolver?: (storedValue: T, initialValue: T) => T;
+}
+/**
+ * Serializer interface for converting values to/from strings for storage.
+ */
+export interface Serializer<T> {
+    readonly write: (value: T) => string;
+    readonly read: (raw: string) => T;
+}
+/**
+ * Signal-based wrapper around the [Web Storage API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API) (localStorage/sessionStorage).
+ *
+ * @param key - Storage key (can be a signal for dynamic keys)
+ * @param initialValue - Default value if key doesn't exist
+ * @param options - Configuration options
+ * @returns A WritableSignal that automatically syncs with storage
+ *
+ * @example
+ * Basic usage with automatic serialization:
+ * ```typescript
+ * @Component({
+ *   template: '
+ *     <input [(ngModel)]="username" />
+ *     <p>Count: {{ count() }}</p>
+ *     <button (click)="count.set(count() + 1)">Increment</button>
+ *   '
+ * })
+ * class UserComponent {
+ *   readonly username = storage('username', '');
+ *   readonly count = storage('counter', 0); // number serialization inferred
+ *   readonly lastVisit = storage('lastVisit', new Date()); // Date serialization inferred
+ * }
+ * ```
+ *
+ * @example
+ * With options:
+ * ```typescript
+ * const preferences = storage('prefs', defaultPrefs, {
+ *   type: 'session',
+ *   mergeWithInitial: true,
+ * });
+ * ```
+ */
+export declare function storage<T>(key: MaybeSignal<string>, initialValue: T, options?: StorageOptions<T>): WritableSignal<T>;
+export declare const Serializers: {
+    readonly string: {
+        read: (v: string) => string;
+        write: (v: string) => string;
+    };
+    readonly number: {
+        read: (v: string) => number;
+        write: (v: number) => string;
+    };
+    readonly boolean: {
+        read: (v: string) => boolean;
+        write: (v: boolean) => string;
+    };
+    readonly bigint: {
+        read: (v: string) => bigint;
+        write: (v: bigint) => string;
+    };
+    readonly date: {
+        read: (v: string) => Date;
+        write: (v: Date) => string;
+    };
+    readonly object: {
+        read: <T>(v: string) => T;
+        write: <T>(v: T) => string;
+    };
+    readonly map: {
+        read: <K, V>(v: string) => Map<K, V>;
+        write: <K, V>(v: Map<K, V>) => string;
+    };
+    readonly set: {
+        read: <T>(v: string) => Set<T>;
+        write: <T>(v: Set<T>) => string;
+    };
+    readonly any: {
+        read: <T>(v: string) => T;
+        write: (v: unknown) => string;
+    };
+};

package/browser/text-direction/index.d.ts

@@ -0,0 +1,43 @@
+import { CreateSignalOptions, WritableSignal } from '@angular/core';
+import type { MaybeElementSignal, WithInjector } from '@signality/core/types';
+/**
+ * Possible text direction values matching the HTML `dir` attribute.
+ */
+export type TextDirection = 'ltr' | 'rtl' | 'auto';
+export interface TextDirectionOptions extends CreateSignalOptions<TextDirection>, WithInjector {
+    /**
+     * Element to observe. Defaults to `document.documentElement` (`<html>`).
+     */
+    readonly target?: MaybeElementSignal<HTMLElement>;
+    /**
+     * Initial direction value used during SSR or before the DOM is read.
+     * @default 'ltr'
+     */
+    readonly initialValue?: TextDirection;
+}
+/**
+ * Reactive read/write wrapper around an element's `dir` attribute for detecting and controlling
+ * [text directionality](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/dir).
+ *
+ * Returns a `WritableSignal` that reflects the current `dir` attribute value and updates the DOM
+ * when written to. Changes made to the attribute externally are picked up via `MutationObserver`.
+ *
+ * @param options - Optional configuration including target element, initial value and injector
+ * @returns A writable signal of the current text direction
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <p>Current direction: {{ dir() }}</p>
+ *     <button (click)="dir.set('rtl')">Set RTL</button>
+ *     <button (click)="dir.set('ltr')">Set LTR</button>
+ *   `
+ * })
+ * class TextDirectionComponent {
+ *   readonly dir = textDirection();
+ * }
+ * ```
+ */
+export declare function textDirection(options?: TextDirectionOptions): WritableSignal<TextDirection>;
+export declare const TEXT_DIRECTION: import("@angular/core").ProviderToken<WritableSignal<TextDirection>>;