@shared-state/persist/dist/index.cjs

此软件包提供状态持久化功能

'use strict';

var core = require('@shared-state/core');

function persist(sharedState, options) {
  var _storage$subscribe;
  var key = options.key,
    storage = options.storage,
    version = options.version,
    migrate = options.migrate,
    onHydrationStart = options.onHydrationStart,
    onHydrationEnd = options.onHydrationEnd,
    onHydrationFailed = options.onHydrationFailed;
  var hydrationState = core.createSharedState(false);
  var ignoreHydration = false;
  var setSharedStateWithPersistentValue = function setSharedStateWithPersistentValue(persistentValue) {
    if (persistentValue.version === version) {
      sharedState.set(persistentValue.value);
    } else if (persistentValue.version !== version && migrate) {
      sharedState.set(migrate(persistentValue.value, persistentValue.version));
    }
  };
  var hydrate = function hydrate() {
    hydrationState.set(true);
    ignoreHydration = false;
    onHydrationStart === null || onHydrationStart === void 0 ? void 0 : onHydrationStart();
    var getStorageResult = storage.get(key);
    var hydrateValueToSharedState = function hydrateValueToSharedState(persistentValue) {
      if (!ignoreHydration && persistentValue !== null) {
        setSharedStateWithPersistentValue(persistentValue);
      }
      hydrationState.set(false);
      onHydrationEnd === null || onHydrationEnd === void 0 ? void 0 : onHydrationEnd();
    };
    if (getStorageResult instanceof Promise) {
      getStorageResult.then(hydrateValueToSharedState)["catch"](onHydrationFailed);
    } else {
      hydrateValueToSharedState(getStorageResult);
    }
  };
  hydrate();
  (_storage$subscribe = storage.subscribe) === null || _storage$subscribe === void 0 ? void 0 : _storage$subscribe.call(storage, key, function (persistentValue) {
    ignoreHydration = true;
    if (persistentValue !== null) {
      setSharedStateWithPersistentValue(persistentValue);
    } else {
      sharedState.reset();
    }
  });
  return {
    get: sharedState.get,
    set: function set(valueOrUpdater) {
      ignoreHydration = true;
      sharedState.set(valueOrUpdater);
      storage.set(key, {
        value: sharedState.get(),
        version: version
      });
    },
    subscribe: sharedState.subscribe,
    reset: function reset() {
      ignoreHydration = true;
      storage.remove(key);
      sharedState.reset();
    },
    hydrate: hydrate,
    hydrationState: hydrationState
  };
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
      _defineProperty(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}

function withConverter(storage, options) {
  var serialize = options.serialize,
    deserialize = options.deserialize;
  var deserializeValue = function deserializeValue(value) {
    if (value === null) return null;
    try {
      return deserialize(value);
    } catch (_unused) {
      return null;
    }
  };
  return _objectSpread2(_objectSpread2({}, storage), {}, {
    get: function get(key) {
      var getStorageResult = storage.get(key);
      if (getStorageResult instanceof Promise) {
        return getStorageResult.then(deserializeValue);
      } else {
        return deserializeValue(getStorageResult);
      }
    },
    set: function set(key, value) {
      return storage.set(key, serialize(value));
    },
    subscribe: function subscribe(key, handler) {
      return storage.subscribe(key, function (nextValue, previousValue) {
        return handler(nextValue !== null ? deserializeValue(nextValue) : null, previousValue !== null ? deserializeValue(previousValue) : null);
      });
    }
  });
}
function createWebPersistentStorage(webStorage, options) {
  return withConverter({
    get: function get(key) {
      return webStorage.getItem(key);
    },
    set: function set(key, value) {
      return webStorage.setItem(key, value);
    },
    remove: function remove(key) {
      return webStorage.removeItem(key);
    },
    subscribe: function subscribe(key, handler) {
      var eventHandler = function eventHandler(event) {
        if (!event.key || event.key !== key || event.newValue === event.oldValue) return;
        handler(event.newValue, event.oldValue);
      };
      window.addEventListener("storage", eventHandler);
      return function () {
        return window.removeEventListener("storage", eventHandler);
      };
    }
  }, {
    serialize: (options === null || options === void 0 ? void 0 : options.serialize) || JSON.stringify,
    deserialize: (options === null || options === void 0 ? void 0 : options.deserialize) || JSON.parse
  });
}

exports.createWebPersistentStorage = createWebPersistentStorage;
exports.persist = persist;
exports.withConverter = withConverter;