coer-elements 0.0.2 → 0.0.4

package/Tools/index.d.ts

@@ -0,0 +1,8 @@
+export * from './src/Breadcrumbs.class';
+export * from './src/ControlValue';
+export * from './src/DateTime.class';
+export * from './src/Files.class';
+export * from './src/Page.class';
+export * from './src/Screen.class';
+export * from './src/Source.class';
+export * from './src/Tools';

package/Tools/src/Breadcrumbs.class.d.ts

@@ -0,0 +1,18 @@
+import { IAppSource } from "../../interfaces";
+export declare class Breadcrumbs {
+    private static readonly storage;
+    /** */
+    static Add(page: string, path: string): void;
+    /** */
+    static Get(): IAppSource[];
+    /** Source */
+    static GetFirst(): IAppSource | null;
+    /** */
+    static Save(breadcrumbs: IAppSource[]): void;
+    /** */
+    static Remove(path: string): void;
+    /** */
+    static SetLast(page: string, path: string): void;
+    /** */
+    static RemoveLast(): void;
+}

package/Tools/src/ControlValue.d.ts

@@ -0,0 +1,23 @@
+import { ControlValueAccessor } from "@angular/forms";
+export declare const CONTROL_VALUE: <T>(component: T) => {
+    provide: import("@angular/core").InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
+export declare class ControlValue implements ControlValueAccessor {
+    protected _value: any;
+    private _isTouched;
+    protected _UpdateValue: Function;
+    private _IsTouched;
+    get isTouched(): boolean;
+    /** */
+    protected SetValue(value: any): void;
+    /** */
+    SetTouched(isTouched: boolean): void;
+    /** */
+    writeValue(value: any): void;
+    /** */
+    registerOnChange(callback: Function): void;
+    /** */
+    registerOnTouched(callback: Function): void;
+}

package/Tools/src/DateTime.class.d.ts

@@ -0,0 +1,11 @@
+import moment from "moment";
+export declare class DateTime {
+    /** Get UTC Offset */
+    static GetUTCOffset(): number;
+    /** Convert UTC Date to Local Zone */
+    static ToLocalZone(utcDate: string | Date | moment.Moment): string;
+    /** Convert Local Zone Date to UTC */
+    static ToUTC(utcDate: string | Date | moment.Moment): string;
+    /** DD MMM YYYY */
+    static GetDateFormat(date: string | Date | moment.Moment): string;
+}

package/Tools/src/Files.class.d.ts

@@ -0,0 +1,16 @@
+export declare class Files {
+    static readonly EXCEL_EXTENSIONS: string[];
+    /** Get Extension File */
+    static GetExtension(file: File): string | null;
+    /** Is Excel File */
+    static IsExcel(file: File): boolean;
+    /** Read excel file */
+    static ReadExcel<T>(file: File): Promise<{
+        columns: string[];
+        rows: T[];
+    }>;
+    /** Export to excel file */
+    static ExportExcel<T>(data: T[], fileName?: string, sheetName?: string): void;
+    /** Convert file to string base64 */
+    static ConvertToBase64(file: File): Promise<string>;
+}

package/Tools/src/Page.class.d.ts

@@ -0,0 +1,66 @@
+import { Router } from '@angular/router';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { IBreadcrumb, IGoBack } from '../../interfaces';
+import { CoerAlert } from '../../components';
+import * as i0 from "@angular/core";
+export declare class Page implements AfterViewInit, OnDestroy {
+    protected readonly alert: CoerAlert;
+    protected readonly router: Router;
+    private readonly activatedRoute;
+    /** */
+    protected isUpdate: boolean;
+    /** */
+    protected isLoading: boolean;
+    /** */
+    protected isReady: boolean;
+    /** */
+    protected enableAnimations: boolean;
+    /** */
+    protected routeParams: any;
+    /** */
+    protected queryParams: any;
+    /** */
+    protected breadcrumbs: IBreadcrumb[];
+    /** */
+    protected pageResponse: any;
+    /** */
+    protected goBack: IGoBack;
+    private _page;
+    private _source;
+    private _preventDestroy;
+    constructor(page: string);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /** Main method. Starts after ngAfterViewInit() */
+    protected RunPage(): void;
+    /** Rename the last breadcrumb and update the url id */
+    protected SetPageName(name: string, id?: string | number | null): void;
+    /** */
+    private SetSource;
+    /** */
+    private GetSource;
+    /** */
+    protected GetPageResponse(): void;
+    /** */
+    private GetNavigation;
+    /** */
+    private SetGoBack;
+    /** */
+    private GoBack;
+    /** Navigate to previous page */
+    protected GoToSource<T>(pageResponse?: T | null): void;
+    /** */
+    protected SetPageResponse<T>(pageResponse?: T | null): void;
+    /** */
+    protected ReloadPage(): void;
+    /** */
+    protected Log(value: any, log?: string | null): void;
+    /** Returns true if the value is null or undefined, false otherwise */
+    protected IsNotNull: <T>(value: T | null | undefined) => boolean;
+    /** Returns true if the value is null or undefined, false otherwise */
+    protected IsNull: <T>(value: T | null | undefined) => boolean;
+    /** Returns true if the value is null or undefined or contains only whitespace, false otherwise */
+    protected IsOnlyWhiteSpace: <T>(value: T | null | undefined) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Page, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Page, "ng-component", never, {}, {}, never, never, false, never>;
+}

package/Tools/src/Screen.class.d.ts

@@ -0,0 +1,11 @@
+import { IScreenSize } from "../../interfaces";
+import { Observable } from "rxjs";
+export declare class Screen {
+    static get WINDOW_WIDTH(): number;
+    static get WINDOW_HEIGHT(): number;
+    static get DEVICE_WIDTH(): number;
+    static get DEVICE_HEIGHT(): number;
+    static get BREAKPOINT(): 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    /** */
+    static Resize: Observable<IScreenSize>;
+}

package/Tools/src/Source.class.d.ts

@@ -0,0 +1,20 @@
+import { IAppSource } from '../../interfaces';
+export declare class Source {
+    private static readonly storage;
+    /** */
+    static Set(page: string): void;
+    /** */
+    private static Save;
+    /** */
+    static Get(): IAppSource | null;
+    /** */
+    static GetRoot(): IAppSource | null;
+    /** */
+    static SetPageResponse<T>(pageResponse: T): void;
+    /** */
+    static GetPageResponse<T>(): T | null;
+    /** */
+    static ClearPageResponse(): void;
+    /** Clear Source */
+    static Reset(): void;
+}

package/Tools/src/Tools.d.ts

@@ -0,0 +1,33 @@
+export declare const Tools: {
+    /** Generate a Guid */
+    GetGuid: (seed?: string) => string;
+    /** Returns true if the value is null or undefined, false otherwise */
+    IsNull: <T>(value: T | null | undefined) => boolean;
+    /** Returns true if the value is not null or undefined, false otherwise */
+    IsNotNull: <T_1>(value: T_1 | null | undefined) => boolean;
+    /** Returns true if the value is null or undefined or contains only whitespace, false otherwise */
+    IsOnlyWhiteSpace: <T_2>(value: T_2 | null | undefined) => boolean;
+    /** Break reference of a object or array */
+    BreakReference: <T_3>(object: T_3) => T_3;
+    /** Clean extra whitespaces */
+    CleanUpBlanks: (text: string | number) => string;
+    /** Get properties of an object */
+    GetObjectProperties: <T_4>(obj: T_4 | null | undefined) => string[];
+    /**
+     * Set an index and merge more arrays of the same type
+     * @returns A new array
+     * */
+    SetIndex: <T_5>(array: T_5[], ...args: T_5[][]) => T_5[];
+    /** Set First Char To Lower */
+    FirstCharToLower: (text: string | null | undefined) => string;
+    /** Set First Char To Upper */
+    FirstCharToUpper: (text: string | null | undefined) => string;
+    /** Sort an array in ascending order by property */
+    SortBy: <T_6>(array: T_6[], property: string, propertyType?: 'string' | 'number') => T_6[];
+    /** Sort an array in descending order by property */
+    SortByDesc: <T_7>(array: T_7[], property: string, propertyType?: 'string' | 'number') => T_7[];
+    /** Return a string with forman numeric */
+    GetNumericFormat: (value: string | number | null | undefined, decimals?: number) => string;
+    /** Wait the time indicated */
+    Sleep: (milliseconds?: number, reference?: string | null) => Promise<unknown>;
+};

package/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/components.module';
+export * from './src/coer-alert/coer-alert.component';

package/components/src/coer-alert/coer-alert.component.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from "@angular/core";
+export declare class CoerAlert {
+    /** */
+    Success(message?: string | null, title?: string | null, icon?: string | null, autohide?: number | null): void;
+    /** */
+    Error(message?: string | null, title?: string | null, icon?: string | null, autohide?: number | null): void;
+    /** */
+    Info(message?: string | null, title?: string | null, icon?: string | null, autohide?: number | null): void;
+    /** */
+    Warning(message?: string | null, title?: string | null, icon?: string | null, autohide?: number | null): void;
+    /** */
+    protected Close(alert: 'alert-success' | 'alert-error' | 'alert-info' | 'alert-warning'): Promise<void>;
+    /** */
+    Confirm(message?: string, alertType?: 'warning' | 'danger' | 'success' | 'info', icon?: string | null): Promise<boolean>;
+    /** */
+    private SetIcon;
+    /** */
+    private SetAutoHide;
+    /** */
+    private GetIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoerAlert, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CoerAlert, "coer-alert", never, {}, {}, never, never, false, never>;
+}

package/components/src/components.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./coer-alert/coer-alert.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/forms";
+export declare class ComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ComponentsModule, [typeof i1.CoerAlert], [typeof i2.CommonModule, typeof i3.RouterModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule], [typeof i1.CoerAlert]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ComponentsModule>;
+}

package/esm2022/Tools/index.mjs

@@ -0,0 +1,9 @@
+export * from './src/Breadcrumbs.class';
+export * from './src/ControlValue';
+export * from './src/DateTime.class';
+export * from './src/Files.class';
+export * from './src/Page.class';
+export * from './src/Screen.class';
+export * from './src/Source.class';
+export * from './src/Tools';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb2VyLWVsZW1lbnRzL1Rvb2xzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NyYy9CcmVhZGNydW1icy5jbGFzcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3JjL0NvbnRyb2xWYWx1ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3JjL0RhdGVUaW1lLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9zcmMvRmlsZXMuY2xhc3MnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NyYy9QYWdlLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9zcmMvU2NyZWVuLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9zcmMvU291cmNlLmNsYXNzJztcclxuZXhwb3J0ICogZnJvbSAnLi9zcmMvVG9vbHMnOyJdfQ==

package/esm2022/Tools/src/Breadcrumbs.class.mjs

@@ -0,0 +1,63 @@
+import { Tools } from '../';
+export class Breadcrumbs {
+    static { this.storage = 'COER-System'; }
+    /** */
+    static Add(page, path) {
+        const breadcrumbs = this.Get();
+        const paths = breadcrumbs.map(item => item.path);
+        if (!paths.includes(path)) {
+            breadcrumbs.push({ page, path });
+            this.Save(breadcrumbs);
+        }
+    }
+    /** */
+    static Get() {
+        let storage = sessionStorage.getItem(this.storage);
+        if (storage) {
+            storage = JSON.parse(storage);
+            if (storage.hasOwnProperty('breadcrumbs')) {
+                return Tools.BreakReference(storage.breadcrumbs);
+            }
+        }
+        return [];
+    }
+    /** Source */
+    static GetFirst() {
+        const breadcrumbs = this.Get();
+        return (breadcrumbs.length > 0) ? breadcrumbs.shift() : null;
+    }
+    /** */
+    static Save(breadcrumbs) {
+        let storage = sessionStorage.getItem(this.storage);
+        if (storage)
+            storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { breadcrumbs });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+    /** */
+    static Remove(path) {
+        let breadcrumbs = this.Get();
+        const index = breadcrumbs.findIndex(x => x.path.toLowerCase().trim() === path.toLowerCase().trim());
+        if (index >= 0) {
+            breadcrumbs = Tools.BreakReference(breadcrumbs).splice(0, index + 1);
+            this.Save(breadcrumbs);
+        }
+    }
+    /** */
+    static SetLast(page, path) {
+        const breadcrumbs = this.Get();
+        if (breadcrumbs.length > 0) {
+            breadcrumbs[breadcrumbs.length - 1] = { page, path };
+            this.Save(breadcrumbs);
+        }
+    }
+    /** */
+    static RemoveLast() {
+        const breadcrumbs = this.Get();
+        if (breadcrumbs.length > 0) {
+            breadcrumbs.pop();
+            this.Save(breadcrumbs);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/Tools/src/ControlValue.mjs

@@ -0,0 +1,44 @@
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { forwardRef } from "@angular/core";
+export const CONTROL_VALUE = (component) => {
+    return {
+        provide: NG_VALUE_ACCESSOR,
+        useExisting: forwardRef(() => component),
+        multi: true
+    };
+};
+export class ControlValue {
+    constructor() {
+        this._isTouched = false;
+    }
+    get isTouched() {
+        return this._isTouched;
+    }
+    /** */
+    SetValue(value) {
+        if (typeof this._UpdateValue === 'function') {
+            this._UpdateValue(value);
+        }
+        this._value = value;
+    }
+    /** */
+    SetTouched(isTouched) {
+        if (typeof this._IsTouched === 'function') {
+            this._IsTouched(isTouched);
+        }
+        this._isTouched = isTouched;
+    }
+    /** */
+    writeValue(value) {
+        this._value = value;
+    }
+    /** */
+    registerOnChange(callback) {
+        this._UpdateValue = callback;
+    }
+    /** */
+    registerOnTouched(callback) {
+        this._IsTouched = callback;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29udHJvbFZhbHVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29lci1lbGVtZW50cy9Ub29scy9zcmMvQ29udHJvbFZhbHVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBd0IsaUJBQWlCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBRyxDQUFJLFNBQVksRUFBRSxFQUFFO0lBQzdDLE9BQU87UUFDSCxPQUFPLEVBQUUsaUJBQWlCO1FBQzFCLFdBQVcsRUFBRSxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsU0FBUyxDQUFDO1FBQ3hDLEtBQUssRUFBRSxJQUFJO0tBQ2QsQ0FBQTtBQUNMLENBQUMsQ0FBQTtBQUdELE1BQU0sT0FBTyxZQUFZO0lBQXpCO1FBSVksZUFBVSxHQUFZLEtBQUssQ0FBQztJQThDeEMsQ0FBQztJQXpDRyxJQUFXLFNBQVM7UUFDaEIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDO0lBQzNCLENBQUM7SUFHRCxNQUFNO0lBQ0ksUUFBUSxDQUFDLEtBQVU7UUFDekIsSUFBRyxPQUFPLElBQUksQ0FBQyxZQUFZLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDekMsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM3QixDQUFDO1FBRUQsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7SUFDeEIsQ0FBQztJQUdELE1BQU07SUFDQyxVQUFVLENBQUMsU0FBa0I7UUFDaEMsSUFBRyxPQUFPLElBQUksQ0FBQyxVQUFVLEtBQUssVUFBVSxFQUFFLENBQUM7WUFDdkMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUMvQixDQUFDO1FBRUQsSUFBSSxDQUFDLFVBQVUsR0FBRyxTQUFTLENBQUM7SUFDaEMsQ0FBQztJQUdELE1BQU07SUFDQyxVQUFVLENBQUMsS0FBVTtRQUN4QixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQztJQUN4QixDQUFDO0lBR0QsTUFBTTtJQUNDLGdCQUFnQixDQUFDLFFBQWtCO1FBQ3RDLElBQUksQ0FBQyxZQUFZLEdBQUcsUUFBUSxDQUFDO0lBQ2pDLENBQUM7SUFHRCxNQUFNO0lBQ0MsaUJBQWlCLENBQUMsUUFBa0I7UUFDdkMsSUFBSSxDQUFDLFVBQVUsR0FBRyxRQUFRLENBQUM7SUFDL0IsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udHJvbFZhbHVlQWNjZXNzb3IsIE5HX1ZBTFVFX0FDQ0VTU09SIH0gZnJvbSBcIkBhbmd1bGFyL2Zvcm1zXCI7XHJcbmltcG9ydCB7IGZvcndhcmRSZWYgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuZXhwb3J0IGNvbnN0IENPTlRST0xfVkFMVUUgPSA8VD4oY29tcG9uZW50OiBUKSA9PiB7XHJcbiAgICByZXR1cm4ge1xyXG4gICAgICAgIHByb3ZpZGU6IE5HX1ZBTFVFX0FDQ0VTU09SLFxyXG4gICAgICAgIHVzZUV4aXN0aW5nOiBmb3J3YXJkUmVmKCgpID0+IGNvbXBvbmVudCksXHJcbiAgICAgICAgbXVsdGk6IHRydWVcclxuICAgIH1cclxufVxyXG5cclxuXHJcbmV4cG9ydCBjbGFzcyBDb250cm9sVmFsdWUgaW1wbGVtZW50cyBDb250cm9sVmFsdWVBY2Nlc3NvciB7XHJcblxyXG4gICAgLy9WYXJpYWJsZXNcclxuICAgIHByb3RlY3RlZCBfdmFsdWU6IGFueTtcclxuICAgIHByaXZhdGUgX2lzVG91Y2hlZDogYm9vbGVhbiA9IGZhbHNlO1xyXG4gICAgcHJvdGVjdGVkIF9VcGRhdGVWYWx1ZSE6IEZ1bmN0aW9uO1xyXG4gICAgcHJpdmF0ZSBfSXNUb3VjaGVkITogRnVuY3Rpb247XHJcblxyXG5cclxuICAgIHB1YmxpYyBnZXQgaXNUb3VjaGVkKCkge1xyXG4gICAgICAgIHJldHVybiB0aGlzLl9pc1RvdWNoZWQ7XHJcbiAgICB9XHJcblxyXG5cclxuICAgIC8qKiAqL1xyXG4gICAgcHJvdGVjdGVkIFNldFZhbHVlKHZhbHVlOiBhbnkpOiB2b2lkIHtcclxuICAgICAgICBpZih0eXBlb2YgdGhpcy5fVXBkYXRlVmFsdWUgPT09ICdmdW5jdGlvbicpIHtcclxuICAgICAgICAgICAgdGhpcy5fVXBkYXRlVmFsdWUodmFsdWUpO1xyXG4gICAgICAgIH1cclxuXHJcbiAgICAgICAgdGhpcy5fdmFsdWUgPSB2YWx1ZTtcclxuICAgIH1cclxuXHJcblxyXG4gICAgLyoqICovXHJcbiAgICBwdWJsaWMgU2V0VG91Y2hlZChpc1RvdWNoZWQ6IGJvb2xlYW4pOiB2b2lkIHtcclxuICAgICAgICBpZih0eXBlb2YgdGhpcy5fSXNUb3VjaGVkID09PSAnZnVuY3Rpb24nKSB7XHJcbiAgICAgICAgICAgIHRoaXMuX0lzVG91Y2hlZChpc1RvdWNoZWQpO1xyXG4gICAgICAgIH1cclxuXHJcbiAgICAgICAgdGhpcy5faXNUb3VjaGVkID0gaXNUb3VjaGVkO1xyXG4gICAgfVxyXG5cclxuXHJcbiAgICAvKiogKi9cclxuICAgIHB1YmxpYyB3cml0ZVZhbHVlKHZhbHVlOiBhbnkpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLl92YWx1ZSA9IHZhbHVlO1xyXG4gICAgfVxyXG5cclxuXHJcbiAgICAvKiogKi9cclxuICAgIHB1YmxpYyByZWdpc3Rlck9uQ2hhbmdlKGNhbGxiYWNrOiBGdW5jdGlvbik6IHZvaWQge1xyXG4gICAgICAgIHRoaXMuX1VwZGF0ZVZhbHVlID0gY2FsbGJhY2s7XHJcbiAgICB9XHJcblxyXG5cclxuICAgIC8qKiAqL1xyXG4gICAgcHVibGljIHJlZ2lzdGVyT25Ub3VjaGVkKGNhbGxiYWNrOiBGdW5jdGlvbik6IHZvaWQge1xyXG4gICAgICAgIHRoaXMuX0lzVG91Y2hlZCA9IGNhbGxiYWNrO1xyXG4gICAgfVxyXG59Il19

package/esm2022/Tools/src/DateTime.class.mjs

@@ -0,0 +1,22 @@
+import moment from "moment";
+export class DateTime {
+    /** Get UTC Offset */
+    static GetUTCOffset() {
+        return moment().utcOffset();
+    }
+    /** Convert UTC Date to Local Zone */
+    static ToLocalZone(utcDate) {
+        return moment(utcDate).add(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    }
+    /** Convert Local Zone Date to UTC */
+    static ToUTC(utcDate) {
+        return moment(utcDate).subtract(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    }
+    /** DD MMM YYYY */
+    static GetDateFormat(date) {
+        if ((typeof date === 'string'))
+            date = date.replaceAll('/', '-');
+        return moment(date).parseZone().local(true).format('DD MMM YYYY');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/Tools/src/Files.class.mjs

@@ -0,0 +1,93 @@
+import { Tools } from "../";
+import * as XLSX from 'xlsx';
+export class Files {
+    static { this.EXCEL_EXTENSIONS = ['xls', 'xlsx', 'csv']; }
+    /** Get Extension File */
+    static GetExtension(file) {
+        const fileName = file.name;
+        if (fileName.includes('.')) {
+            let worlds = fileName.split('.');
+            if (worlds.length > 0) {
+                let extension = worlds.pop();
+                extension = extension.trim().toLowerCase();
+                if (extension.length > 0)
+                    return extension;
+            }
+        }
+        return null;
+    }
+    /** Is Excel File */
+    static IsExcel(file) {
+        const EXTENSION = Files.GetExtension(file);
+        return Tools.IsNotNull(EXTENSION)
+            ? this.EXCEL_EXTENSIONS.includes(EXTENSION)
+            : false;
+    }
+    /** Read excel file */
+    static ReadExcel(file) {
+        return new Promise(Resolve => {
+            let columns = [];
+            let rows = [];
+            const reader = new FileReader();
+            reader.readAsArrayBuffer(file);
+            reader.onload = () => {
+                const dataBytes = new Uint8Array(reader.result);
+                if (dataBytes) {
+                    const workbook = XLSX.read(dataBytes, {});
+                    const sheet = workbook.Sheets[workbook.SheetNames[0]];
+                    let dataSheet = XLSX.utils.sheet_to_json(sheet, {
+                        header: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
+                    });
+                    //Get Headers
+                    for (const column in dataSheet[0]) {
+                        columns.push(Tools.FirstCharToLower(String(dataSheet[0][column]).replaceAll(' ', '')));
+                    }
+                    //Get Rows
+                    rows = XLSX.utils.sheet_to_json(sheet, { header: columns });
+                    rows.shift();
+                    rows = rows.map(row => {
+                        const item = Tools.BreakReference(row);
+                        delete item['__rowNum__'];
+                        return item;
+                    });
+                }
+                Resolve({ columns, rows });
+            };
+            reader.onerror = () => { Resolve({ columns, rows }); };
+        });
+    }
+    /** Export to excel file */
+    static ExportExcel(data, fileName = 'coer_report', sheetName = 'Sheet1') {
+        sheetName = Tools.CleanUpBlanks(sheetName);
+        fileName = Tools.CleanUpBlanks(fileName);
+        if (fileName.endsWith('.xls') || fileName.endsWith('.xlsx') || fileName.endsWith('.csv')) {
+            if (fileName.includes('.xls')) {
+                fileName = fileName.replaceAll('.xls', '.xlsx');
+            }
+            if (fileName.includes('.csv')) {
+                fileName = fileName.replaceAll('.csv', '.xlsx');
+            }
+        }
+        else {
+            fileName += '.xlsx';
+        }
+        const WORK_SHEET = XLSX.utils.json_to_sheet(data);
+        const WORK_BOOK = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(WORK_BOOK, WORK_SHEET, 'Sheet1');
+        XLSX.writeFile(WORK_BOOK, fileName);
+    }
+    /** Convert file to string base64 */
+    static ConvertToBase64(file) {
+        return new Promise(Resolve => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = () => {
+                Resolve(reader.result?.toString() || '');
+            };
+            reader.onerror = () => {
+                Resolve('');
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Files.class.js","sourceRoot":"","sources":["../../../../../projects/coer-elements/Tools/src/Files.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC;AAC5B,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,OAAO,KAAK;aACS,qBAAgB,GAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAE3E,yBAAyB;IAClB,MAAM,CAAC,YAAY,CAAC,IAAU;QACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC;QAE3B,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,IAAI,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAa,CAAC;YAE7C,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpB,IAAI,SAAS,GAAG,MAAM,CAAC,GAAG,EAAG,CAAC;gBAC9B,SAAS,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;gBAC3C,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC;oBAAE,OAAO,SAAS,CAAC;YAC/C,CAAC;QACL,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAGD,oBAAoB;IACb,MAAM,CAAC,OAAO,CAAC,IAAU;QAC5B,MAAM,SAAS,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAE3C,OAAO,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC;YAC7B,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,SAAU,CAAC;YAC5C,CAAC,CAAC,KAAK,CAAC;IAChB,CAAC;IAGD,sBAAsB;IACf,MAAM,CAAC,SAAS,CAAI,IAAU;QACjC,OAAO,IAAI,OAAO,CAAoC,OAAO,CAAC,EAAE;YAC5D,IAAI,OAAO,GAAa,EAAE,CAAC;YAC3B,IAAI,IAAI,GAAQ,EAAE,CAAC;YAEnB,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAChC,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAE/B,MAAM,CAAC,MAAM,GAAG,GAAG,EAAE;gBACjB,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAa,CAAC,CAAC;gBAEvD,IAAI,SAAS,EAAE,CAAC;oBACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;oBAC1C,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;oBACtD,IAAI,SAAS,GAAU,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE;wBACnD,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;qBAC7I,CAAC,CAAC;oBAEH,aAAa;oBACb,KAAI,MAAM,MAAM,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;wBAC/B,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;oBAC3F,CAAC;oBAED,UAAU;oBACV,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;oBAC5D,IAAI,CAAC,KAAK,EAAE,CAAC;oBAEb,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;wBAClB,MAAM,IAAI,GAAG,KAAK,CAAC,cAAc,CAAM,GAAG,CAAC,CAAC;wBAC5C,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC;wBAC1B,OAAO,IAAI,CAAC;oBAChB,CAAC,CAAC,CAAC;gBACP,CAAC;gBAED,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;YAC/B,CAAC,CAAA;YAED,MAAM,CAAC,OAAO,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA,CAAC,CAAC,CAAA;QACzD,CAAC,CAAC,CAAC;IACP,CAAC;IAGD,2BAA2B;IACpB,MAAM,CAAC,WAAW,CAAI,IAAS,EAAE,WAAmB,aAAa,EAAE,YAAoB,QAAQ;QAClG,SAAS,GAAG,KAAK,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC3C,QAAQ,GAAG,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAEzC,IAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtF,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC5B,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACpD,CAAC;YAED,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC5B,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACpD,CAAC;QACL,CAAC;aAEI,CAAC;YACF,QAAQ,IAAI,OAAO,CAAC;QACxB,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACxC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QAC9D,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IACxC,CAAC;IAGD,oCAAoC;IAC7B,MAAM,CAAC,eAAe,CAAC,IAAU;QACpC,OAAO,IAAI,OAAO,CAAS,OAAO,CAAC,EAAE;YACjC,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;YAChC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAE3B,MAAM,CAAC,MAAM,GAAG,GAAG,EAAE;gBACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;YAC7C,CAAC,CAAA;YAED,MAAM,CAAC,OAAO,GAAG,GAAG,EAAE;gBAClB,OAAO,CAAC,EAAE,CAAC,CAAC;YAChB,CAAC,CAAA;QACL,CAAC,CAAC,CAAC;IACP,CAAC","sourcesContent":["import { Tools } from \"../\";\r\nimport * as XLSX from 'xlsx';\r\n\r\nexport class Files {\r\n    public static readonly EXCEL_EXTENSIONS: string[] = ['xls', 'xlsx', 'csv'];\r\n\r\n    /** Get Extension File */\r\n    public static GetExtension(file: File): string | null {\r\n        const fileName = file.name;\r\n\r\n        if (fileName.includes('.')) {\r\n            let worlds = fileName.split('.') as string[];\r\n\r\n            if (worlds.length > 0) {\r\n                let extension = worlds.pop()!;\r\n                extension = extension.trim().toLowerCase();\r\n                if (extension.length > 0) return extension;\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n\r\n    /** Is Excel File */\r\n    public static IsExcel(file: File): boolean {\r\n        const EXTENSION = Files.GetExtension(file);\r\n\r\n        return Tools.IsNotNull(EXTENSION)\r\n            ? this.EXCEL_EXTENSIONS.includes(EXTENSION!)\r\n            : false;\r\n    }\r\n\r\n\r\n    /** Read excel file */\r\n    public static ReadExcel<T>(file: File) {\r\n        return new Promise<{ columns: string[]; rows: T[]; }>(Resolve => {\r\n            let columns: string[] = [];\r\n            let rows: T[] = [];\r\n\r\n            const reader = new FileReader();\r\n            reader.readAsArrayBuffer(file);\r\n\r\n            reader.onload = () => {\r\n                const dataBytes = new Uint8Array(reader.result as any);\r\n\r\n                if (dataBytes) {\r\n                    const workbook = XLSX.read(dataBytes, {});\r\n                    const sheet = workbook.Sheets[workbook.SheetNames[0]];\r\n                    let dataSheet: any[] = XLSX.utils.sheet_to_json(sheet, {\r\n                        header: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\r\n                    });\r\n\r\n                    //Get Headers\r\n                    for(const column in dataSheet[0]) {\r\n                        columns.push(Tools.FirstCharToLower(String(dataSheet[0][column]).replaceAll(' ', '')));\r\n                    }\r\n\r\n                    //Get Rows\r\n                    rows = XLSX.utils.sheet_to_json(sheet, { header: columns });\r\n                    rows.shift();\r\n\r\n                    rows = rows.map(row => {\r\n                        const item = Tools.BreakReference<any>(row);\r\n                        delete item['__rowNum__'];\r\n                        return item;\r\n                    });\r\n                }\r\n\r\n                Resolve({ columns, rows });\r\n            }\r\n\r\n            reader.onerror = () => { Resolve({ columns, rows }) }\r\n        });\r\n    }\r\n\r\n\r\n    /** Export to excel file */\r\n    public static ExportExcel<T>(data: T[], fileName: string = 'coer_report', sheetName: string = 'Sheet1') {\r\n        sheetName = Tools.CleanUpBlanks(sheetName);\r\n        fileName = Tools.CleanUpBlanks(fileName);\r\n\r\n        if(fileName.endsWith('.xls') || fileName.endsWith('.xlsx') || fileName.endsWith('.csv')) {\r\n            if (fileName.includes('.xls')) {\r\n                fileName = fileName.replaceAll('.xls', '.xlsx');\r\n            }\r\n\r\n            if (fileName.includes('.csv')) {\r\n                fileName = fileName.replaceAll('.csv', '.xlsx');\r\n            }\r\n        }\r\n\r\n        else {\r\n            fileName += '.xlsx';\r\n        }\r\n\r\n        const WORK_SHEET = XLSX.utils.json_to_sheet(data);\r\n        const WORK_BOOK = XLSX.utils.book_new();\r\n        XLSX.utils.book_append_sheet(WORK_BOOK, WORK_SHEET, 'Sheet1');\r\n        XLSX.writeFile(WORK_BOOK, fileName);\r\n    }\r\n\r\n\r\n    /** Convert file to string base64 */\r\n    public static ConvertToBase64(file: File) {\r\n        return new Promise<string>(Resolve => {\r\n            const reader = new FileReader();\r\n            reader.readAsDataURL(file);\r\n\r\n            reader.onload = () => {\r\n                Resolve(reader.result?.toString() || '');\r\n            }\r\n\r\n            reader.onerror = () => {\r\n                Resolve('');\r\n            }\r\n        });\r\n    }\r\n}"]}