cmat 0.0.81 → 0.0.83

package/types/cmat-directives-data-exporter.d.ts

@@ -23,8 +23,9 @@ interface ExcelOptions extends Options, Omit<WritingOptions, 'bookType'> {
     columnWidths: number[];
 }
 
+type DataExporterItem = Record<string, unknown>;
 declare class CmatDataExporterDirective implements OnChanges {
-    dataSource: any[];
+    dataSource: DataExporterItem[];
     exportColumns: ExporterListInfo[];
     options?: Options | ExcelOptions | TxtOptions;
     exportType: ExportType | 'xls' | 'xlsx' | 'csv' | 'txt' | 'json';

package/types/cmat-directives-debounce.d.ts

@@ -4,26 +4,26 @@ import { Subject } from 'rxjs';
 
 declare abstract class AbstractDebounceDirective implements OnInit {
     debounceTime: number;
-    emitChanged: EventEmitter<any>;
-    emitEvent$: Subject<any>;
+    emitChanged: EventEmitter<unknown>;
+    emitEvent$: Subject<unknown>;
     private readonly _destroyRef;
     constructor();
     ngOnInit(): void;
-    emitChange(value: any): void;
+    emitChange(value: unknown): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDebounceDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDebounceDirective, never, never, { "debounceTime": { "alias": "debounceTime"; "required": false; }; }, { "emitChanged": "emitChanged"; }, never, never, true, never>;
 }
 
 declare class CmatDebounceClickDirective extends AbstractDebounceDirective {
     constructor();
-    onKeyUp(event: any): void;
+    onKeyUp(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceClickDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceClickDirective, "[cmatDebounceClick]", never, {}, {}, never, never, true, never>;
 }
 
 declare class CmatDebounceKeyupDirective extends AbstractDebounceDirective {
     constructor();
-    onKeyUp(event: any): void;
+    onKeyUp(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatDebounceKeyupDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDebounceKeyupDirective, "input[cmatDebounceKeyup]", never, {}, {}, never, never, true, never>;
 }

package/types/cmat-directives-digit-only.d.ts

@@ -12,16 +12,16 @@ declare class CmatDigitOnlyDirective implements OnChanges {
     pattern?: string | RegExp;
     inputElement: HTMLInputElement;
     value: string;
-    el: ElementRef<any>;
+    el: ElementRef<HTMLInputElement>;
     private _regex;
     private _hasDecimalPoint;
     private _hasNegativeSign;
     private _navigationKeys;
     constructor();
-    onBeforeInput(e: InputEvent): any;
-    onInputChange(event: any): void;
-    onKeyDown(e: KeyboardEvent): any;
-    onPaste(event: any): void;
+    onBeforeInput(e: InputEvent): void;
+    onInputChange(event: Event): void;
+    onKeyDown(e: KeyboardEvent): void;
+    onPaste(event: ClipboardEvent): void;
     onDrop(event: DragEvent): void;
     ngOnChanges(changes: SimpleChanges): void;
     private _pasteData;
@@ -37,13 +37,13 @@ declare class CmatDigitOnlyDirective implements OnChanges {
 }
 
 declare class CmatMaskDirective implements OnInit {
-    el: ElementRef<any>;
+    el: ElementRef<HTMLInputElement>;
     inputElement: HTMLInputElement;
     value: string;
     regex: RegExp;
     private _navigationKeys;
     constructor();
-    onInputChange(event: any): void;
+    onInputChange(event: Event): void;
     onKeyDown(e: KeyboardEvent): void;
     ngOnInit(): void;
     private _forecastValue;

package/types/cmat-directives-seamless-auto-scroll.d.ts

@@ -2,10 +2,10 @@ import * as i0 from '@angular/core';
 import { OnInit, AfterViewInit, OnDestroy, TemplateRef } from '@angular/core';
 
 declare class CmatSeamlessAutoScrollDirective implements OnInit, AfterViewInit, OnDestroy {
-    data: any[];
+    data: unknown[];
     speed: number;
     direction: 'up' | 'down' | 'left' | 'right';
-    itemTemplate: TemplateRef<any>;
+    itemTemplate: TemplateRef<unknown>;
     private _viewContainer;
     private _containerElement;
     private _contentElement;

package/types/cmat-lib-mock-api.d.ts

@@ -51,7 +51,7 @@ declare class CmatMockApiUtils {
 declare class CmatMockApiInterceptor implements HttpInterceptor {
     private _defaultDelay;
     private _cmatMockApiService;
-    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatMockApiInterceptor, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatMockApiInterceptor>;
 }

package/types/cmat-pipes-find-by-key.d.ts

@@ -1,8 +1,9 @@
 import * as i0 from '@angular/core';
 import { PipeTransform } from '@angular/core';
 
+type CmatFindByKeySourceItem = Record<string, unknown>;
 declare class CmatFindByKeyPipe implements PipeTransform {
-    transform(value: string | string[], key: string, source: any[]): any;
+    transform(value: string | string[], key: string, source: CmatFindByKeySourceItem[]): CmatFindByKeySourceItem | CmatFindByKeySourceItem[] | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatFindByKeyPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<CmatFindByKeyPipe, "cmatFindByKey", true>;
 }

package/types/cmat-pipes-group-by.d.ts

@@ -1,8 +1,13 @@
 import * as i0 from '@angular/core';
 import { PipeTransform } from '@angular/core';
 
+type GroupByItem = Record<string, unknown>;
+interface GroupByResult<T extends GroupByItem> {
+    key: string;
+    value: T[];
+}
 declare class CmatGroupByPipe implements PipeTransform {
-    transform(value: any[], field: string): any[];
+    transform<T extends GroupByItem>(value: T[] | null | undefined, field: string): GroupByResult<T>[];
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatGroupByPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<CmatGroupByPipe, "cmatGroupBy", true>;
 }

package/types/cmat-pipes-keys.d.ts

@@ -2,7 +2,10 @@ import * as i0 from '@angular/core';
 import { PipeTransform } from '@angular/core';
 
 declare class CmatKeysPipe implements PipeTransform {
-    transform(value: any): any;
+    transform(value: Record<string, unknown>): {
+        key: string;
+        value: unknown;
+    }[];
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatKeysPipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<CmatKeysPipe, "cmatKeys", true>;
 }

package/types/cmat-pipes-secure.d.ts

@@ -9,6 +9,7 @@ declare class CmatSecurePipe implements PipeTransform {
     private _urlStateConfigService;
     private readonly _destroyRef;
     private _config;
+    private _previousObjectUrl;
     constructor();
     transform(fileId: string): Observable<SafeUrl>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatSecurePipe, never>;

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

@@ -18,19 +18,19 @@ interface ApiResult {
     success: boolean;
     msg: string;
     type: number;
-    data?: any;
-    dataExt?: any;
+    data?: unknown;
+    dataExt?: unknown;
 }
 
 declare class CmatAlertDialog {
     message: string;
     type: CmatDialogType;
-    okCallback?: ((val?: any) => any) | undefined;
-    cancelCallback?: (() => any) | undefined;
+    okCallback?: ((val?: unknown) => void) | undefined;
+    cancelCallback?: (() => void) | undefined;
     defaultValue?: string | undefined;
     okLabel?: string | undefined;
     cancelLabel?: string | undefined;
-    constructor(message: string, type: CmatDialogType, okCallback?: ((val?: any) => any) | undefined, cancelCallback?: (() => any) | undefined, defaultValue?: string | undefined, okLabel?: string | undefined, cancelLabel?: string | undefined);
+    constructor(message: string, type: CmatDialogType, okCallback?: ((val?: unknown) => void) | undefined, cancelCallback?: (() => void) | undefined, defaultValue?: string | undefined, okLabel?: string | undefined, cancelLabel?: string | undefined);
 }
 
 declare class CmatAlertMessage {
@@ -51,25 +51,26 @@ declare class CmatAlertService {
     get messageEvent$(): Observable<CmatAlertMessage>;
     get stickyMessageEvent$(): Observable<CmatAlertMessage | void>;
     get isLoadingInProgress$(): Observable<boolean>;
-    showDialog(message: string, type?: CmatDialogType, okCallback?: (val?: any) => any, cancelCallback?: () => any, okLabel?: string, cancelLabel?: string, defaultValue?: string): void;
+    showDialog(message: string, type?: CmatDialogType, okCallback?: (val?: unknown) => void, cancelCallback?: () => void, okLabel?: string, cancelLabel?: string, defaultValue?: string): void;
     showMessage(summary: string): void;
     showMessage(detail: string | string[] | HttpResponseBase, params: string, severity: CmatMessageSeverity): void;
     showBottomMessage(summary: string): void;
     showBottomMessage(summary: string, detail: string, severity: CmatMessageSeverity): void;
     showStickyMessage(summary: string): void;
-    showStickyMessage(summary: string, detail: string, severity: CmatMessageSeverity, error?: any): void;
+    showStickyMessage(summary: string, detail: string, severity: CmatMessageSeverity, error?: unknown): void;
     showStickyMessage(detail: string[] | HttpResponseBase, params: string, severity: CmatMessageSeverity): void;
     startLoadingMessage(message?: string, caption?: string): void;
     stopLoadingMessage(): void;
-    logDebug(msg: any): void;
-    logError(msg: any): void;
-    logInfo(msg: any): void;
-    logMessage(msg: any): void;
-    logTrace(msg: any): void;
-    logWarning(msg: any): void;
+    logDebug(msg: unknown): void;
+    logError(msg: unknown): void;
+    logInfo(msg: unknown): void;
+    logMessage(msg: unknown): void;
+    logTrace(msg: unknown): void;
+    logWarning(msg: unknown): void;
     resetStickyMessage(): void;
     private _showMessageHelper;
     private isApiResult;
+    private _clearLoadingMessageTimer;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatAlertService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatAlertService>;
 }

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

@@ -8,10 +8,10 @@ declare class CmatDataService {
     private _enableDataProtect;
     constructor();
     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>;
+    post<T>(url: string, data: unknown, params?: Record<string, unknown>, auth?: boolean, idempotent?: boolean): Observable<T>;
+    put<T>(url: string, data: unknown, 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>;
+    patch<T>(url: string, data: unknown, params?: Record<string, unknown>, auth?: boolean): Observable<T>;
     private _buildHttpParams;
     private _decryptResponse;
     private _normalizeParamValue;

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

@@ -1,4 +1,5 @@
 import { Observable } from 'rxjs';
+import { Sheet2JSONOpts } from 'xlsx';
 import * as i0 from '@angular/core';
 
 type SupportedExtensions = 'xlsx' | 'xls' | 'txt' | 'csv' | 'json' | 'xml';
@@ -7,12 +8,12 @@ interface ExportAsConfig {
     elementIdOrContent: string;
     download?: boolean;
     fileName: string;
-    options?: any;
+    options?: Sheet2JSONOpts;
 }
 
 declare class CmatExportAsService {
-    get(config: ExportAsConfig): Observable<any>;
-    save(config: ExportAsConfig, fileName: string): Observable<string | null>;
+    get(config: ExportAsConfig): Observable<string | unknown[] | null>;
+    save(config: ExportAsConfig, fileName: string): Observable<string | unknown[] | null>;
     contentToBlob(content: string): Observable<Blob>;
     removeFileTypeFromBase64(fileContent: string): string;
     addFileTypeToBase64(fileContent: string, fileMime: string): string;

package/types/cmat-services-local-storage.d.ts

@@ -1,11 +1,19 @@
 import * as i0 from '@angular/core';
 
+interface StorageOptions {
+    encrypt?: boolean;
+    ttl?: number;
+}
 declare class CmatLocalStorageService {
-    getItem(key: string): string | null;
-    setItem(key: string, item: string): void;
+    private _encryptionPrefix;
+    getItem(key: string, options?: StorageOptions): string | null;
+    setItem(key: string, item: string, options?: StorageOptions): void;
     removeItem(key: string): void;
+    private _encrypt;
+    private _decrypt;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatLocalStorageService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatLocalStorageService>;
 }
 
 export { CmatLocalStorageService };
+export type { StorageOptions };

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

@@ -1,4 +1,4 @@
-import { Language } from '@ngx-translate/core';
+import { Language, Translation } from '@ngx-translate/core';
 import { Observable } from 'rxjs';
 import * as i0 from '@angular/core';
 
@@ -14,8 +14,8 @@ declare class CmatTranslationService {
     getBrowserLanguage(): Language | void;
     useBrowserLanguage(): Language | void;
     changeLanguage(language?: Language): Language;
-    getTranslation(key: string | string[], interpolateParams?: object): any;
-    getTranslationAsync(key: string | string[], interpolateParams?: object): Observable<any>;
+    getTranslation(key: string | string[], interpolateParams?: object): string;
+    getTranslationAsync(key: string | string[], interpolateParams?: object): Observable<Translation>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatTranslationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatTranslationService>;
 }

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

@@ -1,18 +1,31 @@
 import { HttpHeaders, HttpResponseBase } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
 import { IsActiveMatchOptions } from '@angular/router';
 import { Observable } from 'rxjs';
-import * as i0 from '@angular/core';
 
+interface CmatCryptoConfig {
+    key: string;
+    iv: string;
+    specialParam: string;
+}
+declare const CMAT_CRYPTO_CONFIG: InjectionToken<CmatCryptoConfig>;
+declare function initializeCmatUtilsConfig(config: CmatCryptoConfig): void;
 declare class CmatUtilsService {
     static readonly captionAndMessageSeparator = ":";
     static readonly noNetworkMessageCaption = "\u65E0\u7F51\u7EDC";
     static readonly noNetworkMessageDetail = "\u65E0\u6CD5\u8FDE\u63A5\u670D\u52A1\u5668";
     static readonly accessDeniedMessageCaption = "\u62D2\u7EDD\u8BBF\u95EE!";
     static readonly accessDeniedMessageDetail = "";
-    private static readonly key;
-    private static readonly iv;
+    private static _key;
+    private static _iv;
+    private static _specialParam;
+    private static get key();
+    private static get iv();
+    private static get specialParam();
     get exactMatchOptions(): IsActiveMatchOptions;
     get subsetMatchOptions(): IsActiveMatchOptions;
+    static setCryptoConfig(config: CmatCryptoConfig): void;
     static getRequestHeaders(): HttpHeaders;
     static getRequestIdempotentHeaders(): HttpHeaders;
     static getRequestBypassHeaders(): HttpHeaders;
@@ -23,10 +36,10 @@ declare class CmatUtilsService {
     static getRequestCryptoIdempotentBypassHeaders(params: string): HttpHeaders;
     static getEncryptData(data: string): string;
     static getDecryptData(data: string): string;
-    static handleError(error: any): Observable<never>;
-    static getHttpResponseMessage(data: any): string[];
-    static findHttpResponseMessage(messageToFind: string, data: any, seachInCaptionOnly?: boolean, includeCaptionInResult?: boolean): string | null;
-    static getResponseBody(response: HttpResponseBase): any;
+    static handleError(error: unknown): Observable<never>;
+    static getHttpResponseMessage(data: HttpResponseBase | Record<string, unknown>): string[];
+    static findHttpResponseMessage(messageToFind: string, data: HttpResponseBase | Record<string, unknown>, seachInCaptionOnly?: boolean, includeCaptionInResult?: boolean): string | null;
+    static getResponseBody(response: HttpResponseBase): Record<string, unknown> | string | null;
     static checkNoNetwork(response: HttpResponseBase): boolean;
     static checkAccessDenied(response: HttpResponseBase): boolean;
     static checkNotFound(response: HttpResponseBase): boolean;
@@ -36,11 +49,11 @@ declare class CmatUtilsService {
         firstPart: string;
         secondPart: string | null;
     };
-    static safeStringify(object: any): string;
-    static jsonTryParse(value: string): string | void;
+    static safeStringify(object: Record<string, unknown>): string;
+    static jsonTryParse(value: string): unknown;
     static capitalizeFirstLetter(text: string): string;
     static toTitleCase(text: string): string;
-    static toLowerCase(items: any): string | string[] | void;
+    static toLowerCase(items: string | readonly string[]): string | string[] | void;
     static uniqueId(): string;
     static randomNumber(min: number, max: number): number;
     static baseUrl(): string;
@@ -48,18 +61,21 @@ declare class CmatUtilsService {
     static testIsAbsoluteUrl(url: string): boolean;
     static convertToAbsoluteUrl(url: string): string;
     static urlBase64Decode(str: string): string;
-    static decodeToken(token: string): any;
+    static decodeToken(token: string): Record<string, unknown>;
     static getTokenExpirationDate(token: string): Date | null;
     static isTokenExpired(token: string, offsetSeconds?: number): boolean;
-    static readAsDataURL(file: File): Promise<any>;
+    static readAsDataURL(file: File): Promise<string>;
     static dataURIToBlob(dataURI: string): Blob;
     static getFileType(accept: string): 'csv' | 'gif' | 'word' | 'excel' | 'jpg' | 'outlook' | 'pdf' | 'png' | 'ppt' | 'file' | 'text' | 'video' | 'zip';
-    static isDateString(value: any): boolean;
-    static transformObjectsForExport(jsonObjects: any[], columns: any[]): any[];
+    static isDateString(value: string | number): boolean;
+    static transformObjectsForExport(jsonObjects: Record<string, unknown>[], columns: readonly {
+        code: string;
+    }[]): Record<string, unknown>[];
     private static _base64DecodeUnicode;
     randomId(stringLength?: number): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CmatUtilsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CmatUtilsService>;
 }
 
-export { CmatUtilsService };
+export { CMAT_CRYPTO_CONFIG, CmatUtilsService, initializeCmatUtilsConfig };
+export type { CmatCryptoConfig };

package/types/cmat-validators.d.ts

@@ -1,7 +1,7 @@
 import { ValidatorFn } from '@angular/forms';
 
 declare class CmatValidators {
-    static isEmptyInputValue(value: any): boolean;
+    static isEmptyInputValue(value: unknown): boolean;
     static mustMatch(controlPath: string, matchingControlPath: string): ValidatorFn;
 }