jconsumer-shared 0.0.2 → 0.0.3

package/esm2022/lib/file-service.mjs

@@ -0,0 +1,229 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ *
+ */
+export class FileService {
+    // Supported images types
+    IMAGE_FORMATS = [
+        'image/gif',
+        'image/png',
+        'image/jpeg',
+        'image/bmp',
+        'image/webp'
+    ];
+    FILETYPES_UPLOAD = [
+        'image/jpg',
+        'image/png',
+        'image/jpeg',
+        'image/bmp',
+        'application/pdf',
+        'application/jfif',
+        'video/mp4',
+        'video/mpeg',
+        'audio/mpeg',
+        'audio/mp3',
+        'audio/ogg',
+        'application/vnd.ms-excel',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'application/doc',
+        'application/ms-doc',
+        'application/msword',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'docx',
+        'doc'
+    ];
+    imageSize = 15000000;
+    FILE_MAX_SIZE = 10000000;
+    constructor() { }
+    /**
+     * Method returns supported formats of files which has to be uploaded
+     * @param source image/file
+     * @returns available formats
+     */
+    getSupportedFormats(source) {
+        console.log(source);
+        let formats = [];
+        if (source == 'image') {
+            formats = this.IMAGE_FORMATS;
+            //return this.IMAGE_FORMATS;
+        }
+        else {
+            formats = this.FILETYPES_UPLOAD;
+            //return this.FILETYPES_UPLOAD;
+        }
+        console.log(formats);
+        return formats;
+    }
+    /**
+     * Method will return the maximum uploadable size of a file/image
+     * @returns Maximum size of the image to upload
+     */
+    getMaximumImageSize() {
+        return this.imageSize;
+    }
+    imageValidation(file, source) {
+        console.log("In Image Validation:", source);
+        let file_types = [];
+        if (source === 'attachment' || source === 'consumerimages') {
+            file_types = this.getSupportedFormats('file');
+        }
+        else {
+            file_types = this.getSupportedFormats('image');
+        }
+        const image_max_size = this.getMaximumImageSize();
+        const error = [];
+        console.log(file_types);
+        console.log(file.type);
+        let is_error = false;
+        if (!file.type || (file.type && file_types.indexOf(file.type) === -1)) {
+            error['type'] = true;
+            is_error = true;
+        }
+        if (file.size && file.size > image_max_size) {
+            error['size'] = true;
+            is_error = true;
+        }
+        if (is_error === false) {
+            return true;
+        }
+        else {
+            return error;
+        }
+    }
+    getImage(url, fileObj) {
+        let file = fileObj;
+        if (fileObj && fileObj['mimeType']) {
+            file['type'] = fileObj['mimeType'];
+        }
+        // console.log("File :", file);
+        // console.log("File Type :", file.type)
+        // console.log("File Name :", file.name.includes('docx'))
+        if (file.type) {
+            if (file.type == 'application/pdf') {
+                return './assets/images/pdf.png';
+            }
+            else if (file.type == 'application/vnd.ms-excel' || file.type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') {
+                return './assets/images/xls.png';
+            }
+            else if (file.type == 'audio/mp3' || file.type == 'audio/mpeg' || file.type == 'audio/ogg') {
+                return './assets/images/audio.png';
+            }
+            else if (file.type == 'video/mp4' || file.type == 'video/mpeg') {
+                return './assets/images/video.png';
+            }
+            else if (file.type == 'application/msword' || file.type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || file.type.includes('docx') || file.type.includes('doc')) {
+                return './assets/images/ImgeFileIcon/wordDocsBgWhite.jpg';
+            }
+            else if (file.type.includes('txt')) {
+                return './assets/images/ImgeFileIcon/docTxt.png';
+            }
+            else {
+                return url;
+            }
+        }
+        return url;
+    }
+    getImageByType(type) {
+        if (type == 'pdf') {
+            return './assets/images/pdf.png';
+        }
+        else if (type == 'vnd.ms-excel' || type == 'vnd.openxmlformats-officedocument.spreadsheetml.sheet' || type == 'xls' || type == 'xlsx') {
+            return './assets/images/xls.png';
+        }
+        else if (type == 'mp3' || type == 'mpeg' || type == 'ogg') {
+            return './assets/images/audio.png';
+        }
+        else if (type == 'mp4' || type == 'mpeg') {
+            return './assets/images/video.png';
+        }
+        else if (type == 'application/msword' || type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || type == 'docx' || type == 'doc' || type == 'msword') {
+            return './assets/images/ImgeFileIcon/wordDocsBgWhite.jpg';
+        }
+        else if (type == 'txt') {
+            return './assets/images/ImgeFileIcon/docTxt.png';
+        }
+        else {
+            return './assets/images/img_uplod.png';
+        }
+    }
+    filesSelected(event, selectedMessage) {
+        const _this = this;
+        return new Promise(function (resolve, reject) {
+            // const input = event.target.files;
+            let input = event.files;
+            if (event.target && event.target.files) {
+                input = event.target.files;
+            }
+            console.log("File Selected :", input);
+            if (input) {
+                let count = 0;
+                let filesCount = input.length;
+                for (const file of input) {
+                    if (_this.FILETYPES_UPLOAD.indexOf(file.type) === -1) {
+                        reject("Selected file type not supported");
+                    }
+                    else if (file.size > _this.FILE_MAX_SIZE) {
+                        reject("Please upload files with size < 10mb");
+                    }
+                    else {
+                        selectedMessage.files.push(file);
+                        const reader = new FileReader();
+                        reader.onload = (e) => {
+                            selectedMessage.base64.push(e.target["result"]);
+                            count++;
+                            if (count === filesCount) {
+                                resolve(true);
+                            }
+                        };
+                        reader.readAsDataURL(file);
+                    }
+                }
+            }
+        });
+    }
+    filessSelected(event, selectedMessage) {
+        const _this = this;
+        return new Promise(function (resolve, reject) {
+            // const input = event.target.files;
+            let input = event.files;
+            if (event.target && event.target.files) {
+                input = event.target.files;
+            }
+            console.log("File Selected :", input);
+            if (input) {
+                let count = 0;
+                let filesCount = input.length;
+                for (const file of input) {
+                    if (_this.IMAGE_FORMATS.indexOf(file.type) === -1) {
+                        reject("Selected file type not supported");
+                    }
+                    else if (file.size > _this.FILE_MAX_SIZE) {
+                        reject("Please upload files with size < 10mb");
+                    }
+                    else {
+                        selectedMessage.files.push(file);
+                        const reader = new FileReader();
+                        reader.onload = (e) => {
+                            selectedMessage.base64.push(e.target["result"]);
+                            count++;
+                            if (count === filesCount) {
+                                resolve(true);
+                            }
+                        };
+                        reader.readAsDataURL(file);
+                    }
+                }
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: FileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: FileService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-service.js","sourceRoot":"","sources":["../../../../projects/jconsumer-shared/src/lib/file-service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\n/**\r\n * \r\n */\r\nexport class FileService {\r\n  // Supported images types\r\n  IMAGE_FORMATS = [\r\n    'image/gif',\r\n    'image/png',\r\n    'image/jpeg',\r\n    'image/bmp',\r\n    'image/webp'\r\n  ];\r\n\r\n  FILETYPES_UPLOAD = [\r\n    'image/jpg',\r\n    'image/png',\r\n    'image/jpeg',\r\n    'image/bmp',\r\n    'application/pdf',\r\n    'application/jfif',\r\n    'video/mp4',\r\n    'video/mpeg',\r\n    'audio/mpeg',\r\n    'audio/mp3',\r\n    'audio/ogg',\r\n    'application/vnd.ms-excel',\r\n    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\r\n    'application/doc',\r\n    'application/ms-doc',\r\n    'application/msword',\r\n    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\r\n    'docx',\r\n    'doc'\r\n  ];\r\n\r\n  imageSize = 15000000;\r\n  FILE_MAX_SIZE = 10000000;\r\n  constructor() { }\r\n\r\n  /**\r\n   * Method returns supported formats of files which has to be uploaded\r\n   * @param source image/file\r\n   * @returns available formats\r\n   */\r\n  getSupportedFormats(source: any) {\r\n    console.log(source);\r\n    let formats = [];\r\n    if (source == 'image') {\r\n      formats = this.IMAGE_FORMATS;\r\n      //return this.IMAGE_FORMATS;\r\n    } else {\r\n      formats = this.FILETYPES_UPLOAD;\r\n      //return this.FILETYPES_UPLOAD;\r\n    }\r\n    console.log(formats);\r\n    return formats;\r\n  }\r\n\r\n  /**\r\n   * Method will return the maximum uploadable size of a file/image\r\n   * @returns Maximum size of the image to upload\r\n   */\r\n  getMaximumImageSize() {\r\n    return this.imageSize;\r\n  }\r\n\r\n  imageValidation(file: any, source?: any) {\r\n    console.log(\"In Image Validation:\", source);\r\n    let file_types = [];\r\n    if (source === 'attachment' || source === 'consumerimages') {\r\n      file_types = this.getSupportedFormats('file');\r\n    } else {\r\n      file_types = this.getSupportedFormats('image');\r\n    }\r\n    const image_max_size = this.getMaximumImageSize();\r\n    const error: any = [];\r\n    console.log(file_types);\r\n    console.log(file.type);\r\n    let is_error = false;\r\n    if (!file.type || (file.type && file_types.indexOf(file.type) === -1)) {\r\n      error['type'] = true;\r\n      is_error = true;\r\n    }\r\n    if (file.size && file.size > image_max_size) {\r\n      error['size'] = true;\r\n      is_error = true;\r\n    }\r\n    if (is_error === false) {\r\n      return true;\r\n    } else {\r\n      return error;\r\n    }\r\n  }\r\n  getImage(url: any, fileObj: any) {\r\n    let file = fileObj;\r\n    if (fileObj && fileObj['mimeType']) {\r\n      file['type'] = fileObj['mimeType'];\r\n    }\r\n    // console.log(\"File :\", file);\r\n    // console.log(\"File Type :\", file.type)\r\n    // console.log(\"File Name :\", file.name.includes('docx'))\r\n    if (file.type) {\r\n      if (file.type == 'application/pdf') {\r\n        return './assets/images/pdf.png';\r\n      } else if (file.type == 'application/vnd.ms-excel' || file.type == 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') {\r\n        return './assets/images/xls.png';\r\n      } else if (file.type == 'audio/mp3' || file.type == 'audio/mpeg' || file.type == 'audio/ogg') {\r\n        return './assets/images/audio.png';\r\n      } else if (file.type == 'video/mp4' || file.type == 'video/mpeg') {\r\n        return './assets/images/video.png';\r\n      } else if (file.type == 'application/msword' || file.type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || file.type.includes('docx') || file.type.includes('doc')) {\r\n        return './assets/images/ImgeFileIcon/wordDocsBgWhite.jpg';\r\n      } else if (file.type.includes('txt')) {\r\n        return './assets/images/ImgeFileIcon/docTxt.png';\r\n      } else {\r\n        return url;\r\n      }\r\n    }\r\n    return url;\r\n  }\r\n  getImageByType(type: any) {\r\n    if (type == 'pdf') {\r\n      return './assets/images/pdf.png';\r\n    } else if (type == 'vnd.ms-excel' || type == 'vnd.openxmlformats-officedocument.spreadsheetml.sheet' || type == 'xls' || type == 'xlsx') {\r\n      return './assets/images/xls.png';\r\n    } else if (type == 'mp3' || type == 'mpeg' || type == 'ogg') {\r\n      return './assets/images/audio.png';\r\n    } else if (type == 'mp4' || type == 'mpeg') {\r\n      return './assets/images/video.png';\r\n    } else if (type == 'application/msword' || type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || type == 'docx' || type == 'doc' || type == 'msword') {\r\n      return './assets/images/ImgeFileIcon/wordDocsBgWhite.jpg';\r\n    } else if (type == 'txt') {\r\n      return './assets/images/ImgeFileIcon/docTxt.png';\r\n    } else {\r\n      return './assets/images/img_uplod.png';\r\n    }\r\n  }\r\n\r\n  filesSelected(event: any, selectedMessage: any) {\r\n    const _this = this;\r\n    return new Promise(function (resolve, reject) {\r\n      // const input = event.target.files;\r\n      let input = event.files;\r\n      if (event.target && event.target.files) {\r\n        input = event.target.files;\r\n      }\r\n      console.log(\"File Selected :\", input);\r\n      if (input) {\r\n        let count = 0;\r\n        let filesCount = input.length;\r\n        for (const file of input) {\r\n          if (_this.FILETYPES_UPLOAD.indexOf(file.type) === -1) {\r\n            reject(\"Selected file type not supported\");\r\n          } else if (file.size > _this.FILE_MAX_SIZE) {\r\n            reject(\"Please upload files with size < 10mb\");\r\n          } else {\r\n            selectedMessage.files.push(file);\r\n            const reader = new FileReader();\r\n            reader.onload = (e: any) => {\r\n              selectedMessage.base64.push(e.target[\"result\"]);\r\n              count++;\r\n              if (count === filesCount) {\r\n                resolve(true);\r\n              }\r\n            };\r\n            reader.readAsDataURL(file);\r\n          }\r\n        }\r\n      }\r\n    })\r\n  }\r\n  filessSelected(event: any, selectedMessage: any) {\r\n    const _this = this;\r\n    return new Promise(function (resolve, reject) {\r\n      // const input = event.target.files;\r\n      let input = event.files;\r\n      if (event.target && event.target.files) {\r\n        input = event.target.files;\r\n      }\r\n      console.log(\"File Selected :\", input);\r\n      if (input) {\r\n        let count = 0;\r\n        let filesCount = input.length;\r\n        for (const file of input) {\r\n          if (_this.IMAGE_FORMATS.indexOf(file.type) === -1) {\r\n            reject(\"Selected file type not supported\");\r\n          } else if (file.size > _this.FILE_MAX_SIZE) {\r\n            reject(\"Please upload files with size < 10mb\");\r\n          } else {\r\n            selectedMessage.files.push(file);\r\n            const reader = new FileReader();\r\n            reader.onload = (e: any) => {\r\n              selectedMessage.base64.push(e.target[\"result\"]);\r\n              count++;\r\n              if (count === filesCount) {\r\n                resolve(true);\r\n              }\r\n            };\r\n            reader.readAsDataURL(file);\r\n          }\r\n        }\r\n      }\r\n    })\r\n  }\r\n}\r\n"]}

package/esm2022/lib/group-storage.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./session-storage.service";
+import * as i2 from "./local-storage.service";
+export class GroupStorageService {
+    sessionStorageService;
+    lStorageService;
+    constructor(sessionStorageService, lStorageService) {
+        this.sessionStorageService = sessionStorageService;
+        this.lStorageService = lStorageService;
+    }
+    getGroup() {
+        if (this.sessionStorageService.getitemfromSessionStorage('tabId')) {
+            return this.sessionStorageService.getitemfromSessionStorage('accountid');
+        }
+        else {
+            return 0;
+        }
+    }
+    setitemToGroupStorage(itemname, itemvalue) {
+        const group = this.getGroup();
+        let groupObj = {};
+        if (this.lStorageService.getitemfromLocalStorage(group)) {
+            groupObj = JSON.parse(this.lStorageService.getitemfromLocalStorage(group)) ? JSON.parse(this.lStorageService.getitemfromLocalStorage(group)) : {};
+            if (groupObj) {
+                groupObj[itemname] = itemvalue;
+            }
+        }
+        else {
+            groupObj[itemname] = itemvalue;
+        }
+        this.lStorageService.setitemonLocalStorage(group, JSON.stringify(groupObj));
+    }
+    getitemFromGroupStorage(itemname, type) {
+        let group;
+        if (type) {
+            group = 0;
+        }
+        else {
+            group = this.getGroup();
+        }
+        if (this.lStorageService.getitemfromLocalStorage(group)) {
+            const groupObj = JSON.parse(this.lStorageService.getitemfromLocalStorage(group));
+            if (groupObj[itemname] || (itemname === 'isCheckin' && groupObj[itemname] !== undefined)) {
+                return groupObj[itemname];
+            }
+        }
+    }
+    removeitemFromGroupStorage(itemname) {
+        const group = this.getGroup();
+        const groupObj = JSON.parse(this.lStorageService.getitemfromLocalStorage(group));
+        if (groupObj[itemname]) {
+            delete groupObj[itemname];
+            this.lStorageService.setitemonLocalStorage(group, JSON.stringify(groupObj));
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: GroupStorageService, deps: [{ token: i1.SessionStorageService }, { token: i2.LocalStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: GroupStorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: GroupStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.SessionStorageService }, { type: i2.LocalStorageService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/i8n.module.mjs

@@ -0,0 +1,43 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { TranslateHttpLoader } from '@ngx-translate/http-loader';
+import { TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { SharedService } from './shared.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export function HttpLoaderFactory(http, sharedService) {
+    return new TranslateHttpLoader(http, sharedService.getI8nPath() + 'assets/i18n/', '.json');
+}
+export class I8nModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: I8nModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: I8nModule, imports: [CommonModule, i1.TranslateModule], exports: [TranslateModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: I8nModule, imports: [CommonModule,
+            TranslateModule.forRoot({
+                loader: {
+                    provide: TranslateLoader,
+                    useFactory: HttpLoaderFactory,
+                    deps: [HttpClient, SharedService]
+                }
+            }), TranslateModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: I8nModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useFactory: HttpLoaderFactory,
+                                deps: [HttpClient, SharedService]
+                            }
+                        })
+                    ],
+                    exports: [
+                        TranslateModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/local-storage.service.mjs

@@ -0,0 +1,77 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+/**
+ * Handle Local Storage related actions
+ */
+export class LocalStorageService {
+    /* holds the variables which not removed by clearLocalstorage() method */
+    dont_delete_localstorage = ['refreshToken', 'userType', 'version', 'qrp', 'mUniqueId', 'authToken', 'reqFrom', 'source', 'translatevariable', 'appId', 'installId', 'appUniqueId', 'cleared', 'googleToken', 'sysdate', 'pt_pwd', 'target', 'activeLocation', 'busId'];
+    /**
+     * Default constructor
+     */
+    constructor() {
+    }
+    /**
+     * function to get local storage item value
+     * @param itemname name of variable
+     */
+    getitemfromLocalStorage(itemname) {
+        // if (isPlatformBrowser(this.platformId)) {
+        if (localStorage.getItem(itemname) !== 'undefined') {
+            return JSON.parse(localStorage.getItem(itemname));
+        }
+        // }
+        // return null;
+    }
+    /**
+     * // function to set local storage item value
+     * @param itemname name of variable
+     * @param itemvalue value to set
+     */
+    setitemonLocalStorage(itemname, itemvalue) {
+        // if (isPlatformBrowser(this.platformId)) {
+        localStorage.setItem(itemname, JSON.stringify(itemvalue));
+        // }
+    }
+    /**
+     * Method to remove an item from local storage
+     * @param itemname item to be removed
+     */
+    removeitemfromLocalStorage(itemname) {
+        // if (isPlatformBrowser(this.platformId)) {
+        localStorage.removeItem(itemname);
+        // }
+    }
+    /**
+     * Method to clear the local storage items except the ones contained in 'dont_delete_localstorage'
+     */
+    clearLocalstorage() {
+        // if (isPlatformBrowser(this.platformId)) {
+        this.removeitemfromLocalStorage('ynw-credentials');
+        for (let index = 0; index < localStorage.length; index++) {
+            if (this.dont_delete_localstorage.indexOf(localStorage.key(index)) === -1) {
+                localStorage.removeItem(localStorage.key(index));
+                index = index - 1; // manage index after remove
+            }
+        }
+        // }
+    }
+    /**
+     * Method to clear the local storage items
+     */
+    clearAll() {
+        for (let index = 0; index < localStorage.length; index++) {
+            localStorage.removeItem(localStorage.key(index));
+            index = index - 1; // manage index after remove
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: LocalStorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/phone-input/phone-input.component.mjs

@@ -0,0 +1,127 @@
+import { Component, forwardRef, Input, ViewChild, Output, EventEmitter } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import intlTelInput from 'intl-tel-input';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+export class PhoneInputComponent {
+    initialCountry = 'us'; // Default to 'us'
+    preferredCountries = []; // List of preferred countries
+    nationalMode = true; // Use national mode so dial code is hidden in input box
+    separateDialCode = true; // Whether to separate dial code (controls formatting)
+    otherOptions = {}; // Any other options for intl-tel-input
+    phoneInput;
+    phoneNumber = { dialCode: '', countryCode: '', e164Number: '', number: '' }; // Structured phone number object
+    phoneInputInstance;
+    // Output Event to send the phone number value to the parent component
+    phoneNumberChange = new EventEmitter();
+    // Function to handle form control value changes
+    onChange = (value) => { };
+    onTouched = () => { };
+    ngAfterViewInit() {
+        if (this.phoneInput && this.phoneInput.nativeElement) {
+            this.initializePhoneInput();
+        }
+    }
+    // Initialize intl-tel-input for the phone input field
+    initializePhoneInput() {
+        const options = {
+            initialCountry: this.initialCountry,
+            preferredCountries: this.preferredCountries,
+            nationalMode: this.nationalMode, // Use national mode to hide dial code
+            separateDialCode: this.separateDialCode, // Keep separate dial code for processing
+            utilsScript: 'https://cdnjs.cloudflare.com/ajax/libs/intl-tel-input/17.0.8/js/utils.js',
+            ...this.otherOptions // Merge any additional options provided
+        };
+        // Initialize intl-tel-input
+        this.phoneInputInstance = intlTelInput(this.phoneInput.nativeElement, options);
+        // Capture the country change event to track the selected country code and dial code
+        this.phoneInput.nativeElement.addEventListener('countrychange', () => {
+            this.updatePhoneNumber();
+        });
+        // Capture input event to update phone number in E.164 format
+        this.phoneInput.nativeElement.addEventListener('input', () => {
+            this.updatePhoneNumber();
+        });
+        // Set the initial value if available (without showing the dial code)
+        if (this.phoneNumber.e164Number) {
+            this.phoneInputInstance.setNumber(this.phoneNumber.e164Number); // Set the E.164 formatted number
+        }
+    }
+    // Method to update the phone number object
+    updatePhoneNumber() {
+        const dialCode = '+' + this.phoneInputInstance.getSelectedCountryData().dialCode;
+        const countryCode = this.phoneInputInstance.getSelectedCountryData().iso2;
+        const e164Number = this.phoneInputInstance.getNumber(); // Full number in E.164 format
+        const number = e164Number.split(dialCode)[1];
+        // Update the phoneNumber object with the full details
+        this.phoneNumber = {
+            dialCode,
+            countryCode,
+            e164Number,
+            number
+        };
+        // Emit the updated value to the parent component
+        this.phoneNumberChange.emit(this.phoneNumber); // Sending the value to parent
+    }
+    // Implement the writeValue method for ControlValueAccessor
+    writeValue(value) {
+        if (value && value.e164Number) {
+            this.phoneNumber = value;
+            if (this.phoneInput && this.phoneInput.nativeElement) {
+                this.phoneInputInstance.setNumber(value.e164Number); // Set the E.164 formatted number
+            }
+        }
+    }
+    // Implement the registerOnChange method for ControlValueAccessor
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    // Implement the registerOnTouched method for ControlValueAccessor
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    // Custom Validation Method: Validate the phone number
+    validatePhoneNumber() {
+        if (this.phoneInputInstance) {
+            // Check if the current phone number is valid according to the selected country
+            const isValid = this.phoneInputInstance.isValidNumber() || this.phoneNumber.number.startsWith('555');
+            return isValid;
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: PhoneInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: PhoneInputComponent, selector: "app-phone-input", inputs: { initialCountry: "initialCountry", preferredCountries: "preferredCountries", nationalMode: "nationalMode", separateDialCode: "separateDialCode", otherOptions: "otherOptions" }, outputs: { phoneNumberChange: "phoneNumberChange" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => PhoneInputComponent),
+                multi: true
+            }
+        ], viewQueries: [{ propertyName: "phoneInput", first: true, predicate: ["phoneInput"], descendants: true }], ngImport: i0, template: "<div class=\"phone-input-wrapper\">\r\n    <input #phoneInput type=\"tel\" [(ngModel)]=\"phoneNumber.phoneNumber\"\r\n        name=\"phoneNumber\" [required]=\"true\" #phone=\"ngModel\"\r\n        [ngClass]=\"{'is-invalid': !validatePhoneNumber() && phone.touched}\">\r\n\r\n    <!-- Validation feedback -->\r\n    <!-- <div *ngIf=\"!validatePhoneNumber() && phone.touched\" class=\"text-danger\">\r\n        Invalid phone number.\r\n    </div> -->\r\n    <!-- <input #phoneInput [(ngModel)]=\"phoneNumber.number\" /> -->\r\n</div>", styles: ["::ng-deep .tel-input-container .iti{width:100%!important}::ng-deep .tel-input-container .iti--separate-dial-code .iti__selected-flag{background-color:transparent}::ng-deep .tel-input-container input::-webkit-input-placeholder{color:#ddd!important}::ng-deep .tel-input-container input:focus{outline:none!important;border-color:#e1e2e3!important}::ng-deep .tel-input-container input{height:50px!important;width:100%!important;background:#fff!important;border:1.39032px solid #E1E2E3!important;border-radius:11.1225px!important;padding:15px;font-size:15px}::ng-deep .tel-input-container input.is-invalid{border:1.39032px solid #ff0000!important}::ng-deep .tel-input-container input::placeholder{color:#ddd}::ng-deep .tel-input-container input.custom:focus{color:#495057!important;background-color:#fff!important;border-color:#3c8dbc!important;outline:0!important;box-shadow:0 0 #fff!important}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: PhoneInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-phone-input', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => PhoneInputComponent),
+                            multi: true
+                        }
+                    ], template: "<div class=\"phone-input-wrapper\">\r\n    <input #phoneInput type=\"tel\" [(ngModel)]=\"phoneNumber.phoneNumber\"\r\n        name=\"phoneNumber\" [required]=\"true\" #phone=\"ngModel\"\r\n        [ngClass]=\"{'is-invalid': !validatePhoneNumber() && phone.touched}\">\r\n\r\n    <!-- Validation feedback -->\r\n    <!-- <div *ngIf=\"!validatePhoneNumber() && phone.touched\" class=\"text-danger\">\r\n        Invalid phone number.\r\n    </div> -->\r\n    <!-- <input #phoneInput [(ngModel)]=\"phoneNumber.number\" /> -->\r\n</div>", styles: ["::ng-deep .tel-input-container .iti{width:100%!important}::ng-deep .tel-input-container .iti--separate-dial-code .iti__selected-flag{background-color:transparent}::ng-deep .tel-input-container input::-webkit-input-placeholder{color:#ddd!important}::ng-deep .tel-input-container input:focus{outline:none!important;border-color:#e1e2e3!important}::ng-deep .tel-input-container input{height:50px!important;width:100%!important;background:#fff!important;border:1.39032px solid #E1E2E3!important;border-radius:11.1225px!important;padding:15px;font-size:15px}::ng-deep .tel-input-container input.is-invalid{border:1.39032px solid #ff0000!important}::ng-deep .tel-input-container input::placeholder{color:#ddd}::ng-deep .tel-input-container input.custom:focus{color:#495057!important;background-color:#fff!important;border-color:#3c8dbc!important;outline:0!important;box-shadow:0 0 #fff!important}\n"] }]
+        }], propDecorators: { initialCountry: [{
+                type: Input
+            }], preferredCountries: [{
+                type: Input
+            }], nationalMode: [{
+                type: Input
+            }], separateDialCode: [{
+                type: Input
+            }], otherOptions: [{
+                type: Input
+            }], phoneInput: [{
+                type: ViewChild,
+                args: ['phoneInput', { static: false }]
+            }], phoneNumberChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phone-input.component.js","sourceRoot":"","sources":["../../../../../projects/jconsumer-shared/src/lib/phone-input/phone-input.component.ts","../../../../../projects/jconsumer-shared/src/lib/phone-input/phone-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, forwardRef, Input, ViewChild, Output, EventEmitter } from '@angular/core';\r\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\r\nimport intlTelInput from 'intl-tel-input';\r\n\r\n@Component({\r\n  selector: 'app-phone-input',\r\n  templateUrl: './phone-input.component.html',\r\n  styleUrls: ['./phone-input.component.scss'],\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => PhoneInputComponent),\r\n      multi: true\r\n    }\r\n  ]\r\n})\r\nexport class PhoneInputComponent implements AfterViewInit, ControlValueAccessor {\r\n  @Input() initialCountry: string = 'us'; // Default to 'us'\r\n  @Input() preferredCountries: string[] = []; // List of preferred countries\r\n  @Input() nationalMode: boolean = true; // Use national mode so dial code is hidden in input box\r\n  @Input() separateDialCode: boolean = true; // Whether to separate dial code (controls formatting)\r\n  @Input() otherOptions: any = {}; // Any other options for intl-tel-input\r\n\r\n  @ViewChild('phoneInput', { static: false }) phoneInput: ElementRef;\r\n  phoneNumber: any = { dialCode: '', countryCode: '', e164Number: '', number: '' }; // Structured phone number object\r\n  phoneInputInstance: any;\r\n\r\n  // Output Event to send the phone number value to the parent component\r\n  @Output() phoneNumberChange = new EventEmitter<any>();\r\n\r\n  // Function to handle form control value changes\r\n  onChange = (value: any) => {};\r\n  onTouched = () => {};\r\n\r\n  ngAfterViewInit(): void {\r\n    if (this.phoneInput && this.phoneInput.nativeElement) {\r\n      this.initializePhoneInput();\r\n    }\r\n  }\r\n\r\n  // Initialize intl-tel-input for the phone input field\r\n  initializePhoneInput(): void {\r\n    const options = {\r\n      initialCountry: this.initialCountry,\r\n      preferredCountries: this.preferredCountries,\r\n      nationalMode: this.nationalMode, // Use national mode to hide dial code\r\n      separateDialCode: this.separateDialCode, // Keep separate dial code for processing\r\n      utilsScript: 'https://cdnjs.cloudflare.com/ajax/libs/intl-tel-input/17.0.8/js/utils.js',\r\n      ...this.otherOptions // Merge any additional options provided\r\n    };\r\n\r\n    // Initialize intl-tel-input\r\n    this.phoneInputInstance = intlTelInput(this.phoneInput.nativeElement, options);\r\n\r\n    // Capture the country change event to track the selected country code and dial code\r\n    this.phoneInput.nativeElement.addEventListener('countrychange', () => {\r\n      this.updatePhoneNumber();\r\n    });\r\n\r\n    // Capture input event to update phone number in E.164 format\r\n    this.phoneInput.nativeElement.addEventListener('input', () => {\r\n      this.updatePhoneNumber();\r\n    });\r\n\r\n    // Set the initial value if available (without showing the dial code)\r\n    if (this.phoneNumber.e164Number) {\r\n      this.phoneInputInstance.setNumber(this.phoneNumber.e164Number); // Set the E.164 formatted number\r\n    }\r\n  }\r\n\r\n  // Method to update the phone number object\r\n  updatePhoneNumber(): void {\r\n    const dialCode = '+' + this.phoneInputInstance.getSelectedCountryData().dialCode;\r\n    const countryCode = this.phoneInputInstance.getSelectedCountryData().iso2;\r\n    const e164Number = this.phoneInputInstance.getNumber(); // Full number in E.164 format\r\n    const number = e164Number.split(dialCode)[1];\r\n\r\n    // Update the phoneNumber object with the full details\r\n    this.phoneNumber = {\r\n      dialCode,\r\n      countryCode,\r\n      e164Number,\r\n      number\r\n    };\r\n\r\n    // Emit the updated value to the parent component\r\n    this.phoneNumberChange.emit(this.phoneNumber);  // Sending the value to parent\r\n  }\r\n\r\n  // Implement the writeValue method for ControlValueAccessor\r\n  writeValue(value: any): void {\r\n    if (value && value.e164Number) {\r\n      this.phoneNumber = value;\r\n      if (this.phoneInput && this.phoneInput.nativeElement) {\r\n        this.phoneInputInstance.setNumber(value.e164Number); // Set the E.164 formatted number\r\n      }\r\n    }\r\n  }\r\n\r\n  // Implement the registerOnChange method for ControlValueAccessor\r\n  registerOnChange(fn: any): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  // Implement the registerOnTouched method for ControlValueAccessor\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  // Custom Validation Method: Validate the phone number\r\n  validatePhoneNumber(): boolean {\r\n    if (this.phoneInputInstance) {\r\n      // Check if the current phone number is valid according to the selected country\r\n      const isValid = this.phoneInputInstance.isValidNumber() || this.phoneNumber.number.startsWith('555');\r\n      return isValid;\r\n    }\r\n    return false;\r\n  }\r\n}","<div class=\"phone-input-wrapper\">\r\n    <input #phoneInput type=\"tel\" [(ngModel)]=\"phoneNumber.phoneNumber\"\r\n        name=\"phoneNumber\" [required]=\"true\" #phone=\"ngModel\"\r\n        [ngClass]=\"{'is-invalid': !validatePhoneNumber() && phone.touched}\">\r\n\r\n    <!-- Validation feedback -->\r\n    <!-- <div *ngIf=\"!validatePhoneNumber() && phone.touched\" class=\"text-danger\">\r\n        Invalid phone number.\r\n    </div> -->\r\n    <!-- <input #phoneInput [(ngModel)]=\"phoneNumber.number\" /> -->\r\n</div>"]}