@lifeready/core 1.0.1 → 1.0.3

package/src/lib/_common/run-outside-angular.ts

@@ -1,125 +0,0 @@
-import { LrBadLogicException } from '../_common/exceptions';
-
-export interface RunOutsideAngularConfig {
-  ngZoneName: string;
-  // If true, a single change detection is triggered on resolve of the Promise returned
-  // from the function.
-  // else, the entire function is run outside of zone.
-  // Note that if this is disabled, then change detection is not triggered even if you
-  // use async pipes to subscribe to observables on the resulting promise. This is because
-  // async pipes only _marks_ a component for change detection, it doesn't actually _trigger_
-  // the change detection cycle.
-  exceptLastPromise?: boolean;
-  // Any method or property you wish to exclude from patch. The methods in EXCLUDE_METHODS are
-  // never patched.
-  excludeMethods?: string[];
-  // If true, patch the setters as well. Settings are some
-  // 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.
-  // Note that getters are not patched because getter and setter must use the same type. So if
-  // the getter returns a promise, then the setting must alway take a promise. It doesn't make
-  // much sense to use getters and setters this way. And if getter returns a value, then there's
-  // no need to patch it to run outside angular.
-  patchSetters?: boolean;
-}
-
-/**
- * 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,
-}: RunOutsideAngularConfig) {
-  return (target: any) => {
-    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?.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;
-  };
-}

package/src/lib/_common/tests.ts

@@ -1,82 +0,0 @@
-import { environment } from 'projects/lr-auth-app/src/environments/environment';
-import { TestBed } from '@angular/core/testing';
-import { LifeReadyModule } from '../life-ready.module';
-const enableTests = environment.test.enableTests;
-
-export async function lrExpectAsyncThrow(promise) {
-  async function run() {
-    try {
-      await promise;
-      return expect(void 0);
-    } catch (error) {
-      console.log('lrExpectAsyncThrow: error thrown: ', error);
-      return expect(error);
-    }
-  }
-
-  const res = await run();
-  res.toBeTruthy();
-
-  // Return the expect() so that caller can test it for specific errors.
-  return res;
-}
-
-// Same signature as it()
-export function lrit(
-  expectation: string,
-  assertion?: jasmine.ImplementationCallback,
-  timeout?: number
-) {
-  if (enableTests) {
-    return it(expectation, assertion, timeout);
-  }
-}
-
-export function delaySec(value: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(), value * 1000);
-  });
-}
-
-export function lrConfigureTestingModule() {
-  TestBed.configureTestingModule({
-    imports: [
-      LifeReadyModule.forRoot({
-        authUrl: environment.auth.url,
-        apiUrl: environment.apiUrl,
-        apolloUrl: `${environment.apiUrl}graphql/`,
-        userPoolId: environment.auth.userPoolId,
-        userPoolWebClientId: environment.auth.userPoolWebClientId,
-        disableSessionEncryptionKey:
-          environment.auth.disableSessionEncryptionKey,
-      }),
-    ],
-  });
-}
-
-// export async function lrExpectGqlErrorCode(promise, code: string) {
-//   (await lrExpectAsyncThrow(promise)).toEqual(
-//     jasmine.objectContaining({
-//       errors: jasmine.arrayContaining([jasmine.objectContaining({ code })]),
-//     })
-//   );
-// }
-
-export function lrExpectGqlErrorCodesSync(error) {
-  const codes = (error.errors || []).filter((e) => e.code).map((e) => e.code);
-  return expect(codes);
-}
-
-// Returns expect() so that the source code lines on the failed tests are available.
-export async function lrExpectGqlErrorCodes(promise) {
-  try {
-    await promise;
-    return expect([]);
-  } catch (error) {
-    return lrExpectGqlErrorCodesSync(error);
-  }
-}
-
-export function lrDelay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/lib/_common/utils.ts

@@ -1,57 +0,0 @@
-// 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: any[]): Promise<any> | any {
-  if (!Array.isArray(values)) {
-    throw new Error('not array');
-  }
-  if (values.some((value) => 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: object,
-  // 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: (value: any, key: string, obj: object) => any | Promise<any>
-): Promise<any> | any {
-  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: object,
-  // 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?: (value: any, key: string, obj: object) => any | Promise<any>
-): Promise<any> {
-  const values = Promise.all(
-    Object.entries(obj).map(([key, value]) =>
-      callback ? callback(value, key, obj) : value
-    )
-  );
-
-  return values.then((resolvedValues) => remap(obj, resolvedValues));
-}