@ng-atomic/common 19.0.0-preview.8 → 19.1.1

package/services/form/json-schema/index.d.ts

@@ -1 +1,73 @@
-export * from './json-schema.service';
+import { FormBuilder, NonNullableFormBuilder, FormGroup } from '@angular/forms';
+import { JsonSchema } from 'json-schema-library';
+import { FormFieldMap } from '@ng-atomic/common/pipes/smart-field';
+import * as i0 from '@angular/core';
+
+declare class JsonSchemaFormUtils {
+    static removeObjectPercent<T extends object>(value: T): any;
+    static buildFormGroupByJsonSchema(schema: JsonSchema, { fb, value, }?: {
+        fb?: FormBuilder | NonNullableFormBuilder;
+        value?: object;
+    }): FormGroup;
+    static buildFormArrayByJsonSchema(schema: JsonSchema, { fb, value, }?: {
+        fb?: FormBuilder | NonNullableFormBuilder;
+        value?: any[];
+    }): any;
+    static resolveAllOf(property: JsonSchema): JsonSchema;
+    static resolveOneOf(property: JsonSchema): JsonSchema;
+    static buildFormByJsonSchemaProperty(property: JsonSchema, { fb, value, validators, }?: {
+        fb?: FormBuilder | NonNullableFormBuilder;
+        value?: object | object[];
+        validators?: any[];
+    }): any;
+    static buildFormByJsonSchema(schema: JsonSchema, { fb, value, fieldMap, }?: {
+        fb?: FormBuilder | NonNullableFormBuilder;
+        value?: object;
+        fieldMap?: object;
+    }): any;
+    static buildFormFieldByProperty(property: JsonSchema['properties']): {
+        type: string;
+        options: any;
+    } | {
+        type: any;
+        options?: undefined;
+    };
+    static buildFormFieldMapByJsonSchema(schema: JsonSchema, options?: {
+        merge?: {
+            [key: string]: any;
+        };
+    }): any;
+}
+declare function buildFormGroup(klass: new () => any, { fb, value, }: {
+    fb?: FormBuilder | NonNullableFormBuilder;
+    value?: object;
+}): FormGroup;
+declare function buildFormFieldMap(klass: new () => any, options: {
+    merge?: {
+        [key: string]: any;
+    };
+}): any;
+declare function buildForm(klass: new () => any, { fb, value, fieldMap, }?: {
+    fb?: FormBuilder | NonNullableFormBuilder;
+    value?: object;
+    fieldMap?: FormFieldMap;
+}): {
+    form: FormGroup;
+    fieldMap: FormFieldMap;
+};
+declare class JsonSchemaFormService {
+    private fb;
+    build(schema: JsonSchema, { fb, value, }?: {
+        fb?: FormBuilder | NonNullableFormBuilder;
+        value?: object;
+    }): FormGroup;
+    buildFieldMap(schema: JsonSchema, options?: {
+        merge?: {
+            [key: string]: any;
+        };
+    }): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonSchemaFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsonSchemaFormService>;
+}
+
+export { JsonSchemaFormService, JsonSchemaFormUtils, buildForm, buildFormFieldMap, buildFormGroup };

package/services/form/pagination/index.d.ts

@@ -1 +1,21 @@
-export * from './pagination.service';
+import * as _angular_forms from '@angular/forms';
+import * as i0 from '@angular/core';
+
+interface PaginationFormValue {
+    size: number;
+    index: number;
+    length: number;
+}
+declare class PaginationService {
+    private fb;
+    build({ size, index, length, }?: Partial<PaginationFormValue>): _angular_forms.FormGroup<{
+        size: _angular_forms.FormControl<number>;
+        index: _angular_forms.FormControl<number>;
+        length: _angular_forms.FormControl<number>;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationService>;
+}
+
+export { PaginationService };
+export type { PaginationFormValue };

package/services/form/sort/index.d.ts

@@ -1 +1,21 @@
-export * from './sort.service';
+import { FormBuilder, FormGroup, FormControl } from '@angular/forms';
+import * as i0 from '@angular/core';
+
+interface SortFormValue {
+    key?: string;
+    order?: 'asc' | 'desc';
+}
+declare class SortService {
+    private fb;
+    constructor(fb: FormBuilder);
+    build({ key, order }?: Partial<SortFormValue>): FormGroup<{
+        key: FormControl<string>;
+        order: FormControl<"asc" | "desc">;
+    }>;
+    toggle(form: ReturnType<typeof this.build>, name: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SortService>;
+}
+
+export { SortService };
+export type { SortFormValue };

package/services/initializer/index.d.ts

@@ -1 +1,24 @@
-export * from './initializer.service';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+type StoreInitializer<S> = (store: S) => Promise<void> | void;
+declare function makeInitializerConfig<S>(klass: {
+    new (): S;
+}): {
+    provide<SI extends StoreInitializer<S>>(initializer: SI): {
+        provide: InjectionToken<StoreInitializer<any>>;
+        useValue: {
+            key: new () => S;
+            initializer: StoreInitializer<S>;
+        };
+        multi: boolean;
+    }[];
+    inject(): StoreInitializer<S>[];
+    initializeStore(store: S): Promise<void>;
+};
+declare class InitializerService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitializerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InitializerService>;
+}
+
+export { InitializerService, makeInitializerConfig };

package/services/language/index.d.ts

@@ -1 +1,16 @@
-export * from './language.service';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+type DomainLangMap = Record<string, string>;
+declare const DOMAIN_LANG_MAP: InjectionToken<DomainLangMap>;
+declare class LanguageService {
+    protected map: DomainLangMap;
+    protected regexResolvers: (((key: string) => string) | (() => any))[];
+    translate(text: string, src: string, dest: string, context?: any): string;
+    transform(input: string, map?: DomainLangMap): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageService>;
+}
+
+export { DOMAIN_LANG_MAP, LanguageService };
+export type { DomainLangMap };

package/services/loading/index.d.ts

@@ -1 +1,33 @@
-export * from './loading.service';
+import * as rxjs from 'rxjs';
+import { ObservableInput, OperatorFunction, ObservedValueOf } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+
+type LoadingMap = Record<string, Record<string, boolean>>;
+declare class LoadingService {
+    readonly loadingMap: i0.WritableSignal<LoadingMap>;
+    readonly loadingMap$: rxjs.Observable<LoadingMap>;
+    readonly isLoading: Signal<boolean>;
+    readonly isLoading$: rxjs.Observable<boolean>;
+    readonly isProgress: (domain?: string) => boolean;
+    constructor();
+    getIsLoading(domain?: string): Signal<boolean>;
+    start(key?: string, domain?: string): string;
+    end(key: string, domain?: string): void;
+    await<T = any>(callback: (...args: any[]) => Promise<T | void> | (T | void), domain?: string, key?: string): Promise<T | void>;
+    switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, domain?: string, key?: string): OperatorFunction<T, ObservedValueOf<O>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
+}
+declare class NoopLoadingService extends LoadingService {
+    readonly isLoading$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopLoadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoopLoadingService>;
+}
+declare function provideNoopLoadingService(): {
+    provide: typeof LoadingService;
+    useClass: typeof NoopLoadingService;
+};
+declare function randomStr(n?: number): string;
+
+export { LoadingService, NoopLoadingService, provideNoopLoadingService, randomStr };

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

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

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

@@ -1 +1,32 @@
-export * from './query-resolver.service';
+import * as _ng_atomic_common_services_language from '@ng-atomic/common/services/language';
+import * as _ng_atomic_common_utils from '@ng-atomic/common/utils';
+import * as _ng_atomic_common_pipes_data_accessor from '@ng-atomic/common/pipes/data-accessor';
+import * as i0 from '@angular/core';
+
+interface Query {
+    key: string;
+    operator: ':' | '>' | '<' | '=';
+    value: string;
+    not: boolean;
+}
+declare class QueryParserService {
+    parse(query: string): Query[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryParserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryParserService>;
+}
+declare class QueryResolverService<T extends object> {
+    protected parser: QueryParserService;
+    protected dataAccessor: _ng_atomic_common_pipes_data_accessor.DataAccessor<any>;
+    protected transformer: _ng_atomic_common_utils.ExpressionTransformer;
+    protected map: _ng_atomic_common_services_language.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 { QueryParserService, QueryResolverService };

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

@@ -1,2 +1,100 @@
-export * from './root-property.di';
-export * from './root-property.service';
+import * as _angular_core from '@angular/core';
+import * as _ng_atomic_common_services_ui from '@ng-atomic/common/services/ui';
+import { MaterialCssVarsService } from 'angular-material-css-vars';
+import { Observable } from 'rxjs';
+
+declare function provideRootProperty(): (_angular_core.Provider | _angular_core.EnvironmentProviders)[];
+
+declare class RootPropertyService {
+    static readonly Config: {
+        provide(useFactory?: _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;
+        }>, label?: string): _angular_core.Provider;
+        inject(): _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;
+        }>;
+    };
+    static provideColorSchemaA(): _angular_core.Provider;
+    static provideColorSchema1: typeof RootPropertyService.provideColorSchemaA;
+    static provideMenuWidthForIconButtonMenu(): _angular_core.Provider;
+    readonly config: _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;
+    readonly matCssVar: MaterialCssVarsService;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RootPropertyService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RootPropertyService>;
+}
+declare class NgAtomicStyleDirective {
+    #private;
+    private rootPropertyService;
+    readonly platformId: Object;
+    constructor(rootPropertyService: RootPropertyService);
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgAtomicStyleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgAtomicStyleDirective, "[atomicStyle]", never, {}, {}, never, never, true, never>;
+}
+declare class RootPropertyGuard {
+    readonly properties: _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: _angular_core.ɵɵFactoryDeclaration<RootPropertyGuard, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RootPropertyGuard>;
+}
+
+export { NgAtomicStyleDirective, RootPropertyGuard, RootPropertyService, provideRootProperty };

package/services/router/index.d.ts

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

package/services/secret/index.d.ts

@@ -1 +1,9 @@
-export * from './secret.service';
+import * as i0 from '@angular/core';
+
+declare class SecretService {
+    readonly isSecret: i0.WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SecretService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SecretService>;
+}
+
+export { SecretService };

package/services/sheets/actions/index.d.ts

@@ -1 +1,12 @@
-export * from './actions.sheet';
+import { NgAtomicComponent, Action } from '@ng-atomic/core';
+import * as i0 from '@angular/core';
+
+declare class ActionsSheet extends NgAtomicComponent {
+    protected actions: Action<any>[];
+    private sheetRef;
+    protected onItemClick(action: Action): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsSheet, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionsSheet, "sheets-actions", never, {}, {}, never, never, true, never>;
+}
+
+export { ActionsSheet };

package/services/sheets/index.d.ts

@@ -1,2 +1,20 @@
-export * from './sheets.module';
-export * from './sheets.service';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/material/bottom-sheet';
+import { MatBottomSheet } from '@angular/material/bottom-sheet';
+import { Action } from '@ng-atomic/core';
+
+declare class NgAtomicSheetsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicSheetsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgAtomicSheetsModule, never, [typeof i1.MatBottomSheetModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgAtomicSheetsModule>;
+}
+
+declare class SheetService {
+    private bottomSheet;
+    constructor(bottomSheet: MatBottomSheet);
+    openActions(actions: Action[]): Promise<Action | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SheetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SheetService>;
+}
+
+export { NgAtomicSheetsModule, SheetService };

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

@@ -1 +1,24 @@
-export * from './side-app.service';
+import * as i0 from '@angular/core';
+import { Router, NavigationExtras } from '@angular/router';
+
+declare class SideAppRouter extends Router {
+    protected sideApp: SideAppService;
+    setSideApp(sideApp: SideAppService): void;
+    navigate(commands: any[], extras?: NavigationExtras & {
+        expanded?: boolean;
+    }): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideAppRouter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideAppRouter>;
+}
+declare class SideAppService {
+    readonly opened: i0.WritableSignal<boolean>;
+    readonly router: SideAppRouter;
+    constructor();
+    toggle(): void;
+    collapse(): void;
+    expand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideAppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideAppService>;
+}
+
+export { SideAppRouter, SideAppService };

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

@@ -1 +1,16 @@
-export * from './side-nav-mode.service';
+import * as i0 from '@angular/core';
+
+type SideNavMode = 'expanded' | 'collapsed';
+declare class SideNavModeService {
+    readonly sideNavMode: i0.WritableSignal<SideNavMode>;
+    /** @deprecated use toggle() instead */
+    toggleSideNav(): void;
+    toggle(): void;
+    collapse(): void;
+    expand(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SideNavModeService>;
+}
+
+export { SideNavModeService };
+export type { SideNavMode };

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

@@ -1,2 +1,22 @@
-export * from './snack-bar.service';
-export * from './snack-bar.module';
+import * as _angular_material_snack_bar from '@angular/material/snack-bar';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { Clipboard } from '@angular/cdk/clipboard';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class SnackBarService {
+    protected readonly clipboard: Clipboard;
+    protected readonly snackBar: MatSnackBar;
+    open(message: string, action?: string): _angular_material_snack_bar.MatSnackBarRef<_angular_material_snack_bar.TextOnlySnackBar>;
+    openError(error: Error | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SnackBarService>;
+}
+
+declare class SnackBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SnackBarModule, never, [typeof i1.CommonModule, typeof _angular_material_snack_bar.MatSnackBarModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SnackBarModule>;
+}
+
+export { SnackBarModule, SnackBarService };