killa/dist/cjs/middleware/persist.js

State management for Vanilla and React

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var persist_exports = {};
__export(persist_exports, {
  initRevalidateOnFocus: () => initRevalidateOnFocus,
  normalizeStorage: () => normalizeStorage,
  persist: () => persist
});
module.exports = __toCommonJS(persist_exports);
var import_constants = require("killa/constants");
var import_helpers = require("killa/helpers");
const normalizeStorage = (initializerStorage, { encrypted = false } = {}) => {
  try {
    const storage = initializerStorage();
    if (!storage)
      return null;
    return {
      getItem: (name) => {
        const _name = encrypted ? (0, import_helpers.encoded)(name) : name;
        const value = storage.getItem(_name);
        const data = encrypted && value ? (0, import_helpers.decoded)(value) : value;
        return (0, import_helpers.deserialize)(data);
      },
      setItem: (name, value) => {
        const _name = encrypted ? (0, import_helpers.encoded)(name) : name;
        const data = encrypted ? (0, import_helpers.encoded)((0, import_helpers.serialize)(value)) : (0, import_helpers.serialize)(value);
        return storage.setItem(_name, data);
      },
      removeItem: (name) => {
        const _name = encrypted ? (0, import_helpers.encoded)(name) : name;
        storage.removeItem(_name);
      }
    };
  } catch (e) {
    return null;
  }
};
const validateStorage = (initializerStorage) => {
  if (typeof initializerStorage === "function") {
    try {
      return initializerStorage();
    } catch (error) {
      return null;
    }
  }
  return initializerStorage;
};
const initRevalidateOnFocus = (listener) => {
  (0, import_helpers.addWindowEvent)("focus", listener);
  (0, import_helpers.addDocumentEvent)("visibilitychange", listener);
  return () => {
    (0, import_helpers.removeWindowEvent)("focus", listener);
    (0, import_helpers.removeDocumentEvent)("visibilitychange", listener);
  };
};
const persist = (config) => (store) => {
  const baseConfig = {
    name: "",
    storage: normalizeStorage(() => window.localStorage, {
      encrypted: (config == null ? void 0 : config.encrypted) || false
    }),
    merge: import_helpers.merge,
    revalidate: true,
    revalidateTimeout: 200,
    ...config
  };
  const storageName = baseConfig.name;
  const storage = validateStorage(baseConfig.storage);
  if ((store == null ? void 0 : store.$$store) !== import_constants.SYMBOL_STORE) {
    console.error(
      "[Killa Persist] Provide a valid killa store to persist your store."
    );
    return;
  }
  if (!storageName) {
    console.error("[Killa Persist] Provide a name to persist your store.");
    return;
  }
  if (!storage) {
    console.error("[Killa Persist] Provide a storage to persist your store.");
    return;
  }
  const _setState = store.setState;
  let hydrated = false;
  store.setState = (state, force) => {
    _setState(state, force);
    storage == null ? void 0 : storage.setItem(storageName, store.getState());
  };
  const hydrate = () => {
    const persistedState = storage == null ? void 0 : storage.getItem(storageName);
    store.setState(() => {
      return {
        ...(0, import_helpers.merge)(store.getState(), persistedState)
      };
    });
    hydrated = true;
  };
  if (baseConfig.revalidate) {
    const revalidateOnFocusListener = () => {
      if (document.visibilityState === "visible") {
        setTimeout(hydrate, baseConfig.revalidateTimeout);
      }
    };
    initRevalidateOnFocus(revalidateOnFocusListener);
  }
  hydrate();
  store.persist = Object.freeze({
    $$persist: import_constants.SYMBOL_PERSIST,
    name: storageName,
    destroy: () => storage.removeItem(storageName),
    rehydrate: () => hydrate(),
    hydrated: () => hydrated
  });
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  initRevalidateOnFocus,
  normalizeStorage,
  persist
});