@sdcorejs/angular 20.1.2 → 20.1.4

package/services/cache/index.d.ts

@@ -1,43 +1,79 @@
 import * as i0 from '@angular/core';
 import { InjectionToken } from '@angular/core';
+import { SdPersistenceSerializer, SdPersistenceIdentityCanonicalizer } from '@sdcorejs/angular/services/persistence';
 import { Observable } from 'rxjs';
 
-interface SdCacheOption<T = any> {
+interface SdCacheOption<T = unknown> {
     type?: 'memory' | 'session' | 'local';
     hours?: number;
+    ttlMs?: number;
     default?: T;
-    args?: Record<string, any>;
+    args?: Readonly<Record<string, unknown>>;
+    namespace?: string;
+    version?: string | number;
+    serializer?: SdPersistenceSerializer;
+    identityCanonicalizer?: SdPersistenceIdentityCanonicalizer;
 }
-interface SdCache<T = any> {
-    get: () => T;
+interface SdCache<T = unknown> {
+    get: () => T | undefined;
+    snapshot: () => SdCacheSnapshot<T>;
     set: (data: T) => void;
     has: () => boolean;
     remove: () => void;
+    /** Releases only this facade while preserving its backing cache entry. */
+    release: () => void;
     destroy: () => void;
     observer: Observable<T | undefined>;
     load: (callback: () => Promise<T>) => Promise<T>;
 }
+type SdCacheSnapshot<T> = {
+    present: false;
+} | {
+    present: true;
+    value: T;
+};
+interface SdCacheWithDefault<T> extends Omit<SdCache<T>, 'get' | 'observer'> {
+    get: () => T;
+    observer: Observable<T>;
+}
+interface SdCacheStoredValue<T = unknown> {
+    data: T;
+    createdOn: Date;
+}
+type SdCacheSetCallback = (key: string, value: SdCacheStoredValue<unknown>, option?: SdCacheOption<unknown>) => Promise<void> | void;
+type SdCacheGetCallback = (key: string, option?: SdCacheOption<unknown>) => Promise<SdCacheStoredValue<unknown> | undefined>;
+type SdCacheRemoveCallback = (key: string, option?: SdCacheOption<unknown>) => Promise<void> | void;
 interface ISdCacheConfiguration {
     convertKey?: (key: string) => string;
-    set?: (key: string, value: {
-        data: any;
-        createdOn: Date;
-    }, option?: SdCacheOption) => Promise<void>;
-    get?: (key: string, option?: SdCacheOption) => Promise<{
-        data: any;
-        createdOn: Date;
-    }>;
-    remove?: (key: string, option?: SdCacheOption) => Promise<void>;
+    namespace?: string;
+    version?: string | number;
+    serializer?: SdPersistenceSerializer;
+    identityCanonicalizer?: SdPersistenceIdentityCanonicalizer;
+    set?: SdCacheSetCallback;
+    get?: SdCacheGetCallback;
+    remove?: SdCacheRemoveCallback;
 }
 declare const SD_CACHE_CONFIG: InjectionToken<ISdCacheConfiguration>;
+interface SdLegacyCacheCallbacks<T> {
+    matches: (key: string, option?: SdCacheOption<unknown>) => boolean;
+    isValue: (value: unknown) => value is T;
+    set?: (key: string, value: SdCacheStoredValue<T>, option?: SdCacheOption<unknown>) => Promise<void> | void;
+    get?: (key: string, option?: SdCacheOption<unknown>) => Promise<SdCacheStoredValue<T> | undefined>;
+    remove?: (key: string, option?: SdCacheOption<unknown>) => Promise<void> | void;
+}
+/** @deprecated Prefer globally safe unknown callbacks on `ISdCacheConfiguration`. */
+declare function adaptLegacySdCacheCallbacks<T>(callbacks: SdLegacyCacheCallbacks<T>): ISdCacheConfiguration;
 
 declare class SdCacheService {
     #private;
     constructor();
-    create<T = any>(key: string | object, option?: SdCacheOption<T>): SdCache<T>;
+    create<T>(key: string | object, option: SdCacheOption<T> & {
+        default: T;
+    }): SdCacheWithDefault<T>;
+    create<T = unknown>(key: string | object, option?: SdCacheOption<unknown>): SdCache<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdCacheService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdCacheService>;
 }
 
-export { SD_CACHE_CONFIG, SdCacheService };
-export type { ISdCacheConfiguration, SdCache, SdCacheOption };
+export { SD_CACHE_CONFIG, SdCacheService, adaptLegacySdCacheCallbacks };
+export type { ISdCacheConfiguration, SdCache, SdCacheGetCallback, SdCacheOption, SdCacheRemoveCallback, SdCacheSetCallback, SdCacheSnapshot, SdCacheStoredValue, SdCacheWithDefault, SdLegacyCacheCallbacks };

package/services/confirm/index.d.ts

@@ -1,4 +1,4 @@
-import { MatDialogRef, MatDialog } from '@angular/material/dialog';
+import { MatDialogRef } from '@angular/material/dialog';
 import { Color } from '@sdcorejs/utils/models';
 import * as i0 from '@angular/core';
 
@@ -66,7 +66,8 @@ declare class DialogConfirmComponent {
 declare class SdConfirmService {
     #private;
     private dialog;
-    constructor(dialog: MatDialog);
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
     confirm: (message: string, option?: {
         title?: string;
         yesTitle?: string;

package/services/docx/index.d.ts

@@ -1,5 +1,3 @@
-import { SdNotifyService } from '@sdcorejs/angular/services/notify';
-import { SdLoadingService } from '@sdcorejs/angular/services/loading';
 import * as i0 from '@angular/core';
 
 interface SdDocxConvertOptions {
@@ -16,7 +14,8 @@ declare class SdDocxService {
     #private;
     private notifyService;
     private loadingService;
-    constructor(notifyService: SdNotifyService, loadingService: SdLoadingService);
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
     open(options?: SdDocxConvertOptions): Promise<SdDocxConvertResult | null>;
     convertToHtml(input: File | Blob | ArrayBuffer, options?: SdDocxConvertOptions): Promise<SdDocxConvertResult | null>;
     convertToHtmlString(input: File | Blob | ArrayBuffer, options?: SdDocxConvertOptions): Promise<string | null>;

package/services/index.d.ts

@@ -1,8 +1,12 @@
 export * from '@sdcorejs/angular/services/cache';
 export * from '@sdcorejs/angular/services/storage';
+export * from '@sdcorejs/angular/services/persistence';
 export * from '@sdcorejs/angular/services/notify';
 export * from '@sdcorejs/angular/services/confirm';
 export * from '@sdcorejs/angular/services/api';
 export * from '@sdcorejs/angular/services/loading';
 export * from '@sdcorejs/angular/services/excel';
 export * from '@sdcorejs/angular/services/docx';
+export * from '@sdcorejs/angular/services/viewport';
+export * from '@sdcorejs/angular/services/unsaved-changes';
+export * from '@sdcorejs/angular/services/task';

package/services/loading/index.d.ts

@@ -1,17 +1,25 @@
 import * as i0 from '@angular/core';
-import { RendererFactory2 } from '@angular/core';
 
+interface SdLoadingRef {
+    readonly closed: boolean;
+    close(): void;
+}
 declare class SdLoadingService {
     #private;
-    private loadingId;
-    private renderer;
-    private loadingMap;
-    constructor(rendererFactory: RendererFactory2);
-    start: (element?: string) => void;
-    isLoading: (element?: string) => boolean | null;
-    stop: (element?: string) => void;
+    private static readonly documentRecords;
+    /** Inserted by Angular inject() migration for backwards compatibility. */
+    constructor(...args: unknown[]);
+    /** Starts loading for every current selector match and returns ownership of those exact hosts. */
+    start: (selector?: string) => SdLoadingRef;
+    /** Returns the first matched globally loading host, `false` for idle matches, or `null` when unavailable. */
+    isLoading: (selector?: string) => Element | false | null;
+    /** Releases the oldest exact-selector start, with a current-host fallback for legacy cross-selector calls. */
+    stop: (selector?: string) => void;
+    run<T>(task: () => T | PromiseLike<T>, selector?: string): Promise<T>;
+    run<T>(task: PromiseLike<T>, selector?: string): Promise<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdLoadingService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdLoadingService>;
 }
 
 export { SdLoadingService };
+export type { SdLoadingRef };

package/services/persistence/index.d.ts

@@ -0,0 +1,159 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+declare const SD_GRAPH_FORMAT = "sdcorejs.graph";
+declare const SD_GRAPH_VERSION = 1;
+type SdPersistenceErrorCode = 'INVALID_DOCUMENT' | 'UNKNOWN_FORMAT' | 'UNKNOWN_VERSION' | 'INVALID_NODE' | 'INVALID_REFERENCE' | 'UNSUPPORTED_VALUE' | 'LIMIT_EXCEEDED';
+interface SdGraphSerializerLimits {
+    maxDocumentCharacters: number;
+    maxDepth: number;
+    maxNodes: number;
+    maxEntries: number;
+    maxStringCharacters: number;
+    maxKeyCharacters: number;
+    maxBigIntDigits: number;
+}
+interface SdPersistenceSerializer {
+    readonly format: string;
+    stringify<T>(value: T): string;
+    parse<T = unknown>(serialized: string): T;
+    clone<T>(value: T): T;
+}
+/** Deterministic, versioned canonicalization used only for persistence identity. */
+interface SdPersistenceIdentityCanonicalizer {
+    readonly format: string;
+    canonicalize(value: unknown): string;
+}
+type SdGraphSpecialNumber = 'NaN' | 'Infinity' | '-Infinity' | '-0';
+type SdGraphValue = null | boolean | string | number | {
+    $ref: number;
+} | {
+    $type: 'undefined';
+} | {
+    $type: 'number';
+    value: SdGraphSpecialNumber;
+} | {
+    $type: 'bigint';
+    value: string;
+};
+interface SdGraphArrayNode {
+    type: 'array';
+    values: SdGraphValue[];
+}
+interface SdGraphObjectNode {
+    type: 'object';
+    prototype: 'object' | 'null';
+    entries: [string, SdGraphValue][];
+}
+interface SdGraphDateNode {
+    type: 'date';
+    value: string;
+}
+interface SdGraphMapNode {
+    type: 'map';
+    entries: [SdGraphValue, SdGraphValue][];
+}
+interface SdGraphSetNode {
+    type: 'set';
+    values: SdGraphValue[];
+}
+type SdGraphNode = SdGraphArrayNode | SdGraphObjectNode | SdGraphDateNode | SdGraphMapNode | SdGraphSetNode;
+interface SdGraphEnvelope {
+    format: typeof SD_GRAPH_FORMAT;
+    version: typeof SD_GRAPH_VERSION;
+    root: SdGraphValue;
+    nodes: SdGraphNode[];
+}
+
+declare const SD_GRAPH_HARD_LIMITS: Readonly<SdGraphSerializerLimits>;
+declare class SdPersistenceError extends Error {
+    readonly code: SdPersistenceErrorCode;
+    readonly name = "SdPersistenceError";
+    constructor(code: SdPersistenceErrorCode, message: string);
+}
+declare class SdGraphSerializer implements SdPersistenceSerializer {
+    #private;
+    readonly format = "sdcorejs.graph@1";
+    readonly limits: Readonly<SdGraphSerializerLimits>;
+    constructor(limits?: Partial<SdGraphSerializerLimits>);
+    stringify<T>(value: T): string;
+    parse<T = unknown>(serialized: string): T;
+    clone<T>(value: T): T;
+}
+
+type SdPersistenceStorageArea = 'local' | 'session';
+type SdPersistenceStorageRead = {
+    status: 'found';
+    value: string;
+} | {
+    status: 'absent';
+} | {
+    status: 'unavailable';
+};
+interface SdPersistenceStorageAdapter {
+    /** Optional tri-state read. Legacy adapters may continue to implement only `getItem`. */
+    readItem?(area: SdPersistenceStorageArea, key: string): SdPersistenceStorageRead;
+    getItem(area: SdPersistenceStorageArea, key: string): string | null;
+    setItem(area: SdPersistenceStorageArea, key: string, value: string): boolean;
+    removeItem(area: SdPersistenceStorageArea, key: string): boolean;
+}
+declare class SdBrowserStorageAdapter implements SdPersistenceStorageAdapter {
+    #private;
+    readItem(area: SdPersistenceStorageArea, key: string): SdPersistenceStorageRead;
+    getItem(area: SdPersistenceStorageArea, key: string): string | null;
+    setItem(area: SdPersistenceStorageArea, key: string, value: string): boolean;
+    removeItem(area: SdPersistenceStorageArea, key: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdBrowserStorageAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdBrowserStorageAdapter>;
+}
+declare function readSdPersistenceStorageItem(adapter: SdPersistenceStorageAdapter, area: SdPersistenceStorageArea, key: string): SdPersistenceStorageRead;
+declare const SD_PERSISTENCE_STORAGE_ADAPTER: InjectionToken<SdPersistenceStorageAdapter>;
+
+interface SdPersistenceKeyField {
+    tag: string;
+    value: string;
+}
+declare class SdPersistenceIdentityError extends Error {
+    readonly name = "SdPersistenceIdentityError";
+    constructor(message: string);
+}
+declare function buildSdPersistenceKey(baseKey: string, fields: readonly SdPersistenceKeyField[]): string;
+declare class SdGraphIdentityCanonicalizer implements SdPersistenceIdentityCanonicalizer {
+    #private;
+    readonly format = "sdcorejs.graph-identity@1";
+    canonicalize(value: unknown): string;
+}
+declare function canonicalizeSdPersistenceValue(canonicalizer: SdPersistenceIdentityCanonicalizer, value: unknown, label: string): string;
+declare function digestSdPersistenceKey(value: string): string;
+
+declare const SD_PERSISTENCE_ENVELOPE_FORMAT = "sdcorejs.persistence-envelope";
+declare const SD_PERSISTENCE_ENVELOPE_VERSION = 1;
+interface SdPersistenceEnvelopeLimits {
+    maxDocumentCharacters: number;
+    maxPayloadCharacters: number;
+    maxSerializerCharacters: number;
+    maxIdentityCharacters: number;
+}
+declare const SD_PERSISTENCE_ENVELOPE_HARD_LIMITS: Readonly<SdPersistenceEnvelopeLimits>;
+interface SdPersistenceValueEnvelope {
+    format: typeof SD_PERSISTENCE_ENVELOPE_FORMAT;
+    version: typeof SD_PERSISTENCE_ENVELOPE_VERSION;
+    kind: 'value';
+    identity: string;
+    serializer: string;
+    payload: string;
+}
+interface SdPersistenceTombstoneEnvelope {
+    format: typeof SD_PERSISTENCE_ENVELOPE_FORMAT;
+    version: typeof SD_PERSISTENCE_ENVELOPE_VERSION;
+    kind: 'tombstone';
+    identity: string;
+    serializer: string;
+}
+type SdPersistenceEnvelope = SdPersistenceValueEnvelope | SdPersistenceTombstoneEnvelope;
+declare function stringifySdPersistenceValueEnvelope(identity: string, serializer: string, payload: string, limits?: Partial<SdPersistenceEnvelopeLimits>): string;
+declare function stringifySdPersistenceTombstoneEnvelope(identity: string, serializer: string, limits?: Partial<SdPersistenceEnvelopeLimits>): string;
+declare function parseSdPersistenceEnvelope(serialized: string, expectedIdentity: string, expectedSerializer: string, limits?: Partial<SdPersistenceEnvelopeLimits>): SdPersistenceEnvelope | undefined;
+
+export { SD_GRAPH_FORMAT, SD_GRAPH_HARD_LIMITS, SD_GRAPH_VERSION, SD_PERSISTENCE_ENVELOPE_FORMAT, SD_PERSISTENCE_ENVELOPE_HARD_LIMITS, SD_PERSISTENCE_ENVELOPE_VERSION, SD_PERSISTENCE_STORAGE_ADAPTER, SdBrowserStorageAdapter, SdGraphIdentityCanonicalizer, SdGraphSerializer, SdPersistenceError, SdPersistenceIdentityError, buildSdPersistenceKey, canonicalizeSdPersistenceValue, digestSdPersistenceKey, parseSdPersistenceEnvelope, readSdPersistenceStorageItem, stringifySdPersistenceTombstoneEnvelope, stringifySdPersistenceValueEnvelope };
+export type { SdGraphArrayNode, SdGraphDateNode, SdGraphEnvelope, SdGraphMapNode, SdGraphNode, SdGraphObjectNode, SdGraphSerializerLimits, SdGraphSetNode, SdGraphSpecialNumber, SdGraphValue, SdPersistenceEnvelope, SdPersistenceEnvelopeLimits, SdPersistenceErrorCode, SdPersistenceIdentityCanonicalizer, SdPersistenceKeyField, SdPersistenceSerializer, SdPersistenceStorageAdapter, SdPersistenceStorageArea, SdPersistenceStorageRead, SdPersistenceTombstoneEnvelope, SdPersistenceValueEnvelope };

package/services/storage/index.d.ts

@@ -1,33 +1,51 @@
 import * as i0 from '@angular/core';
 import { InjectionToken } from '@angular/core';
+import { SdPersistenceSerializer, SdPersistenceIdentityCanonicalizer } from '@sdcorejs/angular/services/persistence';
 import { BehaviorSubject, Observable } from 'rxjs';
 
-interface SdStorageOption<T = any> {
-    type?: 'session';
+interface SdStorageOption<T = unknown> {
+    type?: 'local' | 'session';
     default?: T;
-    args?: Record<string, any>;
+    args?: Readonly<Record<string, unknown>>;
+    namespace?: string;
+    version?: string | number;
+    serializer?: SdPersistenceSerializer;
+    identityCanonicalizer?: SdPersistenceIdentityCanonicalizer;
 }
-interface SdStorage<T = any> {
-    get: () => T;
+interface SdStorage<T = unknown> {
+    get: () => T | undefined;
     set: (data: T) => void;
     setSilent: (data: T) => void;
     has: () => boolean;
     remove: () => void;
+    destroy: () => void;
+    subject: BehaviorSubject<T | undefined>;
+    observer: Observable<T | undefined>;
+}
+interface SdStorageWithDefault<T> extends Omit<SdStorage<T>, 'get' | 'subject' | 'observer'> {
+    get: () => T;
     subject: BehaviorSubject<T>;
     observer: Observable<T>;
 }
 interface ISdStorageConfiguration {
     key?: (key: string) => string;
+    namespace?: string;
+    version?: string | number;
+    serializer?: SdPersistenceSerializer;
+    identityCanonicalizer?: SdPersistenceIdentityCanonicalizer;
 }
 declare const SD_STORAGE_CONFIG: InjectionToken<ISdStorageConfiguration>;
 
 declare class SdStorageService {
     #private;
-    private readonly configuration;
-    create<T = any>(key: string | object, option?: SdStorageOption<T>): SdStorage<T>;
+    constructor();
+    create<T>(key: string | object, option: SdStorageOption<T> & {
+        default: T;
+    }): SdStorageWithDefault<T>;
+    create<T = unknown>(key: string | object, option?: SdStorageOption<unknown>): SdStorage<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdStorageService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdStorageService>;
 }
 
 export { SD_STORAGE_CONFIG, SdStorageService };
-export type { ISdStorageConfiguration, SdStorage, SdStorageOption };
+export type { ISdStorageConfiguration, SdStorage, SdStorageOption, SdStorageWithDefault };

package/services/task/index.d.ts

@@ -0,0 +1,104 @@
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken } from '@angular/core';
+
+type SdTaskMaybeAsync<T> = T | PromiseLike<T>;
+type SdTaskStatus = 'idle' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+type SdTaskConnectionState = 'idle' | 'connecting' | 'open' | 'reconnecting' | 'closed' | 'error';
+interface SdTaskState<TResult = unknown> {
+    readonly id: string;
+    readonly status: SdTaskStatus;
+    readonly progress?: number;
+    readonly title?: string;
+    readonly message?: string;
+    readonly error?: unknown;
+    readonly result?: TResult;
+    readonly updatedAt?: number | Date;
+}
+interface SdTaskRetryPolicy {
+    readonly maxAttempts?: number;
+    readonly initialDelayMs?: number;
+    readonly backoff?: number;
+    readonly maxDelayMs?: number;
+    readonly jitter?: number;
+}
+interface SdTaskLoadContext<TResult = unknown> {
+    readonly id: string;
+    readonly signal: AbortSignal;
+    readonly attempt: number;
+    readonly state: SdTaskState<TResult>;
+}
+interface SdTaskActionContext<TResult = unknown> {
+    readonly id: string;
+    readonly state: SdTaskState<TResult>;
+}
+type SdTaskCancelResult<TResult = unknown> = void | boolean | SdTaskState<TResult>;
+type SdTaskCancelHandler<TResult = unknown> = (context: SdTaskActionContext<TResult>) => SdTaskMaybeAsync<SdTaskCancelResult<TResult>>;
+interface SdTaskSourceBase<TResult> {
+    readonly cancel?: SdTaskCancelHandler<TResult>;
+}
+interface SdTaskManualSource<TResult = unknown> extends SdTaskSourceBase<TResult> {
+    readonly mode: 'manual';
+}
+interface SdTaskPollingSource<TResult = unknown> extends SdTaskSourceBase<TResult> {
+    readonly mode: 'poll';
+    readonly load: (context: SdTaskLoadContext<TResult>) => SdTaskMaybeAsync<SdTaskState<TResult>>;
+    readonly intervalMs?: number;
+    readonly retry?: SdTaskRetryPolicy;
+}
+interface SdTaskSseSource<TResult = unknown> extends SdTaskSourceBase<TResult> {
+    readonly mode: 'sse';
+    readonly url: string | (() => string);
+    readonly eventSourceInit?: EventSourceInit;
+    readonly parse?: (event: MessageEvent<string>) => SdTaskMaybeAsync<SdTaskState<TResult>>;
+    readonly retry?: SdTaskRetryPolicy;
+}
+type SdTaskSource<TResult = unknown> = SdTaskManualSource<TResult> | SdTaskPollingSource<TResult> | SdTaskSseSource<TResult>;
+interface SdTaskWatchOptions<TResult = unknown> {
+    readonly id: string;
+    readonly initialState?: SdTaskState<TResult>;
+    readonly source: SdTaskSource<TResult>;
+}
+interface SdTaskView<TResult = unknown> {
+    readonly id: string;
+    readonly state: Signal<SdTaskState<TResult>>;
+    readonly connection: Signal<SdTaskConnectionState>;
+    readonly error: Signal<unknown | null>;
+    readonly subscriberCount: Signal<number>;
+    readonly canCancel: Signal<boolean>;
+    readonly canRetry: Signal<boolean>;
+    cancel(): Promise<boolean>;
+    retry(): void;
+}
+interface SdTaskSubscription<TResult = unknown> extends SdTaskView<TResult> {
+    readonly destroyed: Signal<boolean>;
+    destroy(): void;
+}
+declare function isSdTaskTerminal(status: SdTaskStatus): boolean;
+
+interface SdTaskEventSource {
+    onopen: ((event: Event) => void) | null;
+    onmessage: ((event: MessageEvent<string>) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    close(): void;
+}
+interface SdTaskEventSourceFactory {
+    create(url: string, init?: EventSourceInit): SdTaskEventSource;
+}
+declare const SD_TASK_EVENT_SOURCE_FACTORY: InjectionToken<SdTaskEventSourceFactory | null>;
+declare const SD_TASK_RANDOM: InjectionToken<() => number>;
+
+declare class SdTaskService {
+    #private;
+    readonly tasks: i0.Signal<SdTaskView<unknown>[]>;
+    constructor();
+    watch<TResult = unknown>(options: SdTaskWatchOptions<TResult>): SdTaskSubscription<TResult>;
+    get<TResult = unknown>(id: string): SdTaskView<TResult> | undefined;
+    update<TResult = unknown>(id: string, patch: Partial<Omit<SdTaskState<TResult>, 'id'>>): boolean;
+    cancel(id: string): Promise<boolean>;
+    retry(id: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTaskService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdTaskService>;
+}
+
+export { SD_TASK_EVENT_SOURCE_FACTORY, SD_TASK_RANDOM, SdTaskService, isSdTaskTerminal };
+export type { SdTaskActionContext, SdTaskCancelHandler, SdTaskCancelResult, SdTaskConnectionState, SdTaskEventSource, SdTaskEventSourceFactory, SdTaskLoadContext, SdTaskManualSource, SdTaskMaybeAsync, SdTaskPollingSource, SdTaskRetryPolicy, SdTaskSource, SdTaskSseSource, SdTaskState, SdTaskStatus, SdTaskSubscription, SdTaskView, SdTaskWatchOptions };

package/services/unsaved-changes/index.d.ts

@@ -0,0 +1,83 @@
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { CanDeactivateFn } from '@angular/router';
+
+type SdUnsavedChangesMaybeAsync<T> = T | PromiseLike<T>;
+type SdUnsavedChangesDirtySource = boolean | Signal<boolean> | (() => boolean);
+type SdUnsavedChangesDecision = 'save' | 'discard' | 'cancel';
+type SdUnsavedChangesReason = 'navigation' | 'close' | 'manual';
+interface SdUnsavedChangesWatcher {
+    readonly id: string;
+    readonly scope?: unknown;
+    readonly isDirty: SdUnsavedChangesDirtySource;
+    readonly message?: string;
+    readonly save?: () => SdUnsavedChangesMaybeAsync<void | boolean>;
+    readonly reset?: () => SdUnsavedChangesMaybeAsync<void | boolean>;
+    readonly discard?: () => SdUnsavedChangesMaybeAsync<void | boolean>;
+    readonly cleanup?: () => void;
+}
+interface SdUnsavedChangesPromptContext {
+    readonly reason: SdUnsavedChangesReason;
+    readonly scope?: unknown;
+    readonly message: string;
+    readonly watchers: readonly SdUnsavedChangesRegistration[];
+}
+interface SdUnsavedChangesConfirmationAdapter {
+    confirm(context: SdUnsavedChangesPromptContext): SdUnsavedChangesMaybeAsync<SdUnsavedChangesDecision | boolean>;
+}
+interface SdUnsavedChangesRegistration {
+    readonly id: string;
+    readonly scope?: unknown;
+    readonly message?: string;
+    readonly destroyed: Signal<boolean>;
+    readonly dirty: Signal<boolean>;
+    markDirty(): void;
+    markPristine(): void;
+    save(): Promise<boolean>;
+    reset(): Promise<boolean>;
+    discard(): Promise<boolean>;
+    destroy(): void;
+}
+interface SdUnsavedChangesConfirmOptions {
+    readonly scope?: unknown;
+    readonly reason?: SdUnsavedChangesReason;
+}
+
+interface SdUnsavedChangesWindow {
+    addEventListener(type: 'beforeunload', listener: (event: BeforeUnloadEvent) => void): void;
+    removeEventListener(type: 'beforeunload', listener: (event: BeforeUnloadEvent) => void): void;
+    confirm?(message?: string): boolean;
+}
+declare const SD_UNSAVED_CHANGES_WINDOW: InjectionToken<SdUnsavedChangesWindow | null>;
+declare const SD_UNSAVED_CHANGES_CONFIRMATION_ADAPTER: InjectionToken<SdUnsavedChangesConfirmationAdapter>;
+
+declare class SdUnsavedChangesService {
+    #private;
+    readonly registrations: _angular_core.Signal<SdUnsavedChangesRegistration[]>;
+    readonly dirty: _angular_core.Signal<boolean>;
+    constructor();
+    register(watcher: SdUnsavedChangesWatcher): SdUnsavedChangesRegistration;
+    hasChanges(scope?: unknown): boolean;
+    confirmLeave(options?: SdUnsavedChangesConfirmOptions): Promise<boolean>;
+    saveAll(scope?: unknown): Promise<boolean>;
+    resetAll(scope?: unknown): Promise<boolean>;
+    discardAll(scope?: unknown): Promise<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdUnsavedChangesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdUnsavedChangesService>;
+}
+
+interface SdUnsavedChangesFormOptions<TValue> {
+    readonly id: string;
+    readonly scope?: unknown;
+    readonly message?: string;
+    readonly save?: (value: TValue) => SdUnsavedChangesMaybeAsync<void | boolean>;
+    readonly reset?: (form: FormGroup) => SdUnsavedChangesMaybeAsync<void | boolean>;
+    readonly discard?: (form: FormGroup) => SdUnsavedChangesMaybeAsync<void | boolean>;
+}
+declare function registerSdUnsavedChangesForm<TValue extends Record<string, unknown>>(service: SdUnsavedChangesService, form: FormGroup, options: SdUnsavedChangesFormOptions<TValue>): SdUnsavedChangesRegistration;
+declare function createSdUnsavedChangesCloseGuard(service: SdUnsavedChangesService, options?: Omit<SdUnsavedChangesConfirmOptions, 'reason'>): () => Promise<boolean>;
+declare const sdUnsavedChangesGuard: CanDeactivateFn<unknown>;
+
+export { SD_UNSAVED_CHANGES_CONFIRMATION_ADAPTER, SD_UNSAVED_CHANGES_WINDOW, SdUnsavedChangesService, createSdUnsavedChangesCloseGuard, registerSdUnsavedChangesForm, sdUnsavedChangesGuard };
+export type { SdUnsavedChangesConfirmOptions, SdUnsavedChangesConfirmationAdapter, SdUnsavedChangesDecision, SdUnsavedChangesDirtySource, SdUnsavedChangesFormOptions, SdUnsavedChangesMaybeAsync, SdUnsavedChangesPromptContext, SdUnsavedChangesReason, SdUnsavedChangesRegistration, SdUnsavedChangesWatcher, SdUnsavedChangesWindow };

package/services/viewport/index.d.ts

@@ -0,0 +1,42 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as _sdcorejs_angular_services_viewport from '@sdcorejs/angular/services/viewport';
+
+interface SdViewportBreakpoints {
+    mobile: number;
+    tablet: number;
+    desktop: number;
+}
+type SdViewportBreakpoint = keyof SdViewportBreakpoints;
+interface SdViewport {
+    innerWidth: number;
+    innerHeight?: number;
+    addEventListener(type: 'resize', listener: EventListenerOrEventListenerObject): void;
+    removeEventListener(type: 'resize', listener: EventListenerOrEventListenerObject): void;
+}
+
+declare const SD_VIEWPORT_DEFAULT_BREAKPOINTS: Readonly<SdViewportBreakpoints>;
+declare const SD_VIEWPORT: InjectionToken<SdViewport | null>;
+declare const SD_VIEWPORT_BREAKPOINTS: InjectionToken<Readonly<SdViewportBreakpoints>>;
+declare function sdNormalizeViewportBreakpoints(value: Readonly<SdViewportBreakpoints>): Readonly<SdViewportBreakpoints>;
+
+/**
+ * Exposes one SSR-safe, signal-based viewport state for the application.
+ * Breakpoints use min-width semantics and can be configured through `SD_VIEWPORT_BREAKPOINTS`.
+ */
+declare class SdViewportService {
+    #private;
+    readonly breakpoints: Readonly<_sdcorejs_angular_services_viewport.SdViewportBreakpoints>;
+    readonly width: _angular_core.Signal<number>;
+    readonly height: _angular_core.Signal<number>;
+    readonly currentBreakpoint: _angular_core.Signal<keyof _sdcorejs_angular_services_viewport.SdViewportBreakpoints>;
+    readonly isMobile: _angular_core.Signal<boolean>;
+    readonly isTablet: _angular_core.Signal<boolean>;
+    readonly isDesktop: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SdViewportService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SdViewportService>;
+}
+
+export { SD_VIEWPORT, SD_VIEWPORT_BREAKPOINTS, SD_VIEWPORT_DEFAULT_BREAKPOINTS, SdViewportService, sdNormalizeViewportBreakpoints };
+export type { SdViewport, SdViewportBreakpoint, SdViewportBreakpoints };