@ng-atomic/common 16.1.1 → 16.3.1

package/services/root-property/root-property.service.d.ts

@@ -0,0 +1,91 @@
+import { Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class RootPropertyService {
+    static readonly Config: {
+        provide: (useFactory?: import("@ng-atomic/common/services/ui").ReducerFactory<{
+            '--primary-color': string;
+            '--on-primary-color': string;
+            '--surface-color': string;
+            '--on-surface-color': string;
+            '--background-color': string;
+            '--menu-width': string;
+            '--page-width-lv1': string;
+            '--page-width-lv2': string;
+            '--page-width-lv3': string;
+            '--page-width-lv4': string;
+            '--page-height-lv1': string;
+        }, any>, label?: string) => Provider;
+        inject: () => import("@angular/core").Signal<{
+            '--primary-color': string;
+            '--on-primary-color': string;
+            '--surface-color': string;
+            '--on-surface-color': string;
+            '--background-color': string;
+            '--menu-width': string;
+            '--page-width-lv1': string;
+            '--page-width-lv2': string;
+            '--page-width-lv3': string;
+            '--page-width-lv4': string;
+            '--page-height-lv1': string;
+        }>;
+    };
+    readonly config: import("@angular/core").Signal<{
+        '--primary-color': string;
+        '--on-primary-color': string;
+        '--surface-color': string;
+        '--on-surface-color': string;
+        '--background-color': string;
+        '--menu-width': string;
+        '--page-width-lv1': string;
+        '--page-width-lv2': string;
+        '--page-width-lv3': string;
+        '--page-width-lv4': string;
+        '--page-height-lv1': string;
+    }>;
+    readonly platformId: Object;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootPropertyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RootPropertyService>;
+}
+export declare function provideRootProperty(resolverFactoryFactory?: Parameters<typeof RootPropertyService.Config.provide>[0]): Provider[];
+export declare class NgAtomicStyleDirective {
+    #private;
+    private rootPropertyService;
+    readonly platformId: Object;
+    constructor(rootPropertyService: RootPropertyService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicStyleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgAtomicStyleDirective, "[atomicStyle]", never, {}, {}, never, never, true, never>;
+}
+export declare class RootPropertyGuard {
+    readonly properties: import("@angular/core").Signal<{
+        '--primary-color': string;
+        '--on-primary-color': string;
+        '--surface-color': string;
+        '--on-surface-color': string;
+        '--background-color': string;
+        '--menu-width': string;
+        '--page-width-lv1': string;
+        '--page-width-lv2': string;
+        '--page-width-lv3': string;
+        '--page-width-lv4': string;
+        '--page-height-lv1': string;
+    }>;
+    readonly properties$: Observable<{
+        '--primary-color': string;
+        '--on-primary-color': string;
+        '--surface-color': string;
+        '--on-surface-color': string;
+        '--background-color': string;
+        '--menu-width': string;
+        '--page-width-lv1': string;
+        '--page-width-lv2': string;
+        '--page-width-lv3': string;
+        '--page-width-lv4': string;
+        '--page-height-lv1': string;
+    }>;
+    readonly platformId: Object;
+    canActivate(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootPropertyGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RootPropertyGuard>;
+}

package/services/router/index.d.ts

@@ -0,0 +1 @@
+export * from './router.service';

package/services/router/router.service.d.ts

@@ -0,0 +1,10 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare function walkActivatedRoute(route: ActivatedRoute, callback: (route: ActivatedRoute) => boolean): void;
+export declare class RouterService extends Router {
+    readonly router: Router;
+    readonly events$: import("rxjs").Observable<import("@angular/router").Event>;
+    back(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouterService>;
+}

package/services/secret/index.d.ts

@@ -0,0 +1 @@
+export * from './secret.service';

package/services/secret/secret.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class SecretService {
+    readonly isSecret: import("@angular/core").WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecretService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SecretService>;
+}

package/services/side-app/index.d.ts

@@ -0,0 +1 @@
+export * from './side-app.service';

package/services/side-app/side-app.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class SideAppService {
+    readonly opened: import("@angular/core").WritableSignal<boolean>;
+    toggle(): void;
+    collapse(): void;
+    expand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideAppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideAppService>;
+}

package/services/side-nav-mode/index.d.ts

@@ -0,0 +1 @@
+export * from './side-nav-mode.service';

package/services/side-nav-mode/side-nav-mode.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class SideNavModeService {
+    readonly sideNavMode: import("@angular/core").WritableSignal<string>;
+    /** @deprecated use toggle() instead */
+    toggleSideNav(): void;
+    toggle(): void;
+    collapse(): void;
+    expand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideNavModeService>;
+}

package/services/snack-bar/snack-bar.service.d.ts

@@ -3,7 +3,7 @@ import * as i0 from "@angular/core";
 export declare class SnackBarService {
     private snackBar;
     constructor(snackBar: MatSnackBar);
-    openSnackBar(message: string, action?: string): void;
+    open(message: string, action?: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SnackBarService>;
 }

package/services/ui/index.d.ts

@@ -1 +1,2 @@
+export * from './ui.helpers';
 export * from './ui.service';

package/services/ui/ui.helpers.d.ts

@@ -0,0 +1,28 @@
+import { InjectionToken, Injector, Provider, ProviderToken, Signal } from "@angular/core";
+import { UIContext } from "./ui.service";
+import { Action } from "@ng-atomic/core";
+export declare function scoped<T extends object, TKey extends keyof T>(source: Signal<T>, path: TKey | [TKey]): Signal<T[TKey]>;
+export declare function injectBreakpoint(): Signal<import("./ui.service").Breakpoint>;
+export declare function injectIsMobile(): Signal<boolean>;
+export declare enum NavActionId {
+    TOGGLE_SIDE_NAV = "[@ng-atomic/common/services/ui] TOGGLE_SIDE_NAV",
+    BACK = "[@ng-atomic/common/services/ui] BACK"
+}
+export declare function injectIsRootPage$(): import("rxjs").Observable<boolean>;
+export declare function injectIsRootPage(): Signal<boolean>;
+export declare function injectNavStartActions(isRootPage?: Signal<boolean>): Signal<Action[]>;
+export declare function injectUiContext(): Signal<UIContext>;
+export type UiConfigReducer<T extends object | string, C extends UIContext = any> = (config: T, context: C) => T;
+export declare const UI_CONFIG_REDUCER: InjectionToken<UiConfigReducer<any, any>>;
+export type ReducerFactory<T extends object | string, K extends T = any> = (injector: Injector, hostInjector: Injector) => (config: K, context: UIContext) => T;
+export declare function call<T>(signalOrValue: Signal<T> | T): T;
+export declare function provideUiConfig<T extends object | string>(reducerFactory: ReducerFactory<T>, path?: string[], name?: string): Provider;
+export declare function injectRootConfig<T extends object>(): Signal<T>;
+export declare function injectUiConfig<T extends object>(paths?: string[]): Signal<T>;
+export declare function makeConfig<T extends object>(defaultUseFactory: ReducerFactory<T>, path: string[]): {
+    provide: (useFactory?: ReducerFactory<T>, label?: string) => Provider;
+    inject: () => Signal<T>;
+};
+export declare function injectReducers(): ((hostInjector: Injector) => UiConfigReducer<any>)[];
+export declare function injectDeepMulti<T>(token: ProviderToken<T>, injector?: Injector): T[];
+export declare function debugInjector(injector?: Injector | null): void;

package/services/ui/ui.service.d.ts

@@ -1,54 +1,49 @@
 import { BreakpointObserver } from '@angular/cdk/layout';
-import { Signal } from '@angular/core';
-import { NestedGetType, PathKeys } from '@ng-atomic/common/utils';
-import { Observable } from 'rxjs';
+import { RouterService } from '@ng-atomic/common/services/router';
 import * as i0 from "@angular/core";
-export interface UIConfig {
-    root: {
-        properties: {
-            '--page-width-lv1': string;
-            '--page-width-lv2': string;
-            '--page-width-lv3': string;
-            '--menu-width': string;
-        };
-    };
-    frames: {
-        sideNav: {
-            frameType: 'lineup' | 'drawer';
-            menuType: 'icon-button-menu' | 'menu';
-        };
-        router: {
-            type: 'lineup' | 'overlay';
-        };
-    };
-    templates: {
-        index: {
-            type: 'list' | 'table';
-            width: string;
-        };
-        crud: {
-            type: 'form' | 'table';
-            width: string;
-        };
-        menu: {
-            type: 'list' | 'table';
-            width: string;
-        };
-    };
+export interface UIContext {
+    breakpoint: Breakpoint;
+    paths: any[];
 }
-export declare class UiService {
+export type Breakpoint = 'xSmall' | 'small' | 'medium' | 'large' | 'xLarge' | 'handset' | 'tablet' | 'web';
+export declare class BreakPointService {
     protected readonly breakpointObserver: BreakpointObserver;
-    private readonly breakpoint$;
-    readonly ui$: Observable<UIConfig>;
-    readonly ui: Signal<UIConfig>;
-    mapTo(path: string): Observable<UIConfig>;
-    /**@deprecated */
-    getSignal<P extends (keyof any)[], T = UIConfig>(path: [...P]): Signal<NestedGetType<T, P>>;
-    get$<T, P extends PathKeys<T>>(path: P): Observable<NestedGetType<T, P>>;
-    get<T, P extends PathKeys<T>>(path: P): Signal<NestedGetType<T, P>>;
-    constructor();
+    readonly breakpointMap$: import("rxjs").Observable<{
+        xSmall: import("@angular/cdk/layout").BreakpointState;
+        small: import("@angular/cdk/layout").BreakpointState;
+        medium: import("@angular/cdk/layout").BreakpointState;
+        large: import("@angular/cdk/layout").BreakpointState;
+        xLarge: import("@angular/cdk/layout").BreakpointState;
+        handset: import("@angular/cdk/layout").BreakpointState;
+        tablet: import("@angular/cdk/layout").BreakpointState;
+        web: import("@angular/cdk/layout").BreakpointState;
+    }>;
+    readonly breakpointMap: import("@angular/core").Signal<{
+        xSmall: import("@angular/cdk/layout").BreakpointState;
+        small: import("@angular/cdk/layout").BreakpointState;
+        medium: import("@angular/cdk/layout").BreakpointState;
+        large: import("@angular/cdk/layout").BreakpointState;
+        xLarge: import("@angular/cdk/layout").BreakpointState;
+        handset: import("@angular/cdk/layout").BreakpointState;
+        tablet: import("@angular/cdk/layout").BreakpointState;
+        web: import("@angular/cdk/layout").BreakpointState;
+    }>;
+    readonly breakpoint: import("@angular/core").Signal<Breakpoint>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreakPointService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreakPointService>;
+}
+export declare class UiService {
+    readonly breakpoint: BreakPointService;
+    readonly router: RouterService;
+    readonly platformId: Object;
+    readonly paths$: import("rxjs").Observable<import("@angular/router").UrlSegment[]>;
+    readonly paths: import("@angular/core").Signal<import("@angular/router").UrlSegment[]>;
+    readonly snapshot$: import("rxjs").Observable<import("@angular/router").ActivatedRouteSnapshot>;
+    readonly snapshot: import("@angular/core").Signal<import("@angular/router").ActivatedRouteSnapshot>;
+    readonly uiContext: import("@angular/core").Signal<{
+        breakpoint: Breakpoint;
+        paths: import("@angular/router").UrlSegment[];
+    }>;
     static ɵfac: i0.ɵɵFactoryDeclaration<UiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<UiService>;
 }
-export declare function injectUiConfig$<T extends UIConfig, P extends PathKeys<T>>(path: P): Observable<NestedGetType<T, P>>;
-export declare function injectUiConfig<T extends UIConfig, P extends PathKeys<T>>(path: P): Signal<NestedGetType<T, P>>;

package/stores/entities/di.d.ts

@@ -0,0 +1,15 @@
+import { Signal } from '@angular/core';
+import { Type } from '@nx-ddd/common/domain/models';
+import { Resolver } from '@ng-atomic/common/utils';
+import { Observable } from 'rxjs';
+import { Entity } from './task-composer';
+import { EntityStore } from './entity-store';
+export declare function injectOne$<T extends Entity>(Entity: Type<T>, params?: Record<string | 'id', Observable<any>>, resolverType?: new (params: Record<string, Observable<any>>) => Resolver<T>): Observable<T>;
+export declare function injectOne<T extends Entity>(Entity: Type<T>, params?: Record<string | 'id', Signal<any>>, resolverType?: new (params: Record<string, any>) => Resolver<T>): Signal<T>;
+export declare function injectAll$<T extends Entity>(Entity: Type<T>, params?: Record<string, Observable<any>>, resolverType?: new (params: Record<string, any>) => Resolver<T>): Observable<T[]>;
+export declare const callSignalMap: <T extends Record<string, Signal<any>>>(map: T) => Signal<T>;
+export declare function injectAll<T extends Entity>(Entity: Type<T>, params?: Record<string, Signal<any>>, resolverType?: new (params: Record<string, any>) => Resolver<T>): Signal<T[]>;
+export type ValueOrObservable<T> = T | Observable<T>;
+export declare function mapToOne$<T extends {
+    id: string;
+}>(storeType: new () => EntityStore<T>, keyOrKey$: ValueOrObservable<string>): Observable<T>;

package/stores/entities/entity-store-manager.d.ts

@@ -0,0 +1,12 @@
+import { Type } from '@nx-ddd/common/domain/models';
+import { Entity } from './task-composer';
+import { EntityStore } from './entity-store';
+import * as i0 from "@angular/core";
+export declare const distinctUntilChangedArray: <T>() => import("rxjs").MonoTypeOperatorFunction<T>;
+export declare class EntityStoreManager {
+    protected storeMap: Map<Type<Entity>, EntityStore<Entity>>;
+    resolve<E extends Entity>(Entity: Type<E>): EntityStore<E>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityStoreManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityStoreManager>;
+}
+export declare function injectEntityStore<E extends Entity>(Entity: Type<E>): EntityStore<E>;

package/stores/entities/entity-store.d.ts

@@ -0,0 +1,86 @@
+import { InjectionToken, Injector } from '@angular/core';
+import { Type } from '@nx-ddd/common/domain/models';
+import { ComponentStore } from '@ngrx/component-store';
+import { EntityState, EntityAdapter } from '@ngrx/entity';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { Entity, Task, TaskComposerService } from './task-composer';
+import { ProxyIdService } from './proxy-id.service';
+export declare class EntityStoreAdapter<E extends Entity> {
+    list?(): Observable<E[]>;
+    create?(entity: E): Promise<E>;
+    update?(entity: Partial<E> & {
+        id: string;
+    }): Promise<void>;
+    delete?(entity: Partial<E> & {
+        id: string;
+    }): Promise<void>;
+}
+export declare const ENTITY_STORE_ADAPTER: InjectionToken<{
+    entity: Type<Entity>;
+    adapter: EntityStoreAdapter<Entity>;
+}[]>;
+export declare function provideEntityStoreAdapter<E extends Entity>(entity: Type<E>, adapterFactory: (injector: Injector) => EntityStoreAdapter<E>): {
+    provide: InjectionToken<{
+        entity: Type<Entity>;
+        adapter: EntityStoreAdapter<Entity>;
+    }[]>;
+    multi: boolean;
+    useFactory: (injector: Injector) => {
+        entity: Type<E>;
+        adapter: EntityStoreAdapter<E>;
+    };
+    deps: (typeof Injector)[];
+};
+export declare function injectEntityStoreAdapter<E extends Entity>(entity: Type<E>): EntityStoreAdapter<E>;
+export declare class BaseEntityStore<E extends Entity> extends ComponentStore<EntityState<E>> {
+    protected entity: Type<E>;
+    protected entityAdapter: EntityAdapter<E>;
+    protected adapter: EntityStoreAdapter<E>;
+    protected readonly refresh$: ReplaySubject<void>;
+    protected readonly selectors: import("@ngrx/entity/src/models").EntitySelectors<E, EntityState<E>>;
+    readonly entities$: Observable<E[]>;
+    readonly entities: import("@angular/core").Signal<E[]>;
+    readonly size$: Observable<number>;
+    readonly addOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => import("rxjs").Subscription;
+    readonly addMany: (observableOrValue: E[] | Observable<E[]>) => import("rxjs").Subscription;
+    readonly updateOne: (observableOrValue: {
+        id: string;
+        changes: Partial<E>;
+    } | Observable<{
+        id: string;
+        changes: Partial<E>;
+    }>) => import("rxjs").Subscription;
+    readonly updateMany: (observableOrValue: {
+        id: string;
+        changes: Partial<E>;
+    }[] | Observable<{
+        id: string;
+        changes: Partial<E>;
+    }[]>) => import("rxjs").Subscription;
+    readonly upsertOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => import("rxjs").Subscription;
+    readonly upsertMany: (observableOrValue: E[] | Observable<E[]>) => import("rxjs").Subscription;
+    readonly removeOne: (observableOrValue: string | Observable<string>) => import("rxjs").Subscription;
+    readonly removeMany: (observableOrValue: string[] | Observable<string[]>) => import("rxjs").Subscription;
+    readonly removeAll: () => void;
+    readonly setOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => import("rxjs").Subscription;
+    readonly setAll: (observableOrValue: E[] | Observable<E[]>) => import("rxjs").Subscription;
+    constructor(entity: Type<E>, entityAdapter?: EntityAdapter<E>);
+    getEntities: (observableOrValue?: void | Observable<void>) => import("rxjs").Subscription;
+    refresh(): void;
+    mapToOne(valueOrObs: string | Observable<string>): Observable<E>;
+}
+export declare class EntityStore<E extends Entity> extends BaseEntityStore<E> {
+    protected entity: Type<E>;
+    protected entityAdapter: EntityAdapter<E>;
+    protected proxyId: ProxyIdService;
+    protected composer: TaskComposerService;
+    protected taskSubject$: Subject<Task<E>>;
+    protected task$: Observable<Task<E>>;
+    protected composedTasks$: Observable<Task<E>[]>;
+    constructor(entity: Type<E>, entityAdapter?: EntityAdapter<E>);
+    dispatch(action: Task<E>): void;
+    protected runTask(task: Task<E>): Promise<any>;
+    protected runComposedTasks(tasks: Task<E>[]): Promise<void>;
+    protected onSyncFailed(): void;
+    protected onSyncSucceeded(): void;
+}

package/stores/entities/index.d.ts

@@ -1 +1,5 @@
-export * from './entities.store';
+export * from './di';
+export * from './entity-store-manager';
+export * from './entity-store';
+export * from './proxy-id.service';
+export * from './task-composer';

package/stores/entities/proxy-id.service.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class ProxyIdService {
+    proxyMap: Map<string, string>;
+    isProxyId(id: string | null): boolean;
+    proxyId(_id: string): string;
+    update(proxyId: string, id: string): void;
+    resolve(proxyIdOrId: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProxyIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProxyIdService>;
+}

package/stores/entities/task-composer.d.ts

@@ -0,0 +1,35 @@
+import { ProxyIdService } from "./proxy-id.service";
+import * as i0 from "@angular/core";
+export type Entity = {
+    id: string;
+};
+interface BaseTask {
+    type: 'create' | 'update' | 'delete' | 'noop';
+    timestamp: number;
+}
+interface CreateAction<T extends Entity> extends BaseTask {
+    type: 'create';
+    payload: T;
+}
+interface UpdateAction<T extends Entity> extends BaseTask {
+    type: 'update';
+    payload: Partial<T> & Entity;
+}
+interface DeleteAction extends BaseTask {
+    type: 'delete';
+    payload: Entity;
+}
+interface NoopAction extends BaseTask {
+    type: 'noop';
+    payload: {};
+}
+export type Task<T extends Entity> = CreateAction<T> | UpdateAction<T> | DeleteAction | NoopAction;
+export declare function pushMap<T>(map: Map<string, T[]>, id: string, item: T): Map<string, T[]>;
+export declare class TaskComposerService {
+    readonly proxyId: ProxyIdService;
+    composeTasks<T extends Entity>(tasks: Task<T>[]): Task<T>[];
+    compose<T extends Entity>(tasks: Task<T>[]): Task<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskComposerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskComposerService>;
+}
+export {};

package/stores/query/query.store.d.ts

@@ -4,10 +4,10 @@ import * as i0 from "@angular/core";
 export interface QueryState {
     query: string;
 }
-export declare class QueryStore<E = any> extends ComponentStore<QueryState> {
-    protected queryResolver: QueryResolverService;
+export declare class QueryStore<E extends object = any> extends ComponentStore<QueryState> {
+    protected queryResolver: QueryResolverService<E>;
     protected langMap: Record<string, string>;
-    constructor(queryResolver: QueryResolverService, langMap: Record<string, string>);
+    constructor(queryResolver: QueryResolverService<E>, langMap: Record<string, string>);
     get query(): string;
     query$: import("rxjs").Observable<string>;
     setQuery: (observableOrValue: string | import("rxjs").Observable<string>) => import("rxjs").Subscription;

package/utils/form/form.d.ts

@@ -0,0 +1,10 @@
+import { Signal } from "@angular/core";
+import { AbstractControl } from "@angular/forms";
+import { Observable } from "rxjs";
+export declare function getValue$<T>(control: AbstractControl<T>): Observable<T>;
+export declare function getValue<T>(control: AbstractControl<T>): Signal<T>;
+export declare function getRawValue$<T>(control: AbstractControl<T>): Observable<T>;
+export declare function getRawValue<T>(control: AbstractControl<T>): Signal<T>;
+export declare function computedRawValue<T>(controlFactory: () => AbstractControl<T>): Signal<T>;
+export declare function getInvalid$<T>(control: AbstractControl<T>): Observable<boolean>;
+export declare function getInvalid<T>(form: AbstractControl<T>): Signal<boolean>;

package/utils/form/index.d.ts

@@ -0,0 +1 @@
+export * from './form';

package/utils/get/get.d.ts

@@ -2,4 +2,5 @@ export type PathKeys<T> = T extends object ? {
     [K in keyof T]-?: K extends string | number ? T[K] extends object ? [K] | [K, ...PathKeys<T[K]>] : [K] : never;
 }[keyof T] : [];
 export type NestedGetType<T, P extends any[]> = P extends [infer F, ...infer R] ? F extends keyof T ? NestedGetType<T[F], R> : never : T;
+/** @deprecated use lodash-es */
 export declare function get<T, P extends PathKeys<T>>(obj: T, path: P): NestedGetType<T, P>;

package/utils/index.d.ts

@@ -2,8 +2,11 @@ export * from './comma';
 export * from './compare-by-id';
 export * from './date-utils';
 export * from './diff';
+export * from './form';
 export * from './get';
+export * from './inject';
 export * from './mat-dayjs-date';
+export * from './router';
 export * from './smart-exp-transformer';
 export * from './to-object';
-export * from './query';
+export * from './time';

package/utils/inject/index.d.ts

@@ -0,0 +1 @@
+export * from './inject';

package/utils/inject/inject.d.ts

@@ -0,0 +1,50 @@
+import { Injector, Signal } from "@angular/core";
+import { ActivatedRoute, ParamMap } from "@angular/router";
+import { Observable } from "rxjs";
+import { Type } from "@nx-ddd/common/domain/models";
+import * as i0 from "@angular/core";
+export declare function injectRouterParam$(key: string): Observable<string>;
+/** @deprecated */
+export declare function injectRouterParam(key: string): Signal<string>;
+export declare function injectRouteParam$(key: string): Observable<string>;
+export declare function injectRouteQueryParam$<T extends string = string>(key: string): Observable<T>;
+export declare function injectRouteQueryParam(key: string): Signal<string>;
+export declare function injectRouteParam(key: string, injector?: Injector): Signal<string>;
+export declare function injectRouteParamMap$(): Observable<ParamMap>;
+export declare function injectRouteParamMap(): Signal<ParamMap>;
+export declare function injectRouteParams$(): Observable<Record<string, string>>;
+export declare function injectRouteParams(): Signal<Record<string, string>>;
+export declare function injectChildRouteParam$(key: string, initial?: Observable<Map<string, string>>): Observable<string>;
+export declare function injectChildRouteParam(key: string): Signal<string>;
+export declare function injectChildRoute$(): Observable<ActivatedRoute>;
+export declare function injectChildRoute(): Signal<ActivatedRoute>;
+export declare function injectHasNext$(): Observable<boolean>;
+export declare function injectHasNext(): Signal<boolean>;
+export declare function injectRouterQueryParam$(key: string): Observable<string>;
+export declare function injectRouterQueryParam(key: string): Signal<string>;
+export declare function injectRouteData$<T>(path: string): Observable<T>;
+export declare function injectRouteData<T>(key: string): Signal<T>;
+export declare function injectActivatedComponents(injector?: Injector): any[];
+export interface Resolver<T> {
+    resolve(entry: T): T;
+    resolveMany(entities: T[]): T[];
+}
+export declare function provideResolver(Entity: Type<{
+    id: string;
+}>, ResolverType: new (params: Record<string, Observable<any>>) => Resolver<any>): {
+    provide: Type<{
+        id: string;
+    }>;
+    deps: any[];
+    multi: boolean;
+};
+export declare class ResolverManager {
+    protected map: Map<string, Resolver<any>>;
+    get(Entity: Type<{
+        id: string;
+    }>): Resolver<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolverManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResolverManager>;
+}
+export declare function injectResolver$<T>(ResolverType: new (params: Record<string, any>) => Resolver<T>, params: Record<string, Observable<any>>): Observable<Resolver<T>>;
+export declare function getResolver<T>(ResolverType: new (params: Record<string, any>) => Resolver<T>, params: Record<string, any>): Resolver<T>;

package/utils/mat-dayjs-date/dayjs-date.module.d.ts

@@ -1,11 +1,8 @@
+import { Provider } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class DayjsDateModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DayjsDateModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<DayjsDateModule, never, never, never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DayjsDateModule>;
 }
-export declare class MatDayjsDateModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatDayjsDateModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MatDayjsDateModule, never, [typeof DayjsDateModule], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<MatDayjsDateModule>;
-}
+export declare function provideDayjsDateAdapter(): Provider[];

package/utils/page/page.d.ts

@@ -1,4 +1,4 @@
-import { LegacyPageEvent as PageEvent } from '@angular/material/legacy-paginator';
+import { PageEvent } from '@angular/material/paginator';
 export interface Page extends PageEvent {
     sortKey: string;
     sortOrder: 'asc' | 'desc';

package/utils/router/index.d.ts

@@ -0,0 +1 @@
+export * from './router';

package/utils/router/router.d.ts

@@ -0,0 +1,4 @@
+import { ActivatedRouteSnapshot, RouterStateSnapshot, Routes } from "@angular/router";
+export declare function walkActivatedRouteSnapshot(snapshot: ActivatedRouteSnapshot, callback: (snapshot: ActivatedRouteSnapshot) => boolean, target?: 'children' | 'parent'): void;
+export declare function skippedResolver(outlet?: string): (route: ActivatedRouteSnapshot, snapshot: RouterStateSnapshot) => boolean;
+export declare function wrapRoutes(routes: Routes): any;

package/utils/time.d.ts

@@ -0,0 +1 @@
+export declare function formatSeconds(seconds: number): string;

package/esm2022/pipes/smart-sort-by/index.mjs

@@ -1,4 +0,0 @@
-export * from './smart-sort-by.module';
-export * from './smart-sort-by.pipe';
-export * from './smart-sort-by.transformer';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9AbmctYXRvbWljL2NvbW1vbi9zcmMvbGliL3BpcGVzL3NtYXJ0LXNvcnQtYnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NtYXJ0LXNvcnQtYnkubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtc29ydC1ieS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtc29ydC1ieS50cmFuc2Zvcm1lcic7XG4iXX0=

package/esm2022/pipes/smart-sort-by/ng-atomic-common-pipes-smart-sort-by.mjs

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctYXRvbWljLWNvbW1vbi1waXBlcy1zbWFydC1zb3J0LWJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvQG5nLWF0b21pYy9jb21tb24vc3JjL2xpYi9waXBlcy9zbWFydC1zb3J0LWJ5L25nLWF0b21pYy1jb21tb24tcGlwZXMtc21hcnQtc29ydC1ieS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==