@yoroi/common/lib/module/storage/adapters/observable-storage.js

The Common package of Yoroi SDK

import { observerMaker } from '../../observer/observer';
import { isString } from '../../utils/parsers';
import { intersection } from '../../utils/arrays';
export const observableStorageMaker = storage => {
  const triggers = ['clear',
  // 'removeFolder', can be added later as long the key checks for "/" in the arg when string
  'multiSet', 'setItem', 'multiRemove', 'removeItem'];
  const observable = observerMaker();
  const onChange = (keysToObserve, callback) => {
    const wrappedCallback = keysUpdated => {
      if (!keysUpdated) {
        callback(null);
      } else {
        const keysToAnnounce = intersection(keysToObserve, keysUpdated);
        if (keysToAnnounce.length > 0) callback(keysToAnnounce);
      }
    };
    return observable.subscribe(wrappedCallback);
  };
  const proxyHandler = {
    get(target, property, receiver) {
      const origProperty = target[property];
      if (typeof origProperty === 'function' && triggers.includes(property)) {
        const origMethod = origProperty;
        return function () {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          const notify = () => {
            const [firstArg] = args;
            const isArray = Array.isArray(firstArg);
            if (isString(firstArg)) {
              // single operations
              observable.notify([firstArg]);
            } else if (isArray) {
              // multi operations
              const keys = firstArg;
              observable.notify(keys);
            } else {
              // clear
              observable.notify(null);
            }
          };
          const result = origMethod.apply(target, args);
          if (result instanceof Promise) {
            return result.then(resolvedValue => {
              notify();
              return resolvedValue;
            });
          } else {
            notify();
            return result;
          }
        };
      }
      return Reflect.get(target, property, receiver);
    }
  };
  const proxiedStorage = new Proxy(storage, proxyHandler);
  return {
    ...proxiedStorage,
    onChange
  };
};
export const observableMultiStorageMaker = storage => {
  const triggers = ['clear', 'saveMany'];
  const observable = observerMaker();
  const onChange = callback => observable.subscribe(callback);
  const proxyHandler = {
    get(target, property, receiver) {
      const origProperty = target[property];
      if (typeof origProperty === 'function' && triggers.includes(property)) {
        const origMethod = origProperty;
        return function () {
          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }
          const result = origMethod.apply(target, args);
          if (result instanceof Promise) {
            return result.then(resolvedValue => {
              observable.notify(null);
              return resolvedValue;
            });
          } else {
            observable.notify(null);
            return result;
          }
        };
      }
      return Reflect.get(target, property, receiver);
    }
  };
  const proxiedStorage = new Proxy(storage, proxyHandler);
  return {
    ...proxiedStorage,
    onChange
  };
};
//# sourceMappingURL=observable-storage.js.map