coer-elements 1.0.6 → 1.0.8

package/Tools/Breadcrumbs.class.ts

@@ -0,0 +1,84 @@
+import { IAppSource } from "../interfaces";
+import { Tools } from './Tools';
+
+export class Breadcrumbs {
+
+    private static readonly storage = 'COER-System';
+
+    /** */
+    public static Add(page: string, path: string): void {
+        const breadcrumbs = this.Get();
+        const paths = breadcrumbs.map(item => item.path);
+
+        if (!paths.includes(path)) {
+            breadcrumbs.push({ page, path });
+            this.Save(breadcrumbs);
+        }
+    }
+
+
+    /** */
+    public static Get(): IAppSource[] {
+        let storage = sessionStorage.getItem(this.storage) as any;
+
+        if (storage) {
+            storage = JSON.parse(storage);
+
+            if (storage.hasOwnProperty('breadcrumbs')) {
+                return Tools.BreakReference(storage.breadcrumbs);
+            }
+        }
+
+        return [];
+    }
+
+
+    /** Source */
+    public static GetFirst(): IAppSource | null {
+        const breadcrumbs = this.Get();
+        return (breadcrumbs.length > 0) ? breadcrumbs.shift()! : null;
+    }
+
+
+    /** */
+    public static Save(breadcrumbs: IAppSource[]): void {
+        let storage = sessionStorage.getItem(this.storage) as any;
+        if (storage) storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { breadcrumbs });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+
+
+    /** */
+    public static Remove(path: string): void {
+        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);
+        }
+    }
+
+
+    /** */
+    public static SetLast(page: string, path: string): void {
+        const breadcrumbs = this.Get();
+
+        if (breadcrumbs.length > 0) {
+            breadcrumbs[breadcrumbs.length - 1] = { page, path };
+            this.Save(breadcrumbs);
+        }
+    }
+
+
+    /** */
+    public static RemoveLast(): void {
+        const breadcrumbs = this.Get();
+
+        if (breadcrumbs.length > 0) {
+            breadcrumbs.pop();
+            this.Save(breadcrumbs);
+        }
+    }
+}

package/Tools/ControlValue.ts

@@ -0,0 +1,63 @@
+import { ControlValueAccessor, NG_VALUE_ACCESSOR } from "@angular/forms";
+import { forwardRef } from "@angular/core";
+
+export const CONTROL_VALUE = <T>(component: T) => {
+    return {
+        provide: NG_VALUE_ACCESSOR,
+        useExisting: forwardRef(() => component),
+        multi: true
+    }
+}
+
+
+export class ControlValue implements ControlValueAccessor {
+
+    //Variables
+    protected _value: any;
+    private _isTouched: boolean = false;
+    protected _UpdateValue!: Function;
+    private _IsTouched!: Function;
+
+
+    public get isTouched() {
+        return this._isTouched;
+    }
+
+
+    /** */
+    protected SetValue(value: any): void {
+        if(typeof this._UpdateValue === 'function') {
+            this._UpdateValue(value);
+        }
+
+        this._value = value;
+    }
+
+
+    /** */
+    public SetTouched(isTouched: boolean): void {
+        if(typeof this._IsTouched === 'function') {
+            this._IsTouched(isTouched);
+        }
+
+        this._isTouched = isTouched;
+    }
+
+
+    /** */
+    public writeValue(value: any): void {
+        this._value = value;
+    }
+
+
+    /** */
+    public registerOnChange(callback: Function): void {
+        this._UpdateValue = callback;
+    }
+
+
+    /** */
+    public registerOnTouched(callback: Function): void {
+        this._IsTouched = callback;
+    }
+}

package/Tools/Files.class.ts

@@ -1,4 +1,4 @@
-import { Tools } from ".";
+import { Tools } from "./Tools";
 import * as XLSX from 'xlsx';
 
 export class Files { 

package/Tools/Page.class.ts

@@ -0,0 +1,187 @@
+import { AfterViewInit, Component, Inject, inject, OnDestroy } from '@angular/core';
+import { Breadcrumbs } from "./Breadcrumbs.class";
+import { Source } from './Source.class';
+//import { CoerAlert } from 'src/app/shared/components/coer-alert/coer-alert.component';
+import { IAppSource, IBreadcrumb, IGoBack } from '../interfaces';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Tools } from './Tools';
+
+@Component({ template: '' })
+export class Page implements AfterViewInit, OnDestroy {
+
+    //Injection
+    //protected readonly alert = inject(CoerAlert);
+    protected readonly router = inject(Router);
+    private readonly activatedRoute = inject(ActivatedRoute);
+
+    /** */
+    protected isUpdate: boolean = false;
+
+    /** */
+    protected isLoading: boolean = false;
+
+    /** */
+    protected isReady: boolean = false;
+
+    /** */
+    protected isReadyAnimations: boolean = false;
+
+    /** */
+    protected routeParams: any;
+
+    /** */
+    protected queryParams: any;
+
+    /** */
+    protected breadcrumbs: IBreadcrumb[] = [];
+
+    /** */
+    protected pageResponse: any = null;
+
+    /** */
+    protected goBack: IGoBack = { show: false };
+
+    //Private Variables
+    private _page: string = '';
+    private _source: IAppSource | null = null;
+    private _preventDestroy: boolean = false;
+
+
+    constructor(@Inject(String) page: string) {
+        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.isReady = true;
+            this.RunPage();
+            setTimeout(() => { this.isReadyAnimations = true }, 1000);
+        });
+
+    }
+
+    ngOnDestroy() {
+        if (!this._preventDestroy) Source.ClearPageResponse();
+    }
+
+    /** 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 = null): void {
+        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)
+    }
+
+
+    /** */
+    private SetSource(): void {
+        Source.Set(this._page);
+    }
+
+
+    /** */
+    private GetSource(): void {
+        this._source = Source.Get();
+    }
+
+
+    /** */
+    protected GetPageResponse(): void {
+        this.pageResponse = Source.GetPageResponse();
+    }
+
+
+    /** */
+    private GetNavigation(): void {
+        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 }];
+    }
+
+
+    /** */
+    private SetGoBack(): void {
+        if (this._source) {
+            this.goBack = {
+                show: true,
+                path: this._source.path,
+                click: this.GoBack()
+            };
+        }
+    }
+
+
+    /** */
+    private GoBack = (path?: string) => (() => {
+        if (path) Breadcrumbs.Remove(path);
+        else Breadcrumbs.RemoveLast();
+    });
+
+
+    /** Navigate to previous page */
+    protected GoToSource<T>(pageResponse: T | null = null): void {
+        if(this._source) {
+            Breadcrumbs.RemoveLast();
+            this.SetPageResponse(pageResponse);
+            Tools.Sleep().then(_ => this.router.navigateByUrl(this._source!.path));
+        }
+    };
+
+
+    /** */
+    protected SetPageResponse<T>(pageResponse: T | null = null): void {
+        if (Tools.IsNotNull(pageResponse)) {
+            this._preventDestroy = true;
+            Source.SetPageResponse(pageResponse);
+        }
+    };
+
+
+    /** */
+    protected ReloadPage(): void {
+        Breadcrumbs.RemoveLast();
+        Tools.Sleep().then(_ => window.location.reload());
+    }
+
+
+    /** */
+    protected Log(value: any, log: string | null = null): void {
+        if (Tools.IsNotNull(log)) console.log({ log, value });
+        else console.log(value);
+    }
+}

package/Tools/Screen.class.ts

@@ -1,4 +1,4 @@
-import { IScreenSize } from "interfaces";
+import { IScreenSize } from "../interfaces";
 import { Observable } from "rxjs"; 
 
 export class Screen {

package/Tools/Source.class.ts

@@ -0,0 +1,107 @@
+import { Breadcrumbs } from "./Breadcrumbs.class";
+import { IAppSource } from '../interfaces';
+import { Router } from '@angular/router';
+import { inject } from "@angular/core";
+import { Tools } from './Tools';
+
+export class Source {
+
+    private static readonly storage = 'COER-System';
+
+    /** */
+    public static Set(page: string): void {
+        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);
+    }
+
+
+    /** */
+    private static Save(source: IAppSource | null): void {
+        let storage = sessionStorage.getItem(this.storage) as any;
+        if (storage) storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { source });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+
+
+    /** */
+    public static Get(): IAppSource | null {
+        let storage = sessionStorage.getItem(this.storage) as any;
+
+        if (storage) {
+            storage = JSON.parse(storage);
+
+            if (storage.hasOwnProperty('source')) {
+                return storage.source;
+            }
+        }
+
+        return null;
+    }
+
+
+    /** */
+    public static GetRoot(): IAppSource | null {
+        const breadcrumbs = Breadcrumbs.Get();
+        return (breadcrumbs.length > 0) ? breadcrumbs.shift()! : null;
+    }
+
+
+    /** */
+    public static SetPageResponse<T>(pageResponse: T): void {
+        let storage = sessionStorage.getItem(this.storage) as any;
+        storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { pageResponse });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+
+
+    /** */
+    public static GetPageResponse<T>(): T | null {
+        let storage = sessionStorage.getItem(this.storage) as any;
+
+        if (storage) {
+            storage = JSON.parse(storage);
+
+            if (storage.hasOwnProperty('pageResponse')) {
+                return Tools.BreakReference(storage.pageResponse);
+            }
+        }
+
+        return null;
+    }
+
+
+    /** */
+    public static ClearPageResponse(): void {
+        let storage = sessionStorage.getItem(this.storage) as any;
+        storage = JSON.parse(storage);
+
+        if (storage.hasOwnProperty('pageResponse')) {
+            delete storage.pageResponse;
+        }
+
+        storage = Object.assign({}, storage);
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    }
+
+
+    /** Clear Source */
+    public static Reset(): void {
+        sessionStorage.removeItem(this.storage);
+    }
+}

package/dist_browser/Tools/Files.class.js

@@ -1,4 +1,4 @@
-import { Tools } from ".";
+import { Tools } from "./Tools";
 import * as XLSX from 'xlsx';
 var Files = /** @class */ (function () {
     function Files() {

package/dist_browser/Tools/Tools.js

@@ -0,0 +1,227 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { Guid } from "guid-typescript";
+import { signal } from "@angular/core";
+var reference_signal = signal({});
+export var Tools = {
+    /** Generate a Guid */
+    GetGuid: function (seed) {
+        if (seed === void 0) { seed = 'coer-system'; }
+        return "".concat(seed, "-").concat(Guid.create().toString());
+    },
+    /** Returns true if the value is null or undefined, false otherwise */
+    IsNull: function (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: function (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: function (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: function (object) {
+        if (object === undefined)
+            return undefined;
+        if (object === null)
+            return null;
+        var OBJECT = JSON.parse(JSON.stringify(object));
+        return (Array.isArray(OBJECT)) ? __spreadArray([], OBJECT, true) : __assign({}, OBJECT);
+    },
+    /** Clean extra whitespaces */
+    CleanUpBlanks: function (text) {
+        if (Tools.IsNull(text))
+            return '';
+        var worlds = String(text).split(' ');
+        worlds = worlds.filter(function (x) { return x.length > 0; });
+        return worlds.join(' ');
+    },
+    /** Get properties of an object */
+    GetObjectProperties: function (obj) {
+        var properties = [];
+        if (Tools.IsNull(obj))
+            return properties;
+        for (var property in obj)
+            properties.push(String(property));
+        return properties;
+    },
+    /**
+     * Set an index and merge more arrays of the same type
+     * @returns A new array
+     * */
+    SetIndex: function (array) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var index = 0;
+        for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
+            var arg = args_1[_a];
+            array = Tools.BreakReference(array).concat(Tools.BreakReference(arg));
+        }
+        return Tools.BreakReference(array).map(function (item) { return Object.assign({ index: index++ }, item); });
+    },
+    /** Set First Char To Lower */
+    FirstCharToLower: function (text) {
+        if (Tools.IsNull(text))
+            return '';
+        var textArray = [];
+        for (var 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: function (text) {
+        if (Tools.IsNull(text))
+            return '';
+        var textArray = [];
+        for (var 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: function (array, property, propertyType) {
+        if (propertyType === void 0) { propertyType = 'string'; }
+        switch (propertyType) {
+            case 'string': {
+                return array.sort(function (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(function (x, y) { return Number(x[property] - Number(y[property])); });
+            }
+        }
+    },
+    /** Sort an array in descending order by property */
+    SortByDesc: function (array, property, propertyType) {
+        if (propertyType === void 0) { propertyType = 'string'; }
+        switch (propertyType) {
+            case 'string': {
+                return array.sort(function (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(function (x, y) { return Number(Number(y[property])) - x[property]; });
+            }
+        }
+    },
+    /** Return a string with forman numeric */
+    GetNumericFormat: function (value, decimals) {
+        if (decimals === void 0) { decimals = 0; }
+        if (value == undefined
+            || value == null
+            || value.toString().trim() == ''
+            || isNaN(Number(value))) {
+            return '0';
+        }
+        var valueInteger = '';
+        var valueDecimal = '';
+        value = value.toString().replaceAll(' ', '');
+        if (value.includes('.') || (decimals > 0)) {
+            valueInteger = value.includes('.') ? value.split('.')[0] : value;
+            if (decimals > 0) {
+                var PADDING = decimals - valueDecimal.length;
+                valueDecimal = value.includes('.') ? value.split('.')[1] : '';
+                for (var i = 0; i < PADDING; i++)
+                    valueDecimal += '0';
+                valueDecimal = valueDecimal.substring(0, decimals);
+                valueDecimal = ".".concat(valueDecimal);
+            }
+        }
+        else {
+            valueInteger = value;
+        }
+        var counter = 0;
+        var VALUE_INTEGER_ARRAY = [];
+        for (var _i = 0, _a = valueInteger.split('').reverse(); _i < _a.length; _i++) {
+            var char = _a[_i];
+            if (counter == 3) {
+                VALUE_INTEGER_ARRAY.push(',');
+                counter = 0;
+            }
+            VALUE_INTEGER_ARRAY.push(char);
+            ++counter;
+        }
+        valueInteger = VALUE_INTEGER_ARRAY.reverse().join('');
+        return "".concat(valueInteger).concat(valueDecimal);
+    },
+    /** Wait the time indicated */
+    Sleep: function (milliseconds, reference) {
+        if (milliseconds === void 0) { milliseconds = 0; }
+        if (reference === void 0) { reference = null; }
+        if (Tools.IsNull(reference)) {
+            return new Promise(function (Resolve) { return setTimeout(Resolve, milliseconds); });
+        }
+        else
+            return new Promise(function (Resolve) {
+                var _a;
+                reference = reference.replaceAll(' ', '_').toLowerCase();
+                if (reference_signal().hasOwnProperty(reference)) {
+                    clearInterval(reference_signal()[reference]);
+                }
+                reference_signal.set(Object.assign(reference_signal(), (_a = {},
+                    _a[reference] = setTimeout(function () {
+                        Resolve();
+                        clearInterval(reference_signal()[reference]);
+                        var _reference = __assign({}, reference_signal());
+                        delete _reference[reference];
+                        reference_signal.set(__assign({}, _reference));
+                    }, milliseconds),
+                    _a)));
+            });
+    }
+};

package/dist_browser/index.js

@@ -1,4 +1,4 @@
-export * from 'Tools';
-export * from 'Tools/DateTime.class';
-export * from 'Tools/Files.class';
-export * from 'Tools/Screen.class';
+export * from './Tools/Tools';
+export * from './Tools/DateTime.class';
+export * from './Tools/Files.class';
+export * from './Tools/Screen.class';

package/dist_node/Tools/DateTime.class.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTime = void 0;
+var moment_1 = require("moment");
+var DateTime = /** @class */ (function () {
+    function DateTime() {
+    }
+    /** Get UTC Offset */
+    DateTime.GetUTCOffset = function () {
+        return (0, moment_1.default)().utcOffset();
+    };
+    /** Convert UTC Date to Local Zone */
+    DateTime.ToLocalZone = function (utcDate) {
+        return (0, moment_1.default)(utcDate).add(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    };
+    /** Convert Local Zone Date to UTC */
+    DateTime.ToUTC = function (utcDate) {
+        return (0, moment_1.default)(utcDate).subtract(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    };
+    /** DD MMM YYYY */
+    DateTime.GetDateFormat = function (date) {
+        if ((typeof date === 'string'))
+            date = date.replaceAll('/', '-');
+        return (0, moment_1.default)(date).parseZone().local(true).format('DD MMM YYYY');
+    };
+    return DateTime;
+}());
+exports.DateTime = DateTime;

package/dist_node/Tools/Files.class.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Files = void 0;
+var Tools_1 = require("./Tools");
+var XLSX = require("xlsx");
+var Files = /** @class */ (function () {
+    function Files() {
+    }
+    /** Get Extension File */
+    Files.GetExtension = function (file) {
+        var fileName = file.name;
+        if (fileName.includes('.')) {
+            var worlds = fileName.split('.');
+            if (worlds.length > 0) {
+                var extension = worlds.pop();
+                extension = extension.trim().toLowerCase();
+                if (extension.length > 0)
+                    return extension;
+            }
+        }
+        return null;
+    };
+    /** Is Excel File */
+    Files.IsExcel = function (file) {
+        var EXTENSION = Files.GetExtension(file);
+        return Tools_1.Tools.IsNotNull(EXTENSION)
+            ? this.EXCEL_EXTENSIONS.includes(EXTENSION)
+            : false;
+    };
+    /** Read excel file */
+    Files.ReadExcel = function (file) {
+        return new Promise(function (Resolve) {
+            var columns = [];
+            var rows = [];
+            var reader = new FileReader();
+            reader.readAsArrayBuffer(file);
+            reader.onload = function () {
+                var dataBytes = new Uint8Array(reader.result);
+                if (dataBytes) {
+                    var workbook = XLSX.read(dataBytes, {});
+                    var sheet = workbook.Sheets[workbook.SheetNames[0]];
+                    var 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 (var column in dataSheet[0]) {
+                        columns.push(Tools_1.Tools.FirstCharToLower(String(dataSheet[0][column]).replaceAll(' ', '')));
+                    }
+                    //Get Rows
+                    rows = XLSX.utils.sheet_to_json(sheet, { header: columns });
+                    rows.shift();
+                    rows = rows.map(function (row) {
+                        var item = Tools_1.Tools.BreakReference(row);
+                        delete item['__rowNum__'];
+                        return item;
+                    });
+                }
+                Resolve({ columns: columns, rows: rows });
+            };
+            reader.onerror = function () { Resolve({ columns: columns, rows: rows }); };
+        });
+    };
+    /** Export to excel file */
+    Files.ExportExcel = function (data, fileName, sheetName) {
+        if (fileName === void 0) { fileName = 'coer_report'; }
+        if (sheetName === void 0) { sheetName = 'Sheet1'; }
+        sheetName = Tools_1.Tools.CleanUpBlanks(sheetName);
+        fileName = Tools_1.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';
+        }
+        var WORK_SHEET = XLSX.utils.json_to_sheet(data);
+        var 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 */
+    Files.ConvertToBase64 = function (file) {
+        return new Promise(function (Resolve) {
+            var reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = function () {
+                var _a;
+                Resolve(((_a = reader.result) === null || _a === void 0 ? void 0 : _a.toString()) || '');
+            };
+            reader.onerror = function () {
+                Resolve('');
+            };
+        });
+    };
+    Files.EXCEL_EXTENSIONS = ['xls', 'xlsx', 'csv'];
+    return Files;
+}());
+exports.Files = Files;

package/dist_node/Tools/Screen.class.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Screen = void 0;
+var rxjs_1 = require("rxjs");
+var Screen = /** @class */ (function () {
+    function Screen() {
+    }
+    Object.defineProperty(Screen, "WINDOW_WIDTH", {
+        get: function () {
+            return window.innerWidth;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Screen, "WINDOW_HEIGHT", {
+        get: function () {
+            return window.innerHeight;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Screen, "DEVICE_WIDTH", {
+        get: function () {
+            return window.screen.width;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Screen, "DEVICE_HEIGHT", {
+        get: function () {
+            return window.screen.height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Screen, "BREAKPOINT", {
+        get: function () {
+            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';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    var _a;
+    _a = Screen;
+    /** */
+    Screen.Resize = new rxjs_1.Observable(function (subscriber) {
+        window.addEventListener("load", function () {
+            window.dispatchEvent(new Event('resize'));
+        });
+        window.onresize = function () {
+            subscriber.next({
+                width: window.innerWidth,
+                height: window.innerHeight,
+                breakpoin: _a.BREAKPOINT
+            });
+        };
+    });
+    return Screen;
+}());
+exports.Screen = Screen;

package/dist_node/Tools/Tools.js

@@ -0,0 +1,230 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tools = void 0;
+var guid_typescript_1 = require("guid-typescript");
+var core_1 = require("@angular/core");
+var reference_signal = (0, core_1.signal)({});
+exports.Tools = {
+    /** Generate a Guid */
+    GetGuid: function (seed) {
+        if (seed === void 0) { seed = 'coer-system'; }
+        return "".concat(seed, "-").concat(guid_typescript_1.Guid.create().toString());
+    },
+    /** Returns true if the value is null or undefined, false otherwise */
+    IsNull: function (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: function (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: function (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: function (object) {
+        if (object === undefined)
+            return undefined;
+        if (object === null)
+            return null;
+        var OBJECT = JSON.parse(JSON.stringify(object));
+        return (Array.isArray(OBJECT)) ? __spreadArray([], OBJECT, true) : __assign({}, OBJECT);
+    },
+    /** Clean extra whitespaces */
+    CleanUpBlanks: function (text) {
+        if (exports.Tools.IsNull(text))
+            return '';
+        var worlds = String(text).split(' ');
+        worlds = worlds.filter(function (x) { return x.length > 0; });
+        return worlds.join(' ');
+    },
+    /** Get properties of an object */
+    GetObjectProperties: function (obj) {
+        var properties = [];
+        if (exports.Tools.IsNull(obj))
+            return properties;
+        for (var property in obj)
+            properties.push(String(property));
+        return properties;
+    },
+    /**
+     * Set an index and merge more arrays of the same type
+     * @returns A new array
+     * */
+    SetIndex: function (array) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var index = 0;
+        for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
+            var arg = args_1[_a];
+            array = exports.Tools.BreakReference(array).concat(exports.Tools.BreakReference(arg));
+        }
+        return exports.Tools.BreakReference(array).map(function (item) { return Object.assign({ index: index++ }, item); });
+    },
+    /** Set First Char To Lower */
+    FirstCharToLower: function (text) {
+        if (exports.Tools.IsNull(text))
+            return '';
+        var textArray = [];
+        for (var 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: function (text) {
+        if (exports.Tools.IsNull(text))
+            return '';
+        var textArray = [];
+        for (var 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: function (array, property, propertyType) {
+        if (propertyType === void 0) { propertyType = 'string'; }
+        switch (propertyType) {
+            case 'string': {
+                return array.sort(function (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(function (x, y) { return Number(x[property] - Number(y[property])); });
+            }
+        }
+    },
+    /** Sort an array in descending order by property */
+    SortByDesc: function (array, property, propertyType) {
+        if (propertyType === void 0) { propertyType = 'string'; }
+        switch (propertyType) {
+            case 'string': {
+                return array.sort(function (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(function (x, y) { return Number(Number(y[property])) - x[property]; });
+            }
+        }
+    },
+    /** Return a string with forman numeric */
+    GetNumericFormat: function (value, decimals) {
+        if (decimals === void 0) { decimals = 0; }
+        if (value == undefined
+            || value == null
+            || value.toString().trim() == ''
+            || isNaN(Number(value))) {
+            return '0';
+        }
+        var valueInteger = '';
+        var valueDecimal = '';
+        value = value.toString().replaceAll(' ', '');
+        if (value.includes('.') || (decimals > 0)) {
+            valueInteger = value.includes('.') ? value.split('.')[0] : value;
+            if (decimals > 0) {
+                var PADDING = decimals - valueDecimal.length;
+                valueDecimal = value.includes('.') ? value.split('.')[1] : '';
+                for (var i = 0; i < PADDING; i++)
+                    valueDecimal += '0';
+                valueDecimal = valueDecimal.substring(0, decimals);
+                valueDecimal = ".".concat(valueDecimal);
+            }
+        }
+        else {
+            valueInteger = value;
+        }
+        var counter = 0;
+        var VALUE_INTEGER_ARRAY = [];
+        for (var _i = 0, _a = valueInteger.split('').reverse(); _i < _a.length; _i++) {
+            var char = _a[_i];
+            if (counter == 3) {
+                VALUE_INTEGER_ARRAY.push(',');
+                counter = 0;
+            }
+            VALUE_INTEGER_ARRAY.push(char);
+            ++counter;
+        }
+        valueInteger = VALUE_INTEGER_ARRAY.reverse().join('');
+        return "".concat(valueInteger).concat(valueDecimal);
+    },
+    /** Wait the time indicated */
+    Sleep: function (milliseconds, reference) {
+        if (milliseconds === void 0) { milliseconds = 0; }
+        if (reference === void 0) { reference = null; }
+        if (exports.Tools.IsNull(reference)) {
+            return new Promise(function (Resolve) { return setTimeout(Resolve, milliseconds); });
+        }
+        else
+            return new Promise(function (Resolve) {
+                var _a;
+                reference = reference.replaceAll(' ', '_').toLowerCase();
+                if (reference_signal().hasOwnProperty(reference)) {
+                    clearInterval(reference_signal()[reference]);
+                }
+                reference_signal.set(Object.assign(reference_signal(), (_a = {},
+                    _a[reference] = setTimeout(function () {
+                        Resolve();
+                        clearInterval(reference_signal()[reference]);
+                        var _reference = __assign({}, reference_signal());
+                        delete _reference[reference];
+                        reference_signal.set(__assign({}, _reference));
+                    }, milliseconds),
+                    _a)));
+            });
+    }
+};

package/dist_node/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("Tools"), exports);
-__exportStar(require("Tools/DateTime.class"), exports);
-__exportStar(require("Tools/Files.class"), exports);
-__exportStar(require("Tools/Screen.class"), exports);
+__exportStar(require("./Tools/Tools"), exports);
+__exportStar(require("./Tools/DateTime.class"), exports);
+__exportStar(require("./Tools/Files.class"), exports);
+__exportStar(require("./Tools/Screen.class"), exports);

package/dist_node/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/index.ts

@@ -1,4 +1,7 @@
-export * from './Tools'
+export * from './Tools/Breadcrumbs.class';
+export * from './Tools/ControlValue';
 export * from './Tools/DateTime.class';
 export * from './Tools/Files.class';
-export * from './Tools/Screen.class';
+export * from './Tools/Screen.class';
+export * from './Tools/Source.class';
+export * from './Tools/Tools'

package/interfaces/index.ts

@@ -8,4 +8,23 @@ export interface IScreenSize {
     width: number;
     height: number;
     breakpoin: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+}
+
+export interface IAppSource {
+    page: string;
+    path: string;
+}
+
+export interface IBreadcrumb {
+    page: string;
+    path?: string | null;
+    queryParams?: any;
+    click?: (() => any);
+}
+
+export interface IGoBack {
+    show: boolean;
+    path?: string | null;
+    queryParams?: any;
+    click?: (() => any);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coer-elements",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "author": "Christian Omar Escamilla Rodríguez",
   "keywords": [
     "coer",
@@ -23,9 +23,14 @@
   },
   "dependencies": {
     "@angular/core": "^17.3.0",
+    "@angular/forms": "^17.3.0",
+    "@angular/router": "^17.3.0",
     "guid-typescript": "^1.0.9",
     "moment": "^2.30.1",
     "rxjs": "^7.8.1",
     "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4"
   }
 }

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
+  "compileOnSave": false,
   "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */  
     "outDir": "./dist/out-tsc",
     "strict": true,
     "noImplicitOverride": true,
@@ -19,5 +19,11 @@
     "useDefineForClassFields": false,
     "lib": ["ES2022", "dom"],
     "baseUrl": "./"
+  },
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
   }
 }