coer-elements 0.0.10 → 0.0.11

package/fesm2022/coer-elements.mjs

@@ -1,10 +1,13 @@
 import * as i0 from '@angular/core';
-import { Component, NgModule, forwardRef } from '@angular/core';
+import { Component, NgModule, signal, forwardRef, inject, Inject } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { RouterModule } from '@angular/router';
+import { RouterModule, Router, ActivatedRoute } from '@angular/router';
 import { FormsModule, ReactiveFormsModule, NG_VALUE_ACCESSOR } from '@angular/forms';
 import * as bootstrap from 'bootstrap';
 import Swal from 'sweetalert2';
+import moment from 'moment';
+import * as XLSX from 'xlsx';
+import { Observable } from 'rxjs';
 
 class CoerAlert {
     /** */
@@ -305,6 +308,266 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }]
         }] });
 
+const reference_signal = signal({});
+const Tools = {
+    /** Generate a Guid */
+    GetGuid: (seed = 'coer-system') => {
+        let time = new Date().getTime();
+        seed = seed.toString().trim();
+        return seed + `-xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`.replace(/[xy]/g, (c) => {
+            const random = (time + Math.random() * 16) % 16 | 0;
+            time = Math.floor(time / 16);
+            return (c == 'x' ? random : (random & 0x3 | 0x8)).toString(16);
+        });
+    },
+    /** Returns true if the value is null or undefined, false otherwise */
+    IsNull: (value) => {
+        if (value === undefined)
+            return true;
+        if (value === null)
+            return true;
+        return false;
+    },
+    /** Returns true if the value is not null or undefined, false otherwise */
+    IsNotNull: (value) => {
+        if (value === undefined)
+            return false;
+        if (value === null)
+            return false;
+        return true;
+    },
+    /** Returns true if the value is null or undefined or contains only whitespace, false otherwise */
+    IsOnlyWhiteSpace: (value) => {
+        if (value === undefined)
+            return true;
+        if (value === null)
+            return true;
+        if (value.toString().trim() === '')
+            return true;
+        return false;
+    },
+    /** Break reference of a object or array */
+    BreakReference: (object) => {
+        if (object === undefined)
+            return undefined;
+        if (object === null)
+            return null;
+        const OBJECT = JSON.parse(JSON.stringify(object));
+        return (Array.isArray(OBJECT)) ? [...OBJECT] : { ...OBJECT };
+    },
+    /** Clean extra whitespaces */
+    CleanUpBlanks: (text) => {
+        if (Tools.IsNull(text))
+            return '';
+        let worlds = String(text).split(' ');
+        worlds = worlds.filter(x => x.length > 0);
+        return worlds.join(' ');
+    },
+    /** Get properties of an object */
+    GetObjectProperties: (obj) => {
+        const properties = [];
+        if (Tools.IsNull(obj))
+            return properties;
+        for (const property in obj)
+            properties.push(String(property));
+        return properties;
+    },
+    /**
+     * Set an index and merge more arrays of the same type
+     * */
+    SetIndex: (array, ...args) => {
+        let index = 0;
+        for (const arg of args) {
+            array = Tools.BreakReference(array).concat(Tools.BreakReference(arg));
+        }
+        return Tools.BreakReference(array).map(item => Object.assign({ index: index++ }, item));
+    },
+    /** Set First Char To Lower */
+    FirstCharToLower: (text) => {
+        if (Tools.IsNull(text))
+            return '';
+        const textArray = [];
+        for (let i = 0; i < text.length; i++) {
+            if (i === 0)
+                textArray.push(text[i].toLowerCase());
+            else
+                textArray.push(text[i]);
+        }
+        return textArray.join('');
+    },
+    /** Set First Char To Upper */
+    FirstCharToUpper: (text) => {
+        if (Tools.IsNull(text))
+            return '';
+        const textArray = [];
+        for (let i = 0; i < text.length; i++) {
+            if (i === 0)
+                textArray.push(text[i].toUpperCase());
+            else
+                textArray.push(text[i]);
+        }
+        return textArray.join('');
+    },
+    /** Sort an array in ascending order by property */
+    SortBy: (array, property, propertyType = 'string') => {
+        switch (propertyType) {
+            case 'string': {
+                return array.sort((x, y) => {
+                    if (String(x[property]).toUpperCase().trim() < String(y[property]).toUpperCase().trim())
+                        return -1;
+                    else if (String(x[property]).toUpperCase().trim() > String(y[property]).toUpperCase().trim())
+                        return 1;
+                    else
+                        return 0;
+                });
+            }
+            case 'number': {
+                return array.sort((x, y) => Number(x[property] - Number(y[property])));
+            }
+        }
+    },
+    /** Sort an array in descending order by property */
+    SortByDesc: (array, property, propertyType = 'string') => {
+        switch (propertyType) {
+            case 'string': {
+                return array.sort((x, y) => {
+                    if (String(x[property]).toUpperCase().trim() < String(y[property]).toUpperCase().trim())
+                        return 1;
+                    else if (String(x[property]).toUpperCase().trim() > String(y[property]).toUpperCase().trim())
+                        return -1;
+                    else
+                        return 0;
+                });
+            }
+            case 'number': {
+                return array.sort((x, y) => Number(Number(y[property])) - x[property]);
+            }
+        }
+    },
+    /** Return a string with forman numeric */
+    GetNumericFormat: (value, decimals = 0) => {
+        if (value == undefined
+            || value == null
+            || value.toString().trim() == ''
+            || isNaN(Number(value))) {
+            return '0';
+        }
+        let valueInteger = '';
+        let valueDecimal = '';
+        value = value.toString().replaceAll(' ', '');
+        if (value.includes('.') || (decimals > 0)) {
+            valueInteger = value.includes('.') ? value.split('.')[0] : value;
+            if (decimals > 0) {
+                const PADDING = decimals - valueDecimal.length;
+                valueDecimal = value.includes('.') ? value.split('.')[1] : '';
+                for (let i = 0; i < PADDING; i++)
+                    valueDecimal += '0';
+                valueDecimal = valueDecimal.substring(0, decimals);
+                valueDecimal = `.${valueDecimal}`;
+            }
+        }
+        else {
+            valueInteger = value;
+        }
+        let counter = 0;
+        const VALUE_INTEGER_ARRAY = [];
+        for (const char of valueInteger.split('').reverse()) {
+            if (counter == 3) {
+                VALUE_INTEGER_ARRAY.push(',');
+                counter = 0;
+            }
+            VALUE_INTEGER_ARRAY.push(char);
+            ++counter;
+        }
+        valueInteger = VALUE_INTEGER_ARRAY.reverse().join('');
+        return `${valueInteger}${valueDecimal}`;
+    },
+    /** Wait the time indicated */
+    Sleep: (milliseconds = 0, reference = null) => {
+        if (Tools.IsNull(reference)) {
+            return new Promise(Resolve => setTimeout(Resolve, milliseconds));
+        }
+        else
+            return new Promise(Resolve => {
+                reference = reference.replaceAll(' ', '_').toLowerCase();
+                if (reference_signal().hasOwnProperty(reference)) {
+                    clearInterval(reference_signal()[reference]);
+                }
+                reference_signal.set(Object.assign(reference_signal(), {
+                    [reference]: setTimeout(() => {
+                        Resolve();
+                        clearInterval(reference_signal()[reference]);
+                        const _reference = { ...reference_signal() };
+                        delete _reference[reference];
+                        reference_signal.set({ ..._reference });
+                    }, milliseconds)
+                }));
+            });
+    }
+};
+
+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 [];
+    }
+    /** */
+    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);
+        }
+    }
+}
+
 const CONTROL_VALUE = (component) => {
     return {
         provide: NG_VALUE_ACCESSOR,
@@ -349,9 +612,392 @@ class ControlValue {
     setDisabledState(isDisabled) { }
 }
 
+class DateTime {
+    /** Get UTC Offset */
+    static GetOffset() {
+        return moment().utcOffset();
+    }
+    /** Convert UTC Date to Local Zone */
+    static ToLocalZone(utcDate) {
+        return moment(utcDate).add(DateTime.GetOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    }
+    /** Convert Local Zone Date to UTC */
+    static ToUTC(utcDate) {
+        return moment(utcDate).subtract(DateTime.GetOffset(), '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');
+    }
+}
+
+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, sheetName);
+        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('');
+        });
+    }
+}
+
+class Source {
+    static { this.storage = 'COER-System'; }
+    /** */
+    static Set(page) {
+        const ROUTER = inject(Router);
+        let path = ROUTER.url;
+        if (path.includes('?'))
+            path = path.split('?')[0];
+        Breadcrumbs.Add(page, path);
+        const breadcrumbs = Breadcrumbs.Get();
+        if (breadcrumbs.length >= 2) {
+            breadcrumbs.pop();
+            const breadcrumb = breadcrumbs.pop();
+            this.Save({ page: breadcrumb.page, path: breadcrumb.path });
+        }
+        else
+            this.Save(null);
+    }
+    /** */
+    static Save(source) {
+        let storage = sessionStorage.getItem(this.storage);
+        if (storage)
+            storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { source });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+    /** */
+    static Get() {
+        let storage = sessionStorage.getItem(this.storage);
+        if (storage) {
+            storage = JSON.parse(storage);
+            if (storage.hasOwnProperty('source')) {
+                return storage.source;
+            }
+        }
+        return null;
+    }
+    /** */
+    static GetRoot() {
+        const breadcrumbs = Breadcrumbs.Get();
+        return (breadcrumbs.length > 0) ? breadcrumbs.shift() : null;
+    }
+    /** */
+    static SetPageResponse(pageResponse) {
+        let storage = sessionStorage.getItem(this.storage);
+        storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { pageResponse });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+    /** */
+    static GetPageResponse() {
+        let storage = sessionStorage.getItem(this.storage);
+        if (storage) {
+            storage = JSON.parse(storage);
+            if (storage.hasOwnProperty('pageResponse')) {
+                return Tools.BreakReference(storage.pageResponse);
+            }
+        }
+        return null;
+    }
+    /** */
+    static ClearPageResponse() {
+        let storage = sessionStorage.getItem(this.storage);
+        storage = JSON.parse(storage);
+        if (storage.hasOwnProperty('pageResponse')) {
+            delete storage.pageResponse;
+        }
+        storage = Object.assign({}, storage);
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+    /** */
+    static Reset() {
+        sessionStorage.removeItem(this.storage);
+    }
+}
+
+class Page {
+    constructor(page) {
+        //Injection
+        this.alert = inject(CoerAlert);
+        this.router = inject(Router);
+        this.activatedRoute = inject(ActivatedRoute);
+        /** */
+        this.isUpdate = false;
+        /** */
+        this.isLoading = false;
+        /** */
+        this.isReadyPage = false;
+        /** */
+        this.enableAnimations = false;
+        /** */
+        this.breadcrumbs = [];
+        /** */
+        this.pageResponse = null;
+        /** */
+        this.goBack = { show: false };
+        //Private Variables
+        this._page = '';
+        this._source = null;
+        this._preventDestroy = false;
+        /** */
+        this.GoBack = (path) => (() => {
+            if (path)
+                Breadcrumbs.Remove(path);
+            else
+                Breadcrumbs.RemoveLast();
+        });
+        this.SetPageName(page);
+        this.SetSource();
+        this.GetSource();
+        this.GetNavigation();
+        this.SetGoBack();
+        this.GetPageResponse();
+    }
+    ngAfterViewInit() {
+        this.routeParams = this.activatedRoute.snapshot.params;
+        this.queryParams = this.activatedRoute.snapshot.queryParams;
+        setTimeout(() => {
+            this.isReadyPage = true;
+            this.RunPage();
+            setTimeout(() => { this.enableAnimations = true; }, 1000);
+        });
+    }
+    ngOnDestroy() {
+        if (!this._preventDestroy)
+            Source.ClearPageResponse();
+    }
+    /** Main method. Starts after ngAfterViewInit() */
+    RunPage() { }
+    ;
+    /** Rename the last breadcrumb and update the url id */
+    SetPageName(name, id = null) {
+        this._page = name;
+        let path = this.router.url;
+        if (path.includes('?'))
+            path = path.split('?')[0];
+        if (id) {
+            const PATH_ARRAY = path.split('/');
+            const PATH_ID = Tools.BreakReference(PATH_ARRAY).pop();
+            if (PATH_ID) {
+                PATH_ARRAY[PATH_ARRAY.length - 1] = String(id);
+                path = PATH_ARRAY.join('/');
+            }
+        }
+        if (this.breadcrumbs.length > 0) {
+            this.breadcrumbs[this.breadcrumbs.length - 1].page = name;
+            this.breadcrumbs[this.breadcrumbs.length - 1].path = path;
+            Breadcrumbs.SetLast(name, path);
+        }
+        this.router.navigateByUrl(path);
+    }
+    /** */
+    SetSource() {
+        Source.Set(this._page);
+    }
+    /** */
+    GetSource() {
+        this._source = Source.Get();
+    }
+    /** */
+    GetPageResponse() {
+        this.pageResponse = Source.GetPageResponse();
+    }
+    /** */
+    GetNavigation() {
+        if (this._source) {
+            this.breadcrumbs = Breadcrumbs.Get().map(item => Object.assign({
+                page: item.page,
+                path: item.path,
+                click: this.GoBack(item.path)
+            }));
+        }
+        else
+            this.breadcrumbs = [{ page: this._page }];
+    }
+    /** */
+    SetGoBack() {
+        if (this._source) {
+            this.goBack = {
+                show: true,
+                path: this._source.path,
+                click: this.GoBack()
+            };
+        }
+    }
+    /** Navigate to previous page */
+    GoToSource(pageResponse = null) {
+        if (this._source) {
+            Breadcrumbs.RemoveLast();
+            this.SetPageResponse(pageResponse);
+            Tools.Sleep().then(_ => this.router.navigateByUrl(this._source.path));
+        }
+    }
+    ;
+    /** */
+    SetPageResponse(pageResponse = null) {
+        if (Tools.IsNotNull(pageResponse)) {
+            this._preventDestroy = true;
+            Source.SetPageResponse(pageResponse);
+        }
+    }
+    ;
+    /** */
+    ReloadPage() {
+        Breadcrumbs.RemoveLast();
+        setTimeout(() => window.location.reload());
+    }
+    /** */
+    Log(value, log = null) {
+        if (Tools.IsNotNull(log))
+            console.log({ log, value });
+        else
+            console.log(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Page, deps: [{ token: String }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: Page, selector: "ng-component", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: Page, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [String]
+                }] }] });
+
+class Screen {
+    static get WINDOW_WIDTH() {
+        return window.innerWidth;
+    }
+    static get WINDOW_HEIGHT() {
+        return window.innerHeight;
+    }
+    static get DEVICE_WIDTH() {
+        return window.screen.width;
+    }
+    static get DEVICE_HEIGHT() {
+        return window.screen.height;
+    }
+    static get BREAKPOINT() {
+        if (window.innerWidth < 576)
+            return 'xs';
+        else if (window.innerWidth >= 576 && window.innerWidth < 768)
+            return 'sm';
+        else if (window.innerWidth >= 768 && window.innerWidth < 992)
+            return 'md';
+        else if (window.innerWidth >= 992 && window.innerWidth < 1200)
+            return 'lg';
+        else if (window.innerWidth >= 1200 && window.innerWidth < 1400)
+            return 'xl';
+        else
+            return 'xxl';
+    }
+    /** */
+    static { this.Resize = new Observable(subscriber => {
+        window.addEventListener("load", () => {
+            window.dispatchEvent(new Event('resize'));
+        });
+        window.onresize = () => {
+            subscriber.next({
+                width: this.WINDOW_WIDTH,
+                height: this.WINDOW_HEIGHT,
+                breakpoin: this.BREAKPOINT
+            });
+        };
+    }); }
+}
+
+const breakpointSIGNAL = signal(Screen?.BREAKPOINT || 'xs');
+
+const isLoadingSIG = signal(false);
+
+const isModalOpenSIG = signal(false);
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { CONTROL_VALUE, CoerAlert, ComponentsModule, ControlValue };
+export { Breadcrumbs, CONTROL_VALUE, CoerAlert, ComponentsModule, ControlValue, DateTime, Files, Page, Screen, Source, Tools, breakpointSIGNAL, isLoadingSIG, isModalOpenSIG };
 //# sourceMappingURL=coer-elements.mjs.map