coer-elements 1.0.1 → 1.0.3

package/Signals/index.ts

@@ -0,0 +1,7 @@
+import { signal } from "@angular/core"; 
+import { Screen } from './../Tools/Screen.class';
+
+export const breakpoint_signal = signal<'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl'>(Screen?.BREAKPOINT || 'xs');
+export const isReady_signal = signal<boolean>(false);
+export const isLoading_signal = signal<boolean>(false);
+export const isModalOpen_signal = signal<boolean>(false);

package/Tools/DateTime.class.ts

@@ -0,0 +1,27 @@
+import moment from "moment";
+
+export class DateTime {
+    /** Get UTC Offset */
+    public static GetUTCOffset(): number {
+        return moment().utcOffset();
+    }
+
+
+    /** Convert UTC Date to Local Zone */
+    public static ToLocalZone(utcDate: string | Date | moment.Moment): string {
+        return moment(utcDate).add(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    }
+
+
+    /** Convert Local Zone Date to UTC */
+    public static ToUTC(utcDate: string | Date | moment.Moment): string {
+        return moment(utcDate).subtract(DateTime.GetUTCOffset(), 'minutes').format('YYYY-MM-DD HH:mm:ss');
+    }
+
+
+    /** DD MMM YYYY */
+    public static GetDateFormat(date: string | Date | moment.Moment): string {
+        if ((typeof date === 'string')) date = date.replaceAll('/', '-');
+        return moment(date).parseZone().local(true).format('DD MMM YYYY');
+    }
+}

package/Tools/Files.class.ts

@@ -0,0 +1,119 @@
+import { Tools } from ".";
+import * as XLSX from 'xlsx';
+
+export class Files { 
+    public static readonly EXCEL_EXTENSIONS: string[] = ['xls', 'xlsx', 'csv'];
+
+    /** Get Extension File */
+    public static GetExtension(file: File): string | null {
+        const fileName = file.name;
+
+        if (fileName.includes('.')) {
+            let worlds = fileName.split('.') as string[];
+
+            if (worlds.length > 0) {
+                let extension = worlds.pop()!;
+                extension = extension.trim().toLowerCase();
+                if (extension.length > 0) return extension;
+            }
+        }
+
+        return null;
+    }
+
+
+    /** Is Excel File */
+    public static IsExcel(file: File): boolean {
+        const EXTENSION = Files.GetExtension(file);
+
+        return Tools.IsNotNull(EXTENSION)
+            ? this.EXCEL_EXTENSIONS.includes(EXTENSION!)
+            : false;
+    }
+
+
+    /** Read excel file */
+    public static ReadExcel<T>(file: File) {
+        return new Promise<{ columns: string[]; rows: T[]; }>(Resolve => {
+            let columns: string[] = [];
+            let rows: T[] = [];
+
+            const reader = new FileReader();
+            reader.readAsArrayBuffer(file);
+
+            reader.onload = () => {
+                const dataBytes = new Uint8Array(reader.result as any);
+
+                if (dataBytes) {
+                    const workbook = XLSX.read(dataBytes, {});
+                    const sheet = workbook.Sheets[workbook.SheetNames[0]];
+                    let dataSheet: any[] = 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<any>(row);
+                        delete item['__rowNum__'];
+                        return item;
+                    });
+                }
+
+                Resolve({ columns, rows });
+            }
+
+            reader.onerror = () => { Resolve({ columns, rows }) }
+        });
+    }
+
+
+    /** Export to excel file */
+    public static ExportExcel<T>(data: T[], fileName: string = 'coer_report', sheetName: string = '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 */
+    public static ConvertToBase64(file: File) {
+        return new Promise<string>(Resolve => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+    
+            reader.onload = () => {
+                Resolve(reader.result?.toString() || '');
+            }
+    
+            reader.onerror = () => {
+                Resolve('');
+            }
+        });
+    } 
+}

package/Tools/Screen.class.ts

@@ -0,0 +1,55 @@
+import { Observable } from "rxjs";
+
+export interface IScreenSize {
+    width: number;
+    height: number;
+    breakpoin: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+}
+
+export class Screen {
+
+    public static get WINDOW_WIDTH(): number {
+        return window.innerWidth;
+    }
+
+    
+    public static get WINDOW_HEIGHT(): number {
+        return window.innerHeight;
+    }
+
+
+    public static get DEVICE_WIDTH(): number {
+        return window.screen.width;
+    }
+
+
+    public static get DEVICE_HEIGHT(): number {
+        return window.screen.height;
+    }
+
+
+    public static get BREAKPOINT(): 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' {
+        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';
+    }
+
+
+    /** */
+    public static Resize = new Observable<IScreenSize>(subscriber => {
+        window.addEventListener("load", () => {
+            window.dispatchEvent(new Event('resize'));
+        });
+
+        window.onresize = () => {
+            subscriber.next({
+                width: window.innerWidth,
+                height: window.innerHeight,
+                breakpoin: this.BREAKPOINT
+            });
+        }
+    });
+}

package/Tools/index.ts

@@ -0,0 +1,212 @@
+import { Guid } from "guid-typescript";
+import { signal } from "@angular/core"; 
+const reference_signal = signal<any>({});
+
+export const Tools = {
+    /** Generate a Guid */
+    GetGuid: (seed: string = 'coer-system') => {
+        return `${seed}-${Guid.create().toString()}`;
+    },
+
+
+    /** Returns true if the value is null or undefined, false otherwise */
+    IsNull: (value: any): boolean => {
+        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: any): boolean => {
+        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: any): boolean => {
+        if (value === undefined) return true;
+        if (value === null) return true; 
+        if((value as string).toString().trim() === '') return true;
+        return false;
+    },
+
+
+    /** Break reference of a object or array */
+    BreakReference: <T>(object: T): T => {
+        if (object === undefined) return undefined as T;
+        if (object === null) return null as T;
+        const OBJECT = JSON.parse(JSON.stringify(object))
+        return (Array.isArray(OBJECT)) ? [...OBJECT] : { ...OBJECT }
+    },
+
+
+    /** Clean extra whitespaces */
+    CleanUpBlanks: (text: string | number): string => {
+        if(Tools.IsNull(text)) return '';
+        let worlds: string[] = String(text).split(' ');
+        worlds = worlds.filter(x => x.length > 0);
+        return worlds.join(' ');
+    },
+
+
+    /** Get properties of an object */
+    GetObjectProperties: <T>(obj: T | null | undefined): string[] => {
+        const properties: string[] = [];
+        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 
+     * @returns A new array 
+     * */
+    SetIndex: <T>(array: T[], ...args: T[][]): T[] => {
+        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: string | null | undefined): string => {
+        if (Tools.IsNull(text)) return '';
+
+        const textArray: string[] = [];
+        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: string | null | undefined): string => {
+        if (Tools.IsNull(text)) return '';
+
+        const textArray: string[] = [];
+        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: <T>(array: T[], property: string, propertyType: 'string' | 'number' = 'string'): T[] => {
+        switch (propertyType) {
+            case 'string': {
+                return array.sort((x: any, y: any) => {
+                    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: any, y: any) => Number(x[property] - Number(y[property])));
+            }
+        }
+    },
+
+
+    /** Sort an array in descending order by property */
+    SortByDesc: <T>(array: T[], property: string, propertyType: 'string' | 'number' = 'string'): T[] => {
+        switch (propertyType) {
+            case 'string': {
+                return array.sort((x: any, y: any) => {
+                    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: any, y: any) => Number(Number(y[property])) - x[property]);
+            }
+        }
+    },
+
+
+    /** Return a string with forman numeric */
+    GetNumericFormat: (value: string | number | null | undefined, decimals: number = 0): string => {
+        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: string[] = [];
+        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: number = 0, reference: string | null = null) => {
+        if (Tools.IsNull(reference)) {
+            return new Promise(Resolve => setTimeout(Resolve, milliseconds));
+        }
+
+        else return new Promise<void>(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)
+            }));
+        });
+    }
+};

package/index.ts

@@ -1,127 +1,4 @@
-export const Tools = {
-    /** Returns true if the value is null or undefined, false otherwise */
-    IsNull: (value: any): boolean => {
-        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: any): boolean => {
-        if (value === undefined) return false;
-        if (value === null) return false;
-        return true;
-    },
-
-
-    /** Break reference of a object or array */
-    BreakReference: <T>(object: T): T => {
-        if (object === undefined) return undefined as T;
-        if (object === null) return null as T;
-        const OBJECT = JSON.parse(JSON.stringify(object))
-        return (Array.isArray(OBJECT)) ? [...OBJECT] : { ...OBJECT }
-    },
-
-
-    /** Clean extra whitespaces */
-    CleanUpBlanks: (text: string | number): string => {
-        if(Tools.IsNull(text)) return '';
-        let worlds: string[] = String(text).split(' ');
-        worlds = worlds.filter(x => x.length > 0);
-        return worlds.join(' ');
-    },
-
-
-    /** Get properties of an object */
-    GetObjectProperties: <T>(obj: T | null | undefined): string[] => {
-        const properties: string[] = [];
-        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 
-     * @returns A new array 
-     * */
-    SetIndex: <T>(array: T[], ...args: T[][]): T[] => {
-        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: string | null | undefined): string => {
-        if (Tools.IsNull(text)) return '';
-
-        const textArray: string[] = [];
-        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: string | null | undefined): string => {
-        if (Tools.IsNull(text)) return '';
-
-        const textArray: string[] = [];
-        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 
-     * @returns A new array 
-     * */
-    SortBy: <T>(array: T[], property: string, propertyType: 'string' | 'number' = 'string'): T[] => {
-        switch (propertyType) {
-            case 'string': {
-                return [...array].sort((x: any, y: any) => {
-                    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: any, y: any) => Number(x[property] - Number(y[property])));
-            }
-        }
-    },
-
-
-    /**
-     * Sort an array in descending order by property
-     * @returns A new array
-     * */
-    SortByDesc: <T>(array: T[], property: string, propertyType: 'string' | 'number' = 'string'): T[] => {
-        switch (propertyType) {
-            case 'string': {
-                return array.sort((x: any, y: any) => {
-                    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: any, y: any) => Number(Number(y[property])) - x[property]);
-            }
-        }
-    }
-};
+export * from './Tools'
+export * from './Tools/DateTime.class';
+export * from './Tools/Files.class';
+export * from './Tools/Screen.class';

package/interfaces/index.ts

@@ -0,0 +1,5 @@
+export interface IPatch {
+    op: 'remove' | 'add' | 'replace';
+    path: string;
+    value: any;
+}

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "coer-elements",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "author": "Christian Omar Escamilla Rodríguez",
-  "keywords": ["coer", "tools"],
+  "keywords": [
+    "coer",
+    "tools"
+  ],
   "description": "",
   "license": "MIT",
   "main": "dist_node/index.js",
@@ -16,9 +19,16 @@
     "build-browser": "tsc index.ts --outDir dist_browser --module ES6",
     "build-node": "tsc index.ts --outDir dist_node",
     "build": "npm run build-browser & npm run build-node",
-    "publish": "npm publish --access public"
+    "push": "npm publish --access public"
+  },
+  "dependencies": {
+    "@angular/core": "^18.2.3",
+    "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

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */  
+    "outDir": "./dist/out-tsc",
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "declaration": false,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "target": "ES2022",
+    "module": "ES2022",
+    "useDefineForClassFields": false,
+    "lib": ["ES2022", "dom"],
+    "baseUrl": "./"
+  }
+}