@lifeready/core 0.6.0-beta.1

package/esm2015/lib/_common/ast.js

@@ -0,0 +1,40 @@
+// Abstract Syntax Tree
+import gql from 'graphql-tag';
+import { LrBadArgumentException, LrBadLogicException } from './exceptions';
+export function getAstOperation(astDocument, operation) {
+    const operations = astDocument.definitions.filter((def) => def.kind === 'OperationDefinition');
+    if (operations.length > 1) {
+        throw new LrBadLogicException(`There can be only one '${operation}' operation, instead there are ${operations.length}`);
+    }
+    return operations[0];
+}
+export function getQuery(doc) {
+    return getAstOperation(doc, 'query');
+}
+export function getMutation(doc) {
+    return getAstOperation(doc, 'mutation');
+}
+export function getFragments(doc) {
+    return doc.definitions.filter((def) => def.kind === 'FragmentDefinition');
+}
+export function getFragment(astDocument) {
+    const fragments = getFragments(astDocument);
+    if (fragments.length > 1) {
+        throw new LrBadArgumentException('GraphQL document can only contain one fragment.');
+    }
+    return fragments[0];
+}
+export function name(value) {
+    return {
+        kind: 'Name',
+        value,
+    };
+}
+export function getAliasOrName(field) {
+    var _a;
+    return ((_a = field.alias) === null || _a === void 0 ? void 0 : _a.value) || field.name.value;
+}
+export function gqlTyped(literals, ...placeholders) {
+    return gql(literals, ...placeholders);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/_common/deferred-promise.js

@@ -0,0 +1,24 @@
+export class DeferredPromise {
+    constructor() {
+        /* tslint:disable: variable-name */
+        this._fulfilled = false;
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        }).finally(() => {
+            // finally() simply gets called on both then() and catch(). The promise
+            // chain continues on.
+            this._fulfilled = true;
+        });
+    }
+    get resolve() {
+        return this._resolve;
+    }
+    get reject() {
+        return this._reject;
+    }
+    get fulfilled() {
+        return this._fulfilled;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/_common/exceptions.js

@@ -0,0 +1,157 @@
+export function handleApolloError(errors) {
+    if (!errors || !errors.length)
+        return;
+    const lrErrors = errors.map((x) => ({
+        code: x.extensions && x.extensions.code,
+        source: x.extensions && x.extensions.source,
+        message: x.message,
+        debug: {
+            locations: x.locations,
+            path: x.path,
+        },
+    }));
+    throw new LrException(...lrErrors);
+}
+export class LrError {
+}
+export class LrException {
+    constructor(...errors) {
+        this.errors = errors;
+    }
+    toString() {
+        return this.errors.map((t) => JSON.stringify(t, null, 2));
+    }
+}
+export var LrApiErrorCode;
+(function (LrApiErrorCode) {
+    LrApiErrorCode["ARCHIVED_RESOURCE"] = "ARCHIVED_RESOURCE";
+    LrApiErrorCode["BAD_ARGUMENT"] = "BAD_ARGUMENT";
+    LrApiErrorCode["BAD_SIGNATURE"] = "BAD_SIGNATURE";
+    LrApiErrorCode["BAD_STATE"] = "BAD_STATE";
+    LrApiErrorCode["CHANGED_PERMISSIONS"] = "CHANGED_PERMISSIONS";
+    LrApiErrorCode["CONCURRENT_ACCESS"] = "CONCURRENT_ACCESS";
+    LrApiErrorCode["CONFIG_ERROR"] = "CONFIG_ERROR";
+    LrApiErrorCode["CYCLE_DETECTED"] = "CYCLE_DETECTED";
+    LrApiErrorCode["EXPIRED"] = "EXPIRED";
+    LrApiErrorCode["INVALID_TOKEN"] = "INVALID_TOKEN";
+    LrApiErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    LrApiErrorCode["JSON_DECODE_ERROR"] = "JSON_DECODE_ERROR";
+    LrApiErrorCode["KEY_MISMATCH"] = "KEY_MISMATCH";
+    LrApiErrorCode["LIMIT_REACHED"] = "LIMIT_REACHED";
+    LrApiErrorCode["LOCKED"] = "LOCKED";
+    LrApiErrorCode["LOGIC_ERROR"] = "LOGIC_ERROR";
+    LrApiErrorCode["LR_DEBUG_ONLY"] = "LR_DEBUG_ONLY";
+    LrApiErrorCode["MIN_DELAY"] = "MIN_DELAY";
+    LrApiErrorCode["MISSING_FIELD"] = "MISSING_FIELD";
+    LrApiErrorCode["MISSING_FIELD_VALUE"] = "MISSING_FIELD_VALUE";
+    LrApiErrorCode["MISSING_QUERY_PARAM"] = "MISSING_QUERY_PARAM";
+    LrApiErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+    LrApiErrorCode["OBJECT_DOES_NOT_EXIST"] = "OBJECT_DOES_NOT_EXIST";
+    LrApiErrorCode["OBJECT_EXISTS"] = "OBJECT_EXISTS";
+    LrApiErrorCode["RANGE_ERROR"] = "RANGE_ERROR";
+    LrApiErrorCode["TRUSTED_PARTY_NOT_FOUND"] = "TRUSTED_PARTY_NOT_FOUND";
+    LrApiErrorCode["UNAUTHENTICATED_USER"] = "UNAUTHENTICATED_USER";
+    LrApiErrorCode["USER_NOT_FOUND"] = "USER_NOT_FOUND";
+    LrApiErrorCode["VERSION_MISMATCH"] = "VERSION_MISMATCH";
+    LrApiErrorCode["WRONG_PERMISSIONS"] = "WRONG_PERMISSIONS";
+})(LrApiErrorCode || (LrApiErrorCode = {}));
+export var LrErrorCode;
+(function (LrErrorCode) {
+    LrErrorCode["BadTimeSync"] = "LrBadTimeSync";
+    LrErrorCode["ReceiveClaimMismatch"] = "LrReceiveClaimMismatch";
+    LrErrorCode["BadState"] = "LrBadState";
+    LrErrorCode["BadSignature"] = "LrBadSignature";
+    LrErrorCode["Auth"] = "LrAuth";
+    LrErrorCode["BadArgument"] = "LrBadArgument";
+    LrErrorCode["SuspiciousException"] = "LrSuspiciousException";
+    LrErrorCode["NotFound"] = "LrNotFound";
+    LrErrorCode["BadLogic"] = "LrBadLogicException";
+    LrErrorCode["CodeMismatch"] = "LrCodeMismatchException";
+    LrErrorCode["ConcurrentAccess"] = "LrConcurrentAccessException";
+    LrErrorCode["BadRequest"] = "LrBadRequestException";
+    LrErrorCode["Encryption"] = "LrEncryptionGoBad";
+    LrErrorCode["Locked"] = "LrLockedException";
+})(LrErrorCode || (LrErrorCode = {}));
+export class LrBadArgumentException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.BadArgument, message });
+    }
+}
+export class LrSuspiciousException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.BadArgument, message });
+    }
+}
+export class LrNotFoundException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.NotFound, message });
+    }
+}
+export class LrBadLogicException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.BadLogic, message });
+    }
+}
+export class LrCodeMismatchException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.CodeMismatch, message });
+    }
+}
+export class LrConcurrentAccessException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.ConcurrentAccess, message });
+    }
+}
+export class LrLockedException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.Locked, message });
+    }
+}
+export class LrBadRequestException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.BadRequest, message });
+    }
+}
+export class LrAuthException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.Auth, message });
+    }
+}
+export class LrEncryptionException extends LrException {
+    constructor(message) {
+        super({ code: LrErrorCode.Encryption, message });
+    }
+}
+export class LrUnsupportedException extends LrException {
+    constructor(message) {
+        super({
+            code: 'LrUnsupportedException',
+            message,
+        });
+    }
+}
+export class LrExpiredCodeException extends LrException {
+    constructor(message) {
+        super({
+            code: 'LrExpiredCodeException',
+            message,
+        });
+    }
+}
+export class LrExpiredException extends LrException {
+    constructor(message) {
+        super({
+            code: 'LrExpiredException',
+            message,
+        });
+    }
+}
+export class LrBadStateException extends LrException {
+    constructor(message) {
+        super({
+            code: 'LrBadStateException',
+            message,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exceptions.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/_common/exceptions.ts"],"names":[],"mappings":"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","sourcesContent":["import { GraphQLError } from 'graphql';\r\nimport { debuglog } from 'util';\r\n\r\nexport function handleApolloError(errors: ReadonlyArray<GraphQLError>) {\r\n  if (!errors || !errors.length) return;\r\n\r\n  const lrErrors = errors.map((x) => ({\r\n    code: x.extensions && x.extensions.code,\r\n    source: x.extensions && x.extensions.source,\r\n    message: x.message,\r\n    debug: {\r\n      locations: x.locations as any,\r\n      path: x.path as string[],\r\n    },\r\n  }));\r\n\r\n  throw new LrException(...lrErrors);\r\n}\r\n\r\nexport class LrError {\r\n  code?: string;\r\n  source?: string;\r\n  message: string;\r\n  debug?: {\r\n    locations: {\r\n      line: number;\r\n      column: number;\r\n    }[];\r\n    path: string[];\r\n  };\r\n}\r\n\r\nexport class LrException {\r\n  public errors: LrError[];\r\n\r\n  constructor(...errors: LrError[]) {\r\n    this.errors = errors;\r\n  }\r\n\r\n  public toString() {\r\n    return this.errors.map((t) => JSON.stringify(t, null, 2));\r\n  }\r\n}\r\n\r\nexport enum LrApiErrorCode {\r\n  ARCHIVED_RESOURCE = 'ARCHIVED_RESOURCE',\r\n  BAD_ARGUMENT = 'BAD_ARGUMENT',\r\n  BAD_SIGNATURE = 'BAD_SIGNATURE',\r\n  BAD_STATE = 'BAD_STATE',\r\n  CHANGED_PERMISSIONS = 'CHANGED_PERMISSIONS',\r\n  CONCURRENT_ACCESS = 'CONCURRENT_ACCESS',\r\n  CONFIG_ERROR = 'CONFIG_ERROR',\r\n  CYCLE_DETECTED = 'CYCLE_DETECTED',\r\n  EXPIRED = 'EXPIRED',\r\n  INVALID_TOKEN = 'INVALID_TOKEN',\r\n  INTERNAL_ERROR = 'INTERNAL_ERROR',\r\n  JSON_DECODE_ERROR = 'JSON_DECODE_ERROR',\r\n  KEY_MISMATCH = 'KEY_MISMATCH',\r\n  LIMIT_REACHED = 'LIMIT_REACHED',\r\n  LOCKED = 'LOCKED',\r\n  LOGIC_ERROR = 'LOGIC_ERROR',\r\n  LR_DEBUG_ONLY = 'LR_DEBUG_ONLY',\r\n  MIN_DELAY = 'MIN_DELAY',\r\n  MISSING_FIELD = 'MISSING_FIELD',\r\n  MISSING_FIELD_VALUE = 'MISSING_FIELD_VALUE',\r\n  MISSING_QUERY_PARAM = 'MISSING_QUERY_PARAM',\r\n  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',\r\n  OBJECT_DOES_NOT_EXIST = 'OBJECT_DOES_NOT_EXIST',\r\n  OBJECT_EXISTS = 'OBJECT_EXISTS',\r\n  RANGE_ERROR = 'RANGE_ERROR',\r\n  TRUSTED_PARTY_NOT_FOUND = 'TRUSTED_PARTY_NOT_FOUND',\r\n  UNAUTHENTICATED_USER = 'UNAUTHENTICATED_USER',\r\n  USER_NOT_FOUND = 'USER_NOT_FOUND',\r\n  VERSION_MISMATCH = 'VERSION_MISMATCH',\r\n  WRONG_PERMISSIONS = 'WRONG_PERMISSIONS',\r\n}\r\n\r\nexport enum LrErrorCode {\r\n  BadTimeSync = 'LrBadTimeSync',\r\n  ReceiveClaimMismatch = 'LrReceiveClaimMismatch',\r\n  BadState = 'LrBadState',\r\n  BadSignature = 'LrBadSignature',\r\n  Auth = 'LrAuth',\r\n  BadArgument = 'LrBadArgument',\r\n  SuspiciousException = 'LrSuspiciousException',\r\n  NotFound = 'LrNotFound',\r\n  BadLogic = 'LrBadLogicException',\r\n  CodeMismatch = 'LrCodeMismatchException',\r\n  ConcurrentAccess = 'LrConcurrentAccessException',\r\n  BadRequest = 'LrBadRequestException',\r\n  Encryption = 'LrEncryptionGoBad',\r\n  Locked = 'LrLockedException',\r\n}\r\n\r\nexport class LrBadArgumentException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.BadArgument, message });\r\n  }\r\n}\r\n\r\nexport class LrSuspiciousException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.BadArgument, message });\r\n  }\r\n}\r\n\r\nexport class LrNotFoundException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.NotFound, message });\r\n  }\r\n}\r\n\r\nexport class LrBadLogicException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.BadLogic, message });\r\n  }\r\n}\r\n\r\nexport class LrCodeMismatchException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.CodeMismatch, message });\r\n  }\r\n}\r\n\r\nexport class LrConcurrentAccessException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.ConcurrentAccess, message });\r\n  }\r\n}\r\n\r\nexport class LrLockedException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.Locked, message });\r\n  }\r\n}\r\n\r\nexport class LrBadRequestException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.BadRequest, message });\r\n  }\r\n}\r\n\r\nexport class LrAuthException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.Auth, message });\r\n  }\r\n}\r\n\r\nexport class LrEncryptionException extends LrException {\r\n  constructor(message) {\r\n    super({ code: LrErrorCode.Encryption, message });\r\n  }\r\n}\r\n\r\nexport class LrUnsupportedException extends LrException {\r\n  constructor(message) {\r\n    super({\r\n      code: 'LrUnsupportedException',\r\n      message,\r\n    });\r\n  }\r\n}\r\n\r\nexport class LrExpiredCodeException extends LrException {\r\n  constructor(message) {\r\n    super({\r\n      code: 'LrExpiredCodeException',\r\n      message,\r\n    });\r\n  }\r\n}\r\n\r\nexport class LrExpiredException extends LrException {\r\n  constructor(message) {\r\n    super({\r\n      code: 'LrExpiredException',\r\n      message,\r\n    });\r\n  }\r\n}\r\n\r\nexport class LrBadStateException extends LrException {\r\n  constructor(message) {\r\n    super({\r\n      code: 'LrBadStateException',\r\n      message,\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2015/lib/_common/queries.gql.js

@@ -0,0 +1,190 @@
+import gql from 'graphql-tag';
+const KeyGraphFragmentBase = `
+{
+  keys {
+    id
+  }
+  keyLinks {
+    keyId
+    wrappingKeyId
+    wrappedKey
+  }
+  passKeys {
+    id
+  }
+  passKeyLinks {
+    keyId
+    passKeyId
+    wrappedKey
+  }
+  __typename
+}
+`;
+export const KeyGraphFragment = gql `
+fragment KeyGraphFragment on KeyGraphType ${KeyGraphFragmentBase}
+`;
+export const KeyGraphField = `keyGraph ${KeyGraphFragmentBase}`;
+export const FetchKeyGraphField = `keyGraph: fetchKeyGraph ${KeyGraphFragmentBase}`;
+export const FileQuery = gql `
+  query File($id: LrRelayIdInput!, $cachedKeyIds: [LrRelayIdInput!]) {
+    file(id: $id) {
+      id
+      keyId
+      currentVersion {
+        id
+        operation
+        state {
+          keyId
+          plainMeta
+          cipherMeta
+          contentResource
+        }
+      }
+      versions {
+        edges {
+          node {
+            id
+            state {
+              keyId
+              plainMeta
+              cipherMeta
+              contentResource
+            }
+          }
+        }
+      }
+      parentDirectoryLinks {
+        edges {
+          node {
+            parentDirectory {
+              id
+              plainMeta
+            }
+          }
+        }
+      }
+    }
+    keyGraph(cachedKeyIds: $cachedKeyIds) {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export const DirectoryQuery = gql `
+  query Directory($id: LrRelayIdInput!, $cachedKeyIds: [LrRelayIdInput!]) {
+    directory(id: $id) {
+      id
+      keyId
+      plainMeta
+      cipherMeta
+    }
+    keyGraph(cachedKeyIds: $cachedKeyIds) {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export const CreateFileQuery = gql `
+  mutation CreateFile($input: CreateFileInput!) {
+    createFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+export const UpdateFileQuery = gql `
+  mutation UpdateFile($input: UpdateFileInput!) {
+    updateFile(input: $input) {
+      file {
+        id
+        currentVersion {
+          id
+          state {
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+export const RevertFileQuery = gql `
+  mutation RevertFile($input: RevertFileInput!) {
+    revertFile(input: $input) {
+      file {
+        id
+        currentVersion {
+          id
+          state {
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+export const MoveFileQuery = gql `
+  mutation MoveFile(
+    $fileId: LrRelayIdInput!
+    $fromParentDirectoryId: LrRelayIdInput!
+    $toParentDirectoryId: LrRelayIdInput!
+    $wrappingKeyId: LrRelayIdInput!
+    $wrappedKey: String!
+  ) {
+    moveFile(
+      input: {
+        fileId: $fileId
+        fromParentDirectoryId: $fromParentDirectoryId
+        toParentDirectoryId: $toParentDirectoryId
+        wrappingKeyId: $wrappingKeyId
+        wrappedKey: $wrappedKey
+      }
+    ) {
+      file {
+        id
+        parentDirectoryLinks {
+          edges {
+            node {
+              parentDirectory {
+                plainMeta
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+export const MoveDirectoryQuery = gql `
+  mutation MoveDirectory(
+    $directoryId: LrRelayIdInput!
+    $fromParentDirectoryId: LrRelayIdInput
+    $toParentDirectoryId: LrRelayIdInput!
+    $wrappedKey: String!
+    $wrappingKeyId: LrRelayIdInput!
+  ) {
+    moveDirectory(
+      input: {
+        directoryId: $directoryId
+        fromParentDirectoryId: $fromParentDirectoryId
+        toParentDirectoryId: $toParentDirectoryId
+        wrappedKey: $wrappedKey
+        wrappingKeyId: $wrappingKeyId
+      }
+    ) {
+      directory {
+        id
+        parentDirectoryLinks {
+          edges {
+            node {
+              parentDirectory {
+                plainMeta
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/_common/run-outside-angular.js

@@ -0,0 +1,79 @@
+import { LrBadLogicException } from '../_common/exceptions';
+/**
+ * If you wish to change the behaviour of those, you'll need to create a derived
+ * class and override the methods.
+ * However, can't figure out a way to call the super() in the derived class ctor, error says
+ * the super call can't be in tested function.
+ */
+export const EXCLUDE_METHODS = [
+    'constructor',
+    'ngOnChanges',
+    'ngOnInit',
+    'ngDoCheck',
+    'ngAfterContentInit',
+    'ngAfterContentChecked',
+    'ngAfterViewInit',
+    'ngAfterViewChecked',
+    'ngOnDestroy',
+];
+// Patch all methods of the class.
+//
+// Note, this will not patch functions in the base class, it only
+// patches the function defined in the current class because it's
+// using getOwnPropertyNames(). You should be using composition for
+// services anyway.
+//
+// Ref: https://stackoverflow.com/a/44409244
+// The above approach might be a bit old. Now that we have ngZone.runOutsideAngular(),
+// we should probably use that and not touch any angular zone internals. But the approach
+// above doesn't require injecting ngZone.
+//
+// Ref: https://github.com/2ng/run-outside-angular/blob/master/src/run-outside-angular.ts
+export function RunOutsideAngular({ ngZoneName, exceptLastPromise = true, excludeMethods = [], patchSetters = true, }) {
+    return (target) => {
+        function run(original, args) {
+            if (!this[ngZoneName]) {
+                throw new LrBadLogicException(`RunOutsideAngular decorator requires that ${target.name} inject NgZone as ${ngZoneName}`);
+            }
+            // runOutsideAngular() synchronously runs the callback and returns the result.
+            const result = this[ngZoneName].runOutsideAngular(() => original.apply(this, args));
+            if (exceptLastPromise && (result === null || result === void 0 ? void 0 : result.then)) {
+                // Bring back into zone which will trigger change detection properly.
+                // If this doesn't work, then we'll have to trigger change detection explicitly.
+                return Promise.resolve(result);
+            }
+            else {
+                return result;
+            }
+        }
+        // There should be no reason to run any of the ones in EXCLUDE_METHODS outside angular.
+        // So we always exclude them from patching. You can always explicit implement these ones differently.
+        excludeMethods = [...excludeMethods, ...EXCLUDE_METHODS];
+        const methods = Object.getOwnPropertyNames(target.prototype);
+        methods
+            .filter((method) => !excludeMethods.includes(method))
+            .forEach((method) => {
+            // Patch setters
+            // Note that setters do not return any thing. But they can still issue async calls.
+            // These async calls are not visible to the wrapper. So we can't issue change detection
+            // for setters when they are running outside angular.
+            if (patchSetters &&
+                Object.getOwnPropertyDescriptor(target.prototype, method).set) {
+                const original = Object.getOwnPropertyDescriptor(target.prototype, method).set;
+                Object.defineProperty(target.prototype, method, {
+                    set(...args) {
+                        return run.apply(this, [original, args]);
+                    },
+                });
+            }
+            if (typeof target.prototype[method] === 'function') {
+                const original = target.prototype[method];
+                target.prototype[method] = function (...args) {
+                    return run.apply(this, [original, args]);
+                };
+            }
+        });
+        return target;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run-outside-angular.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/_common/run-outside-angular.ts"],"names":[],"mappings":"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","sourcesContent":["import { LrBadLogicException } from '../_common/exceptions';\r\n\r\nexport interface RunOutsideAngularConfig {\r\n  ngZoneName: string;\r\n  // If true, a single change detection is triggered on resolve of the Promise returned\r\n  // from the function.\r\n  // else, the entire function is run outside of zone.\r\n  // Note that if this is disabled, then change detection is not triggered even if you\r\n  // use async pipes to subscribe to observables on the resulting promise. This is because\r\n  // async pipes only _marks_ a component for change detection, it doesn't actually _trigger_\r\n  // the change detection cycle.\r\n  exceptLastPromise?: boolean;\r\n  // Any method or property you wish to exclude from patch. The methods in EXCLUDE_METHODS are\r\n  // never patched.\r\n  excludeMethods?: string[];\r\n  // If true, patch the setters as well. Settings are some\r\n  // Note that setters do not return any thing. But they can still issue async calls.\r\n  // These async calls are not visible to the wrapper. So we can't issue change detection\r\n  // for setters when they are running outside angular.\r\n  // Note that getters are not patched because getter and setter must use the same type. So if\r\n  // the getter returns a promise, then the setting must alway take a promise. It doesn't make\r\n  // much sense to use getters and setters this way. And if getter returns a value, then there's\r\n  // no need to patch it to run outside angular.\r\n  patchSetters?: boolean;\r\n}\r\n\r\n/**\r\n * If you wish to change the behaviour of those, you'll need to create a derived\r\n * class and override the methods.\r\n * However, can't figure out a way to call the super() in the derived class ctor, error says\r\n * the super call can't be in tested function.\r\n */\r\nexport const EXCLUDE_METHODS = [\r\n  'constructor',\r\n  'ngOnChanges',\r\n  'ngOnInit',\r\n  'ngDoCheck',\r\n  'ngAfterContentInit',\r\n  'ngAfterContentChecked',\r\n  'ngAfterViewInit',\r\n  'ngAfterViewChecked',\r\n  'ngOnDestroy',\r\n];\r\n\r\n// Patch all methods of the class.\r\n//\r\n// Note, this will not patch functions in the base class, it only\r\n// patches the function defined in the current class because it's\r\n// using getOwnPropertyNames(). You should be using composition for\r\n// services anyway.\r\n//\r\n// Ref: https://stackoverflow.com/a/44409244\r\n// The above approach might be a bit old. Now that we have ngZone.runOutsideAngular(),\r\n// we should probably use that and not touch any angular zone internals. But the approach\r\n// above doesn't require injecting ngZone.\r\n//\r\n// Ref: https://github.com/2ng/run-outside-angular/blob/master/src/run-outside-angular.ts\r\nexport function RunOutsideAngular({\r\n  ngZoneName,\r\n  exceptLastPromise = true,\r\n  excludeMethods = [],\r\n  patchSetters = true,\r\n}: RunOutsideAngularConfig) {\r\n  return (target: any) => {\r\n    function run(original, args) {\r\n      if (!this[ngZoneName]) {\r\n        throw new LrBadLogicException(\r\n          `RunOutsideAngular decorator requires that ${target.name} inject NgZone as ${ngZoneName}`\r\n        );\r\n      }\r\n      // runOutsideAngular() synchronously runs the callback and returns the result.\r\n      const result = this[ngZoneName].runOutsideAngular(() =>\r\n        original.apply(this, args)\r\n      );\r\n\r\n      if (exceptLastPromise && result?.then) {\r\n        // Bring back into zone which will trigger change detection properly.\r\n        // If this doesn't work, then we'll have to trigger change detection explicitly.\r\n        return Promise.resolve(result);\r\n      } else {\r\n        return result;\r\n      }\r\n    }\r\n\r\n    // There should be no reason to run any of the ones in EXCLUDE_METHODS outside angular.\r\n    // So we always exclude them from patching. You can always explicit implement these ones differently.\r\n    excludeMethods = [...excludeMethods, ...EXCLUDE_METHODS];\r\n\r\n    const methods = Object.getOwnPropertyNames(target.prototype);\r\n\r\n    methods\r\n      .filter((method) => !excludeMethods.includes(method))\r\n      .forEach((method) => {\r\n        // Patch setters\r\n        // Note that setters do not return any thing. But they can still issue async calls.\r\n        // These async calls are not visible to the wrapper. So we can't issue change detection\r\n        // for setters when they are running outside angular.\r\n        if (\r\n          patchSetters &&\r\n          Object.getOwnPropertyDescriptor(target.prototype, method).set\r\n        ) {\r\n          const original = Object.getOwnPropertyDescriptor(\r\n            target.prototype,\r\n            method\r\n          ).set;\r\n\r\n          Object.defineProperty(target.prototype, method, {\r\n            set(...args) {\r\n              return run.apply(this, [original, args]);\r\n            },\r\n          });\r\n        }\r\n\r\n        if (typeof target.prototype[method] === 'function') {\r\n          const original = target.prototype[method];\r\n\r\n          target.prototype[method] = function(...args) {\r\n            return run.apply(this, [original, args]);\r\n          };\r\n        }\r\n      });\r\n\r\n    return target;\r\n  };\r\n}\r\n"]}

package/esm2015/lib/_common/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVjdHMvdGVzdC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9fY29tbW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIYXNLZXlHcmFwaCB9IGZyb20gJy4uL2NyeXB0b2dyYXBoeS9jcnlwdG9ncmFwaHkudHlwZXMnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBFZGdlPFQ+IHtcclxuICBub2RlOiBUO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhhc0VkZ2VzPFQ+IHtcclxuICBlZGdlczogRWRnZTxUPltdO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhhc0tleUdyYXBoRWRnZXM8VD4gZXh0ZW5kcyBIYXNLZXlHcmFwaCB7XHJcbiAgbGlzdDogSGFzRWRnZXM8VD47XHJcbn1cclxuIl19

package/esm2015/lib/_common/utils.js

@@ -0,0 +1,44 @@
+// Promise.all always returns a promise, even if all the values are not async.
+// During processing of deep hierarchies of nested objects we don't always need to
+// promote everything to a promise.
+export function promiseAllMayAsync(values) {
+    if (!Array.isArray(values)) {
+        throw new Error('not array');
+    }
+    if (values.some((value) => value === null || value === void 0 ? void 0 : value.then)) {
+        const ret = Promise.all(values);
+        return ret;
+    }
+    else {
+        return values;
+    }
+}
+function remap(obj, values) {
+    const ret = {};
+    for (const [i, key] of Object.keys(obj).entries()) {
+        ret[key] = values[i];
+    }
+    return ret;
+}
+export function mapValuesMayAsync(obj, 
+// callback can either return a Promise, or a value.
+// The Promise<any> type is redundant but it shows that it can return a promise
+callback) {
+    const values = promiseAllMayAsync(Object.entries(obj).map(([key, value]) => callback(value, key, obj)));
+    if (values.then) {
+        return values.then((resolvedValues) => remap(obj, resolvedValues));
+    }
+    else {
+        return remap(obj, values);
+    }
+}
+export function mapValuesAsync(obj, 
+// callback can either return a Promise, or a value.
+// The Promise<any> type is redundant but it shows that it can return a promise
+// By default, it returns the value without any process, so you can use
+// this to simply wait for all promises in an object to resolve.
+callback) {
+    const values = Promise.all(Object.entries(obj).map(([key, value]) => callback ? callback(value, key, obj) : value));
+    return values.then((resolvedValues) => remap(obj, resolvedValues));
+}
+//# sourceMappingURL=data:application/json;base64,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