coer-elements 1.0.16 → 1.0.18

package/components/index.ts

@@ -1,7 +1,6 @@
 import { NgModule } from '@angular/core';
-import { CommonModule } from '@angular/common';
 import { RouterModule } from '@angular/router';
-import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
 //import { DirectivesModule } from 'src/app/shared/directives/directives.module';
 //import { PipesModule } from 'src/app/shared/pipes/pipes.module';
 
@@ -15,6 +14,7 @@ import { FormsModule, ReactiveFormsModule } from '@angular/forms';
 
 //Components
 import { CoerAlert } from './coer-alert/coer-alert.component';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
 //import { CoerButton } from './coer-button/coer-button.component';
 //import { CoerCheckbox } from './coer-checkbox/coer-checkbox.component';
 //import { CoerFilebox } from './coer-filebox/coer-filebox.component';

package/dist_browser/Tools/Breadcrumbs.class.js

@@ -0,0 +1,66 @@
+import { Tools } from './Tools';
+var Breadcrumbs = /** @class */ (function () {
+    function Breadcrumbs() {
+    }
+    /** */
+    Breadcrumbs.Add = function (page, path) {
+        var breadcrumbs = this.Get();
+        var paths = breadcrumbs.map(function (item) { return item.path; });
+        if (!paths.includes(path)) {
+            breadcrumbs.push({ page: page, path: path });
+            this.Save(breadcrumbs);
+        }
+    };
+    /** */
+    Breadcrumbs.Get = function () {
+        var storage = sessionStorage.getItem(this.storage);
+        if (storage) {
+            storage = JSON.parse(storage);
+            if (storage.hasOwnProperty('breadcrumbs')) {
+                return Tools.BreakReference(storage.breadcrumbs);
+            }
+        }
+        return [];
+    };
+    /** Source */
+    Breadcrumbs.GetFirst = function () {
+        var breadcrumbs = this.Get();
+        return (breadcrumbs.length > 0) ? breadcrumbs.shift() : null;
+    };
+    /** */
+    Breadcrumbs.Save = function (breadcrumbs) {
+        var storage = sessionStorage.getItem(this.storage);
+        if (storage)
+            storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { breadcrumbs: breadcrumbs });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    };
+    /** */
+    Breadcrumbs.Remove = function (path) {
+        var breadcrumbs = this.Get();
+        var index = breadcrumbs.findIndex(function (x) { return x.path.toLowerCase().trim() === path.toLowerCase().trim(); });
+        if (index >= 0) {
+            breadcrumbs = Tools.BreakReference(breadcrumbs).splice(0, index + 1);
+            this.Save(breadcrumbs);
+        }
+    };
+    /** */
+    Breadcrumbs.SetLast = function (page, path) {
+        var breadcrumbs = this.Get();
+        if (breadcrumbs.length > 0) {
+            breadcrumbs[breadcrumbs.length - 1] = { page: page, path: path };
+            this.Save(breadcrumbs);
+        }
+    };
+    /** */
+    Breadcrumbs.RemoveLast = function () {
+        var breadcrumbs = this.Get();
+        if (breadcrumbs.length > 0) {
+            breadcrumbs.pop();
+            this.Save(breadcrumbs);
+        }
+    };
+    Breadcrumbs.storage = 'COER-System';
+    return Breadcrumbs;
+}());
+export { Breadcrumbs };

package/dist_browser/Tools/ControlValue.js

@@ -0,0 +1,49 @@
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { forwardRef } from "@angular/core";
+export var CONTROL_VALUE = function (component) {
+    return {
+        provide: NG_VALUE_ACCESSOR,
+        useExisting: forwardRef(function () { return component; }),
+        multi: true
+    };
+};
+var ControlValue = /** @class */ (function () {
+    function ControlValue() {
+        this._isTouched = false;
+    }
+    Object.defineProperty(ControlValue.prototype, "isTouched", {
+        get: function () {
+            return this._isTouched;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** */
+    ControlValue.prototype.SetValue = function (value) {
+        if (typeof this._UpdateValue === 'function') {
+            this._UpdateValue(value);
+        }
+        this._value = value;
+    };
+    /** */
+    ControlValue.prototype.SetTouched = function (isTouched) {
+        if (typeof this._IsTouched === 'function') {
+            this._IsTouched(isTouched);
+        }
+        this._isTouched = isTouched;
+    };
+    /** */
+    ControlValue.prototype.writeValue = function (value) {
+        this._value = value;
+    };
+    /** */
+    ControlValue.prototype.registerOnChange = function (callback) {
+        this._UpdateValue = callback;
+    };
+    /** */
+    ControlValue.prototype.registerOnTouched = function (callback) {
+        this._IsTouched = callback;
+    };
+    return ControlValue;
+}());
+export { ControlValue };

package/dist_browser/Tools/DateTime.class.js

@@ -0,0 +1,25 @@
+import moment from "moment";
+var DateTime = /** @class */ (function () {
+    function DateTime() {
+    }
+    /** Get UTC Offset */
+    DateTime.GetUTCOffset = function () {
+        return moment().utcOffset();
+    };
+    /** Convert UTC Date to Local Zone */
+    DateTime.ToLocalZone = function (utcDate) {
+        return moment(utcDate).add(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    };
+    /** Convert Local Zone Date to UTC */
+    DateTime.ToUTC = function (utcDate) {
+        return moment(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 moment(date).parseZone().local(true).format('DD MMM YYYY');
+    };
+    return DateTime;
+}());
+export { DateTime };

package/dist_browser/Tools/Files.class.js

@@ -0,0 +1,99 @@
+import { Tools } from "./Tools";
+import * as XLSX from '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.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.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.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.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';
+        }
+        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;
+}());
+export { Files };

package/dist_browser/Tools/Page.class.js

@@ -0,0 +1,213 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+import { Component, inject } from '@angular/core';
+import { Breadcrumbs } from "./Breadcrumbs.class";
+import { Source } from './Source.class';
+import { CoerAlert } from '../components/coer-alert/coer-alert.component';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Tools } from './Tools';
+var Page = function () {
+    var _classDecorators = [Component({ template: '' })];
+    var _classDescriptor;
+    var _classExtraInitializers = [];
+    var _classThis;
+    var Page = _classThis = /** @class */ (function () {
+        function Page_1(page) {
+            //Injection
+            this.alert = inject(CoerAlert);
+            this.router = inject(Router);
+            this.activatedRoute = inject(ActivatedRoute);
+            /** */
+            this.isUpdate = false;
+            /** */
+            this.isLoading = false;
+            /** */
+            this.isReady = 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 = function (path) { return (function () {
+                if (path)
+                    Breadcrumbs.Remove(path);
+                else
+                    Breadcrumbs.RemoveLast();
+            }); };
+            /** Returns true if the value is null or undefined, false otherwise */
+            this.IsNotNull = Tools.IsNotNull;
+            /** Returns true if the value is null or undefined, false otherwise */
+            this.IsNull = Tools.IsNull;
+            /** Returns true if the value is null or undefined or contains only whitespace, false otherwise */
+            this.IsOnlyWhiteSpace = Tools.IsOnlyWhiteSpace;
+            this.SetPageName(page);
+            this.SetSource();
+            this.GetSource();
+            this.GetNavigation();
+            this.SetGoBack();
+            this.GetPageResponse();
+        }
+        Page_1.prototype.ngAfterViewInit = function () {
+            var _this = this;
+            this.routeParams = this.activatedRoute.snapshot.params;
+            this.queryParams = this.activatedRoute.snapshot.queryParams;
+            setTimeout(function () {
+                _this.isReady = true;
+                _this.RunPage();
+                setTimeout(function () { _this.enableAnimations = true; }, 1000);
+            });
+        };
+        Page_1.prototype.ngOnDestroy = function () {
+            if (!this._preventDestroy)
+                Source.ClearPageResponse();
+        };
+        /** Main method. Starts after ngAfterViewInit() */
+        Page_1.prototype.RunPage = function () { };
+        ;
+        /** Rename the last breadcrumb and update the url id */
+        Page_1.prototype.SetPageName = function (name, id) {
+            if (id === void 0) { id = null; }
+            this._page = name;
+            var path = this.router.url;
+            if (path.includes('?'))
+                path = path.split('?')[0];
+            if (id) {
+                var PATH_ARRAY = path.split('/');
+                var 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);
+        };
+        /** */
+        Page_1.prototype.SetSource = function () {
+            Source.Set(this._page);
+        };
+        /** */
+        Page_1.prototype.GetSource = function () {
+            this._source = Source.Get();
+        };
+        /** */
+        Page_1.prototype.GetPageResponse = function () {
+            this.pageResponse = Source.GetPageResponse();
+        };
+        /** */
+        Page_1.prototype.GetNavigation = function () {
+            var _this = this;
+            if (this._source) {
+                this.breadcrumbs = Breadcrumbs.Get().map(function (item) { return Object.assign({
+                    page: item.page,
+                    path: item.path,
+                    click: _this.GoBack(item.path)
+                }); });
+            }
+            else
+                this.breadcrumbs = [{ page: this._page }];
+        };
+        /** */
+        Page_1.prototype.SetGoBack = function () {
+            if (this._source) {
+                this.goBack = {
+                    show: true,
+                    path: this._source.path,
+                    click: this.GoBack()
+                };
+            }
+        };
+        /** Navigate to previous page */
+        Page_1.prototype.GoToSource = function (pageResponse) {
+            var _this = this;
+            if (pageResponse === void 0) { pageResponse = null; }
+            if (this._source) {
+                Breadcrumbs.RemoveLast();
+                this.SetPageResponse(pageResponse);
+                Tools.Sleep().then(function (_) { return _this.router.navigateByUrl(_this._source.path); });
+            }
+        };
+        ;
+        /** */
+        Page_1.prototype.SetPageResponse = function (pageResponse) {
+            if (pageResponse === void 0) { pageResponse = null; }
+            if (Tools.IsNotNull(pageResponse)) {
+                this._preventDestroy = true;
+                Source.SetPageResponse(pageResponse);
+            }
+        };
+        ;
+        /** */
+        Page_1.prototype.ReloadPage = function () {
+            Breadcrumbs.RemoveLast();
+            Tools.Sleep().then(function (_) { return window.location.reload(); });
+        };
+        /** */
+        Page_1.prototype.Log = function (value, log) {
+            if (log === void 0) { log = null; }
+            if (Tools.IsNotNull(log))
+                console.log({ log: log, value: value });
+            else
+                console.log(value);
+        };
+        return Page_1;
+    }());
+    __setFunctionName(_classThis, "Page");
+    (function () {
+        var _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        Page = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return Page = _classThis;
+}();
+export { Page };

package/dist_browser/Tools/Screen.class.js

@@ -0,0 +1,68 @@
+import { Observable } from "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 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;
+}());
+export { Screen };

package/dist_browser/Tools/Source.class.js

@@ -0,0 +1,83 @@
+import { Breadcrumbs } from "./Breadcrumbs.class";
+import { Router } from '@angular/router';
+import { inject } from "@angular/core";
+import { Tools } from './Tools';
+var Source = /** @class */ (function () {
+    function Source() {
+    }
+    /** */
+    Source.Set = function (page) {
+        var ROUTER = inject(Router);
+        var path = ROUTER.url;
+        if (path.includes('?'))
+            path = path.split('?')[0];
+        Breadcrumbs.Add(page, path);
+        var breadcrumbs = Breadcrumbs.Get();
+        if (breadcrumbs.length >= 2) {
+            breadcrumbs.pop();
+            var breadcrumb = breadcrumbs.pop();
+            this.Save({ page: breadcrumb.page, path: breadcrumb.path });
+        }
+        else
+            this.Save(null);
+    };
+    /** */
+    Source.Save = function (source) {
+        var storage = sessionStorage.getItem(this.storage);
+        if (storage)
+            storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { source: source });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    };
+    /** */
+    Source.Get = function () {
+        var storage = sessionStorage.getItem(this.storage);
+        if (storage) {
+            storage = JSON.parse(storage);
+            if (storage.hasOwnProperty('source')) {
+                return storage.source;
+            }
+        }
+        return null;
+    };
+    /** */
+    Source.GetRoot = function () {
+        var breadcrumbs = Breadcrumbs.Get();
+        return (breadcrumbs.length > 0) ? breadcrumbs.shift() : null;
+    };
+    /** */
+    Source.SetPageResponse = function (pageResponse) {
+        var storage = sessionStorage.getItem(this.storage);
+        storage = JSON.parse(storage);
+        storage = Object.assign({}, storage, { pageResponse: pageResponse });
+        sessionStorage.setItem(this.storage, JSON.stringify(storage));
+    };
+    /** */
+    Source.GetPageResponse = function () {
+        var storage = sessionStorage.getItem(this.storage);
+        if (storage) {
+            storage = JSON.parse(storage);
+            if (storage.hasOwnProperty('pageResponse')) {
+                return Tools.BreakReference(storage.pageResponse);
+            }
+        }
+        return null;
+    };
+    /** */
+    Source.ClearPageResponse = function () {
+        var 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));
+    };
+    /** Clear Source */
+    Source.Reset = function () {
+        sessionStorage.removeItem(this.storage);
+    };
+    Source.storage = 'COER-System';
+    return Source;
+}());
+export { Source };