@belloai/ls/lib/index.js

base64 的Local Storage

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@babel/runtime/helpers/classCallCheck'), require('@babel/runtime/helpers/createClass'), require('@babel/runtime/helpers/defineProperty'), require('store'), require('js-base64')) :
  typeof define === 'function' && define.amd ? define(['@babel/runtime/helpers/classCallCheck', '@babel/runtime/helpers/createClass', '@babel/runtime/helpers/defineProperty', 'store', 'js-base64'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global["@belloai/ls"] = factory(global._classCallCheck, global._createClass, global._defineProperty, global.store, global.jsBase64));
})(this, (function (_classCallCheck, _createClass, _defineProperty, store, jsBase64) { 'use strict';

  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

  var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
  var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
  var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
  var store__default = /*#__PURE__*/_interopDefaultLegacy(store);

  var Base64Store = /*#__PURE__*/function () {
    function Base64Store(props) {
      _classCallCheck__default["default"](this, Base64Store);

      _defineProperty__default["default"](this, "notClearKeys", [// 退出登录时候需要保留的
      ]);

      _defineProperty__default["default"](this, "passLocalStorageB64Key", 'passLocalStorageB64');

      _defineProperty__default["default"](this, "isBase64", true);

      var _ref = props || {},
          notClearKeys = _ref.notClearKeys,
          _ref$isBase = _ref.isBase64,
          isBase64 = _ref$isBase === void 0 ? true : _ref$isBase;

      this.notClearKeys = notClearKeys || [];
      this.isBase64 = isBase64;
    }

    _createClass__default["default"](Base64Store, [{
      key: "get",
      value: function get(key) {
        return this.b64ToUtf8(store__default["default"].get(key));
      }
    }, {
      key: "remove",
      value: function remove(key) {
        store__default["default"].remove(key);
      }
    }, {
      key: "set",
      value: function set(key, val) {
        return store__default["default"].set(key, this.utf8ToB64(val));
      }
    }, {
      key: "clear",
      value: function clear() {
        store__default["default"].clearAll();
      }
    }, {
      key: "getKeys",
      value: function getKeys() {
        var keys = [];
        store__default["default"].each(function (item, key) {
          keys.push(key);
        });
        return keys;
      }
    }, {
      key: "clearAllExcept",
      value: function clearAllExcept(item) {
        var temp = [];

        if (typeof item === 'string') {
          temp.push({
            key: item,
            val: store__default["default"].get(item)
          });
        } else if (Array.isArray(item)) {
          item.forEach(function (key) {
            temp.push({
              key: key,
              val: store__default["default"].get(key)
            });
          });
        } else {
          this.notClearKeys.forEach(function (key) {
            temp.push({
              key: key,
              val: store__default["default"].get(key)
            });
          });
        }

        store__default["default"].clearAll();
        temp.forEach(function (obj) {
          if (obj.val) {
            store__default["default"].set(obj.key, obj.val);
          }
        });
      }
    }, {
      key: "b64ToUtf8",
      value: function b64ToUtf8(str) {
        var utfStr = str;

        try {
          utfStr = decodeURIComponent(escape(jsBase64.decode(str)));
        } catch (error) {// console.warn(error)
        }

        try {
          return JSON.parse(utfStr);
        } catch (error) {// console.warn(error)
        }

        return utfStr;
      }
    }, {
      key: "utf8ToB64",
      value: function utf8ToB64(str) {
        if (!this.isPass()) {
          try {
            return jsBase64.encode(unescape(encodeURIComponent(JSON.stringify(str))));
          } catch (error) {// console.warn(error)
          }
        }

        return str;
      }
    }, {
      key: "isPass",
      value: function isPass() {
        return !!store__default["default"].get(this.passLocalStorageB64Key) || !this.isBase64;
      }
    }]);

    return Base64Store;
  }();

  return Base64Store;

}));

    if(typeof window !== 'undefined') {
      window.pgk__belloai_ls_version = '0.0.1'
    }
    /*!
  * @belloai/ls v0.0.1
  * (c) 2021 thomas-ballo <liurongliang@balloai.com>
  * @license MIT
  */