react-x-keychain/build/Keychain.js

Cross-platform persistent storage for ReactDOM (cookies) and React Native (keychain) apps.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _invariant = _interopRequireDefault(require("invariant"));

var _lodash = _interopRequireDefault(require("lodash.omit"));

var _KeychainX = _interopRequireDefault(require("./KeychainX"));

// Libraries
// Modules

/**
 * Persistent secure storage for all apps.
 */
var Keychain =
/*#__PURE__*/
function () {
  // --------------------------------------------------
  // Initialize
  // --------------------------------------------------
  function Keychain(_ref) {
    var namespace = _ref.namespace,
        domain = _ref.domain,
        expires = _ref.expires,
        _ref$path = _ref.path,
        path = _ref$path === void 0 ? '/' : _ref$path,
        _ref$secure = _ref.secure,
        secure = _ref$secure === void 0 ? false : _ref$secure;
    (0, _classCallCheck2["default"])(this, Keychain);
    this.initialized = false;
    this.all = {};
    this.options = {
      domain: domain,
      expires: expires,
      path: path,
      secure: secure
    };
    this.keychain = new _KeychainX["default"]({
      namespace: namespace
    });
  }

  (0, _createClass2["default"])(Keychain, [{
    key: "initialize",
    value: function () {
      var _initialize = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(keys) {
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return this.getEntries(keys);

              case 2:
                this.all = _context.sent;
                this.initialized = true;

              case 4:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function initialize(_x) {
        return _initialize.apply(this, arguments);
      }

      return initialize;
    }() // --------------------------------------------------
    // Public
    // --------------------------------------------------

  }, {
    key: "get",
    value: function get(key) {
      this.assertInitialized('get');
      return this.all[key];
    }
  }, {
    key: "set",
    value: function () {
      var _set = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2(key, value) {
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                this.assertInitialized('set');
                return _context2.abrupt("return", this.setEntries((0, _defineProperty2["default"])({}, key, value)));

              case 2:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function set(_x2, _x3) {
        return _set.apply(this, arguments);
      }

      return set;
    }()
  }, {
    key: "reset",
    value: function () {
      var _reset = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee3() {
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                this.assertInitialized('reset');
                return _context3.abrupt("return", this.clearKeys(Object.keys(this.all)));

              case 2:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function reset() {
        return _reset.apply(this, arguments);
      }

      return reset;
    }() // --------------------------------------------------
    // Private
    // --------------------------------------------------

  }, {
    key: "assertInitialized",
    value: function assertInitialized(method) {
      (0, _invariant["default"])(this.initialized, "Keychain calling '".concat(method, "' before it has been initialized."));
    }
  }, {
    key: "setEntries",
    value: function () {
      var _setEntries = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee4() {
        var entries,
            _args4 = arguments;
        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                entries = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : {};
                this.assertInitialized('setEntries');
                this.all = (0, _objectSpread2["default"])({}, this.all, entries);
                return _context4.abrupt("return", this.save(this.all));

              case 4:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function setEntries() {
        return _setEntries.apply(this, arguments);
      }

      return setEntries;
    }() // --------------------------------------------------
    // KeychainX
    // --------------------------------------------------

  }, {
    key: "getEntries",
    value: function () {
      var _getEntries = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee5() {
        var keys,
            _args5 = arguments;
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                keys = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : [];
                return _context5.abrupt("return", this.keychain.getEntries(keys));

              case 2:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function getEntries() {
        return _getEntries.apply(this, arguments);
      }

      return getEntries;
    }()
  }, {
    key: "save",
    value: function () {
      var _save = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee6() {
        var all,
            _args6 = arguments;
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                all = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {};
                return _context6.abrupt("return", this.keychain.save(all, this.options));

              case 2:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function save() {
        return _save.apply(this, arguments);
      }

      return save;
    }()
  }, {
    key: "clearKeys",
    value: function () {
      var _clearKeys = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee7() {
        var keys,
            _args7 = arguments;
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                keys = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : [];
                // Modify the cache before clearing the actual keychain.
                this.all = (0, _lodash["default"])(this.all, keys);
                return _context7.abrupt("return", this.keychain.clearKeys(keys, this.all, this.options));

              case 3:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function clearKeys() {
        return _clearKeys.apply(this, arguments);
      }

      return clearKeys;
    }()
  }]);
  return Keychain;
}();

var _default = Keychain;
exports["default"] = _default;