@sdcorejs/angular 19.1.3 → 19.1.4

package/modules/layout/configurations/layout.configuration.d.ts

@@ -2,6 +2,7 @@ import { InjectionToken } from '@angular/core';
 import { MaybeAsync } from '@sdcorejs/utils/models';
 export interface ISdLayoutConfiguration {
     homeUrl?: string;
+    mobileBreakpoint?: number;
     sidebar: ISdSidebarConfiguration | (() => MaybeAsync<ISdSidebarConfiguration>);
     userInfo: SdLayoutUserInfo | (() => MaybeAsync<SdLayoutUserInfo>);
     signout: () => void | Promise<void>;
@@ -30,8 +31,18 @@ export interface SdLayoutUserInfo {
      */
     avatar?: string;
 }
-export type ISdSidebarConfiguration = SidebarConfigurationV1;
-export interface SidebarConfigurationV1 {
+export declare const DEFAULT_LAYOUT_MOBILE_BREAKPOINT = 1024;
+export interface SidebarConfigurationBase {
+    brandColor?: string;
+    brandLightColor?: string;
+    logoUrl?: string;
+    defaultTitle?: string;
+    pin?: {
+        enabled?: boolean;
+    };
+}
+export type ISdSidebarConfiguration = SidebarConfigurationV1 | SidebarConfigurationV2 | SidebarConfigurationV3;
+export interface SidebarConfigurationV1 extends SidebarConfigurationBase {
     version: 1;
     /**
      * Màu brand chính.
@@ -64,4 +75,27 @@ export interface SidebarConfigurationV1 {
         enabled?: boolean;
     };
 }
+export interface SidebarConfigurationV2 extends SidebarConfigurationBase {
+    version: 2;
+    interaction?: 'click' | 'hover-lock';
+    primaryMenuIds?: string[];
+}
+export interface SidebarConfigurationV3 extends SidebarConfigurationBase {
+    version: 3;
+    defaultCollapsed?: boolean;
+    recent?: {
+        enabled?: boolean;
+        maxItems?: number;
+    };
+}
+export interface ResolvedSidebarRecentConfiguration {
+    enabled: boolean;
+    maxItems: number;
+}
+export declare function normalizeLayoutMobileBreakpoint(value: number | undefined): number;
+export declare function resolveSidebarV2Interaction(sidebar: SidebarConfigurationV2): 'click' | 'hover-lock';
+export declare function resolveSidebarV3Recent(sidebar: SidebarConfigurationV3): ResolvedSidebarRecentConfiguration;
+export declare function normalizeSidebarConfiguration(_sidebar: SidebarConfigurationV1): SidebarConfigurationV1;
+export declare function normalizeSidebarConfiguration(_sidebar: SidebarConfigurationV2): SidebarConfigurationV2;
+export declare function normalizeSidebarConfiguration(_sidebar: SidebarConfigurationV3): SidebarConfigurationV3;
 export declare const SD_LAYOUT_CONFIGURATION: InjectionToken<ISdLayoutConfiguration>;

package/modules/layout/index.d.ts

@@ -2,4 +2,5 @@ export * from './modules';
 export * from './services';
 export * from './components';
 export * from './configurations';
+export * from './pipes';
 export * from './layout.module';

package/modules/layout/pipes/menu.pipe.d.ts

@@ -1,11 +1,11 @@
 import { PipeTransform } from '@angular/core';
 import { SdLayoutMenu } from '../services/menu/menu.model';
-import { SdPermissionService } from '@sdcorejs/angular/modules/permission';
 import * as i0 from "@angular/core";
 export declare class MenuPipe implements PipeTransform {
     #private;
     private permissionService;
-    constructor(permissionService: SdPermissionService);
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
     transform(menus: SdLayoutMenu[]): SdLayoutMenu[];
     static ɵfac: i0.ɵɵFactoryDeclaration<MenuPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<MenuPipe, "menu", true>;

package/modules/layout/services/index.d.ts

@@ -1,3 +1,6 @@
 export type * from './menu/menu.model';
 export * from './storage/storage.service';
+export * from './responsive/responsive.service';
+export * from './navigation-state/navigation-state.service';
+export * from './menu/menu.utils';
 export * from './layout.service';

package/modules/layout/services/layout.service.d.ts

@@ -1,9 +1,9 @@
-import { SdLayoutUserInfo } from '../configurations';
+import { ISdSidebarConfiguration, SdLayoutUserInfo } from '../configurations';
 import * as i0 from "@angular/core";
 export declare class SdLayoutService {
     #private;
     userInfo: import("@angular/core").WritableSignal<SdLayoutUserInfo | undefined>;
-    sidebar: import("@angular/core").WritableSignal<import("@sdcorejs/angular/modules/layout").SidebarConfigurationV1 | undefined>;
+    sidebar: import("@angular/core").WritableSignal<ISdSidebarConfiguration | undefined>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<SdLayoutService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdLayoutService>;

package/modules/layout/services/menu/menu.utils.d.ts

@@ -0,0 +1,6 @@
+import { SdLayoutChildrenMenu, SdLayoutMenu, SdLayoutRootMenu } from './menu.model';
+export declare function getMenuStableKey(menu: SdLayoutMenu | null | undefined, ancestors?: string[]): string;
+export declare function searchMenuLeaves(menus: SdLayoutMenu[], query: string): SdLayoutRootMenu[];
+export declare function selectPrimaryMenuGroups(menus: SdLayoutMenu[], requestedIds: string[] | undefined, maximum?: number): SdLayoutMenu[];
+export declare function resolveMenuKeys(menus: SdLayoutMenu[], keys: string[]): (SdLayoutRootMenu | SdLayoutChildrenMenu)[];
+export declare function flattenMenuLeaves(menus: SdLayoutMenu[]): SdLayoutRootMenu[];

package/modules/layout/services/navigation-state/navigation-state.service.d.ts

@@ -0,0 +1,18 @@
+import { ResolvedSidebarRecentConfiguration } from '../../configurations';
+import { SdLayoutMenu } from '../menu/menu.model';
+import { SdLayoutVersionState } from '../storage/storage.service';
+import * as i0 from "@angular/core";
+export declare class SdLayoutNavigationStateService {
+    #private;
+    readonly pinnedKeys: import("@angular/core").WritableSignal<string[]>;
+    readonly recentKeys: import("@angular/core").WritableSignal<string[]>;
+    readonly pinnedMenus: import("@angular/core").Signal<(import("@sdcorejs/angular/modules/layout").SdLayoutRootMenu | import("@sdcorejs/angular/modules/layout").SdLayoutChildrenMenu)[]>;
+    readonly recentMenus: import("@angular/core").Signal<(import("@sdcorejs/angular/modules/layout").SdLayoutRootMenu | import("@sdcorejs/angular/modules/layout").SdLayoutChildrenMenu)[]>;
+    hydrate(menus: SdLayoutMenu[], recentMaximum?: number): void;
+    togglePinned(menu: SdLayoutMenu): void;
+    recordRecent(menu: SdLayoutMenu, configuration: ResolvedSidebarRecentConfiguration): void;
+    patchVersionState(version: 1 | 2 | 3, patch: SdLayoutVersionState): void;
+    versionState(version: 1 | 2 | 3): SdLayoutVersionState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdLayoutNavigationStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdLayoutNavigationStateService>;
+}

package/modules/layout/services/responsive/responsive.service.d.ts

@@ -0,0 +1,12 @@
+import { SdViewport } from '@sdcorejs/angular/services/viewport';
+import * as i0 from "@angular/core";
+export type SdLayoutViewport = SdViewport;
+export declare const SD_LAYOUT_VIEWPORT: import("@angular/core").InjectionToken<SdViewport | null>;
+/** @deprecated Prefer `SdViewportService` from `@sdcorejs/angular/services/viewport`. */
+export declare class SdLayoutResponsiveService {
+    #private;
+    readonly viewportWidth: import("@angular/core").Signal<number>;
+    isMobile(breakpoint: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdLayoutResponsiveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdLayoutResponsiveService>;
+}

package/modules/layout/services/storage/storage.service.d.ts

@@ -1,13 +1,26 @@
-import { SdStorage, SdStorageService } from '@sdcorejs/angular/services';
-import { SdLayoutChildrenMenu } from '../menu/menu.model';
+import { SdStorage } from '@sdcorejs/angular/services';
+import { SdLayoutChildrenMenu, SdLayoutMenu } from '../menu/menu.model';
 import * as i0 from "@angular/core";
 export declare class SdLayoutStorageService {
-    private sdStorageService;
-    isShowSidebar: SdStorage<boolean>;
-    menuLockStatus: SdStorage<boolean>;
-    lastActiveMenuGroupId: SdStorage<string>;
-    pinnedMenuGroup: SdStorage<SdLayoutChildrenMenu>;
-    constructor(sdStorageService: SdStorageService);
+    #private;
+    readonly isShowSidebar: SdStorage<boolean>;
+    readonly menuLockStatus: SdStorage<boolean>;
+    readonly lastActiveMenuGroupId: SdStorage<string>;
+    readonly pinnedMenuGroup: SdStorage<SdLayoutChildrenMenu>;
+    readonly pinnedMenuKeys: SdStorage<string[]>;
+    readonly recentMenuKeys: SdStorage<string[]>;
+    readonly versionStates: SdStorage<Record<string, SdLayoutVersionState>>;
+    readPinnedMenuKeys(menus: SdLayoutMenu[]): string[];
+    writePinnedMenuKeys(keys: string[]): void;
+    readRecentMenuKeys(menus: SdLayoutMenu[], maximum?: number): string[];
+    writeRecentMenuKeys(keys: string[]): void;
+    readVersionState(version: 1 | 2 | 3): SdLayoutVersionState;
+    patchVersionState(version: 1 | 2 | 3, patch: SdLayoutVersionState): SdLayoutVersionState;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdLayoutStorageService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SdLayoutStorageService>;
 }
+export interface SdLayoutVersionState {
+    activeGroupKey?: string;
+    locked?: boolean;
+    collapsed?: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdcorejs/angular",
-  "version": "19.1.3",
+  "version": "19.1.4",
   "license": "MIT",
   "peerDependencies": {
     "@angular/common": "^19.0.0 || ^20.0.0 || ^21.0.0",
@@ -87,6 +87,10 @@
       "types": "./components/anchor/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-anchor.mjs"
     },
+    "./components/audit-diff": {
+      "types": "./components/audit-diff/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-components-audit-diff.mjs"
+    },
     "./components/autoid-inspector": {
       "types": "./components/autoid-inspector/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-autoid-inspector.mjs"
@@ -103,6 +107,10 @@
       "types": "./components/base/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-base.mjs"
     },
+    "./components/breadcrumb": {
+      "types": "./components/breadcrumb/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-components-breadcrumb.mjs"
+    },
     "./components/button": {
       "types": "./components/button/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-button.mjs"
@@ -119,6 +127,10 @@
       "types": "./components/code-editor/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-code-editor.mjs"
     },
+    "./components/data-state": {
+      "types": "./components/data-state/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-components-data-state.mjs"
+    },
     "./components/document-builder": {
       "types": "./components/document-builder/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-document-builder.mjs"
@@ -143,6 +155,10 @@
       "types": "./components/inform/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-inform.mjs"
     },
+    "./components/job-progress": {
+      "types": "./components/job-progress/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-components-job-progress.mjs"
+    },
     "./components/mini-editor": {
       "types": "./components/mini-editor/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-components-mini-editor.mjs"
@@ -251,6 +267,10 @@
       "types": "./forms/directives/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-forms-directives.mjs"
     },
+    "./forms/entity-picker": {
+      "types": "./forms/entity-picker/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-forms-entity-picker.mjs"
+    },
     "./forms/inline-text": {
       "types": "./forms/inline-text/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-forms-inline-text.mjs"
@@ -291,6 +311,18 @@
       "types": "./forms/textarea/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-forms-textarea.mjs"
     },
+    "./forms/time": {
+      "types": "./forms/time/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-forms-time.mjs"
+    },
+    "./forms/time-range": {
+      "types": "./forms/time-range/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-forms-time-range.mjs"
+    },
+    "./forms/tree-select": {
+      "types": "./forms/tree-select/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-forms-tree-select.mjs"
+    },
     "./modules/auth": {
       "types": "./modules/auth/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-modules-auth.mjs"
@@ -343,10 +375,26 @@
       "types": "./services/notify/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-services-notify.mjs"
     },
+    "./services/persistence": {
+      "types": "./services/persistence/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-services-persistence.mjs"
+    },
     "./services/storage": {
       "types": "./services/storage/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-services-storage.mjs"
     },
+    "./services/task": {
+      "types": "./services/task/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-services-task.mjs"
+    },
+    "./services/unsaved-changes": {
+      "types": "./services/unsaved-changes/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-services-unsaved-changes.mjs"
+    },
+    "./services/viewport": {
+      "types": "./services/viewport/index.d.ts",
+      "default": "./fesm2022/sdcorejs-angular-services-viewport.mjs"
+    },
     "./utilities/data-state": {
       "types": "./utilities/data-state/index.d.ts",
       "default": "./fesm2022/sdcorejs-angular-utilities-data-state.mjs"

package/pipes/src/safe-html.pipe.d.ts

@@ -1,9 +1,9 @@
 import { PipeTransform } from '@angular/core';
-import { DomSanitizer } from '@angular/platform-browser';
 import * as i0 from "@angular/core";
 export declare class SdSafeHtmlPipe implements PipeTransform {
     private sanitizer;
-    constructor(sanitizer: DomSanitizer);
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
     transform(html: string | number | undefined | null): import("@angular/platform-browser").SafeHtml | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdSafeHtmlPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<SdSafeHtmlPipe, "sdSafeHtml", true>;

package/services/api/src/api.model.d.ts

@@ -1,36 +1,75 @@
-import { HttpClient, HttpErrorResponse, HttpRequest, HttpResponse } from '@angular/common/http';
+import { HttpContext, HttpErrorResponse, HttpHeaders, HttpParams, HttpRequest, HttpResponse } from '@angular/common/http';
 import { InjectionToken } from '@angular/core';
 import { SdCacheOption } from '@sdcorejs/angular/services/cache';
+export type SdApiResponseType = 'arraybuffer' | 'blob' | 'json' | 'text';
+type SdApiBivariantCallback<TArgument, TResult> = {
+    bivarianceHack(argument: TArgument): TResult;
+}['bivarianceHack'];
+export 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;
+}
+export 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;
+}
 export 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];
-export type SdGetOption = HttpGetOption & SdApiOption;
-type HttpPostOption = Parameters<HttpClient['post']>[2];
-export type SdPostOption = HttpPostOption & SdApiOption;
-type HttpPutOption = Parameters<HttpClient['put']>[2];
-export type SdPutOption = HttpPutOption & SdApiOption;
-type HttpDeleteOption = Parameters<HttpClient['delete']>[1];
-export type SdDeleteOption = HttpDeleteOption & SdApiOption;
+export type SdGetOption = SdApiHttpOption & SdApiOption;
+export type SdPostOption = SdApiHttpOption & SdApiOption;
+export type SdPutOption = SdApiHttpOption & SdApiOption;
+export type SdPatchOption = SdApiHttpOption & SdApiOption;
+export type SdDeleteOption = SdApiHttpOption & SdApiOption;
+export type SdApiRequestUpdate = Parameters<HttpRequest<unknown>['clone']>[0];
 export 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;
 }
 export interface ISdApiConfiguration {
-    handlers: SdApiHandler[];
+    handlers?: SdApiHandler[];
 }
 export declare const SD_API_CONFIG: InjectionToken<ISdApiConfiguration>;
+/** @deprecated Use `SD_API_CONFIG`. This is the same injection token. */
 export declare const SD_API_CONFIGURATION: InjectionToken<ISdApiConfiguration>;
 export {};

package/services/api/src/api.service.d.ts

@@ -1,19 +1,24 @@
 import { HttpClient } from '@angular/common/http';
-import { SdDeleteOption, SdGetOption, SdPostOption, SdPutOption } from './api.model';
+import { SdDeleteOption, SdGetOption, SdPatchOption, SdPostOption, SdPutOption } from './api.model';
 import * as i0 from "@angular/core";
+/**
+ * Response generics intentionally default to `unknown` for type safety.
+ * Callers should specify `T`; migration guidance is tracked for Task 13.
+ */
 export 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>;
 }

package/services/api/src/interceptors/api.interceptor.d.ts

@@ -3,7 +3,7 @@ import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export 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>;
 }

package/services/cache/src/cache.model.d.ts

@@ -1,30 +1,63 @@
 import { InjectionToken } from '@angular/core';
+import { SdPersistenceIdentityCanonicalizer, SdPersistenceSerializer } from '@sdcorejs/angular/services/persistence';
 import { Observable } from 'rxjs';
-export interface SdCacheOption<T = any> {
+export 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;
 }
-export interface SdCache<T = any> {
-    get: () => T;
+export 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>;
 }
+export type SdCacheSnapshot<T> = {
+    present: false;
+} | {
+    present: true;
+    value: T;
+};
+export interface SdCacheWithDefault<T> extends Omit<SdCache<T>, 'get' | 'observer'> {
+    get: () => T;
+    observer: Observable<T>;
+}
+export interface SdCacheStoredValue<T = unknown> {
+    data: T;
+    createdOn: Date;
+}
+export type SdCacheSetCallback = (key: string, value: SdCacheStoredValue<unknown>, option?: SdCacheOption<unknown>) => Promise<void> | void;
+export type SdCacheGetCallback = (key: string, option?: SdCacheOption<unknown>) => Promise<SdCacheStoredValue<unknown> | undefined>;
+export type SdCacheRemoveCallback = (key: string, option?: SdCacheOption<unknown>) => Promise<void> | void;
 export 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;
 }
 export declare const SD_CACHE_CONFIG: InjectionToken<ISdCacheConfiguration>;
+export 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`. */
+export declare function adaptLegacySdCacheCallbacks<T>(callbacks: SdLegacyCacheCallbacks<T>): ISdCacheConfiguration;

package/services/cache/src/cache.service.d.ts

@@ -1,9 +1,12 @@
-import { SdCache, SdCacheOption } from './cache.model';
+import { SdCache, SdCacheOption, SdCacheWithDefault } from './cache.model';
 import * as i0 from "@angular/core";
 export 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>;
 }

package/services/confirm/src/lib/confirm.service.d.ts

@@ -1,10 +1,10 @@
-import { MatDialog } from '@angular/material/dialog';
 import { Color } from '@sdcorejs/utils/models';
 import * as i0 from "@angular/core";
 export 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/src/lib/docx.service.d.ts

@@ -1,12 +1,11 @@
-import { SdNotifyService } from '@sdcorejs/angular/services/notify';
-import { SdLoadingService } from '@sdcorejs/angular/services/loading';
 import { SdDocxConvertOptions, SdDocxConvertResult } from './docx.model';
 import * as i0 from "@angular/core";
 export 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/src/loading.service.d.ts

@@ -1,14 +1,21 @@
-import { RendererFactory2 } from '@angular/core';
 import * as i0 from "@angular/core";
+export interface SdLoadingRef {
+    readonly closed: boolean;
+    close(): void;
+}
 export 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>;
 }

package/services/notify/src/components/toast/toast.component.d.ts

@@ -1,7 +1,5 @@
 import { OnDestroy, OnInit } from '@angular/core';
-import { DomSanitizer } from '@angular/platform-browser';
 import { ToastData } from '../../notify.model';
-import { SdNotifyService } from '../../notify.service';
 import * as i0 from "@angular/core";
 export declare class ToastComponent implements OnInit, OnDestroy {
     private notifyService;
@@ -15,7 +13,8 @@ export declare class ToastComponent implements OnInit, OnDestroy {
     private closeTimer;
     private start;
     private remaining;
-    constructor(notifyService: SdNotifyService, sanitizer: DomSanitizer);
+    /** Inserted by Angular inject() migration for backwards compatibility */
+    constructor(...args: unknown[]);
     ngOnInit(): void;
     ngOnDestroy(): void;
     pauseTimer(): void;

package/services/persistence/index.d.ts

@@ -0,0 +1,5 @@
+export * from './src/persistence.model';
+export * from './src/graph-serializer';
+export * from './src/storage-adapter';
+export * from './src/persistence-key';
+export * from './src/persistence-envelope';