http-request-manager 15.0.26 → 18.0.2

package/esm2022/lib/services/utils/encryption/asymmetrical-encryption.service.mjs

@@ -0,0 +1,186 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, EMPTY, from } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class AsymmetricalEncryptionService {
+    constructor() { }
+    generateKeyPair(modulusLength = 2048) {
+        // modulusLength - 1024, 2048, 4096
+        // hash - SHA-256
+        return from(crypto.subtle.generateKey({
+            name: "RSA-OAEP",
+            modulusLength,
+            publicExponent: new Uint8Array([1, 0, 1]), // 65537
+            hash: { name: "SHA-256" }
+        }, true, // Extractable keys
+        ["encrypt", "decrypt"]));
+    }
+    encryptData(publicKey, data) {
+        const encodedData = new TextEncoder().encode(data);
+        return from(crypto.subtle.encrypt({
+            name: "RSA-OAEP"
+        }, publicKey, encodedData)).pipe(map(enc => this.arrayBufferToBase64(enc)));
+    }
+    decryptData(privateKey, encryptedData) {
+        const encStr = this.base64ToArrayBuffer(encryptedData);
+        return from(crypto.subtle.decrypt({
+            name: "RSA-OAEP"
+        }, privateKey, encStr).then(decryptedData => {
+            return new TextDecoder().decode(decryptedData);
+        }));
+    }
+    pemToArrayBuffer(pem) {
+        const b64 = pem.replace(/(-----BEGIN (RSA )?(PRIVATE|PUBLIC) KEY-----|-----END (RSA )?(PRIVATE|PUBLIC) KEY-----|\n)/g, '');
+        const binaryString = atob(b64);
+        const len = binaryString.length;
+        const buffer = new ArrayBuffer(len);
+        const view = new Uint8Array(buffer);
+        for (let i = 0; i < len; i++) {
+            view[i] = binaryString.charCodeAt(i);
+        }
+        return buffer;
+    }
+    base64ToArrayBuffer(base64) {
+        const binaryString = atob(base64);
+        const len = binaryString.length;
+        const buffer = new ArrayBuffer(len);
+        const view = new Uint8Array(buffer);
+        for (let i = 0; i < len; i++) {
+            view[i] = binaryString.charCodeAt(i);
+        }
+        return buffer;
+    }
+    arrayBufferToBase64(buffer) {
+        let binary = '';
+        const bytes = new Uint8Array(buffer);
+        const len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(binary);
+    }
+    base64ToPEM(base64Key, publicKey = true) {
+        const keyType = (publicKey) ? 'PUBLIC' : 'PRIVATE';
+        const header = `-----BEGIN ${keyType} KEY-----\n`;
+        const footer = `\n-----END ${keyType} KEY-----`;
+        const keyBody = base64Key.match(/.{1,64}/g)?.join("\n") || "";
+        return header + keyBody + footer;
+    }
+    pemToCryptoKey(pem, algorithm, extractable, keyUsages, format = "pkcs8" //"raw" | "pkcs8" | "spki"
+    ) {
+        const buffer = this.pemToArrayBuffer(pem);
+        console.log('buffer found ', buffer);
+        return from(crypto.subtle.importKey(format, buffer, algorithm, extractable, keyUsages));
+    }
+    // TESTING
+    testGenerateKeys() {
+        const testSequence = new BehaviorSubject("");
+        const testSequence$ = testSequence.asObservable();
+        testSequence.next("Test Generating Keys");
+        // GENERATE KEYS
+        this.generateKeyPair().subscribe((data) => {
+            console.log("GEN-GENERATED KEYS: ", data);
+            crypto.subtle.exportKey('spki', data.publicKey)
+                .then(key => {
+                const publicKeyBase64 = this.arrayBufferToBase64(key);
+                console.log("GEN-EXPORT PUBLIC KEY: ", this.base64ToPEM(publicKeyBase64, true));
+            });
+            crypto.subtle.exportKey('pkcs8', data.privateKey)
+                .then(key => {
+                const privateKeyBase64 = this.arrayBufferToBase64(key);
+                console.log("GEN-EXPORT PRIVATE KEY: ", this.base64ToPEM(privateKeyBase64, false));
+            });
+            // TEST WITH GENERATED KEYS
+            this.encryptData(data.publicKey, "Sample Data here - Mike Bonifacio")
+                .subscribe((enc) => {
+                console.log("GEN-ENCRYPT==>: ", enc);
+                this.decryptData(data.privateKey, enc).subscribe((dec) => {
+                    testSequence.next('Test Passed');
+                    testSequence.complete();
+                });
+            });
+        });
+        return testSequence$;
+    }
+    testDecryptionWithKeys() {
+        const testSequence = new BehaviorSubject("");
+        const testSequence$ = testSequence.asObservable();
+        testSequence.next("Test Generating Keys");
+        const privateKey = `-----BEGIN PRIVATE KEY-----
+    MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDKVBkCWNb9eHVF
+    twAA5mdAyvXFix3WavdrsoYRkvtCl8ogDBQf8f6N0bRkDF1zcVHRrNAEyozXDtuD
+    kFgSiivBFREI7fiS3sOvduq6FaGXzX0IY6oaVMu8oOPgDvC0yvoohR+0Qxq2d6lP
+    SPyHeKQaxP4KxzCJJzB1XAcbd2eFzUUDv25mNlwdVkmW8FI/sAxnJLgPTW78dzfX
+    Ddfk+nxdIqxVKSLATnL0kMN7aGJx24UozioAIpzvvvF5/+7HTd1gi6NeCqrAYr3g
+    iP364AE26CFwFvHnafO9uNQhlQ+uiNnOoInXByfFGVP+RidSpfLzaxDjs6RDwpol
+    h098btONAgMBAAECggEAAVhHM2OD5IkUtuowwcKNaCTKGmrClRE3gMuzJeBsSJEy
+    uAReUFILZylcnhegDytSti2vDA9T7xqtO6CU0p3V8LpU89JMOPRb/deirI4UXSpx
+    xbNyjirOO6bnrNlOWfKexdQQsikYPzF2iM1Scpr1u9ZDCHZOl1ZYSrkve5My4coP
+    3Gx6tTBqL0jQBfcpf4ES8BH3JSawR/MgqzDS74+bI2VH+kvuPAC1L4fBgaV3VUv0
+    nFzim5A3s5VaXPgJbEIghP9BkYGFkeT9ma3nliEZWc96AzsmowFn1ayCvrNVPo9R
+    ECD2NnttBiCJZt3H93sR9+OTeA8Bls+aZGlKd5mLAQKBgQDpf8nIYUm/Zmls7/lQ
+    QBUSGHEYrbjNsEejQsPgNDtg2EVSxdUkvTn7Wb+HExTk09Z5bNvhaO2532/FH9y8
+    ahSXafiMXpfR2olwXdOB9yXXl4F5C0LGnmzGim4OSeWzAX0JCL470KaS0QN3EmoG
+    9F0YCfMnZXNTweSSx4xvlO6ggQKBgQDd01uIolm7z1DIWCwNERAXP2GDwcvxyzYK
+    YqJfKDeHt2t6yIzZMMotnPDy+OlcdGspIIHkB5a+SZN5Nt7DUKg/MnyOZ3KbVq41
+    k7dR4Ka3LRnGkesy7lSr7ef1rfquyR75OXJQcPWvkFcLu0TMiQhvptatZ8VN+F4n
+    fDQELRotDQKBgQCgN+AUT7VT0QjcCBnRV/ddUEoiPenFsYSmYMSYzh5ESIHg1wB2
+    0iS79Iw4Of6nOTg8X1bM57vfQ5Kk90T2P+/bKYqzfqC8DTErWiYsUpKzyTC9Bt4N
+    /Vz0Kr5zrX8ggg/yp/4oevYhXav8AzWfigNq4EDpMnKc8TlPAf+5/L50gQKBgQC2
+    mLPhPhr1gUszD3l7bA89w7uGlLFHoQoj9FtKTzWervp3QLzIT+QtNeIVb5XQuDg5
+    y3uAdEq+6pvNjMBEMJG+K9Xh9v+dJPYUPjsJ2A4D/MkZ7qWX8B2cxSJK1uLim8W2
+    S3ZxBvsGgJ9WldmlMCvUlJZkeWYtr4P5psC+q02/xQKBgQCDII/jcV2+lRM2iNTe
+    vBijZSaNMEWOK/Y+/HFK8GYKXnB+xNWhrm8rKgWGzpDJAUPMh9Tt+leW9LKEBuzF
+    Y1bGblmGm1zsPWpIx05Fdtv9eOJmFnXbGzIsYyhadZnPcQOWhqxtpVxSuul0Jc7Q
+    XNq4qPaPXhbQAshgtyBt75DMkw==
+    -----END PRIVATE KEY-----`;
+        const pubKey = `-----BEGIN PUBLIC KEY-----
+    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylQZAljW/Xh1RbcAAOZn
+    QMr1xYsd1mr3a7KGEZL7QpfKIAwUH/H+jdG0ZAxdc3FR0azQBMqM1w7bg5BYEoor
+    wRURCO34kt7Dr3bquhWhl819CGOqGlTLvKDj4A7wtMr6KIUftEMatnepT0j8h3ik
+    GsT+CscwiScwdVwHG3dnhc1FA79uZjZcHVZJlvBSP7AMZyS4D01u/Hc31w3X5Pp8
+    XSKsVSkiwE5y9JDDe2hicduFKM4qACKc777xef/ux03dYIujXgqqwGK94Ij9+uAB
+    NughcBbx52nzvbjUIZUProjZzqCJ1wcnxRlT/kYnUqXy82sQ47OkQ8KaJYdPfG7T
+    jQIDAQAB
+    -----END PUBLIC KEY-----`;
+        const algorithm = {
+            name: "RSA-OAEP",
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: "SHA-256"
+        };
+        // ENCRYPT
+        this.pemToCryptoKey(pubKey, algorithm, true, ["encrypt"], "spki").subscribe((keyPublic) => {
+            // console.log("PUBLIC KEY: ", keyPublic)
+            this.encryptData(keyPublic, "Sample Data here - Mike Bonifacio")
+                .subscribe((str) => {
+                console.log("ENCRYPTED STRING: ", str);
+                testSequence.next('encrypted string success');
+            });
+        });
+        const enc = "r7UOuEGBZ6jbVTOIBuv9jFOEtRiedmS27hfW40k7XKCTsQ5VhWup0qu2BA2ANZaGKii/uehJ/RSPiyfGbJ6leJrat0mA1hPqH/XodaBzLMDigvdYM1NSXFZMDa40OpLUIXbPlAvybjcGu7Bal+LMA8htHrFu/OmM/fHI66xOzzpuXSYx0OkWjtY81rUQ1FFkvrkx2jGFPZ0p+Nw/v3Q4cJnet6V63vCueFlD749VMcVXo7pvz4AIPpB+IOy3kbxaYTPakLVioJERU6GFMXWkECuRvohhS9CETcORZtRVRkvhcHk3lxgIhfqojUKYgD6K5dDELDPsWIS+iTG1XIQIlg==";
+        // DECRYPTION
+        this.pemToCryptoKey(privateKey, algorithm, false, ["decrypt"], "pkcs8").subscribe((key) => {
+            // console.log("DECRYPT ===", key)
+            this.decryptData(key, enc)
+                .pipe(catchError(err => {
+                console.log("ERROR: ", err);
+                return EMPTY;
+            })).subscribe((str) => {
+                console.log("DECRYPTED STRING: ", str);
+                testSequence.next('decrypted string success');
+            });
+        });
+        return testSequence$;
+    }
+    ;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AsymmetricalEncryptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AsymmetricalEncryptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AsymmetricalEncryptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asymmetrical-encryption.service.js","sourceRoot":"","sources":["../../../../../../../projects/http-request-manager/src/lib/services/utils/encryption/asymmetrical-encryption.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { BehaviorSubject, EMPTY, Observable, from, of } from 'rxjs';\nimport { map, catchError } from 'rxjs/operators';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AsymmetricalEncryptionService {\n\n  constructor() {}\n\n  generateKeyPair(modulusLength = 2048): Observable<CryptoKeyPair> {\n  \n    // modulusLength - 1024, 2048, 4096\n    // hash - SHA-256\n\n   return from(crypto.subtle.generateKey(\n      {\n        name: \"RSA-OAEP\",\n        modulusLength,\n        publicExponent: new Uint8Array([1, 0, 1]), // 65537\n        hash: { name: \"SHA-256\" }\n      },\n      true, // Extractable keys\n      [\"encrypt\", \"decrypt\"]\n    ))\n\n  }\n\n  encryptData(publicKey: CryptoKey, data: string) {\n\n    const encodedData = new TextEncoder().encode(data)\n\n    return from(crypto.subtle.encrypt(\n      {\n        name: \"RSA-OAEP\"\n      },\n      publicKey,\n      encodedData\n    )).pipe(\n      map(enc => this.arrayBufferToBase64(enc))\n    )\n\n  }\n\n  decryptData(privateKey: CryptoKey, encryptedData: string) {\n\n    const encStr = this.base64ToArrayBuffer(encryptedData)\n\n    return from(crypto.subtle.decrypt(\n      {\n        name: \"RSA-OAEP\"\n      },\n      privateKey,\n      encStr\n    ).then(decryptedData => {\n      return new TextDecoder().decode(decryptedData)\n    }))\n\n  }\n\n  pemToArrayBuffer(pem: string): ArrayBuffer {\n\n    const b64 = pem.replace(/(-----BEGIN (RSA )?(PRIVATE|PUBLIC) KEY-----|-----END (RSA )?(PRIVATE|PUBLIC) KEY-----|\\n)/g, '')\n    const binaryString = atob(b64)\n    const len = binaryString.length\n    const buffer = new ArrayBuffer(len)\n    const view = new Uint8Array(buffer)\n\n    for (let i = 0; i < len; i++) {\n      view[i] = binaryString.charCodeAt(i)\n    }\n\n    return buffer\n\n  }\n\n  base64ToArrayBuffer(base64: string): ArrayBuffer {\n    \n    const binaryString = atob(base64);\n    const len = binaryString.length;\n    const buffer = new ArrayBuffer(len);\n    const view = new Uint8Array(buffer);\n\n    for (let i = 0; i < len; i++) {\n        view[i] = binaryString.charCodeAt(i);\n    }\n\n    return buffer;\n  }\n\n  arrayBufferToBase64(buffer: ArrayBuffer): string {\n\n    let binary = '';\n    const bytes = new Uint8Array(buffer);\n    const len = bytes.byteLength;\n\n    for (let i = 0; i < len; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }\n\n    return window.btoa(binary)\n\n  }\n\n  base64ToPEM(base64Key: string, publicKey = true) {\n\n    const keyType = (publicKey) ? 'PUBLIC' : 'PRIVATE'\n\n    const header = `-----BEGIN ${keyType} KEY-----\\n`\n    const footer = `\\n-----END ${keyType} KEY-----`\n\n    const keyBody = base64Key.match(/.{1,64}/g)?.join(\"\\n\") || \"\"\n\n    return header + keyBody + footer\n\n  }\n\n  pemToCryptoKey(\n    pem: string, \n    algorithm: RsaHashedKeyGenParams, \n    extractable: boolean, \n    keyUsages: KeyUsage[],\n    format: any = \"pkcs8\" //\"raw\" | \"pkcs8\" | \"spki\"\n    ) {\n    \n    const buffer = this.pemToArrayBuffer(pem);\n\n    console.log('buffer found ', buffer);\n    \n    return from(crypto.subtle.importKey(\n      format,\n      buffer,\n      algorithm,\n      extractable,\n      keyUsages\n    ))\n\n  }\n  \n  // TESTING\n\n  testGenerateKeys(): Observable<string> {\n    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>(\"\");\n    const testSequence$: Observable<string> = testSequence.asObservable();\n    testSequence.next(\"Test Generating Keys\");\n\n    // GENERATE KEYS\n    this.generateKeyPair().subscribe((data) => {\n\n      console.log(\"GEN-GENERATED KEYS: \", data)\n\n      crypto.subtle.exportKey('spki', data.publicKey)\n      .then(key => {\n        const publicKeyBase64 = this.arrayBufferToBase64(key);\n        console.log(\"GEN-EXPORT PUBLIC KEY: \", this.base64ToPEM(publicKeyBase64, true));\n      })\n\n      crypto.subtle.exportKey('pkcs8', data.privateKey)\n      .then(key => {\n        const privateKeyBase64 = this.arrayBufferToBase64(key);\n        console.log(\"GEN-EXPORT PRIVATE KEY: \", this.base64ToPEM(privateKeyBase64, false));\n      });\n\n      // TEST WITH GENERATED KEYS\n      this.encryptData(data.publicKey, \"Sample Data here - Mike Bonifacio\")\n          .subscribe((enc) => {\n\n            console.log(\"GEN-ENCRYPT==>: \", enc)\n\n            this.decryptData(data.privateKey, enc).subscribe((dec) => {\n              testSequence.next('Test Passed');\n              testSequence.complete();\n            })\n\n          })\n\n    })\n    return testSequence$;\n\n  }\n\n  testDecryptionWithKeys(): Observable<string> {\n    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>(\"\");\n    const testSequence$: Observable<string> = testSequence.asObservable();\n    testSequence.next(\"Test Generating Keys\");\n\n    const privateKey = `-----BEGIN PRIVATE KEY-----\n    MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDKVBkCWNb9eHVF\n    twAA5mdAyvXFix3WavdrsoYRkvtCl8ogDBQf8f6N0bRkDF1zcVHRrNAEyozXDtuD\n    kFgSiivBFREI7fiS3sOvduq6FaGXzX0IY6oaVMu8oOPgDvC0yvoohR+0Qxq2d6lP\n    SPyHeKQaxP4KxzCJJzB1XAcbd2eFzUUDv25mNlwdVkmW8FI/sAxnJLgPTW78dzfX\n    Ddfk+nxdIqxVKSLATnL0kMN7aGJx24UozioAIpzvvvF5/+7HTd1gi6NeCqrAYr3g\n    iP364AE26CFwFvHnafO9uNQhlQ+uiNnOoInXByfFGVP+RidSpfLzaxDjs6RDwpol\n    h098btONAgMBAAECggEAAVhHM2OD5IkUtuowwcKNaCTKGmrClRE3gMuzJeBsSJEy\n    uAReUFILZylcnhegDytSti2vDA9T7xqtO6CU0p3V8LpU89JMOPRb/deirI4UXSpx\n    xbNyjirOO6bnrNlOWfKexdQQsikYPzF2iM1Scpr1u9ZDCHZOl1ZYSrkve5My4coP\n    3Gx6tTBqL0jQBfcpf4ES8BH3JSawR/MgqzDS74+bI2VH+kvuPAC1L4fBgaV3VUv0\n    nFzim5A3s5VaXPgJbEIghP9BkYGFkeT9ma3nliEZWc96AzsmowFn1ayCvrNVPo9R\n    ECD2NnttBiCJZt3H93sR9+OTeA8Bls+aZGlKd5mLAQKBgQDpf8nIYUm/Zmls7/lQ\n    QBUSGHEYrbjNsEejQsPgNDtg2EVSxdUkvTn7Wb+HExTk09Z5bNvhaO2532/FH9y8\n    ahSXafiMXpfR2olwXdOB9yXXl4F5C0LGnmzGim4OSeWzAX0JCL470KaS0QN3EmoG\n    9F0YCfMnZXNTweSSx4xvlO6ggQKBgQDd01uIolm7z1DIWCwNERAXP2GDwcvxyzYK\n    YqJfKDeHt2t6yIzZMMotnPDy+OlcdGspIIHkB5a+SZN5Nt7DUKg/MnyOZ3KbVq41\n    k7dR4Ka3LRnGkesy7lSr7ef1rfquyR75OXJQcPWvkFcLu0TMiQhvptatZ8VN+F4n\n    fDQELRotDQKBgQCgN+AUT7VT0QjcCBnRV/ddUEoiPenFsYSmYMSYzh5ESIHg1wB2\n    0iS79Iw4Of6nOTg8X1bM57vfQ5Kk90T2P+/bKYqzfqC8DTErWiYsUpKzyTC9Bt4N\n    /Vz0Kr5zrX8ggg/yp/4oevYhXav8AzWfigNq4EDpMnKc8TlPAf+5/L50gQKBgQC2\n    mLPhPhr1gUszD3l7bA89w7uGlLFHoQoj9FtKTzWervp3QLzIT+QtNeIVb5XQuDg5\n    y3uAdEq+6pvNjMBEMJG+K9Xh9v+dJPYUPjsJ2A4D/MkZ7qWX8B2cxSJK1uLim8W2\n    S3ZxBvsGgJ9WldmlMCvUlJZkeWYtr4P5psC+q02/xQKBgQCDII/jcV2+lRM2iNTe\n    vBijZSaNMEWOK/Y+/HFK8GYKXnB+xNWhrm8rKgWGzpDJAUPMh9Tt+leW9LKEBuzF\n    Y1bGblmGm1zsPWpIx05Fdtv9eOJmFnXbGzIsYyhadZnPcQOWhqxtpVxSuul0Jc7Q\n    XNq4qPaPXhbQAshgtyBt75DMkw==\n    -----END PRIVATE KEY-----`\n    \n        const pubKey = `-----BEGIN PUBLIC KEY-----\n    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylQZAljW/Xh1RbcAAOZn\n    QMr1xYsd1mr3a7KGEZL7QpfKIAwUH/H+jdG0ZAxdc3FR0azQBMqM1w7bg5BYEoor\n    wRURCO34kt7Dr3bquhWhl819CGOqGlTLvKDj4A7wtMr6KIUftEMatnepT0j8h3ik\n    GsT+CscwiScwdVwHG3dnhc1FA79uZjZcHVZJlvBSP7AMZyS4D01u/Hc31w3X5Pp8\n    XSKsVSkiwE5y9JDDe2hicduFKM4qACKc777xef/ux03dYIujXgqqwGK94Ij9+uAB\n    NughcBbx52nzvbjUIZUProjZzqCJ1wcnxRlT/kYnUqXy82sQ47OkQ8KaJYdPfG7T\n    jQIDAQAB\n    -----END PUBLIC KEY-----`\n\n    const algorithm: RsaHashedKeyGenParams = {\n      name: \"RSA-OAEP\",\n      modulusLength: 2048,\n      publicExponent: new Uint8Array([1, 0, 1]),\n      hash: \"SHA-256\"\n    };\n\n    // ENCRYPT\n    this.pemToCryptoKey(\n      pubKey,\n      algorithm,\n      true,\n      [\"encrypt\"],\n      \"spki\"\n    ).subscribe((keyPublic) => {\n\n      // console.log(\"PUBLIC KEY: \", keyPublic)\n\n      this.encryptData(keyPublic, \"Sample Data here - Mike Bonifacio\")\n      .subscribe((str) => {\n        console.log(\"ENCRYPTED STRING: \", str);\n        testSequence.next('encrypted string success');\n      })\n\n    })\n\n    const enc = \"r7UOuEGBZ6jbVTOIBuv9jFOEtRiedmS27hfW40k7XKCTsQ5VhWup0qu2BA2ANZaGKii/uehJ/RSPiyfGbJ6leJrat0mA1hPqH/XodaBzLMDigvdYM1NSXFZMDa40OpLUIXbPlAvybjcGu7Bal+LMA8htHrFu/OmM/fHI66xOzzpuXSYx0OkWjtY81rUQ1FFkvrkx2jGFPZ0p+Nw/v3Q4cJnet6V63vCueFlD749VMcVXo7pvz4AIPpB+IOy3kbxaYTPakLVioJERU6GFMXWkECuRvohhS9CETcORZtRVRkvhcHk3lxgIhfqojUKYgD6K5dDELDPsWIS+iTG1XIQIlg==\";\n\n    // DECRYPTION\n    this.pemToCryptoKey(\n      privateKey,\n      algorithm,\n      false,\n      [\"decrypt\"],\n      \"pkcs8\"\n    ).subscribe((key) => {\n\n      // console.log(\"DECRYPT ===\", key)\n\n      this.decryptData(key, enc)\n      .pipe(\n        catchError(err => {\n          console.log(\"ERROR: \", err);\n          return EMPTY\n        })\n      ).subscribe((str) => {\n        console.log(\"DECRYPTED STRING: \", str);\n        testSequence.next('decrypted string success');\n      })\n\n    })\n\n    return testSequence$;\n  };\n}\n"]}

package/esm2022/lib/services/utils/encryption/encryption-test.service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EncryptionTestService {
+    constructor() { }
+    isBase64(str) {
+        const base64Pattern = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i;
+        return base64Pattern.test(str);
+    }
+    isHexadecimal(str) {
+        const hexPattern = /^[0-9a-fA-F]+$/;
+        return hexPattern.test(str) && (str.length % 2 === 0);
+    }
+    hasHighEntropy(str) {
+        const uniqueChars = new Set(str).size;
+        return uniqueChars > str.length * 0.6;
+    }
+    isEncrypted(str) {
+        if (typeof str !== 'string') {
+            return false;
+        }
+        if (this.isBase64(str) || this.isHexadecimal(str)) {
+            return true;
+        }
+        return this.hasHighEntropy(str);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EncryptionTestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EncryptionTestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EncryptionTestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils/encryption/index.mjs

@@ -0,0 +1,4 @@
+export * from "./asymmetrical-encryption.service";
+export * from './symmetrical-encryption.service';
+export * from './random';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvbGliL3NlcnZpY2VzL3V0aWxzL2VuY3J5cHRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGtDQUFrQyxDQUFDO0FBRWpELGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXN5bW1ldHJpY2FsLWVuY3J5cHRpb24uc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSAnLi9zeW1tZXRyaWNhbC1lbmNyeXB0aW9uLnNlcnZpY2UnO1xuXG5leHBvcnQgKiBmcm9tICcuL3JhbmRvbSc7XG5cbiJdfQ==

package/esm2022/lib/services/utils/encryption/random.mjs

@@ -0,0 +1,52 @@
+export const Random = () => {
+    const typedArray = new Uint8Array(1);
+    const randomValue = crypto.getRandomValues(typedArray)[0];
+    const randomFloat = randomValue / Math.pow(2, 8);
+    return randomFloat;
+};
+export const RandomNumber = (min, max) => {
+    return Math.floor(Random() * max) + min;
+};
+export const RandomNumbers = (min, max, length) => {
+    const numbers = [];
+    for (let i = 0; i < length; i++)
+        numbers.push(Math.floor(Random() * max) + min);
+    return numbers;
+};
+export const RandomNumbersUnique = (min, max, length) => {
+    let count = 0;
+    // Adjust the length if it exceeds the number of unique numbers possible in the range
+    if (length > (max - min + 1)) {
+        console.error('error encountered');
+        length = max - min + 1;
+    }
+    console.log('length', length);
+    const numbers = [];
+    const maxAttempts = length * 100; // Safeguard to prevent infinite loops
+    while (numbers.length < length && count < maxAttempts) {
+        const num = Math.floor(Random() * max) + min;
+        if (!numbers.includes(num)) {
+            numbers.push(num);
+        }
+    }
+    if (count >= maxAttempts) {
+        throw new Error('Maximum attempts exceeded while generating unique numbers');
+    }
+    return numbers;
+};
+export const RandomStr = () => {
+    const typedArray = new Uint8Array(8);
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0].toString(36);
+};
+export const RandomSignature = () => {
+    const typedArray = new Uint8Array(8);
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0];
+};
+export const UUID = () => {
+    return self.crypto.randomUUID();
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils/encryption/symmetrical-encryption.service.mjs

@@ -0,0 +1,77 @@
+import { Injectable, inject } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import { RandomSignature } from './random';
+import { AppService } from '../app.service';
+import * as i0 from "@angular/core";
+export class SymmetricalEncryptionService {
+    constructor() {
+        this.appService = inject(AppService);
+        // TODO: The APP ID is not a string, it is a function
+        this.appID = (this.appService.appID) ? this.appService.appID : '';
+        if (this.appID === '')
+            console.warn('No App Key has been define');
+    }
+    generateCipherKey() {
+        return (RandomSignature().toString() + RandomSignature().toString()).substring(0, 8);
+    }
+    encrypt(str, key = this.appID) {
+        if (!str || key === '')
+            return '';
+        let _key = CryptoJS.enc.Utf8.parse(key);
+        let _iv = CryptoJS.enc.Utf8.parse(key);
+        try {
+            const encrypted = CryptoJS.AES.encrypt(JSON.stringify(str), _key, {
+                keySize: 16,
+                iv: _iv,
+                mode: CryptoJS.mode.ECB,
+                padding: CryptoJS.pad.Pkcs7
+            });
+            return encrypted.toString();
+        }
+        catch (error) {
+            console.log(error);
+        }
+        return;
+    }
+    decrypt(str, key = this.appID) {
+        if (!str || key === '')
+            return;
+        let _key = CryptoJS.enc.Utf8.parse(key);
+        let _iv = CryptoJS.enc.Utf8.parse(key);
+        try {
+            return CryptoJS.AES.decrypt(str, _key, {
+                keySize: 16,
+                iv: _iv,
+                mode: CryptoJS.mode.ECB,
+                padding: CryptoJS.pad.Pkcs7
+            }).toString(CryptoJS.enc.Utf8);
+        }
+        catch (error) {
+            console.log(error);
+        }
+        return;
+    }
+    createSignature(url, len = 16) {
+        const sig = CryptoJS.SHA256(url).toString(CryptoJS.enc.Hex);
+        return sig.substring(0, len).toUpperCase();
+    }
+    normalizeURL(url) {
+        const normalizedURL = url.replace(/(https?:\/\/)?(www\.)?/, '').replace(/\/+$/, '');
+        return normalizedURL;
+    }
+    generateSignature(url) {
+        const normalizedURL = this.normalizeURL(url);
+        const hash = CryptoJS.SHA256(normalizedURL);
+        const signature = hash.toString(CryptoJS.enc.Hex);
+        return signature;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SymmetricalEncryptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SymmetricalEncryptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SymmetricalEncryptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ltbWV0cmljYWwtZW5jcnlwdGlvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaHR0cC1yZXF1ZXN0LW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy91dGlscy9lbmNyeXB0aW9uL3N5bW1ldHJpY2FsLWVuY3J5cHRpb24uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEtBQUssUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUV0QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7QUFLNUMsTUFBTSxPQUFPLDRCQUE0QjtJQU12QztRQUZRLGVBQVUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUE7UUFHckMscURBQXFEO1FBQ3JELElBQUksQ0FBQyxLQUFLLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFBO1FBQ2pFLElBQUcsSUFBSSxDQUFDLEtBQUssS0FBSyxFQUFFO1lBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyw0QkFBNEIsQ0FBQyxDQUFBO0lBQ2xFLENBQUM7SUFFRCxpQkFBaUI7UUFDZixPQUFPLENBQUMsZUFBZSxFQUFFLENBQUMsUUFBUSxFQUFFLEdBQUcsZUFBZSxFQUFFLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFBO0lBQ3RGLENBQUM7SUFFRCxPQUFPLENBQUMsR0FBUSxFQUFFLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSztRQUVoQyxJQUFHLENBQUMsR0FBRyxJQUFJLEdBQUcsS0FBSyxFQUFFO1lBQUUsT0FBTyxFQUFFLENBQUE7UUFFaEMsSUFBSSxJQUFJLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQ3ZDLElBQUksR0FBRyxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUV0QyxJQUFJLENBQUM7WUFFTCxNQUFNLFNBQVMsR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FDcEMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsRUFBRSxJQUFJLEVBQUU7Z0JBQ3pCLE9BQU8sRUFBRSxFQUFFO2dCQUNYLEVBQUUsRUFBRSxHQUFHO2dCQUNQLElBQUksRUFBRSxRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUc7Z0JBQ3ZCLE9BQU8sRUFBRSxRQUFRLENBQUMsR0FBRyxDQUFDLEtBQUs7YUFDNUIsQ0FBQyxDQUFDO1lBRUgsT0FBTyxTQUFTLENBQUMsUUFBUSxFQUFFLENBQUE7UUFFN0IsQ0FBQztRQUFDLE9BQU0sS0FBVSxFQUFFLENBQUM7WUFDbkIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQTtRQUNwQixDQUFDO1FBRUQsT0FBTTtJQUNSLENBQUM7SUFFRCxPQUFPLENBQUMsR0FBVyxFQUFFLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSztRQUVuQyxJQUFHLENBQUMsR0FBRyxJQUFJLEdBQUcsS0FBSyxFQUFFO1lBQUUsT0FBTTtRQUU3QixJQUFJLElBQUksR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDdkMsSUFBSSxHQUFHLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBRXRDLElBQUksQ0FBQztZQUVMLE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQ3pCLEdBQUcsRUFBRSxJQUFJLEVBQUU7Z0JBQ1QsT0FBTyxFQUFFLEVBQUU7Z0JBQ1gsRUFBRSxFQUFFLEdBQUc7Z0JBQ1AsSUFBSSxFQUFFLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRztnQkFDdkIsT0FBTyxFQUFFLFFBQVEsQ0FBQyxHQUFHLENBQUMsS0FBSzthQUM1QixDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFakMsQ0FBQztRQUFDLE9BQU0sS0FBVSxFQUFFLENBQUM7WUFDbkIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQTtRQUNwQixDQUFDO1FBRUQsT0FBTTtJQUNSLENBQUM7SUFFRCxlQUFlLENBQUMsR0FBVyxFQUFFLEdBQUcsR0FBRyxFQUFFO1FBQ25DLE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDM0QsT0FBTyxHQUFHLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQTtJQUM1QyxDQUFDO0lBRUQsWUFBWSxDQUFDLEdBQVc7UUFDdEIsTUFBTSxhQUFhLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQyx3QkFBd0IsRUFBRSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3BGLE9BQU8sYUFBYSxDQUFDO0lBQ3ZCLENBQUM7SUFFRCxpQkFBaUIsQ0FBQyxHQUFXO1FBQzNCLE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDNUMsTUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQTtRQUMzQyxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDakQsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQzsrR0FqRlUsNEJBQTRCO21IQUE1Qiw0QkFBNEIsY0FGM0IsTUFBTTs7NEZBRVAsNEJBQTRCO2tCQUh4QyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0ICogYXMgQ3J5cHRvSlMgZnJvbSAnY3J5cHRvLWpzJztcblxuaW1wb3J0IHsgUmFuZG9tU2lnbmF0dXJlIH0gZnJvbSAnLi9yYW5kb20nO1xuaW1wb3J0IHsgQXBwU2VydmljZSB9IGZyb20gJy4uL2FwcC5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgU3ltbWV0cmljYWxFbmNyeXB0aW9uU2VydmljZSB7XG5cbiAgYXBwSUQ6IHN0cmluZzsgLy8gQVBQIFNFUlZJQ0UgVE8gTUFOQUdFUiBFTkNSWVBUSU9OIEtFWVxuXG4gIHByaXZhdGUgYXBwU2VydmljZSA9IGluamVjdChBcHBTZXJ2aWNlKVxuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIC8vIFRPRE86IFRoZSBBUFAgSUQgaXMgbm90IGEgc3RyaW5nLCBpdCBpcyBhIGZ1bmN0aW9uXG4gICAgdGhpcy5hcHBJRCA9ICh0aGlzLmFwcFNlcnZpY2UuYXBwSUQpID8gdGhpcy5hcHBTZXJ2aWNlLmFwcElEIDogJydcbiAgICBpZih0aGlzLmFwcElEID09PSAnJykgY29uc29sZS53YXJuKCdObyBBcHAgS2V5IGhhcyBiZWVuIGRlZmluZScpXG4gIH1cblxuICBnZW5lcmF0ZUNpcGhlcktleSgpIHtcbiAgICByZXR1cm4gKFJhbmRvbVNpZ25hdHVyZSgpLnRvU3RyaW5nKCkgKyBSYW5kb21TaWduYXR1cmUoKS50b1N0cmluZygpKS5zdWJzdHJpbmcoMCwgOClcbiAgfVxuXG4gIGVuY3J5cHQoc3RyOiBhbnksIGtleSA9IHRoaXMuYXBwSUQpIHtcblxuICAgIGlmKCFzdHIgfHwga2V5ID09PSAnJykgcmV0dXJuICcnXG5cbiAgICBsZXQgX2tleSA9IENyeXB0b0pTLmVuYy5VdGY4LnBhcnNlKGtleSlcbiAgICBsZXQgX2l2ID0gQ3J5cHRvSlMuZW5jLlV0ZjgucGFyc2Uoa2V5KVxuXG4gICAgdHJ5IHtcblxuICAgIGNvbnN0IGVuY3J5cHRlZCA9IENyeXB0b0pTLkFFUy5lbmNyeXB0KFxuICAgICAgSlNPTi5zdHJpbmdpZnkoc3RyKSwgX2tleSwge1xuICAgICAgICBrZXlTaXplOiAxNixcbiAgICAgICAgaXY6IF9pdixcbiAgICAgICAgbW9kZTogQ3J5cHRvSlMubW9kZS5FQ0IsXG4gICAgICAgIHBhZGRpbmc6IENyeXB0b0pTLnBhZC5Qa2NzN1xuICAgICAgfSk7XG5cbiAgICAgIHJldHVybiBlbmNyeXB0ZWQudG9TdHJpbmcoKVxuXG4gICAgfSBjYXRjaChlcnJvcjogYW55KSB7XG4gICAgICBjb25zb2xlLmxvZyhlcnJvcilcbiAgICB9XG5cbiAgICByZXR1cm5cbiAgfVxuXG4gIGRlY3J5cHQoc3RyOiBzdHJpbmcsIGtleSA9IHRoaXMuYXBwSUQpIHtcblxuICAgIGlmKCFzdHIgfHwga2V5ID09PSAnJykgcmV0dXJuXG5cbiAgICBsZXQgX2tleSA9IENyeXB0b0pTLmVuYy5VdGY4LnBhcnNlKGtleSlcbiAgICBsZXQgX2l2ID0gQ3J5cHRvSlMuZW5jLlV0ZjgucGFyc2Uoa2V5KVxuXG4gICAgdHJ5IHtcblxuICAgIHJldHVybiBDcnlwdG9KUy5BRVMuZGVjcnlwdChcbiAgICAgIHN0ciwgX2tleSwge1xuICAgICAgICBrZXlTaXplOiAxNixcbiAgICAgICAgaXY6IF9pdixcbiAgICAgICAgbW9kZTogQ3J5cHRvSlMubW9kZS5FQ0IsXG4gICAgICAgIHBhZGRpbmc6IENyeXB0b0pTLnBhZC5Qa2NzN1xuICAgICAgfSkudG9TdHJpbmcoQ3J5cHRvSlMuZW5jLlV0ZjgpO1xuXG4gICAgfSBjYXRjaChlcnJvcjogYW55KSB7XG4gICAgICBjb25zb2xlLmxvZyhlcnJvcilcbiAgICB9XG5cbiAgICByZXR1cm5cbiAgfVxuXG4gIGNyZWF0ZVNpZ25hdHVyZSh1cmw6IHN0cmluZywgbGVuID0gMTYpIHtcbiAgICBjb25zdCBzaWcgPSBDcnlwdG9KUy5TSEEyNTYodXJsKS50b1N0cmluZyhDcnlwdG9KUy5lbmMuSGV4KVxuICAgIHJldHVybiBzaWcuc3Vic3RyaW5nKDAsIGxlbikudG9VcHBlckNhc2UoKVxuICB9XG5cbiAgbm9ybWFsaXplVVJMKHVybDogc3RyaW5nKSB7XG4gICAgY29uc3Qgbm9ybWFsaXplZFVSTCA9IHVybC5yZXBsYWNlKC8oaHR0cHM/OlxcL1xcLyk/KHd3d1xcLik/LywgJycpLnJlcGxhY2UoL1xcLyskLywgJycpO1xuICAgIHJldHVybiBub3JtYWxpemVkVVJMO1xuICB9XG5cbiAgZ2VuZXJhdGVTaWduYXR1cmUodXJsOiBzdHJpbmcpIHtcbiAgICBjb25zdCBub3JtYWxpemVkVVJMID0gdGhpcy5ub3JtYWxpemVVUkwodXJsKVxuICAgIGNvbnN0IGhhc2ggPSBDcnlwdG9KUy5TSEEyNTYobm9ybWFsaXplZFVSTClcbiAgICBjb25zdCBzaWduYXR1cmUgPSBoYXNoLnRvU3RyaW5nKENyeXB0b0pTLmVuYy5IZXgpXG4gICAgcmV0dXJuIHNpZ25hdHVyZTtcbiAgfVxuXG59XG4iXX0=

package/esm2022/lib/services/utils/headers.service.mjs

@@ -0,0 +1,21 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HeadersService {
+    constructor() {
+        this.headers = {};
+    }
+    generateHeaders(headers) {
+        const allHeaders = headers ? { ...this.headers, ...headers } : {};
+        return { headers: new HttpHeaders(allHeaders) };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HeadersService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HeadersService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HeadersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVycy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaHR0cC1yZXF1ZXN0LW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy91dGlscy9oZWFkZXJzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxjQUFjO0lBSDNCO1FBS0UsWUFBTyxHQUFHLEVBQUUsQ0FBQTtLQVNiO0lBUEMsZUFBZSxDQUFDLE9BQWdDO1FBRTlDLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsR0FBRyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFBO1FBQ2pFLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxXQUFXLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQTtJQUVqRCxDQUFDOytHQVRVLGNBQWM7bUhBQWQsY0FBYyxjQUZiLE1BQU07OzRGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cEhlYWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIEhlYWRlcnNTZXJ2aWNlIHtcblxuICBoZWFkZXJzID0ge31cblxuICBnZW5lcmF0ZUhlYWRlcnMoaGVhZGVycz86IFJlY29yZDxzdHJpbmcsIHN0cmluZz4pOiB7IGhlYWRlcnM6IEh0dHBIZWFkZXJzIH0ge1xuXG4gICAgY29uc3QgYWxsSGVhZGVycyA9IGhlYWRlcnMgPyB7IC4uLnRoaXMuaGVhZGVycywgLi4uaGVhZGVycyB9IDoge31cbiAgICByZXR1cm4geyBoZWFkZXJzOiBuZXcgSHR0cEhlYWRlcnMoYWxsSGVhZGVycykgfVxuXG4gIH1cblxufVxuIl19

package/esm2022/lib/services/utils/index.mjs

@@ -0,0 +1,6 @@
+export * from './app.service';
+export * from './headers.service';
+export * from './path-query.service';
+export * from './utils.service';
+export * from './encryption/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvbGliL3NlcnZpY2VzL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlCQUFpQixDQUFDO0FBRWhDLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FwcC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaGVhZGVycy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGF0aC1xdWVyeS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMuc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdGlvbi9pbmRleCc7XG5cbiJdfQ==

package/esm2022/lib/services/utils/object-merger.service.mjs

@@ -0,0 +1,50 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { ApiRequest } from '../request-manager-state-service/models';
+import { SettingOptions } from '../local-storage-manager-service';
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ConfigHTTPOptions, ConfigOptions, LocalStorageOptions } from '../request-manager-services';
+import * as i0 from "@angular/core";
+import * as i1 from "../request-manager-services";
+export class ObjectMergerService {
+    constructor(configOptions) {
+        this.configOptions = configOptions;
+        if (!this.configOptions)
+            this.configOptions = ConfigOptions.adapt();
+    }
+    mergeOptions(options = ApiRequest.adapt()) {
+        const configForRoot = (this.configOptions?.httpRequestOptions) ? this.configOptions.httpRequestOptions : ConfigHTTPOptions.adapt();
+        const mergedOptions = ApiRequest.adapt(options);
+        mergedOptions.server = (options && options.server === '') ? configForRoot?.server || '' : options.server;
+        mergedOptions.path = [...options.path || [], ...configForRoot?.path || []];
+        mergedOptions.headers = { ...options.headers || {}, ...configForRoot?.headers || {} };
+        mergedOptions.retry = (options && (options?.retry?.times !== 0 || options?.retry?.delay !== 3)) ? options.retry : configForRoot?.retry || { times: 0, delay: 3 };
+        mergedOptions.polling = (options && options?.polling !== 0) ? options.polling : configForRoot?.polling || 0;
+        mergedOptions.displayError = (options && options?.displayError) ? options.displayError : configForRoot?.displayError || false;
+        mergedOptions.stream = (options && options?.stream) ? options.stream : configForRoot?.stream || false;
+        return mergedOptions;
+    }
+    mergeStorageOptions(options = SettingOptions.adapt()) {
+        const configForRoot = (this.configOptions?.LocalStorageOptions) ? this.configOptions.LocalStorageOptions : LocalStorageOptions.adapt();
+        const configForRootOptions = configForRoot.options || LocalStorageOptions.adapt().options;
+        const mergedOptions = SettingOptions.adapt(options);
+        mergedOptions.storage = (options && options.storage === 0) ? configForRootOptions?.storage || 0 : options.storage;
+        mergedOptions.expires = (options && options.expires === 0) ? configForRootOptions?.expires || 0 : options.expires;
+        mergedOptions.expiresIn = (options && options.expiresIn === '') ? configForRootOptions?.expiresIn || '' : options.expiresIn;
+        mergedOptions.encrypted = (options && !options.encrypted) ? configForRootOptions?.encrypted || false : options.encrypted;
+        return mergedOptions;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectMergerService, deps: [{ token: CONFIG_SETTINGS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectMergerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectMergerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ConfigOptions, decorators: [{
+                    type: Inject,
+                    args: [CONFIG_SETTINGS_TOKEN]
+                }, {
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LW1lcmdlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaHR0cC1yZXF1ZXN0LW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy91dGlscy9vYmplY3QtbWVyZ2VyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTdELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFbEUsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDeEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGFBQWEsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDOzs7QUFLcEcsTUFBTSxPQUFPLG1CQUFtQjtJQUU5QixZQUErRCxhQUE2QjtRQUE3QixrQkFBYSxHQUFiLGFBQWEsQ0FBZ0I7UUFDeEYsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhO1lBQUUsSUFBSSxDQUFDLGFBQWEsR0FBRyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDdEUsQ0FBQztJQUVGLFlBQVksQ0FBQyxPQUFPLEdBQUcsVUFBVSxDQUFDLEtBQUssRUFBRTtRQUV2QyxNQUFNLGFBQWEsR0FBRyxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDLENBQUMsaUJBQWlCLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDbEksTUFBTSxhQUFhLEdBQUcsVUFBVSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUUvQyxhQUFhLENBQUMsTUFBTSxHQUFHLENBQUMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLGFBQWEsRUFBRSxNQUFNLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFBO1FBRXhHLGFBQWEsQ0FBQyxJQUFJLEdBQUcsQ0FBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLElBQUksRUFBRSxFQUFFLEdBQUcsYUFBYSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUUsQ0FBQTtRQUU1RSxhQUFhLENBQUMsT0FBTyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxJQUFJLEVBQUUsRUFBRSxHQUFHLGFBQWEsRUFBRSxPQUFPLElBQUksRUFBRSxFQUFFLENBQUE7UUFFckYsYUFBYSxDQUFDLEtBQUssR0FBRyxDQUFDLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFBRSxLQUFLLEVBQUUsS0FBSyxLQUFLLENBQUMsSUFBSSxPQUFPLEVBQUUsS0FBSyxFQUFFLEtBQUssS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxhQUFhLEVBQUUsS0FBSyxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLENBQUM7UUFFakssYUFBYSxDQUFDLE9BQU8sR0FBRyxDQUFDLE9BQU8sSUFBSSxPQUFPLEVBQUUsT0FBTyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxhQUFhLEVBQUUsT0FBTyxJQUFJLENBQUMsQ0FBQztRQUU1RyxhQUFhLENBQUMsWUFBWSxHQUFHLENBQUMsT0FBTyxJQUFJLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsYUFBYSxFQUFFLFlBQVksSUFBSSxLQUFLLENBQUM7UUFFOUgsYUFBYSxDQUFDLE1BQU0sR0FBRyxDQUFDLE9BQU8sSUFBSSxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGFBQWEsRUFBRSxNQUFNLElBQUksS0FBSyxDQUFDO1FBRXRHLE9BQU8sYUFBYSxDQUFDO0lBRXZCLENBQUM7SUFFRCxtQkFBbUIsQ0FBQyxPQUFPLEdBQUcsY0FBYyxDQUFDLEtBQUssRUFBRTtRQUVsRCxNQUFNLGFBQWEsR0FBRyxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLENBQUMsbUJBQW1CLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDdEksTUFBTSxvQkFBb0IsR0FBRyxhQUFhLENBQUMsT0FBTyxJQUFJLG1CQUFtQixDQUFDLEtBQUssRUFBRSxDQUFDLE9BQU8sQ0FBQTtRQUV6RixNQUFNLGFBQWEsR0FBRyxjQUFjLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFBO1FBRW5ELGFBQWEsQ0FBQyxPQUFPLEdBQUcsQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsb0JBQW9CLEVBQUUsT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQTtRQUVqSCxhQUFhLENBQUMsT0FBTyxHQUFHLENBQUMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxPQUFPLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLG9CQUFvQixFQUFFLE9BQU8sSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUE7UUFFakgsYUFBYSxDQUFDLFNBQVMsR0FBRyxDQUFDLE9BQU8sSUFBSSxPQUFPLENBQUMsU0FBUyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxvQkFBb0IsRUFBRSxTQUFTLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFBO1FBRTNILGFBQWEsQ0FBQyxTQUFTLEdBQUcsQ0FBQyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLG9CQUFvQixFQUFFLFNBQVMsSUFBSSxLQUFLLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUE7UUFFeEgsT0FBTyxhQUFhLENBQUM7SUFFdkIsQ0FBQzsrR0E5Q1UsbUJBQW1CLGtCQUVWLHFCQUFxQjttSEFGOUIsbUJBQW1CLGNBRmxCLE1BQU07OzRGQUVQLG1CQUFtQjtrQkFIL0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OzBCQUdjLE1BQU07MkJBQUMscUJBQXFCOzswQkFBRyxRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0LCBJbmplY3RhYmxlLCBPcHRpb25hbCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBBcGlSZXF1ZXN0IH0gZnJvbSAnLi4vcmVxdWVzdC1tYW5hZ2VyLXN0YXRlLXNlcnZpY2UvbW9kZWxzJztcbmltcG9ydCB7IFNldHRpbmdPcHRpb25zIH0gZnJvbSAnLi4vbG9jYWwtc3RvcmFnZS1tYW5hZ2VyLXNlcnZpY2UnO1xuXG5pbXBvcnQgeyBDT05GSUdfU0VUVElOR1NfVE9LRU4gfSBmcm9tICcuLi8uLi9tb2RlbHMvY29uZmlnLXRva2VuLm1vZGVsJztcbmltcG9ydCB7IENvbmZpZ0hUVFBPcHRpb25zLCBDb25maWdPcHRpb25zLCBMb2NhbFN0b3JhZ2VPcHRpb25zIH0gZnJvbSAnLi4vcmVxdWVzdC1tYW5hZ2VyLXNlcnZpY2VzJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgT2JqZWN0TWVyZ2VyU2VydmljZSB7XG5cbiAgY29uc3RydWN0b3IoQEluamVjdChDT05GSUdfU0VUVElOR1NfVE9LRU4pIEBPcHRpb25hbCgpIHByaXZhdGUgY29uZmlnT3B0aW9ucz86IENvbmZpZ09wdGlvbnMpIHtcbiAgICAgIGlmICghdGhpcy5jb25maWdPcHRpb25zKSB0aGlzLmNvbmZpZ09wdGlvbnMgPSBDb25maWdPcHRpb25zLmFkYXB0KClcbiAgIH1cblxuICBtZXJnZU9wdGlvbnMob3B0aW9ucyA9IEFwaVJlcXVlc3QuYWRhcHQoKSkge1xuXG4gICAgY29uc3QgY29uZmlnRm9yUm9vdCA9ICh0aGlzLmNvbmZpZ09wdGlvbnM/Lmh0dHBSZXF1ZXN0T3B0aW9ucykgPyB0aGlzLmNvbmZpZ09wdGlvbnMuaHR0cFJlcXVlc3RPcHRpb25zIDogQ29uZmlnSFRUUE9wdGlvbnMuYWRhcHQoKVxuICAgIGNvbnN0IG1lcmdlZE9wdGlvbnMgPSBBcGlSZXF1ZXN0LmFkYXB0KG9wdGlvbnMpXG5cbiAgICBtZXJnZWRPcHRpb25zLnNlcnZlciA9IChvcHRpb25zICYmIG9wdGlvbnMuc2VydmVyID09PSAnJykgPyBjb25maWdGb3JSb290Py5zZXJ2ZXIgfHwgJycgOiBvcHRpb25zLnNlcnZlclxuXG4gICAgbWVyZ2VkT3B0aW9ucy5wYXRoID0gWyAuLi5vcHRpb25zLnBhdGggfHwgW10sIC4uLmNvbmZpZ0ZvclJvb3Q/LnBhdGggfHwgW10gXVxuXG4gICAgbWVyZ2VkT3B0aW9ucy5oZWFkZXJzID0geyAuLi5vcHRpb25zLmhlYWRlcnMgfHwge30sIC4uLmNvbmZpZ0ZvclJvb3Q/LmhlYWRlcnMgfHwge30gfVxuXG4gICAgbWVyZ2VkT3B0aW9ucy5yZXRyeSA9IChvcHRpb25zICYmIChvcHRpb25zPy5yZXRyeT8udGltZXMgIT09IDAgfHwgb3B0aW9ucz8ucmV0cnk/LmRlbGF5ICE9PSAzKSkgPyBvcHRpb25zLnJldHJ5IDogY29uZmlnRm9yUm9vdD8ucmV0cnkgfHwgeyB0aW1lczogMCwgZGVsYXk6IDMgfTtcblxuICAgIG1lcmdlZE9wdGlvbnMucG9sbGluZyA9IChvcHRpb25zICYmIG9wdGlvbnM/LnBvbGxpbmcgIT09IDApID8gb3B0aW9ucy5wb2xsaW5nIDogY29uZmlnRm9yUm9vdD8ucG9sbGluZyB8fCAwO1xuXG4gICAgbWVyZ2VkT3B0aW9ucy5kaXNwbGF5RXJyb3IgPSAob3B0aW9ucyAmJiBvcHRpb25zPy5kaXNwbGF5RXJyb3IpID8gb3B0aW9ucy5kaXNwbGF5RXJyb3IgOiBjb25maWdGb3JSb290Py5kaXNwbGF5RXJyb3IgfHwgZmFsc2U7XG5cbiAgICBtZXJnZWRPcHRpb25zLnN0cmVhbSA9IChvcHRpb25zICYmIG9wdGlvbnM/LnN0cmVhbSkgPyBvcHRpb25zLnN0cmVhbSA6IGNvbmZpZ0ZvclJvb3Q/LnN0cmVhbSB8fCBmYWxzZTtcblxuICAgIHJldHVybiBtZXJnZWRPcHRpb25zO1xuXG4gIH1cblxuICBtZXJnZVN0b3JhZ2VPcHRpb25zKG9wdGlvbnMgPSBTZXR0aW5nT3B0aW9ucy5hZGFwdCgpKSB7XG5cbiAgICBjb25zdCBjb25maWdGb3JSb290ID0gKHRoaXMuY29uZmlnT3B0aW9ucz8uTG9jYWxTdG9yYWdlT3B0aW9ucykgPyB0aGlzLmNvbmZpZ09wdGlvbnMuTG9jYWxTdG9yYWdlT3B0aW9ucyA6IExvY2FsU3RvcmFnZU9wdGlvbnMuYWRhcHQoKVxuICAgIGNvbnN0IGNvbmZpZ0ZvclJvb3RPcHRpb25zID0gY29uZmlnRm9yUm9vdC5vcHRpb25zIHx8IExvY2FsU3RvcmFnZU9wdGlvbnMuYWRhcHQoKS5vcHRpb25zXG5cbiAgICBjb25zdCBtZXJnZWRPcHRpb25zID0gU2V0dGluZ09wdGlvbnMuYWRhcHQob3B0aW9ucylcblxuICAgIG1lcmdlZE9wdGlvbnMuc3RvcmFnZSA9IChvcHRpb25zICYmIG9wdGlvbnMuc3RvcmFnZSA9PT0gMCkgPyBjb25maWdGb3JSb290T3B0aW9ucz8uc3RvcmFnZSB8fCAwIDogb3B0aW9ucy5zdG9yYWdlXG5cbiAgICBtZXJnZWRPcHRpb25zLmV4cGlyZXMgPSAob3B0aW9ucyAmJiBvcHRpb25zLmV4cGlyZXMgPT09IDApID8gY29uZmlnRm9yUm9vdE9wdGlvbnM/LmV4cGlyZXMgfHwgMCA6IG9wdGlvbnMuZXhwaXJlc1xuXG4gICAgbWVyZ2VkT3B0aW9ucy5leHBpcmVzSW4gPSAob3B0aW9ucyAmJiBvcHRpb25zLmV4cGlyZXNJbiA9PT0gJycpID8gY29uZmlnRm9yUm9vdE9wdGlvbnM/LmV4cGlyZXNJbiB8fCAnJyA6IG9wdGlvbnMuZXhwaXJlc0luXG5cbiAgICBtZXJnZWRPcHRpb25zLmVuY3J5cHRlZCA9IChvcHRpb25zICYmICFvcHRpb25zLmVuY3J5cHRlZCkgPyBjb25maWdGb3JSb290T3B0aW9ucz8uZW5jcnlwdGVkIHx8IGZhbHNlIDogb3B0aW9ucy5lbmNyeXB0ZWRcblxuICAgIHJldHVybiBtZXJnZWRPcHRpb25zO1xuXG4gIH1cblxufVxuIl19

package/esm2022/lib/services/utils/path-query.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PathQueryService {
+    constructor() {
+        this.removeEmptyParams = (obj) => Object.fromEntries(Object.entries(obj)
+            .map(([key, value]) => [key, value && typeof value === 'object' ? this.removeEmptyParams(value) : value])
+            .filter(([_, value]) => value !== undefined && value !== ""));
+    }
+    buildAPIPath(server, params) {
+        server = (Array.isArray(server)) ? server.join('/') : server;
+        const pathObjects = (params) ? params.filter((path) => (!this.isObject(path))) : [];
+        const queryObjects = (params) ? params.filter((path) => (this.isObject(path))) : [];
+        const query = this.removeEmptyParams(queryObjects.reduce((r, c) => {
+            Object.entries(c).forEach(([key, value]) => {
+                r[key] = Array.isArray(value) ? value.join(',') : value;
+            });
+            return r;
+        }, {}));
+        let path = this.buildRestPath(server, pathObjects);
+        return (Object.keys(query).length > 0) ? path + '?' + this.buildQueryPath(query) : path;
+    }
+    buildRestPath(server, params) {
+        server = (server) ? server : '';
+        server = (server.charAt(0) === '/') ? server.substring(1) : server;
+        return this.cleanUrlPath(server + '/' + params.join('/'));
+    }
+    buildQueryPath(params) {
+        const searchParams = new URLSearchParams();
+        for (const key in params) {
+            if (Array.isArray(params[key])) {
+                params[key].forEach((value) => searchParams.append(key, value));
+            }
+            else {
+                searchParams.append(key, params[key]);
+            }
+        }
+        return searchParams.toString();
+    }
+    cleanUrlPath(str) {
+        return str.replace(/([^:]\/)\/+/g, "$1").replace(/\/$/, '');
+    }
+    isObject(val) {
+        return (val === null) ? false : ((typeof val === 'function') || (typeof val === 'object'));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PathQueryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PathQueryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PathQueryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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