@yoroi/common/lib/commonjs/storage/adapters/async-storage.js

The Common package of Yoroi SDK

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.mountAsyncStorage = exports.mountAsyncMultiStorage = void 0;
var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
var _parsers = require("../../utils/parsers");
var _isFolderKey = require("../helpers/is-folder-key");
var _isFileKey = require("../helpers/is-file-key");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const mountAsyncStorage = _ref => {
  let {
    path
  } = _ref;
  const withPath = key => `${path}${key}`;
  const withoutPath = value => value.slice(path.length);
  async function getItem(key) {
    let parse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _parsers.parseSafe;
    const item = await _asyncStorage.default.getItem(withPath(key));
    return parse(item);
  }
  async function multiGet(keys) {
    let parse = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _parsers.parseSafe;
    const absolutePaths = keys.map(key => withPath(key));
    const items = await _asyncStorage.default.multiGet(absolutePaths);
    return items.map(_ref2 => {
      let [key, value] = _ref2;
      return [withoutPath(key), parse(value)];
    });
  }
  return {
    join: folderName => mountAsyncStorage({
      path: `${path}${folderName}`
    }),
    getItem,
    multiGet,
    setItem: async function (key, value) {
      let stringify = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : JSON.stringify;
      const item = stringify(value);
      await _asyncStorage.default.setItem(withPath(key), item);
    },
    multiSet: async function (tuples) {
      let stringify = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : JSON.stringify;
      const items = tuples.map(_ref3 => {
        let [key, value] = _ref3;
        return [withPath(key), stringify(value)];
      });
      await _asyncStorage.default.multiSet(items);
    },
    removeItem: async key => {
      await _asyncStorage.default.removeItem(withPath(key));
    },
    removeFolder: async folderName => {
      const keys = await _asyncStorage.default.getAllKeys();
      const filteredKeys = keys.filter(key => key.startsWith(path) && withoutPath(key).startsWith(folderName) && (0, _isFolderKey.isFolderKey)({
        key,
        path
      }));
      await _asyncStorage.default.multiRemove(filteredKeys);
    },
    multiRemove: async keys => {
      await _asyncStorage.default.multiRemove(keys.map(key => withPath(key)));
    },
    getAllKeys: () => {
      return _asyncStorage.default.getAllKeys().then(keys => keys.filter(key => key.startsWith(path) && (0, _isFileKey.isFileKey)({
        key,
        path
      }))).then(
      // temporary any until async interface is migrated to receive keys for multi storage
      filteredKeys => filteredKeys.map(withoutPath));
    },
    clear: async () => {
      const keys = await _asyncStorage.default.getAllKeys();
      const filteredKeys = keys.filter(key => key.startsWith(path));
      await _asyncStorage.default.multiRemove(filteredKeys);
    }
  };
};
exports.mountAsyncStorage = mountAsyncStorage;
const mountAsyncMultiStorage = options => {
  const {
    storage,
    dataFolder,
    keyExtractor,
    serializer = JSON.stringify,
    deserializer = _parsers.parseSafe
  } = options;
  const dataStorage = storage.join(dataFolder);
  const {
    getAllKeys: getAllKeysStorage,
    multiSet,
    multiGet
  } = dataStorage;
  const clear = () => storage.removeFolder(dataFolder);
  const saveMany = items => {
    const entries = items.map(item => {
      if (typeof keyExtractor === 'function') {
        return [keyExtractor(item), item];
      }
      return [String(item[keyExtractor]), item];
    });
    const entriesWithKeys = entries.filter(_ref4 => {
      let [key] = _ref4;
      return key != null && key !== '';
    });
    return multiSet(entriesWithKeys, serializer);
  };
  const readAll = () => getAllKeys().then(keysToRead => multiGet(keysToRead, deserializer));
  const readMany = keysToRead => dataStorage.multiGet(keysToRead, deserializer);
  const removeMany = keysToRead => dataStorage.multiRemove(keysToRead);
  const getAllKeys = () => getAllKeysStorage().then(keys => keys);
  return {
    getAllKeys,
    clear,
    readAll,
    saveMany,
    readMany,
    removeMany
  };
};
exports.mountAsyncMultiStorage = mountAsyncMultiStorage;
//# sourceMappingURL=async-storage.js.map