cmat 0.0.78 → 0.0.80

package/types/cmat-services-config.d.ts

@@ -2,29 +2,51 @@ import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
 import { InjectionToken } from '@angular/core';
 
-declare class CmatConfigService {
-    private _config;
-    constructor();
-    get config$(): Observable<any>;
-    set config(value: any);
-    reset(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CmatConfigService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CmatConfigService>;
+type CmatScheme = 'auto' | 'dark' | 'light';
+type CmatTheme = string;
+type CmatScreens = Record<string, string>;
+type CmatThemeOption<TExtra extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    name: string;
+} & TExtra;
+interface CmatAppConfigBase {
+    layout: string;
+    scheme: CmatScheme;
+    screens: CmatScreens;
+    theme: CmatTheme;
+    themes: CmatThemeOption[];
 }
-
-declare const CMAT_APP_CONFIG: InjectionToken<any>;
+type CmatAppConfig<TExtra extends Record<string, unknown> = Record<string, unknown>> = CmatAppConfigBase & TExtra;
+declare const CMAT_APP_CONFIG: InjectionToken<CmatAppConfig<Record<string, unknown>>>;
 interface IUrlStateConfig {
     fileUrl: string;
     enableDataProtect: boolean;
 }
 
+declare class CmatConfigService {
+    private readonly _defaultConfig;
+    private readonly _config;
+    private readonly _config$;
+    get config$(): Observable<CmatAppConfig>;
+    set config(value: Partial<CmatAppConfig>);
+    updateConfig(value: Partial<CmatAppConfig>): void;
+    reset(): void;
+    private _mergeConfig;
+    private _isRecord;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatConfigService>;
+}
+
 declare class CmatUrlStateConfigService {
-    private _config;
+    private readonly _defaultConfig;
+    private readonly _config;
+    private readonly _config$;
     get config$(): Observable<IUrlStateConfig>;
-    config(value: IUrlStateConfig): void;
+    config(value: Partial<IUrlStateConfig>): void;
+    updateConfig(value: Partial<IUrlStateConfig>): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatUrlStateConfigService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatUrlStateConfigService>;
 }
 
 export { CMAT_APP_CONFIG, CmatConfigService, CmatUrlStateConfigService };
-export type { IUrlStateConfig };
+export type { CmatAppConfig, CmatAppConfigBase, CmatScheme, CmatScreens, CmatTheme, CmatThemeOption, IUrlStateConfig };

package/types/cmat-services-data.d.ts

@@ -1,19 +1,20 @@
-import * as i0 from '@angular/core';
-import { OnDestroy } from '@angular/core';
 import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
 
-declare class CmatDataService implements OnDestroy {
-    private _http;
-    private _urlStateConfigService;
+declare class CmatDataService {
+    private readonly _http;
+    private readonly _urlStateConfigService;
+    private readonly _destroyRef;
     private _enableDataProtect;
-    private _unsubscribeAll;
     constructor();
-    ngOnDestroy(): void;
-    get<T>(url: string, params?: {}, auth?: boolean): Observable<T>;
-    post<T>(url: string, data: any, params?: {}, auth?: boolean, idempotent?: boolean): Observable<T>;
-    put<T>(url: string, data: any, params?: {}, auth?: boolean): Observable<T>;
-    delete<T>(url: string, params?: {}, auth?: boolean): Observable<T>;
-    patch<T>(url: string, data: any, params?: {}, auth?: boolean): Observable<T>;
+    get<T>(url: string, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    post<T>(url: string, data: any, params?: Record<string, unknown>, auth?: boolean, idempotent?: boolean): Observable<T>;
+    put<T>(url: string, data: any, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    delete<T>(url: string, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    patch<T>(url: string, data: any, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
+    private _buildHttpParams;
+    private _decryptResponse;
+    private _normalizeParamValue;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatDataService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatDataService>;
 }

package/types/cmat-services-export-as.d.ts

@@ -11,32 +11,10 @@ interface ExportAsConfig {
 }
 
 declare class CmatExportAsService {
-    /**
-     * Main base64 get method, it will return the file as base64 string
-     * @param config your config
-     */
     get(config: ExportAsConfig): Observable<any>;
-    /**
-     * Save exported file in old javascript way
-     * @param config your custom config
-     * @param fileName Name of the file to be saved as
-     */
     save(config: ExportAsConfig, fileName: string): Observable<string | null>;
-    /**
-     * Converts content string to blob object
-     * @param content string to be converted
-     */
     contentToBlob(content: string): Observable<Blob>;
-    /**
-     * Removes base64 file type from a string like "data:text/csv;base64,"
-     * @param fileContent the base64 string to remove the type from
-     */
     removeFileTypeFromBase64(fileContent: string): string;
-    /**
-     * Structure the base64 file content with the file type string
-     * @param fileContent file content
-     * @param fileMime file mime type "text/csv"
-     */
     addFileTypeToBase64(fileContent: string, fileMime: string): string;
     downloadFromDataURL(fileName: string, dataURL: string): void;
     downloadFromBlob(blob: Blob, fileName: string): void;

package/types/cmat-services-loading.d.ts

@@ -3,16 +3,23 @@ import * as i0 from '@angular/core';
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
 
 declare class CmatLoadingService {
-    private _httpClient;
-    private _auto$;
-    private _mode$;
-    private _progress$;
-    private _show$;
-    private _urlMap;
+    private readonly _auto$;
+    private readonly _mode$;
+    private readonly _progress$;
+    private readonly _show$;
+    private readonly _autoObservable$;
+    private readonly _modeObservable$;
+    private readonly _progressObservable$;
+    private readonly _showObservable$;
+    private readonly _urlSet;
     get auto$(): Observable<boolean>;
+    get isAuto(): boolean;
     get mode$(): Observable<'determinate' | 'indeterminate'>;
+    get currentMode(): 'determinate' | 'indeterminate';
     get progress$(): Observable<number | null>;
+    get currentProgress(): number | null;
     get show$(): Observable<boolean>;
+    get isShowing(): boolean;
     show(): void;
     hide(): void;
     setAutoMode(value: boolean): void;
@@ -24,10 +31,8 @@ declare class CmatLoadingService {
 }
 
 declare class CmatLoadingInterceptor implements HttpInterceptor {
-    handleRequestsAutomatically: boolean;
-    private _cmatLoadingService;
-    constructor();
-    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    private readonly _cmatLoadingService;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatLoadingInterceptor, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatLoadingInterceptor>;
 }

package/types/cmat-services-media-watcher.d.ts

@@ -1,20 +1,17 @@
 import { BreakpointState } from '@angular/cdk/layout';
-import * as i0 from '@angular/core';
-import { OnDestroy } from '@angular/core';
 import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
 
-declare class CmatMediaWatcherService implements OnDestroy {
-    private _breakpointObserver;
-    private _cmatConfigService;
-    private _onMediaChange;
-    private _unsubscribeAll;
-    constructor();
-    get onMediaChange$(): Observable<{
-        matchingAliases: string[];
-        matchingQueries: any;
-    }>;
-    ngOnDestroy(): void;
+interface CmatMediaChange {
+    matchingAliases: string[];
+    matchingQueries: Record<string, string>;
+}
+declare class CmatMediaWatcherService {
+    private readonly _breakpointObserver;
+    private readonly _cmatConfigService;
+    get onMediaChange$(): Observable<CmatMediaChange>;
     onMediaQueryChange$(query: string | string[]): Observable<BreakpointState>;
+    private _screensAreEqual;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatMediaWatcherService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatMediaWatcherService>;
 }

package/types/cmat-services-splash-screen.d.ts

@@ -1,12 +1,10 @@
 import * as i0 from '@angular/core';
-import { OnDestroy } from '@angular/core';
 
-declare class CmatSplashScreenService implements OnDestroy {
+declare class CmatSplashScreenService {
     private _document;
     private _router;
-    private _unsubscribeAll;
+    private readonly _destroyRef;
     constructor();
-    ngOnDestroy(): void;
     show(): void;
     hide(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatSplashScreenService, never>;

package/types/cmat-services-title.d.ts

@@ -1,11 +1,9 @@
-import { Subscription } from 'rxjs';
 import * as i0 from '@angular/core';
 
 declare class CmatTitleService {
-    sub: Subscription;
-    appName: string;
-    private _titleService;
-    private _router;
+    private readonly _destroyRef;
+    private readonly _router;
+    private readonly _titleService;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatTitleService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatTitleService>;