@ng-atomic/common 16.2.0 → 16.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-atomic/common",
-  "version": "16.2.0",
+  "version": "16.3.1",
   "license": "MIT",
   "peerDependencies": {
     "@angular/cdk": "^16.0.0",
@@ -12,7 +12,7 @@
     "@angular/router": "^16.0.0",
     "@ngrx/component-store": "^16.0.0",
     "@ngrx/entity": "^16.0.0",
-    "@nx-ddd/core": "16.2.0",
+    "@nx-ddd/core": "16.3.1",
     "dayjs": "1.11.10",
     "firebase": "^9.0.0",
     "flat": "^5.0.2",
@@ -37,6 +37,12 @@
       "esm": "./esm2022/ng-atomic-common.mjs",
       "default": "./fesm2022/ng-atomic-common.mjs"
     },
+    "./interceptors": {
+      "types": "./interceptors/index.d.ts",
+      "esm2022": "./esm2022/interceptors/ng-atomic-common-interceptors.mjs",
+      "esm": "./esm2022/interceptors/ng-atomic-common-interceptors.mjs",
+      "default": "./fesm2022/ng-atomic-common-interceptors.mjs"
+    },
     "./models": {
       "types": "./models/index.d.ts",
       "esm2022": "./esm2022/models/ng-atomic-common-models.mjs",
@@ -49,6 +55,12 @@
       "esm": "./esm2022/utils/ng-atomic-common-utils.mjs",
       "default": "./fesm2022/ng-atomic-common-utils.mjs"
     },
+    "./directives/fallback-src": {
+      "types": "./directives/fallback-src/index.d.ts",
+      "esm2022": "./esm2022/directives/fallback-src/ng-atomic-common-directives-fallback-src.mjs",
+      "esm": "./esm2022/directives/fallback-src/ng-atomic-common-directives-fallback-src.mjs",
+      "default": "./fesm2022/ng-atomic-common-directives-fallback-src.mjs"
+    },
     "./directives/ios-safari-scroll-buggyfill": {
       "types": "./directives/ios-safari-scroll-buggyfill/index.d.ts",
       "esm2022": "./esm2022/directives/ios-safari-scroll-buggyfill/ng-atomic-common-directives-ios-safari-scroll-buggyfill.mjs",
@@ -103,12 +115,30 @@
       "esm": "./esm2022/pipes/grouped-by/ng-atomic-common-pipes-grouped-by.mjs",
       "default": "./fesm2022/ng-atomic-common-pipes-grouped-by.mjs"
     },
+    "./pipes/index": {
+      "types": "./pipes/index/index.d.ts",
+      "esm2022": "./esm2022/pipes/index/ng-atomic-common-pipes-index.mjs",
+      "esm": "./esm2022/pipes/index/ng-atomic-common-pipes-index.mjs",
+      "default": "./fesm2022/ng-atomic-common-pipes-index.mjs"
+    },
+    "./pipes/index-length": {
+      "types": "./pipes/index-length/index.d.ts",
+      "esm2022": "./esm2022/pipes/index-length/ng-atomic-common-pipes-index-length.mjs",
+      "esm": "./esm2022/pipes/index-length/ng-atomic-common-pipes-index-length.mjs",
+      "default": "./fesm2022/ng-atomic-common-pipes-index-length.mjs"
+    },
     "./pipes/keys": {
       "types": "./pipes/keys/index.d.ts",
       "esm2022": "./esm2022/pipes/keys/ng-atomic-common-pipes-keys.mjs",
       "esm": "./esm2022/pipes/keys/ng-atomic-common-pipes-keys.mjs",
       "default": "./fesm2022/ng-atomic-common-pipes-keys.mjs"
     },
+    "./pipes/page": {
+      "types": "./pipes/page/index.d.ts",
+      "esm2022": "./esm2022/pipes/page/ng-atomic-common-pipes-page.mjs",
+      "esm": "./esm2022/pipes/page/ng-atomic-common-pipes-page.mjs",
+      "default": "./fesm2022/ng-atomic-common-pipes-page.mjs"
+    },
     "./pipes/pagination": {
       "types": "./pipes/pagination/index.d.ts",
       "esm2022": "./esm2022/pipes/pagination/ng-atomic-common-pipes-pagination.mjs",
@@ -121,6 +151,12 @@
       "esm": "./esm2022/pipes/query/ng-atomic-common-pipes-query.mjs",
       "default": "./fesm2022/ng-atomic-common-pipes-query.mjs"
     },
+    "./pipes/secret": {
+      "types": "./pipes/secret/index.d.ts",
+      "esm2022": "./esm2022/pipes/secret/ng-atomic-common-pipes-secret.mjs",
+      "esm": "./esm2022/pipes/secret/ng-atomic-common-pipes-secret.mjs",
+      "default": "./fesm2022/ng-atomic-common-pipes-secret.mjs"
+    },
     "./pipes/select-id": {
       "types": "./pipes/select-id/index.d.ts",
       "esm2022": "./esm2022/pipes/select-id/ng-atomic-common-pipes-select-id.mjs",
@@ -145,11 +181,11 @@
       "esm": "./esm2022/pipes/smart-field/ng-atomic-common-pipes-smart-field.mjs",
       "default": "./fesm2022/ng-atomic-common-pipes-smart-field.mjs"
     },
-    "./pipes/smart-sort-by": {
-      "types": "./pipes/smart-sort-by/index.d.ts",
-      "esm2022": "./esm2022/pipes/smart-sort-by/ng-atomic-common-pipes-smart-sort-by.mjs",
-      "esm": "./esm2022/pipes/smart-sort-by/ng-atomic-common-pipes-smart-sort-by.mjs",
-      "default": "./fesm2022/ng-atomic-common-pipes-smart-sort-by.mjs"
+    "./pipes/sort-by": {
+      "types": "./pipes/sort-by/index.d.ts",
+      "esm2022": "./esm2022/pipes/sort-by/ng-atomic-common-pipes-sort-by.mjs",
+      "esm": "./esm2022/pipes/sort-by/ng-atomic-common-pipes-sort-by.mjs",
+      "default": "./fesm2022/ng-atomic-common-pipes-sort-by.mjs"
     },
     "./pipes/yen": {
       "types": "./pipes/yen/index.d.ts",
@@ -187,12 +223,48 @@
       "esm": "./esm2022/services/loading/ng-atomic-common-services-loading.mjs",
       "default": "./fesm2022/ng-atomic-common-services-loading.mjs"
     },
+    "./services/navigation-history": {
+      "types": "./services/navigation-history/index.d.ts",
+      "esm2022": "./esm2022/services/navigation-history/ng-atomic-common-services-navigation-history.mjs",
+      "esm": "./esm2022/services/navigation-history/ng-atomic-common-services-navigation-history.mjs",
+      "default": "./fesm2022/ng-atomic-common-services-navigation-history.mjs"
+    },
     "./services/query-resolver": {
       "types": "./services/query-resolver/index.d.ts",
       "esm2022": "./esm2022/services/query-resolver/ng-atomic-common-services-query-resolver.mjs",
       "esm": "./esm2022/services/query-resolver/ng-atomic-common-services-query-resolver.mjs",
       "default": "./fesm2022/ng-atomic-common-services-query-resolver.mjs"
     },
+    "./services/root-property": {
+      "types": "./services/root-property/index.d.ts",
+      "esm2022": "./esm2022/services/root-property/ng-atomic-common-services-root-property.mjs",
+      "esm": "./esm2022/services/root-property/ng-atomic-common-services-root-property.mjs",
+      "default": "./fesm2022/ng-atomic-common-services-root-property.mjs"
+    },
+    "./services/router": {
+      "types": "./services/router/index.d.ts",
+      "esm2022": "./esm2022/services/router/ng-atomic-common-services-router.mjs",
+      "esm": "./esm2022/services/router/ng-atomic-common-services-router.mjs",
+      "default": "./fesm2022/ng-atomic-common-services-router.mjs"
+    },
+    "./services/secret": {
+      "types": "./services/secret/index.d.ts",
+      "esm2022": "./esm2022/services/secret/ng-atomic-common-services-secret.mjs",
+      "esm": "./esm2022/services/secret/ng-atomic-common-services-secret.mjs",
+      "default": "./fesm2022/ng-atomic-common-services-secret.mjs"
+    },
+    "./services/side-app": {
+      "types": "./services/side-app/index.d.ts",
+      "esm2022": "./esm2022/services/side-app/ng-atomic-common-services-side-app.mjs",
+      "esm": "./esm2022/services/side-app/ng-atomic-common-services-side-app.mjs",
+      "default": "./fesm2022/ng-atomic-common-services-side-app.mjs"
+    },
+    "./services/side-nav-mode": {
+      "types": "./services/side-nav-mode/index.d.ts",
+      "esm2022": "./esm2022/services/side-nav-mode/ng-atomic-common-services-side-nav-mode.mjs",
+      "esm": "./esm2022/services/side-nav-mode/ng-atomic-common-services-side-nav-mode.mjs",
+      "default": "./fesm2022/ng-atomic-common-services-side-nav-mode.mjs"
+    },
     "./services/snack-bar": {
       "types": "./services/snack-bar/index.d.ts",
       "esm2022": "./esm2022/services/snack-bar/ng-atomic-common-services-snack-bar.mjs",

package/pipes/data-accessor/data-accessor.pipe.d.ts

@@ -3,10 +3,14 @@ import * as i0 from "@angular/core";
 export type DataAccessor<T> = (obj: T, key: string) => string;
 export declare const DATA_ACCESSOR: InjectionToken<DataAccessor<any>>;
 export declare const defaultDataAccessor: DataAccessor<any>;
+export declare function provideDataAccessor<T>(useFactory?: () => DataAccessor<T>): {
+    provide: InjectionToken<DataAccessor<any>>;
+    useFactory: () => DataAccessor<T>;
+};
+export declare function injectDataAccessor<T>(): DataAccessor<T>;
 export declare class DataAccessorPipe<T> {
-    protected dataAccessor?: DataAccessor<T>;
-    constructor(dataAccessor?: DataAccessor<T>);
+    protected dataAccessor: DataAccessor<any>;
     transform(data: T, key: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DataAccessorPipe<any>, [{ optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataAccessorPipe<any>, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<DataAccessorPipe<any>, "dataAccessor", true>;
 }

package/pipes/domain/domain.pipe.d.ts

@@ -1,11 +1,57 @@
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, Injector, Signal } from '@angular/core';
+import { Entity, Type } from '@nx-ddd/common/domain/models';
+import { SignalOrValue } from '@ng-atomic/common/pipes/signal';
 import * as i0 from "@angular/core";
 export type DomainLangMap = Record<string, string>;
+export declare const DOMAIN_MODEL: InjectionToken<Type<{
+    id: string;
+}>>;
 export declare const DOMAIN_LANG_MAP: InjectionToken<DomainLangMap>;
+export declare const DOMAIN_PROPS: InjectionToken<Signal<string[]>>;
+export declare const DOMAIN_MODEL_NAME: InjectionToken<Signal<string>>;
 export declare class DomainPipe {
-    private map;
-    constructor(map: DomainLangMap);
-    transform(input: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DomainPipe, [{ optional: true; }]>;
+    protected map: DomainLangMap;
+    transform(input: string, map?: DomainLangMap): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DomainPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<DomainPipe, "domain", true>;
 }
+export declare function provideLangMap(useFactory: () => DomainLangMap): {
+    provide: InjectionToken<DomainLangMap>;
+    useFactory: () => DomainLangMap;
+};
+export declare function provideDomainLang<E>(domain: Type<E>, mergeObj?: DomainLangMap): {
+    provide: InjectionToken<DomainLangMap>;
+    useFactory: () => DomainLangMap;
+};
+export declare function provideModel<E>(useFactory: () => Type<E>): {
+    provide: InjectionToken<Type<{
+        id: string;
+    }>>;
+    useFactory: () => Type<E>;
+};
+export declare function injectModel<E = Entity>(): Type<E>;
+export declare function provideProps(useFactory: () => SignalOrValue<string[]>): {
+    provide: InjectionToken<Signal<string[]>>;
+    useFactory: () => Signal<string[]>;
+};
+export declare function provideModelName(useFactory: () => SignalOrValue<string>): {
+    provide: InjectionToken<Signal<string>>;
+    useFactory: () => Signal<string>;
+};
+export declare function injectProps(): Signal<string[]>;
+export declare function injectModelName(injector?: Injector): Signal<string>;
+export declare function provideDomain<E>(useFactory: () => Type<E>): ({
+    provide: InjectionToken<DomainLangMap>;
+    useFactory: () => DomainLangMap;
+} | {
+    provide: InjectionToken<Signal<string[]>>;
+    useFactory: () => Signal<string[]>;
+} | {
+    provide: InjectionToken<Signal<string>>;
+    useFactory: () => Signal<string>;
+} | {
+    provide: InjectionToken<Type<{
+        id: string;
+    }>>;
+    useFactory: () => Type<E>;
+})[];

package/pipes/grouped-by/grouped-by.pipe.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class GroupedByPipe {
     private dataAccessor;
-    transform<T>(items: T[], groupedBy: string): {
+    transform<T>(items: T[], groupedBy?: string): {
         [id: string]: T[];
     };
     static ɵfac: i0.ɵɵFactoryDeclaration<GroupedByPipe, never>;

package/pipes/index/index.d.ts

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

package/pipes/index/index.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { Index } from '@ng-atomic/common/models';
+import * as i0 from "@angular/core";
+export declare class IndexPipe<T> implements PipeTransform {
+    protected query: (items: T[], query: string) => any[];
+    protected sortBy: (items: T[], { key, order }?: Partial<import("@ng-atomic/common/models").Sort>, dataAccessor?: import("../../../../../../../dist/packages/@ng-atomic/common/pipes/data-accessor").DataAccessor<T>) => T[];
+    protected page: typeof import("@ng-atomic/common/pipes/page").defaultPageTransformer;
+    transform(items: T[], params: Partial<Index>): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IndexPipe<any>, "index", true>;
+}

package/pipes/index-length/index-length.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { Index } from '@ng-atomic/common/models';
+import * as i0 from "@angular/core";
+export declare class IndexLengthPipe<T> implements PipeTransform {
+    protected query: (items: T[], query: string) => any[];
+    protected sortBy: (items: T[], { key, order }?: Partial<import("@ng-atomic/common/models").Sort>, dataAccessor?: import("../../../../../../../dist/packages/@ng-atomic/common/pipes/data-accessor").DataAccessor<T>) => T[];
+    transform(items: T[], prams: Partial<Index>): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexLengthPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IndexLengthPipe<any>, "indexLength", true>;
+}

package/pipes/index-length/index.d.ts

@@ -0,0 +1 @@
+export * from './index-length.pipe';

package/pipes/page/index.d.ts

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

package/pipes/page/page.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { Page } from '@ng-atomic/common/models';
+import * as i0 from "@angular/core";
+export declare function defaultPageTransformer<T>(items: T[], { pageIndex, pageSize }?: Partial<Page>): T[];
+export declare function injectPageTransformer<T>(): typeof defaultPageTransformer;
+export declare class PagePipe<T> implements PipeTransform {
+    protected transformer: typeof defaultPageTransformer;
+    transform(items: T[], params?: Partial<Page>): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagePipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PagePipe<any>, "page", true>;
+}

package/pipes/query/query.pipe.d.ts

@@ -1,9 +1,10 @@
 import { PipeTransform } from '@angular/core';
-import { QueryResolverService } from '@ng-atomic/common/services/query-resolver';
 import * as i0 from "@angular/core";
-export declare class QueryPipe<E> implements PipeTransform {
-    protected resolver: QueryResolverService;
-    transform(items: E[], query: string): E[];
+export declare function defaultQueryTransformer<T>(items: T[], query: string): T[];
+export declare function injectQueryTransformer<T>(): (items: T[], query: string) => any[];
+export declare class QueryPipe<T> implements PipeTransform {
+    protected transformer: (items: T[], query: string) => any[];
+    transform(items: T[], query: string): T[];
     static ɵfac: i0.ɵɵFactoryDeclaration<QueryPipe<any>, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<QueryPipe<any>, "query", true>;
     static ɵprov: i0.ɵɵInjectableDeclaration<QueryPipe<any>>;

package/pipes/secret/index.d.ts

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

package/pipes/secret/secret.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SecretPipe implements PipeTransform {
+    private secret;
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecretPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SecretPipe, "secret", true>;
+}

package/pipes/signal/signal.pipe.d.ts

@@ -2,6 +2,7 @@ import { Signal } from '@angular/core';
 import * as i0 from "@angular/core";
 export type SignalOrValue<T> = T | Signal<T>;
 export declare function signalize<T = any>(valueOrSignal: T | Signal<T>): Signal<T>;
+export declare function wrapFactory<T>(valueOrSignalFactory: (...args: any[]) => T | Signal<T>): () => Signal<T>;
 export declare function resolveSignal<T>(valueOrSignal: T | Signal<T>): T;
 export declare class SignalPipe {
     transform<T>(obj: T | Signal<T>): T;

package/pipes/smart-field/smart-field.pipe.d.ts

@@ -2,17 +2,24 @@ import { InjectionToken, PipeTransform, Signal } from '@angular/core';
 import { Action } from '@ng-atomic/core';
 import { SignalOrValue } from '@ng-atomic/common/pipes/signal';
 import * as i0 from "@angular/core";
-interface Option<T> {
+export interface Option<T> {
     name: string;
     value: T;
 }
 interface BaseField {
     placeholder?: string;
-    hint?: string;
+    hint?: SignalOrValue<string>;
+    actions?: Action[] | Signal<Action[]>;
 }
-interface InputField extends BaseField {
-    type: 'input';
-    autoComplete?: SignalOrValue<(string | number)[]>;
+interface TextField extends BaseField {
+    type: 'text';
+    autoComplete?: SignalOrValue<string[]>;
+}
+interface PasswordField extends BaseField {
+    type: 'password';
+}
+interface NumberField extends BaseField {
+    type: 'number';
 }
 interface TextareaField extends BaseField {
     type: 'textarea';
@@ -21,36 +28,62 @@ interface TextareaField extends BaseField {
 interface DateInputField extends BaseField {
     type: 'date';
 }
+interface DateRangeInputField extends BaseField {
+    type: 'date-range';
+}
 interface SelectField<T> extends BaseField {
     type: 'select';
-    options: Option<T>[];
+    options: Option<T>[] | Signal<Option<T>[]>;
+    multiple?: boolean;
+}
+interface TimeRangeField extends BaseField {
+    type: 'time-range';
 }
 interface MultiSelectField<T> extends BaseField {
     type: 'multi-select';
-    options: Option<T>[];
+    options: Option<T>[] | Signal<Option<T>[]>;
 }
 interface FileField extends BaseField {
     type: 'file';
-    progress?: Signal<number>;
+    progress?: Signal<number | null>;
 }
 interface ActionField extends BaseField {
     type: 'action';
     actions: Action[] | Signal<Action[]>;
     disabled?: boolean;
 }
-interface NoneField {
-    type: 'none';
+interface AgreementField {
+    type: 'agreement';
+    labelTemp: null | any;
+}
+interface HiddenField {
+    type: 'hidden';
+}
+interface PreviewField extends BaseField {
+    type: 'preview';
+}
+interface PreviewImageField extends BaseField {
+    type: 'preview:image';
 }
-type FormField<V> = InputField | TextareaField | DateInputField | SelectField<V> | MultiSelectField<V> | FileField | ActionField | NoneField;
+export type FormField<V = any> = TextField | PasswordField | TextareaField | DateInputField | DateRangeInputField | SelectField<V> | TimeRangeField | MultiSelectField<V> | FileField | ActionField | HiddenField | NumberField | PreviewField | AgreementField | PreviewImageField;
 export interface FormFieldMap {
     [key: string]: FormField<any> | FormFieldMap;
 }
+/** @deprecated */
 export declare const FORM_FIELD_MAP: InjectionToken<FormFieldMap>;
+/** @deprecated */
+export declare function provideFormFieldMap(useFactory: () => FormFieldMap): {
+    provide: InjectionToken<FormFieldMap>;
+    useFactory: () => FormFieldMap;
+};
+type Enum<T> = Record<string, T>;
+/** @deprecated */
+export declare function buildOptions<T>(_enum: Enum<T>): Option<T>[];
+/** @deprecated */
 export declare class SmartFieldPipe implements PipeTransform {
-    private map;
-    constructor(map: Record<string, FormField<any>>);
-    transform(key: string): FormField<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFieldPipe, [{ optional: true; }]>;
+    protected map: FormFieldMap;
+    transform(key: string, map?: FormFieldMap): FormField<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFieldPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<SmartFieldPipe, "smartField", true>;
 }
 export {};

package/pipes/sort-by/index.d.ts

@@ -0,0 +1 @@
+export * from './sort-by.pipe';

package/pipes/sort-by/sort-by.pipe.d.ts

@@ -0,0 +1,17 @@
+import { InjectionToken, PipeTransform } from '@angular/core';
+import { Sort } from '@ng-atomic/common/models';
+import { DataAccessor } from '@ng-atomic/common/pipes/data-accessor';
+import * as i0 from "@angular/core";
+export declare function sortByTransformer<T>(items: T[], { key, order }?: Partial<Sort>, dataAccessor?: DataAccessor<T>): T[];
+export declare function sortByTransformerFactory<T>(dataAccessor: DataAccessor<T>): (items: any, params: any) => T[];
+export declare const SMART_SORT_BY_TRANSFORMER: InjectionToken<typeof sortByTransformer>;
+export declare function injectSortByTransformer<T>(): typeof sortByTransformer<T>;
+export declare class SortByPipe<T> implements PipeTransform {
+    protected transformer: (items: T[], { key, order }?: Partial<Sort>, dataAccessor?: DataAccessor<T>) => T[];
+    transform(items: T[], params?: {
+        key?: string;
+        order?: 'asc' | 'desc';
+    }): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortByPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SortByPipe<any>, "sortBy", true>;
+}

package/services/auth/auth.service.d.ts

@@ -1,34 +1,41 @@
-import { Auth } from '@angular/fire/auth';
-import { UserCredential } from 'firebase/auth';
+import { UserCredential } from '@angular/fire/auth';
+import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export interface TwitterCredential {
-    _tokenResponse: {
-        context: string;
-        displayName: string;
-        email: string;
-        emailVerified: boolean;
-        expiresIn: string;
-        federatedId: string;
-        fullName: string;
-        idToken: string;
-        kind: 'identitytoolkit#VerifyAssertionResponse';
-        localId: string;
-        oauthAccessToken: string;
-        oauthTokenSecret: string;
-        photoUrl: string;
-        providerId: 'twitter.com';
-        rawUserInfo: string;
-        refreshToken: string;
-        screenName: string;
-    };
+    context: string;
+    displayName: string;
+    email: string;
+    emailVerified: boolean;
+    expiresIn: string;
+    federatedId: string;
+    fullName: string;
+    idToken: string;
+    kind: 'identitytoolkit#VerifyAssertionResponse';
+    localId: string;
+    oauthAccessToken: string;
+    oauthTokenSecret: string;
+    photoUrl: string;
+    providerId: 'twitter.com';
+    rawUserInfo: string;
+    refreshToken: string;
+    screenName: string;
 }
+export type Result = UserCredential & {
+    _tokenResponse: TwitterCredential;
+};
 export declare class AuthService {
-    private auth;
-    auth$: import("rxjs").Observable<import("@firebase/auth").User>;
-    constructor(auth: Auth);
-    signInWithTwitter(): Promise<void>;
+    #private;
+    auth$: Observable<import("@firebase/auth").User>;
+    auth: import("@angular/core").Signal<import("@firebase/auth").User>;
+    signInWithTwitter(): Promise<Result>;
     signInWithGoogle(): Promise<UserCredential>;
+    signInWithCustomToken(customToken: string): Promise<Result>;
     signOut(): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
 }
+export declare function injectAuthState$(): Observable<import("@firebase/auth").User>;
+export declare function injectAuthState(): import("@angular/core").Signal<import("@firebase/auth").User>;
+export declare function injectUserId$(): Observable<string | null>;
+export declare function injectTwitterId$(): Observable<string>;
+export declare function injectClaim$<T = string>(claim: string): Observable<T>;

package/services/loading/loading.service.d.ts

@@ -1,17 +1,29 @@
+import { ObservableInput, ObservedValueOf, OperatorFunction } from 'rxjs';
 import * as i0 from "@angular/core";
-type LoadingMap = Map<string, boolean>;
 export declare class LoadingService {
     private loadingEntries$;
-    loadingMap: LoadingMap;
-    loadingMap$: import("rxjs").Observable<Map<string, boolean>>;
-    isLoading$: import("rxjs").Observable<boolean>;
-    constructor();
+    readonly loadingMap$: import("rxjs").Observable<Map<string, boolean>>;
+    readonly loadingMap: import("@angular/core").Signal<Map<string, boolean>>;
+    readonly isLoading$: import("rxjs").Observable<boolean>;
+    readonly isLoading: import("@angular/core").Signal<boolean>;
+    start(key?: string): string;
+    end(key: string): void;
+    /** @deprecated: use start() instead */
     setKey(key: string): void;
+    /** @deprecated: use end() instead*/
     removeKey(key: string): void;
-    start(callback: (done: any) => void, key?: string): void;
-    await<T = any>(callback: (...args: any[]) => Promise<T>): Promise<T>;
+    await<T = any>(callback: (...args: any[]) => Promise<T>): Promise<T | void>;
+    switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
 }
+export declare class NoopLoadingService extends LoadingService {
+    readonly isLoading$: import("rxjs").Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoopLoadingService>;
+}
+export declare function provideNoopLoadingService(): {
+    provide: typeof LoadingService;
+    useClass: typeof NoopLoadingService;
+};
 export declare function randomStr(n?: number): string;
-export {};

package/services/navigation-history/index.d.ts

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

package/services/navigation-history/navigation-history.service.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class NavigationHistoryService {
+    private readonly platformId;
+    private readonly router;
+    protected readonly history: import("@angular/core").WritableSignal<string[]>;
+    readonly hasPrevHistory: import("@angular/core").Signal<boolean>;
+    readonly isInitial: import("@angular/core").Signal<boolean>;
+    pop(): void;
+    push(url: string): void;
+    replace(url: string): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationHistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationHistoryService>;
+}

package/services/query-resolver/query-resolver.service.d.ts

@@ -1,10 +1,27 @@
-import { SmartExpTransformer } from '@ng-atomic/common/utils';
 import * as i0 from "@angular/core";
-export declare class QueryResolverService {
-    private transformer?;
-    private map?;
-    constructor(transformer?: SmartExpTransformer, map?: Record<string, string>);
-    resolve<T>(items: T[], query: string, map?: Record<string, string>): T[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<QueryResolverService, [{ optional: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<QueryResolverService>;
+interface Query {
+    key: string;
+    operator: ':' | '>' | '<' | '=';
+    value: string;
+    not: boolean;
 }
+export declare class QueryParserService {
+    parse(query: string): Query[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryParserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryParserService>;
+}
+export declare class QueryResolverService<T extends object> {
+    protected parser: QueryParserService;
+    protected dataAccessor: import("@ng-atomic/common/pipes/data-accessor").DataAccessor<any>;
+    protected transformer: import("@ng-atomic/common/utils").SmartExpTransformer;
+    protected map: import("@ng-atomic/common/pipes/domain").DomainLangMap;
+    protected reversedMap: Record<string, string>;
+    resolve(items: T[], queryStr?: string): T[];
+    protected executeQuery(items: T[], query: Query): T[];
+    protected operateByKey(item: T, operator: QueryOperator, { key, value, not }: Query): boolean;
+    protected operateByAllKey(item: T, operator: QueryOperator, query: Query): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryResolverService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryResolverService<any>>;
+}
+type QueryOperator = (_value: any, query: string) => boolean;
+export {};

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

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