@sdcorejs/angular 20.1.3 → 20.1.5

package/services/api/index.d.ts

@@ -1,62 +1,106 @@
-import { HttpRequest, HttpResponse, HttpErrorResponse, HttpClient, HttpInterceptor, HttpHandler, HttpEvent } from '@angular/common/http';
+import { HttpRequest, HttpResponse, HttpErrorResponse, HttpHeaders, HttpContext, HttpParams, HttpClient, HttpInterceptor, HttpHandler, HttpEvent } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { InjectionToken } from '@angular/core';
 import { SdCacheOption } from '@sdcorejs/angular/services/cache';
 import { Observable } from 'rxjs';
 
+type SdApiResponseType = 'arraybuffer' | 'blob' | 'json' | 'text';
+type SdApiBivariantCallback<TArgument, TResult> = {
+    bivarianceHack(argument: TArgument): TResult;
+}['bivarianceHack'];
+interface SdApiHttpOption {
+    headers?: HttpHeaders | Record<string, string | string[]>;
+    context?: HttpContext;
+    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+    observe?: 'body';
+    reportProgress?: boolean;
+    responseType?: SdApiResponseType;
+    withCredentials?: boolean;
+    transferCache?: {
+        includeHeaders?: string[];
+    } | boolean;
+}
+interface SdApiRetryOption {
+    /** Number of retries after the initial request. Values are clamped to a finite safe limit. */
+    attempts: number;
+    /** Delay before the first retry. Defaults to 0. */
+    delayMs?: number;
+    /** Multiplier applied to each subsequent delay. Defaults to 1. */
+    backoff?: number;
+    /** Overrides the default transient HTTP-status predicate. `attempt` is one-based. */
+    retryWhen?: (error: unknown, attempt: number) => boolean;
+    /** Required to retry POST, PUT, PATCH, or DELETE. */
+    mutations?: boolean;
+}
 interface SdApiOption {
     cacheOption?: SdCacheOption;
     timeout?: number;
+    /** Cancels only this caller; a shared HTTP request continues while another caller remains. */
+    signal?: AbortSignal;
+    /** Enables request deduplication. Defaults to true for GET and false for mutations. */
+    dedupe?: boolean;
+    /** Keeps a successful dedupe result replayable for this duration. Defaults to 1000ms. */
+    dedupeWindowMs?: number;
+    /** Opt-in bounded retry policy. The default is no retries. */
+    retry?: SdApiRetryOption;
+    /**
+     * @deprecated Use `dedupe`. When both are provided, `dedupe` takes precedence.
+     * Explicit `true` remains a compatibility opt-in for mutation deduplication.
+     */
     autoCache?: boolean;
 }
-type HttpGetOption = Parameters<HttpClient['get']>[1];
-type SdGetOption = HttpGetOption & SdApiOption;
-type HttpPostOption = Parameters<HttpClient['post']>[2];
-type SdPostOption = HttpPostOption & SdApiOption;
-type HttpPutOption = Parameters<HttpClient['put']>[2];
-type SdPutOption = HttpPutOption & SdApiOption;
-type HttpDeleteOption = Parameters<HttpClient['delete']>[1];
-type SdDeleteOption = HttpDeleteOption & SdApiOption;
+type SdGetOption = SdApiHttpOption & SdApiOption;
+type SdPostOption = SdApiHttpOption & SdApiOption;
+type SdPutOption = SdApiHttpOption & SdApiOption;
+type SdPatchOption = SdApiHttpOption & SdApiOption;
+type SdDeleteOption = SdApiHttpOption & SdApiOption;
+type SdApiRequestUpdate = Parameters<HttpRequest<unknown>['clone']>[0];
 interface SdApiHandler {
     /** Danh sách host URL mà handler này sẽ xử lý */
     hosts: string[];
     /** Can thiệp request: gắn header, token, transform body... */
-    intercept?: (request: HttpRequest<any>) => HttpRequest<any>;
+    intercept?: SdApiBivariantCallback<HttpRequest<unknown>, HttpRequest<unknown> | SdApiRequestUpdate>;
     /** Hook chạy TRƯỚC khi gửi request (dùng để log, tracking...) */
-    beforeRemote?: (request: HttpRequest<any>) => void | Promise<void>;
+    beforeRemote?: SdApiBivariantCallback<HttpRequest<unknown>, void | Promise<void>>;
     /** Hook chạy SAU khi nhận response (xử lý lỗi, notify...) */
-    afterRemote?: (response: HttpResponse<any> | HttpErrorResponse | Error) => void | Promise<void>;
+    afterRemote?: SdApiBivariantCallback<HttpResponse<unknown> | HttpErrorResponse | Error, void | Promise<void>>;
     /** Transform response body thành kiểu dữ liệu mong muốn */
-    mapResponse?: <Tres = any, Tdata = any>(response: Tres) => Tdata;
-    /** Timeout tính bằng milliseconds. Mặc định: 30000 (30 giây) */
+    mapResponse?: SdApiBivariantCallback<unknown, unknown>;
+    /** Timeout tính bằng milliseconds. Mặc định: 60000 (60 giây) */
     timeout?: number;
 }
 interface ISdApiConfiguration {
-    handlers: SdApiHandler[];
+    handlers?: SdApiHandler[];
 }
 declare const SD_API_CONFIG: InjectionToken<ISdApiConfiguration>;
+/** @deprecated Use `SD_API_CONFIG`. This is the same injection token. */
 declare const SD_API_CONFIGURATION: InjectionToken<ISdApiConfiguration>;
 
+/**
+ * Response generics intentionally default to `unknown` for type safety.
+ * Callers should specify `T`; migration guidance is tracked for Task 13.
+ */
 declare class SdApiService {
     #private;
     constructor();
     get http(): HttpClient;
-    get: <T = any>(url: string, option?: SdGetOption) => Promise<T>;
-    post: <T = any>(url: string, body?: any, option?: SdPostOption) => Promise<T>;
-    put: <T = any>(url: string, body?: any, option?: SdPutOption) => Promise<T>;
-    delete: <T = any>(url: string, option?: SdDeleteOption) => Promise<T>;
-    upload: (url: string, option?: {
+    get: <T = unknown>(url: string, option?: SdGetOption) => Promise<T>;
+    post: <T = unknown>(url: string, body?: unknown, option?: SdPostOption) => Promise<T>;
+    put: <T = unknown>(url: string, body?: unknown, option?: SdPutOption) => Promise<T>;
+    patch: <T = unknown>(url: string, body?: unknown, option?: SdPatchOption) => Promise<T>;
+    delete: <T = unknown>(url: string, option?: SdDeleteOption) => Promise<T>;
+    upload: <T = unknown>(url: string, option?: {
         extensions?: string[];
         maxSizeInMb?: number;
-    }) => Promise<any>;
-    uploadFile: (url: string, file: File) => Promise<any>;
+    }) => Promise<T | null | undefined>;
+    uploadFile: <T = unknown>(url: string, file: File | null | undefined) => Promise<T | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdApiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdApiService>;
 }
 
 declare class SdHttpInterceptor implements HttpInterceptor {
     #private;
-    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdHttpInterceptor, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdHttpInterceptor>;
 }
@@ -68,4 +112,4 @@ declare class SdApiModule {
 }
 
 export { SD_API_CONFIG, SD_API_CONFIGURATION, SdApiModule, SdApiService, SdHttpInterceptor };
-export type { ISdApiConfiguration, SdApiHandler, SdApiOption, SdDeleteOption, SdGetOption, SdPostOption, SdPutOption };
+export type { ISdApiConfiguration, SdApiHandler, SdApiHttpOption, SdApiOption, SdApiRequestUpdate, SdApiResponseType, SdApiRetryOption, SdDeleteOption, SdGetOption, SdPatchOption, SdPostOption, SdPutOption };

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) => false | Element | 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 };