@elite.framework/ng.core 2.0.20 → 2.0.22

package/tokens/index.d.ts

@@ -1,23 +1,37 @@
 import { InjectionToken } from '@angular/core';
-import { Root } from '@elite.framework/ng.core/models';
-
-declare const ENVIRONMENT: InjectionToken<EnvironmentConfig>;
-interface EnvironmentConfig {
-    production: boolean;
-    apiUrl: string;
-    logLevel: 'debug' | 'info' | 'warn' | 'error' | 'off';
-    version: string;
-    features?: {
-        [key: string]: boolean;
-    };
-    externalServices?: {
-        [key: string]: string;
-    };
-    [key: string]: any;
-}
+import { Root, Localization, PipeToLoginFn, CheckAuthenticationStateFn } from '@elite.framework/ng.core/models';
+import { BehaviorSubject } from 'rxjs';
+import { QueueManager } from '@elite.framework/ng.core/utils';
+import { HttpErrorResponse } from '@angular/common/http';
+
+type AppInitErrorFn = (error: any) => void;
+declare const APP_INIT_ERROR_HANDLERS: InjectionToken<AppInitErrorFn[]>;
 
 declare const CORE_OPTIONS: InjectionToken<Root>;
 declare function coreOptionsFactory({ ...options }: Root): Root;
 
-export { CORE_OPTIONS, ENVIRONMENT, coreOptionsFactory };
-export type { EnvironmentConfig };
+declare const LOCALIZATIONS: InjectionToken<unknown>;
+declare function localizationContributor(localizations?: Localization[]): void;
+declare const localizations$: BehaviorSubject<Localization[]>;
+declare const INCUDE_LOCALIZATION_RESOURCES_TOKEN: InjectionToken<boolean>;
+
+declare const TENANT_KEY: InjectionToken<string>;
+
+declare const QUEUE_MANAGER: InjectionToken<QueueManager>;
+
+declare const OTHERS_GROUP: InjectionToken<string>;
+
+declare const DYNAMIC_LAYOUTS_TOKEN: InjectionToken<Map<string, string>>;
+
+declare const COOKIE_LANGUAGE_KEY: InjectionToken<string>;
+
+declare const PIPE_TO_LOGIN_FN_KEY: InjectionToken<PipeToLoginFn>;
+
+declare const CHECK_AUTHENTICATION_STATE_FN_KEY: InjectionToken<CheckAuthenticationStateFn>;
+
+declare const DISABLE_PROJECT_NAME: InjectionToken<boolean>;
+
+declare const TENANT_NOT_FOUND_BY_NAME: InjectionToken<(HttpErrorResponse: HttpErrorResponse) => void>;
+
+export { APP_INIT_ERROR_HANDLERS, CHECK_AUTHENTICATION_STATE_FN_KEY, COOKIE_LANGUAGE_KEY, CORE_OPTIONS, DISABLE_PROJECT_NAME, DYNAMIC_LAYOUTS_TOKEN, INCUDE_LOCALIZATION_RESOURCES_TOKEN, LOCALIZATIONS, OTHERS_GROUP, PIPE_TO_LOGIN_FN_KEY, QUEUE_MANAGER, TENANT_KEY, TENANT_NOT_FOUND_BY_NAME, coreOptionsFactory, localizationContributor, localizations$ };
+export type { AppInitErrorFn };

package/utils/index.d.ts

@@ -1,5 +1,7 @@
 import * as i0 from '@angular/core';
 import * as i1 from '@angular/common';
+import { DeepPartial, ApplicationLocalizationConfigurationDto } from '@elite.framework/ng.core/models';
+import * as rxjs from 'rxjs';
 
 declare class UtilsModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<UtilsModule, never>;
@@ -15,4 +17,86 @@ declare function isPromise(promise: any): boolean;
 declare function notEmptyValue(value: string | string[]): boolean;
 declare function transformStringToArray(value: string | string[]): string[];
 
-export { UtilsModule, isBoolean, isFunction, isPlainObject, isPromise, isString, notEmptyValue, transformStringToArray };
+declare function deepMerge<T>(target: DeepPartial<T> | T, source: DeepPartial<T> | T): DeepPartial<T> | T;
+
+declare function getLocaleDirection(locale: string): 'ltr' | 'rtl';
+declare function createLocalizer(localization: ApplicationLocalizationConfigurationDto): (resourceName: string, key: string, defaultValue: string | null) => string | null;
+declare function createLocalizerWithFallback(localization: ApplicationLocalizationConfigurationDto): (resourceNames: string[], keys: string[], defaultValue: string) => string;
+declare function createLocalizationPipeKeyGenerator(localization: ApplicationLocalizationConfigurationDto): (resourceNames: string[], keys: string[], defaultKey: string | undefined) => string | undefined;
+
+declare function noop(): () => void;
+declare function isUndefinedOrEmptyString(value: unknown): boolean;
+declare function isNullOrUndefined<T>(obj: T): boolean;
+declare function isNullOrEmpty<T>(obj: T): boolean;
+declare function exists<T>(obj: T): obj is T;
+declare function isObject<T>(obj: T): boolean;
+declare function isArray<T>(obj: T): boolean;
+declare function isObjectAndNotArray<T>(obj: T): boolean;
+declare function isNode<T>(obj: T): boolean;
+declare function isObjectAndNotArrayNotNode<T>(obj: T): boolean;
+declare function checkHasProp<T>(object: T, key: string | keyof T): key is keyof T;
+
+declare class InternalStore<State> {
+    private initialState;
+    private state$;
+    private update$;
+    get state(): State;
+    sliceState: <Slice>(selector: (state: State) => Slice, compareFn?: (s1: Slice, s2: Slice) => boolean) => rxjs.Observable<Slice>;
+    sliceUpdate: <Slice>(selector: (state: DeepPartial<State>) => Slice, filterFn?: (x: Slice) => x is Slice & ({} | null)) => rxjs.Observable<Slice & ({} | null)>;
+    constructor(initialState: State);
+    patch(state: Partial<State>): void;
+    deepPatch(state: DeepPartial<State>): void;
+    set(state: State): void;
+    reset(): void;
+}
+
+declare function createTokenParser(format: string): (str: string) => Record<string, string[]>;
+declare function interpolate(text: string, params: string[]): string;
+declare function escapeHtmlChars(value: any): any;
+
+interface QueueManager {
+    add(fn: () => void): void;
+    init(interval: number, stackSize: number): void;
+}
+declare class DefaultQueueManager implements QueueManager {
+    private queue;
+    private isRunning;
+    private stack;
+    private interval;
+    private stackSize;
+    init(interval: number, stackSize: number): void;
+    add(fn: () => void): void;
+    private run;
+}
+
+declare class BaseTreeNode<T extends object> {
+    children: TreeNode<T>[];
+    isLeaf: boolean;
+    parent?: TreeNode<T>;
+    constructor(props: T);
+    static create<T extends object>(props: T): TreeNode<T>;
+}
+declare function createTreeFromList<T extends object, R>(list: T[], keySelector: (item: T) => NodeKey, parentKeySelector: typeof keySelector, valueMapper: (item: T) => R): R[];
+declare function createMapFromList<T extends object, R>(list: T[], keySelector: (item: T) => NodeKey, valueMapper: (item: T) => R): Map<NodeKey, R>;
+declare function createTreeNodeFilterCreator<T extends object>(key: keyof T, mapperFn: (value: any) => string): (search: string) => (nodes: TreeNode<T>[], matches?: TreeNode<T>[]) => TreeNode<T>[];
+declare function createGroupMap<T extends {
+    group?: string;
+}>(list: TreeNode<T>[], othersGroupKey: string): Map<string, TreeNode<T>[]> | undefined;
+type TreeNode<T extends object> = {
+    [K in keyof T]: T[K];
+} & {
+    children: TreeNode<T>[];
+    isLeaf: boolean;
+    parent?: TreeNode<T>;
+};
+type RouteGroup<T extends object> = {
+    readonly group: string;
+    readonly items: TreeNode<T>[];
+};
+type NodeKey = number | string | symbol | undefined | null;
+type NodeValue<T extends object, F extends (...args: any) => any> = F extends undefined ? TreeNode<T> : ReturnType<F>;
+
+declare function pushValueTo<T>(array: T[]): (element: T) => T[];
+
+export { BaseTreeNode, DefaultQueueManager, InternalStore, UtilsModule, checkHasProp, createGroupMap, createLocalizationPipeKeyGenerator, createLocalizer, createLocalizerWithFallback, createMapFromList, createTokenParser, createTreeFromList, createTreeNodeFilterCreator, deepMerge, escapeHtmlChars, exists, getLocaleDirection, interpolate, isArray, isBoolean, isFunction, isNode, isNullOrEmpty, isNullOrUndefined, isObject, isObjectAndNotArray, isObjectAndNotArrayNotNode, isPlainObject, isPromise, isString, isUndefinedOrEmptyString, noop, notEmptyValue, pushValueTo, transformStringToArray };
+export type { NodeKey, NodeValue, QueueManager, RouteGroup, TreeNode };