@lifeready/core 1.0.21 → 1.0.23

package/esm2015/lib/contact-card/contact-card2.service.js

@@ -0,0 +1,103 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { LrMutation } from '../api/lr-graphql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyMetaService } from '../key/key-meta.service';
+import { KeyService } from '../key/key.service';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { CreateContactCardMutation, DeleteContactCardMutation, UpdateContactCardMutation, } from './contact-card2.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key-factory.service";
+import * as i2 from "../key/key.service";
+import * as i3 from "../encryption/encryption.service";
+import * as i4 from "../key/key-graph.service";
+import * as i5 from "../key/key-meta.service";
+export class OwnerPlainDataJson {
+}
+let ContactCard2Service = class ContactCard2Service {
+    constructor(keyFactory, keyService, encryptionService, keyGraph, keyMetaService, ngZone) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.keyMetaService = keyMetaService;
+        this.ngZone = ngZone;
+    }
+    createContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(rootKey.jwk, key.toJSON(true));
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: CreateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { wrappingKeyId: rootKey.id, wrappedKey,
+                        cipherData }),
+                },
+            });
+        });
+    }
+    updateContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const cipherData = yield this.keyGraph.encryptToString(input.keyId, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: UpdateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { id: input.id, cipherData }),
+                },
+            });
+        });
+    }
+    deleteContactCard(id) {
+        return new LrMutation({
+            mutation: DeleteContactCardMutation,
+            variables: {
+                input: {
+                    id,
+                },
+            },
+        });
+    }
+    prepareContactCardInput(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const publicDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicDataJson));
+            const publicSearchableSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson));
+            const plainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.plainDataJson));
+            return {
+                sigPxkId: sigPxk.id,
+                publicDataSig,
+                publicSearchableSig,
+                plainDataSig,
+            };
+        });
+    }
+};
+ContactCard2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContactCard2Service_Factory() { return new ContactCard2Service(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.KeyMetaService), i0.ɵɵinject(i0.NgZone)); }, token: ContactCard2Service, providedIn: "root" });
+ContactCard2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ContactCard2Service.ctorParameters = () => [
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: KeyMetaService },
+    { type: NgZone }
+];
+ContactCard2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], ContactCard2Service);
+export { ContactCard2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-card2.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/contact-card/contact-card2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { LrMutation } from '../api/lr-graphql';\nimport { JSONObject } from '../api/types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyFactoryService } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyMetaService } from '../key/key-meta.service';\nimport { KeyService } from '../key/key.service';\nimport { MainContactCardPlainFields } from '../profile/profile.types';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport {\n  CreateContactCardMutation,\n  DeleteContactCardMutation,\n  UpdateContactCardMutation,\n} from './contact-card2.gql';\n\nexport interface CreateContactCardInput2 {\n  publicDataJson: JSONObject;\n  publicSearchableJson: JSONObject;\n  plainCipherDataJson: JSONObject;\n  plainDataJson: MainContactCardPlainFields;\n}\n\n// These contact name fields are enforced by the server so that it can send out emails with\n// appropriate format.\nexport interface ContactCardName2 {\n  name: string;\n  title?: string;\n  firstName?: string;\n  lastName?: string;\n  // additional fields are not allowed by the server\n}\n\nexport class OwnerPlainDataJson {\n  name: ContactCardName2;\n}\n\nexport interface UpdateContactCardInput2 extends CreateContactCardInput2 {\n  id: string;\n  keyId: string;\n}\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class ContactCard2Service {\n  constructor(\n    private keyFactory: KeyFactoryService,\n    private keyService: KeyService,\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService,\n    private keyMetaService: KeyMetaService,\n    private ngZone: NgZone\n  ) {}\n\n  async createContactCard(input: CreateContactCardInput2) {\n    // Get encryption key\n    const rootKey = await this.keyService.getCurrentRootKey();\n    const key = await this.keyFactory.createKey();\n    const wrappedKey = await this.keyGraph.encryptToString(\n      rootKey.jwk,\n      key.toJSON(true)\n    );\n    const cipherData = await this.keyGraph.encryptToString(\n      key,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    return new LrMutation({\n      mutation: CreateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          wrappingKeyId: rootKey.id,\n          wrappedKey,\n          cipherData,\n        },\n      },\n    });\n  }\n\n  async updateContactCard(input: UpdateContactCardInput2) {\n    // Get encryption key\n    const cipherData = await this.keyGraph.encryptToString(\n      input.keyId,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    return new LrMutation({\n      mutation: UpdateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          id: input.id,\n          cipherData,\n        },\n      },\n    });\n  }\n\n  deleteContactCard(id: string) {\n    return new LrMutation({\n      mutation: DeleteContactCardMutation,\n      variables: {\n        input: {\n          id,\n        },\n      },\n    });\n  }\n\n  private async prepareContactCardInput(input: CreateContactCardInput2) {\n    const sigPxk = await this.keyService.getCurrentSigPxk();\n    const publicDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\n    );\n    const publicSearchableSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\n    );\n    const plainDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\n    );\n\n    return {\n      sigPxkId: sigPxk.id,\n      publicDataSig,\n      publicSearchableSig,\n      plainDataSig,\n    };\n  }\n}\n"]}

package/esm2015/lib/encryption/encryption.service.js

@@ -0,0 +1,190 @@
+import { __awaiter } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import { JWE, JWS } from 'node-jose';
+import { TimeService } from '../time/time.service';
+import { LrBadArgumentException, LrErrorCode, LrException, } from './../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "../time/time.service";
+export var JoseSerialization;
+(function (JoseSerialization) {
+    JoseSerialization["JSON"] = "JSON";
+    JoseSerialization["COMPACT"] = "COMPACT";
+})(JoseSerialization || (JoseSerialization = {}));
+export const VERIFY_OPTIONS_DEFAULT = {
+    payloadType: 'json',
+    returnOnlyPayload: true,
+};
+export const DECRYPT_OPTIONS_DEFAULT = {
+    payloadType: 'json',
+    returnOnlyPayload: true,
+    serializations: [JoseSerialization.JSON],
+};
+export function isSymmetricKey(key) {
+    // TODO: make sure this covers all cases.
+    return key.kty === 'oct';
+}
+export function asJwk(key) {
+    // TODO: make sure this covers all cases.
+    // Excluded:
+    //   key.use - only for public keys, Ref: https://tools.ietf.org/html/rfc7517#section-4.2
+    if (key.id && key.jwk) {
+        return key.jwk;
+    }
+    else if (key.keystore && key.length && key.kty && key.kid && key.alg) {
+        return key;
+    }
+    else {
+        return null;
+    }
+}
+export class EncryptionService {
+    constructor(timeService) {
+        this.timeService = timeService;
+    }
+    decrypt(key, // string is assumed to be key.id, will unwrap key.
+    jwe, // string will be JSON.parsed
+    options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = {
+                algorithms: ['dir', 'A*GCM', 'RSA-OAEP-*'],
+            };
+            options = Object.assign(Object.assign({}, DECRYPT_OPTIONS_DEFAULT), options);
+            if (key.jwk) {
+                key = key.jwk;
+            }
+            if (typeof jwe === 'string') {
+                if (options.serializations.includes(JoseSerialization.JSON)) {
+                    try {
+                        jwe = JSON.parse(jwe);
+                    }
+                    catch (error) {
+                        if (options.serializations.includes(JoseSerialization.COMPACT)) {
+                            console.log('Not a JSON-formatted JWE, it maybe compact serialisation format.');
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            // {result} is a Object with:
+            // *  header: the combined 'protected' and 'unprotected' header members
+            // *  protected: an array of the member names from the "protected" member
+            // *  key: Key used to decrypt
+            // *  payload: Buffer of the decrypted content
+            // *  plaintext: Buffer of the decrypted content (alternate), just a reference to payload
+            const res = yield JWE.createDecrypt(key, opt).decrypt(jwe);
+            res.payload = this.decodePayload(options.payloadType, res.payload);
+            if (options.returnOnlyPayload) {
+                return res.payload;
+            }
+            else {
+                return res;
+            }
+        });
+    }
+    // TODO rename this to encrypt() and use as the most common usecase
+    encryptToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.encrypt(key, content));
+        });
+    }
+    // TODO rename this to encryptToJSON() and use this when required.
+    encrypt(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (content == null) {
+                throw new Error('Encrypting null/undefined content.');
+            }
+            if (!(content instanceof ArrayBuffer)) {
+                content = new TextEncoder().encode(JSON.stringify(content));
+            }
+            return JWE.createEncrypt({
+                contentAlg: 'A256GCM',
+                fields: {
+                    timestamp: yield this.timeService.serverNow(),
+                },
+            }, key)
+                .update(content)
+                .final();
+        });
+    }
+    // <AZ> Unlike signContent, the serialised "content" variable is contained inside
+    // the result. So ordering of fields within "content" is not an issue.
+    sign(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = JWS.createSign({
+                fields: {
+                    timestamp: yield this.timeService.serverNow(),
+                },
+            }, key);
+            if (content instanceof Buffer) {
+                signer.update(content);
+            }
+            else {
+                signer.update(JSON.stringify(content), 'utf8');
+            }
+            return signer.final();
+        });
+    }
+    signToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.sign(key, content));
+        });
+    }
+    verify(key, jws, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = {
+                algorithms: ['RS*'],
+            };
+            options = Object.assign(Object.assign({}, VERIFY_OPTIONS_DEFAULT), options);
+            try {
+                const res = yield JWS.createVerify(key, opt).verify(jws);
+                res.payload = this.decodePayload(options.payloadType, res.payload);
+                if (options.returnOnlyPayload) {
+                    return res.payload;
+                }
+                else {
+                    return res;
+                }
+            }
+            catch (error) {
+                throw new LrException({
+                    code: LrErrorCode.BadSignature,
+                    message: `Bad signature: ${error}`,
+                });
+            }
+        });
+    }
+    encryptThenSign({ key, sigPrk, }, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cipher = JSON.stringify(yield this.encrypt(key, content));
+            const sig = yield this.sign(sigPrk, cipher);
+            delete sig.payload;
+            return {
+                cipher,
+                sig: JSON.stringify(sig),
+            };
+        });
+    }
+    decodePayload(payloadType, payload) {
+        switch (payloadType) {
+            case 'json':
+                return JSON.parse(new TextDecoder().decode(payload));
+            case 'ArrayBuffer':
+                return payload;
+            default:
+                throw new LrBadArgumentException(`Unknown payloadType: ${payloadType}`);
+        }
+    }
+}
+EncryptionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EncryptionService_Factory() { return new EncryptionService(i0.ɵɵinject(i1.TimeService)); }, token: EncryptionService, providedIn: "root" });
+EncryptionService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+EncryptionService.ctorParameters = () => [
+    { type: TimeService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/encryption/encryption.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from '@angular/core';\nimport { JWE, JWK, JWS } from 'node-jose';\nimport { JSONObject } from '../api/types';\nimport { Key, PayloadType } from '../key/key.types';\nimport { TimeService } from '../time/time.service';\nimport {\n  LrBadArgumentException,\n  LrErrorCode,\n  LrException,\n} from './../_common/exceptions';\n\nexport enum JoseSerialization {\n  JSON = 'JSON',\n  COMPACT = 'COMPACT',\n}\n\nexport interface VerifyOptions {\n  payloadType?: PayloadType;\n  returnOnlyPayload?: boolean; // If true, return only the decoded payload.\n}\n\nexport interface DecryptOptions {\n  payloadType?: PayloadType;\n  returnOnlyPayload?: boolean; // If true, return only the decoded payload.\n  serializations?: JoseSerialization[];\n}\n\nexport const VERIFY_OPTIONS_DEFAULT: VerifyOptions = {\n  payloadType: 'json',\n  returnOnlyPayload: true,\n};\n\nexport const DECRYPT_OPTIONS_DEFAULT: DecryptOptions = {\n  payloadType: 'json',\n  returnOnlyPayload: true,\n  serializations: [JoseSerialization.JSON],\n};\n\nexport function isSymmetricKey(key: JWK.Key) {\n  // TODO: make sure this covers all cases.\n  return key.kty === 'oct';\n}\n\nexport function asJwk(key: JWK.Key | Key | any): JWK.Key | null {\n  // TODO: make sure this covers all cases.\n  // Excluded:\n  //   key.use - only for public keys, Ref: https://tools.ietf.org/html/rfc7517#section-4.2\n\n  if (key.id && key.jwk) {\n    return key.jwk;\n  } else if (key.keystore && key.length && key.kty && key.kid && key.alg) {\n    return key;\n  } else {\n    return null;\n  }\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class EncryptionService {\n  constructor(private timeService: TimeService) {}\n\n  async decrypt(\n    key: JWK.Key | Key, // string is assumed to be key.id, will unwrap key.\n    jwe: Record<string, JSONObject> | string, // string will be JSON.parsed\n    options?: DecryptOptions\n  ): Promise<JWE.DecryptResult | any> {\n    const opt = {\n      algorithms: ['dir', 'A*GCM', 'RSA-OAEP-*'],\n    };\n\n    options = {\n      ...DECRYPT_OPTIONS_DEFAULT,\n      ...options,\n    };\n\n    if ((key as Key).jwk) {\n      key = (key as Key).jwk;\n    }\n\n    if (typeof jwe === 'string') {\n      if (options.serializations.includes(JoseSerialization.JSON)) {\n        try {\n          jwe = JSON.parse(jwe);\n        } catch (error) {\n          if (options.serializations.includes(JoseSerialization.COMPACT)) {\n            console.log(\n              'Not a JSON-formatted JWE, it maybe compact serialisation format.'\n            );\n          } else {\n            throw error;\n          }\n        }\n      }\n    }\n\n    // {result} is a Object with:\n    // *  header: the combined 'protected' and 'unprotected' header members\n    // *  protected: an array of the member names from the \"protected\" member\n    // *  key: Key used to decrypt\n    // *  payload: Buffer of the decrypted content\n    // *  plaintext: Buffer of the decrypted content (alternate), just a reference to payload\n    const res = await JWE.createDecrypt(key as JWK.Key, opt).decrypt(\n      jwe as any\n    );\n\n    res.payload = this.decodePayload(options.payloadType, res.payload);\n\n    if (options.returnOnlyPayload) {\n      return res.payload;\n    } else {\n      return res;\n    }\n  }\n\n  // TODO rename this to encrypt() and use as the most common usecase\n  async encryptToString(\n    key: JWK.Key,\n    content: ArrayBuffer | string | Record<string, JSONObject>\n  ): Promise<string> {\n    return JSON.stringify(await this.encrypt(key, content));\n  }\n\n  // TODO rename this to encryptToJSON() and use this when required.\n  async encrypt(\n    key: JWK.Key,\n    content: ArrayBuffer | string | Record<string, JSONObject>\n  ): Promise<any> {\n    if (content == null) {\n      throw new Error('Encrypting null/undefined content.');\n    }\n\n    if (!(content instanceof ArrayBuffer)) {\n      content = new TextEncoder().encode(JSON.stringify(content));\n    }\n\n    return JWE.createEncrypt(\n      {\n        contentAlg: 'A256GCM',\n        fields: {\n          timestamp: await this.timeService.serverNow(),\n        },\n      } as any,\n      key\n    )\n      .update(content)\n      .final() as any;\n  }\n\n  // <AZ> Unlike signContent, the serialised \"content\" variable is contained inside\n  // the result. So ordering of fields within \"content\" is not an issue.\n  async sign(\n    key: JWK.Key,\n    content: Buffer | string | Record<string, JSONObject>\n  ): Promise<any> {\n    const signer = JWS.createSign(\n      {\n        fields: {\n          timestamp: await this.timeService.serverNow(),\n        },\n      },\n      key\n    );\n\n    if (content instanceof Buffer) {\n      signer.update(content);\n    } else {\n      signer.update(JSON.stringify(content), 'utf8');\n    }\n\n    return signer.final();\n  }\n\n  async signToString(\n    key: JWK.Key,\n    content: Buffer | string | Record<string, JSONObject>\n  ): Promise<string> {\n    return JSON.stringify(await this.sign(key, content));\n  }\n\n  async verify(\n    key: JWK.Key,\n    jws: Record<string, JSONObject>,\n    options?: VerifyOptions\n  ): Promise<any> {\n    const opt = {\n      algorithms: ['RS*'],\n    };\n\n    options = {\n      ...VERIFY_OPTIONS_DEFAULT,\n      ...options,\n    };\n\n    try {\n      const res = await JWS.createVerify(key, opt).verify(jws as any);\n\n      res.payload = this.decodePayload(options.payloadType, res.payload);\n\n      if (options.returnOnlyPayload) {\n        return res.payload;\n      } else {\n        return res;\n      }\n    } catch (error) {\n      throw new LrException({\n        code: LrErrorCode.BadSignature,\n        message: `Bad signature: ${error}`,\n      });\n    }\n  }\n\n  async encryptThenSign(\n    {\n      key,\n      sigPrk,\n    }: {\n      key: JWK.Key;\n      sigPrk: JWK.Key;\n    },\n    content: ArrayBuffer | string | Record<string, JSONObject>\n  ): Promise<{ cipher: string; sig: string }> {\n    const cipher = JSON.stringify(await this.encrypt(key, content));\n    const sig = await this.sign(sigPrk, cipher);\n    delete sig.payload;\n\n    return {\n      cipher,\n      sig: JSON.stringify(sig),\n    };\n  }\n\n  private decodePayload(\n    payloadType: PayloadType,\n    payload: ArrayBuffer\n  ): ArrayBuffer | any {\n    switch (payloadType) {\n      case 'json':\n        return JSON.parse(new TextDecoder().decode(payload));\n      case 'ArrayBuffer':\n        return payload;\n      default:\n        throw new LrBadArgumentException(`Unknown payloadType: ${payloadType}`);\n    }\n  }\n}\n"]}

package/esm2015/lib/file-upload/file-upload.service.js

@@ -0,0 +1,74 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { LR_CONFIG } from '../life-ready.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../auth/life-ready-auth.service";
+export class FileUploadService {
+    constructor(config, http, lrAuth) {
+        this.config = config;
+        this.http = http;
+        this.lrAuth = lrAuth;
+    }
+    downloadEncryptedFile(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.parse(yield this.downloadEncryptedFile2(fileStateNodeId));
+        });
+    }
+    downloadEncryptedFile2(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.config.apiUrl}files/download/?file_state_node_id=${fileStateNodeId}`;
+            const content = yield this.http
+                .get(url, {
+                responseType: 'text',
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content;
+        });
+    }
+    loadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    // OK to type cast here since we are using readAsArrayBuffer.
+                    resolve(reader.result);
+                };
+                reader.readAsArrayBuffer(file);
+            });
+        });
+    }
+    uploadEncryptedFile(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { encryptedContent, fileName } = options;
+            const formData = new FormData();
+            formData.append('content', new Blob([encryptedContent]), fileName);
+            const { content_resource } = yield this.http
+                .post(`${this.config.apiUrl}files/upload/`, formData, {
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content_resource;
+        });
+    }
+}
+FileUploadService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FileUploadService_Factory() { return new FileUploadService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LifeReadyAuthService)); }, token: FileUploadService, providedIn: "root" });
+FileUploadService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+FileUploadService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LifeReadyAuthService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/file-upload/file-upload.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS11cGxvYWQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9saWIvZmlsZS11cGxvYWQvZmlsZS11cGxvYWQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEZpbGVDb250ZW50Q29udGV4dCA9ICdGSUxFX1NUQVRFJztcblxuZXhwb3J0IGludGVyZmFjZSBVcGxvYWRFbmNyeXB0ZWRGaWxlT3B0aW9ucyB7XG4gIGVuY3J5cHRlZENvbnRlbnQ6IHN0cmluZztcbiAgLy8gVE9ETyBBZGQgaW4gdGhlIGNvbnRleHQgZmllbGQgYW5kIG1ha2UgaXQgbWFuZGF0b3J5XG4gIC8vIGNvbnRleHQ6IEZpbGVDb250ZW50Q29udGV4dDtcbiAgZmlsZU5hbWU/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2015/lib/idle/idle.service.js

@@ -0,0 +1,168 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { DEFAULT_INTERRUPTSOURCES, Idle } from '@ng-idle/core';
+import { Keepalive } from '@ng-idle/keepalive';
+import { KeyService } from '../key/key.service';
+import { LR_CONFIG } from '../life-ready.config';
+import { LrBadArgumentException, LrBadStateException, } from '../_common/exceptions';
+import { Config } from './idle.types';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@ng-idle/core";
+import * as i4 from "@ng-idle/keepalive";
+import * as i5 from "../key/key.service";
+import * as i6 from "@aws-amplify/auth/lib-esm/Auth";
+export class IdleService {
+    constructor(config, http, idle, keepalive, keyService, auth) {
+        this.config = config;
+        this.http = http;
+        this.idle = idle;
+        this.keepalive = keepalive;
+        this.keyService = keyService;
+        this.auth = auth;
+        this.IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';
+        this.IDLING_KEY = 'ng2Idle.main.idling';
+        this.initCalled = false;
+    }
+    assertInit() {
+        if (!this.initCalled) {
+            throw new LrBadStateException('Call IdleService.init() first.');
+        }
+    }
+    init(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initCalled) {
+                throw new LrBadStateException('IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.');
+            }
+            this.initCalled = true;
+            // Defaults
+            params = Object.assign({ onTimeout: null, onKeepalive: null, idleSec: Config.IDLE, timeoutSec: Config.TIMEOUT, keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL }, params);
+            // If timeoutSec == 0 then the onTimeout() callback is never called.
+            if (params.timeoutSec < 0.01) {
+                throw new LrBadArgumentException('Minimum value for IdleService.init({ timeoutSec }) is 0.01');
+            }
+            this.onTimeout = params.onTimeout;
+            this.onKeepalive = params.onKeepalive;
+            // ------------------------------------------------------------------------
+            // Setup Idle
+            // ------------------------------------------------------------------------
+            // sets an idle timeout of 5 seconds, for testing purposes.
+            this.idle.setIdle(params.idleSec);
+            // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.
+            this.idle.setTimeout(params.timeoutSec);
+            // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document
+            this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);
+            this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));
+            this.idle.onIdleStart.subscribe(() => console.log('Idle started'));
+            this.idle.onTimeout.subscribe(() => __awaiter(this, void 0, void 0, function* () {
+                console.log('Idle timed out');
+                this.reset();
+                yield Promise.resolve(this.onTimeout && this.onTimeout());
+            }));
+            this.idle.onTimeoutWarning.subscribe((countdown) => console.log(`Will timeout in ${countdown} seconds!`));
+            // ------------------------------------------------------------------------
+            // Setup Keepalive
+            // ------------------------------------------------------------------------
+            // Ref: https://github.com/moribvndvs/ng2-idle#readme
+            // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once
+            // they go idle or time out. When the user resumes activity or the idle state is reset, it will
+            // ping immediately and then resume pinging.
+            this.keepalive.interval(params.keepAliveIntervalSec);
+            console.log(`Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`);
+            this.keepalive.onPing.subscribe(() => this.onPing());
+            // If the browser tab has been closed for a period longer thant the inactivity
+            // period, then we should logout right from the start.
+            const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);
+            if (idleExpiry &&
+                parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()) {
+                this.reset();
+                yield Promise.resolve(this.onTimeout && this.onTimeout());
+            }
+        });
+    }
+    keepalivePost() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // currentAuthenticatedUser() refreshes the access token if required.
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            const keepaliveResult = yield this.http
+                .post(`${this.config.authUrl}auth/keepalive/`, null, {
+                withCredentials: true,
+                headers: {
+                    Authorization: `Bearer ${cognitoUser
+                        .getSignInUserSession()
+                        .getAccessToken()
+                        .getJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return {
+                keepaliveResult,
+                expiresAfterSeconds: this.idle.getIdle() +
+                    this.idle.getTimeout() +
+                    this.keepalive.interval(),
+            };
+        });
+    }
+    persistMasterKey(masterKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie
+            // expiry, and returns the session expiry.
+            // NOTE Use time delta rather than absolute time, since client clock and server clock maybe
+            // out of sync. We can't use the serverTime() functionality because the cookie expiry still
+            // run on local clock.
+            const { expiresAfterSeconds } = yield this.keepalivePost();
+            // Persist the derived passKey
+            yield this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);
+            console.log('setMasterKey() done');
+        });
+    }
+    onPing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`);
+            // Keepalive API will extend the session expiry.
+            const { expiresAfterSeconds } = yield this.keepalivePost();
+            // Extend the expiry of the persisted key
+            yield this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);
+            yield Promise.resolve(this.onKeepalive && this.onKeepalive());
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initCalled) {
+                yield this.init();
+            }
+            if (this.idle.isRunning()) {
+                return;
+            }
+            // Ping does not seem to happen right at the start. So we call it explicitly
+            yield this.onPing();
+            this.idle.watch();
+        });
+    }
+    stop() {
+        this.idle.stop();
+        this.reset();
+    }
+    reset() {
+        localStorage.removeItem(this.IDLE_EXPIRY_KEY);
+        localStorage.removeItem(this.IDLING_KEY);
+    }
+}
+IdleService.ɵprov = i0.ɵɵdefineInjectable({ factory: function IdleService_Factory() { return new IdleService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.Idle), i0.ɵɵinject(i4.Keepalive), i0.ɵɵinject(i5.KeyService), i0.ɵɵinject(i6.AuthClass)); }, token: IdleService, providedIn: "root" });
+IdleService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+IdleService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: Idle },
+    { type: Keepalive },
+    { type: KeyService },
+    { type: AuthClass }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/idle/idle.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { CognitoUser } from '@aws-amplify/auth';\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\nimport { DEFAULT_INTERRUPTSOURCES, Idle } from '@ng-idle/core';\nimport { Keepalive } from '@ng-idle/keepalive';\nimport { KeyService } from '../key/key.service';\nimport { Key } from '../key/key.types';\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\nimport {\n  LrBadArgumentException,\n  LrBadStateException,\n} from '../_common/exceptions';\nimport { Config, KeepaliveResult } from './idle.types';\n\nexport interface IdleServiceInit {\n  // TODO: this should be EventEmitter instead of a callback.\n  onTimeout?: (() => void) | (() => Promise<void>) | null;\n  onKeepalive?: (() => void) | (() => Promise<void>) | null;\n  idleSec?: number;\n  timeoutSec?: number;\n  keepAliveIntervalSec?: number;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IdleService {\n  private readonly IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';\n  private readonly IDLING_KEY = 'ng2Idle.main.idling';\n\n  private initCalled = false;\n  private onTimeout: (() => void) | (() => Promise<void>) | null;\n  private onKeepalive: (() => void) | (() => Promise<void>) | null;\n\n  constructor(\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\n    private http: HttpClient,\n    private idle: Idle,\n    private keepalive: Keepalive,\n    private keyService: KeyService,\n    private auth: AuthClass\n  ) {}\n\n  private assertInit(): void {\n    if (!this.initCalled) {\n      throw new LrBadStateException('Call IdleService.init() first.');\n    }\n  }\n\n  public async init(params?: IdleServiceInit): Promise<void> {\n    if (this.initCalled) {\n      throw new LrBadStateException(\n        'IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.'\n      );\n    }\n\n    this.initCalled = true;\n\n    // Defaults\n    params = {\n      onTimeout: null,\n      onKeepalive: null,\n      idleSec: Config.IDLE,\n      timeoutSec: Config.TIMEOUT,\n      keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL,\n      ...params,\n    };\n\n    // If timeoutSec == 0 then the onTimeout() callback is never called.\n    if (params.timeoutSec < 0.01) {\n      throw new LrBadArgumentException(\n        'Minimum value for IdleService.init({ timeoutSec }) is 0.01'\n      );\n    }\n\n    this.onTimeout = params.onTimeout;\n    this.onKeepalive = params.onKeepalive;\n\n    // ------------------------------------------------------------------------\n    // Setup Idle\n    // ------------------------------------------------------------------------\n    // sets an idle timeout of 5 seconds, for testing purposes.\n    this.idle.setIdle(params.idleSec);\n    // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.\n    this.idle.setTimeout(params.timeoutSec);\n    // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document\n    this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);\n\n    this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));\n    this.idle.onIdleStart.subscribe(() => console.log('Idle started'));\n\n    this.idle.onTimeout.subscribe(async () => {\n      console.log('Idle timed out');\n      this.reset();\n      await Promise.resolve(this.onTimeout && this.onTimeout());\n    });\n    this.idle.onTimeoutWarning.subscribe((countdown) =>\n      console.log(`Will timeout in ${countdown} seconds!`)\n    );\n\n    // ------------------------------------------------------------------------\n    // Setup Keepalive\n    // ------------------------------------------------------------------------\n    // Ref: https://github.com/moribvndvs/ng2-idle#readme\n    // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once\n    // they go idle or time out. When the user resumes activity or the idle state is reset, it will\n    // ping immediately and then resume pinging.\n    this.keepalive.interval(params.keepAliveIntervalSec);\n    console.log(\n      `Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`\n    );\n\n    this.keepalive.onPing.subscribe(() => this.onPing());\n\n    // If the browser tab has been closed for a period longer thant the inactivity\n    // period, then we should logout right from the start.\n    const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);\n    if (\n      idleExpiry &&\n      parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()\n    ) {\n      this.reset();\n      await Promise.resolve(this.onTimeout && this.onTimeout());\n    }\n  }\n\n  public async keepalivePost(): Promise<{\n    expiresAfterSeconds: number;\n    keepaliveResult: KeepaliveResult;\n  }> {\n    // currentAuthenticatedUser() refreshes the access token if required.\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\n\n    const keepaliveResult = await this.http\n      .post<KeepaliveResult>(`${this.config.authUrl}auth/keepalive/`, null, {\n        withCredentials: true, // /auth/keepalive/ will be extending the sessions cookie.\n        headers: {\n          Authorization: `Bearer ${cognitoUser\n            .getSignInUserSession()\n            .getAccessToken()\n            .getJwtToken()}`,\n        },\n      })\n      .toPromise();\n\n    return {\n      keepaliveResult,\n      expiresAfterSeconds:\n        this.idle.getIdle() +\n        this.idle.getTimeout() +\n        this.keepalive.interval(),\n    };\n  }\n\n  public async persistMasterKey(masterKey: Key): Promise<void> {\n    // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie\n    // expiry, and returns the session expiry.\n    // NOTE Use time delta rather than absolute time, since client clock and server clock maybe\n    // out of sync. We can't use the serverTime() functionality because the cookie expiry still\n    // run on local clock.\n    const { expiresAfterSeconds } = await this.keepalivePost();\n\n    // Persist the derived passKey\n    await this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);\n\n    console.log('setMasterKey() done');\n  }\n\n  private async onPing(): Promise<void> {\n    console.log(\n      `Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`\n    );\n\n    // Keepalive API will extend the session expiry.\n    const { expiresAfterSeconds } = await this.keepalivePost();\n\n    // Extend the expiry of the persisted key\n    await this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);\n\n    await Promise.resolve(this.onKeepalive && this.onKeepalive());\n  }\n\n  public async start(): Promise<void> {\n    if (!this.initCalled) {\n      await this.init();\n    }\n\n    if (this.idle.isRunning()) {\n      return;\n    }\n\n    // Ping does not seem to happen right at the start. So we call it explicitly\n    await this.onPing();\n\n    this.idle.watch();\n  }\n\n  public stop(): void {\n    this.idle.stop();\n    this.reset();\n  }\n\n  private reset() {\n    localStorage.removeItem(this.IDLE_EXPIRY_KEY);\n    localStorage.removeItem(this.IDLING_KEY);\n  }\n}\n"]}

package/esm2015/lib/idle/idle.types.js

@@ -0,0 +1,7 @@
+export var Config;
+(function (Config) {
+    Config[Config["TIMEOUT"] = 0.01] = "TIMEOUT";
+    Config[Config["IDLE"] = 1200] = "IDLE";
+    Config[Config["KEEP_ALIVE_INTERVAL"] = 60] = "KEEP_ALIVE_INTERVAL";
+})(Config || (Config = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRsZS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmUvc3JjL2xpYi9pZGxlL2lkbGUudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksTUFJWDtBQUpELFdBQVksTUFBTTtJQUNoQiw0Q0FBYyxDQUFBO0lBQ2Qsc0NBQWMsQ0FBQTtJQUNkLGtFQUE0QixDQUFBO0FBQzlCLENBQUMsRUFKVyxNQUFNLEtBQU4sTUFBTSxRQUlqQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIENvbmZpZyB7XG4gIFRJTUVPVVQgPSAwLjAxLCAvLyBzZWNvbmRzLCBtaW4gdmFsdWUgMC4wMSwgYWZ0ZXIgc3RhdGUgaXMgaWRsZSwgd2FpdCBmb3IgVElNRU9VVCBzZWNvbmRzIGJlZm9yZSB0YWtpbmcgYWN0aW9uXG4gIElETEUgPSA2MCAqIDIwLCAvLyBzZWNvbmRzLCBwZXJpb2Qgb2YgaW5hY3Rpdml0eSB0byBjb25zaWRlciBzdGF0ZSBhcyBpZGxlXG4gIEtFRVBfQUxJVkVfSU5URVJWQUwgPSA2MCAqIDEsIC8vIHNlY29uZHMsIHRyaWdnZXJlZCBvbiBhIHJlZ3VsYXIgYmFzaXMgd2hpbGUgYWN0aXZlIChpLmUuIHdoaWxlIG5vdCBpZGxpbmcpXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgS2VlcGFsaXZlUmVzdWx0IHtcbiAgc2Vzc2lvbjoge1xuICAgIGV4cGlyZXNfYWZ0ZXJfc2Vjb25kczogbnVtYmVyO1xuICB9O1xufVxuIl19