@hanzogui/use-store 2.0.0

package/dist/cjs/useStore.cjs

@@ -0,0 +1,390 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var useStore_exports = {};
+__export(useStore_exports, {
+  allStores: () => allStores,
+  createStore: () => createStore,
+  createUseStore: () => createUseStore,
+  createUseStoreSelector: () => createUseStoreSelector,
+  getOrCreateStore: () => getOrCreateStore,
+  getStore: () => getStore,
+  getStoreInfo: () => getStoreInfo,
+  onCreateStore: () => onCreateStore,
+  setIsInReaction: () => setIsInReaction,
+  trackStoresAccess: () => trackStoresAccess,
+  useGlobalStore: () => useGlobalStore,
+  useGlobalStoreSelector: () => useGlobalStoreSelector,
+  useStore: () => useStore,
+  useStoreDebug: () => useStoreDebug,
+  useStoreSelector: () => useStoreSelector
+});
+module.exports = __toCommonJS(useStore_exports);
+var import_react = __toESM(require("react"), 1),
+  import_comparators = require("./comparators.cjs"),
+  import_configureUseStore = require("./configureUseStore.cjs"),
+  import_constants = require("./constants.cjs"),
+  import_helpers = require("./helpers.cjs"),
+  import_useStoreDebug = require("./useStoreDebug.cjs");
+const idFn = _ => _;
+function useStore(StoreKlass, props, options = import_constants.defaultOptions) {
+  const info = getOrCreateStoreInfo(StoreKlass, props, options);
+  return useStoreFromInfo(info, options.selector, options);
+}
+function useStoreDebug(StoreKlass, props) {
+  return useStore(StoreKlass, props, {
+    debug: !0
+  });
+}
+function createStore(StoreKlass, props, options) {
+  return getOrCreateStoreInfo(StoreKlass, props, options)?.store;
+}
+function useGlobalStore(instance, debug) {
+  const store = instance[import_constants.UNWRAP_PROXY],
+    uid = (0, import_helpers.getStoreUid)(store.constructor, store.props),
+    info = import_helpers.cache.get(uid);
+  if (!info) throw new Error("This store not created using createStore()");
+  return useStoreFromInfo(info, void 0, {
+    debug
+  });
+}
+function useGlobalStoreSelector(instance, selector, debug) {
+  const store = instance[import_constants.UNWRAP_PROXY],
+    uid = (0, import_helpers.getStoreUid)(store.constructor, store.props),
+    info = import_helpers.cache.get(uid);
+  if (!info) throw new Error("This store not created using createStore()");
+  return useStoreFromInfo(info, selector, {
+    debug
+  });
+}
+function createUseStore(StoreKlass) {
+  return (props, options) => useStore(StoreKlass, props, options);
+}
+function createUseStoreSelector(StoreKlass, selector) {
+  return props => useStore(StoreKlass, props, {
+    selector
+  });
+}
+function useStoreSelector(StoreKlass, selector, props) {
+  return useStore(StoreKlass, props, {
+    selector
+  });
+}
+const storeAccessTrackers = /* @__PURE__ */new Set();
+function trackStoresAccess(cb) {
+  return storeAccessTrackers.add(cb), () => {
+    storeAccessTrackers.delete(cb);
+  };
+}
+function getStore(StoreKlass, props) {
+  return getStoreInfo(StoreKlass, props)?.store;
+}
+function getOrCreateStore(StoreKlass, props) {
+  return getOrCreateStoreInfo(StoreKlass, props, {
+    refuseCreation: !1
+  })?.store;
+}
+function getStoreInfo(StoreKlass, props) {
+  return getOrCreateStoreInfo(StoreKlass, props, {
+    refuseCreation: !0
+  });
+}
+const onCreateListeners = /* @__PURE__ */new Set();
+function onCreateStore(cb) {
+  return onCreateListeners.add(cb), () => {
+    onCreateListeners.delete(cb);
+  };
+}
+function getOrCreateStoreInfo(StoreKlass, props, options, propsKeyCalculated) {
+  if (!StoreKlass) return null;
+  const uid = (0, import_helpers.getStoreUid)(StoreKlass, propsKeyCalculated ?? props);
+  if (!options?.avoidCache && import_helpers.cache.has(uid)) return import_helpers.cache.get(uid);
+  if (options?.refuseCreation) throw new Error(`No store exists (${StoreKlass.name}) with props: ${props}`);
+  const storeInstance = new StoreKlass(props);
+  storeInstance.props = props;
+  const getters = {},
+    actions = {},
+    stateKeys = /* @__PURE__ */new Set(),
+    descriptors = (0, import_helpers.getStoreDescriptors)(storeInstance);
+  for (const key in descriptors) {
+    const descriptor = descriptors[key];
+    typeof descriptor.value == "function" ? actions[key] = descriptor.value : typeof descriptor.get == "function" ? getters[key] = descriptor.get : key !== "props" && key[0] !== "_" && stateKeys.add(key);
+  }
+  const keyComparators = storeInstance._comparators,
+    listeners = /* @__PURE__ */new Set(),
+    storeInfo = {
+      uid,
+      keyComparators,
+      storeInstance,
+      getters,
+      stateKeys,
+      props,
+      actions,
+      debug: options?.debug,
+      disableTracking: !1,
+      gettersState: {
+        getCache: /* @__PURE__ */new Map(),
+        depsToGetter: /* @__PURE__ */new Map(),
+        curGetKeys: /* @__PURE__ */new Set(),
+        isGetting: !1
+      },
+      listeners,
+      trackers: /* @__PURE__ */new Set(),
+      version: 0,
+      subscribe: onChanged => (listeners.add(onChanged), () => {
+        listeners.delete(onChanged);
+      }),
+      triggerUpdate: () => {
+        storeInfo.version = (storeInfo.version + 1) % Number.MAX_SAFE_INTEGER;
+        for (const cb of listeners) cb();
+      }
+    },
+    store = createProxiedStore(
+    // we assign store right after and proxiedStore never accesses it until later on
+    storeInfo);
+  process.env.NODE_ENV === "development" && (allStores[StoreKlass.name + uid] = store), store.mount?.(), storeInfo.store = store;
+  const result = storeInfo;
+  return import_helpers.cache.set(uid, result), onCreateListeners.forEach(cb => cb(result)), result;
+}
+const allStores = {};
+process.env.NODE_ENV === "development" && (globalThis.Store ||= allStores);
+const emptyObj = {},
+  selectKeys = (obj, keys) => {
+    if (!keys.length) return emptyObj;
+    const res = {};
+    for (const key of keys) res[key] = obj[key];
+    return res;
+  };
+let isInReaction = !1;
+const setIsInReaction = val => {
+  isInReaction = val;
+};
+function useStoreFromInfo(info, userSelector, options) {
+  const store = info?.store,
+    internal = import_react.default.useRef(void 0),
+    component = (0, import_useStoreDebug.useCurrentComponent)();
+  internal.current || (internal.current = {
+    component,
+    tracked: /* @__PURE__ */new Set(),
+    last: null,
+    lastKeys: null
+  });
+  const curInternal = internal.current,
+    shouldPrintDebug = options?.debug,
+    getSnapshot = import_react.default.useCallback(() => {
+      if (!info || !store) return;
+      const curInternal2 = internal.current,
+        isTracking = curInternal2.tracked.size,
+        keys = [...(isTracking ? curInternal2.tracked : info.stateKeys)],
+        nextKeys = `${info.version}${keys.join("")}${userSelector || ""}`,
+        lastKeys = curInternal2.lastKeys;
+      if (nextKeys === curInternal2.lastKeys) return curInternal2.last;
+      curInternal2.lastKeys = nextKeys;
+      let snap;
+      info.disableTracking = !0;
+      const last = curInternal2.last;
+      userSelector ? snap = userSelector(store) : snap = selectKeys(store, keys), info.disableTracking = !1;
+      const isUnchanged = !userSelector && !isTracking && last || typeof last < "u" && (0, import_comparators.isEqualSubsetShallow)(last, snap, {
+        keyComparators: info.keyComparators
+      });
+      return shouldPrintDebug && console.info("\u{1F311} getSnapshot", {
+        storeState: selectKeys(store, Object.keys(store)),
+        userSelector,
+        info,
+        isUnchanged,
+        component,
+        keys,
+        last,
+        snap,
+        curInternal: curInternal2,
+        nextKeys,
+        lastKeys
+      }), isUnchanged ? last : (curInternal2.last = snap, snap);
+    }, [store]),
+    state = import_react.default.useSyncExternalStore(info?.subscribe || idFn, getSnapshot, getSnapshot);
+  return !info || !store || !state || userSelector ? state : new Proxy(store, {
+    get(target, key) {
+      const curVal = Reflect.get(target, key);
+      if (isInReaction) return curVal;
+      const keyString = key;
+      return (info.stateKeys.has(keyString) || keyString in info.getters) && (shouldPrintDebug && console.info("\u{1F440} tracking", keyString), curInternal.tracked.add(keyString)), Reflect.has(state, key) ? Reflect.get(state, key) : curVal;
+    }
+  });
+}
+let setters = /* @__PURE__ */new Set();
+const logStack = /* @__PURE__ */new Set();
+function createProxiedStore(storeInfo) {
+  const {
+      actions,
+      storeInstance,
+      getters,
+      gettersState
+    } = storeInfo,
+    {
+      getCache,
+      curGetKeys,
+      depsToGetter
+    } = gettersState,
+    constr = storeInstance.constructor,
+    shouldDebug2 = storeInfo.debug ?? import_useStoreDebug.DebugStores.has(constr);
+  let didSet = !1;
+  const wrappedActions = {};
+  for (const key in actions) {
+    if (key === "subscribe") continue;
+    const actionFn = actions[key],
+      isGetFn = key.startsWith("get");
+    if (wrappedActions[key] = function (...args) {
+      let res;
+      return isGetFn || gettersState.isGetting ? Reflect.apply(actionFn, proxiedStore, args) : (process.env.NODE_ENV === "development" && shouldDebug2 && console.info("(debug) startAction", key), res = Reflect.apply(actionFn, proxiedStore, args), res instanceof Promise ? res.then(finishAction) : (finishAction(), res));
+    }, process.env.NODE_ENV === "development") {
+      let hashCode = function (str) {
+          let hash = 0;
+          for (let i = 0; i < str.length; i++) hash = str.charCodeAt(i) + ((hash << 5) - hash);
+          return hash;
+        },
+        strColor = function (str) {
+          return `hsl(${hashCode(str) % 360}, 90%, 40%)`;
+        };
+      if (!key.startsWith("get") && !key.startsWith("_") && key !== "subscribe") {
+        const ogAction = wrappedActions[key];
+        wrappedActions[key] = new Proxy(ogAction, {
+          apply(target, thisArg, args) {
+            const isDebugging = shouldDebug2 || storeInfo.debug;
+            if (!(process.env.LOG_LEVEL !== "0" && (isDebugging || import_configureUseStore.configureOpts.logLevel !== "error"))) return Reflect.apply(target, thisArg, args);
+            setters = /* @__PURE__ */new Set();
+            const curSetters = setters,
+              isTopLevelLogger = logStack.size == 0,
+              logs = /* @__PURE__ */new Set();
+            logStack.add(logs);
+            let res;
+            const id = counter++;
+            try {
+              res = Reflect.apply(target, thisArg, args);
+            } catch (err) {
+              throw console.error("Error", err), err;
+            } finally {
+              logStack.add("end");
+              const name = constr.name,
+                color = strColor(name),
+                simpleArgs = args.map(import_helpers.simpleStr);
+              if (logs.add([`%c \u{1F311} ${id} ${name.padStart(isTopLevelLogger ? 8 : 4)}%c.${key}(${simpleArgs.join(", ")})${isTopLevelLogger && logStack.size > 1 ? ` (+${logStack.size - 1})` : ""}`, `color: ${color};`, "color: black;"]), curSetters.size && curSetters.forEach(({
+                key: key2,
+                value
+              }) => {
+                typeof value == "string" || typeof value == "number" || typeof value == "boolean" ? logs.add([` SET ${key2} ${value}`, value]) : logs.add([` SET ${key2}`, value]);
+              }), isTopLevelLogger) {
+                let error = null;
+                try {
+                  for (const item of logStack) {
+                    if (item === "end") {
+                      console.groupEnd();
+                      continue;
+                    }
+                    const [head, ...rest] = item;
+                    if (head) {
+                      console.groupCollapsed(...head), console.groupCollapsed("..."), console.info("args", args), console.info("response", res), console.groupCollapsed("trace"), console.trace(), console.groupEnd(), console.groupEnd();
+                      for (const [name2, ...log] of rest) console.groupCollapsed(name2), console.info(...log), console.groupEnd();
+                    } else console.info("Weird log", head, ...rest);
+                  }
+                } catch (err) {
+                  error = err;
+                }
+                for (const _ of logStack) console.groupEnd();
+                error && console.error("error loggin", error), logStack.clear();
+              }
+              return res;
+            }
+          }
+        });
+      }
+    }
+  }
+  const finishAction = val => (process.env.NODE_ENV === "development" && shouldDebug2 && console.info("(debug) finishAction", {
+    didSet
+  }), didSet && (storeInfo.triggerUpdate(), didSet = !1), val);
+  let isTriggering = !1;
+  const proxiedStore = new Proxy(storeInstance, {
+    // GET
+    get(_, key) {
+      if (key in wrappedActions) return wrappedActions[key];
+      if (key in passThroughKeys) return Reflect.get(storeInstance, key);
+      if (key === import_constants.UNWRAP_PROXY) return storeInstance;
+      if (key === import_helpers.UNWRAP_STORE_INFO) return storeInfo;
+      if (storeAccessTrackers.size && storeAccessTrackers.forEach(cb => cb(storeInfo)), typeof key != "string") return Reflect.get(storeInstance, key);
+      if (storeInfo.disableTracking || gettersState.isGetting && gettersState.curGetKeys.add(key), key in getters) {
+        if (getCache.has(key)) return getCache.get(key);
+        curGetKeys.clear();
+        const isSubGetter = gettersState.isGetting;
+        gettersState.isGetting = !0;
+        const res = getters[key].call(proxiedStore);
+        isSubGetter || (gettersState.isGetting = !1);
+        for (const gk of curGetKeys) depsToGetter.has(gk) || depsToGetter.set(gk, /* @__PURE__ */new Set()), depsToGetter.get(gk).add(key);
+        return getCache.set(key, res), res;
+      }
+      return Reflect.get(storeInstance, key);
+    },
+    // SET
+    set(target, key, value, receiver) {
+      const cur = Reflect.get(target, key),
+        res = Reflect.set(target, key, value, receiver);
+      return res && cur !== value && (typeof key == "string" && (clearGetterCache(key), shouldDebug2 && (setters.add({
+        key,
+        value
+      }), getShouldDebug(storeInfo) && console.info("(debug) SET", res, key, value)), process.env.NODE_ENV === "development" && shouldDebug2 && console.info("SET...", {
+        key,
+        value
+      })), isTriggering || (isTriggering = !0, waitForEventLoop(() => {
+        storeInfo.triggerUpdate(), isTriggering = !1;
+      }))), res;
+    }
+  });
+  function clearGetterCache(setKey) {
+    const parentGetters = depsToGetter.get(setKey);
+    if (getCache.delete(setKey), !!parentGetters) for (const gk of parentGetters) getCache.delete(gk), depsToGetter.has(gk) && clearGetterCache(gk);
+  }
+  return proxiedStore;
+}
+const waitForEventLoop = process.env.NODE_ENV === "test" ? cb => cb() : queueMicrotask;
+let counter = 0;
+const passThroughKeys = {
+  subscribe: !0,
+  _version: !0,
+  _trackers: !0,
+  $$typeof: !0,
+  _listeners: !0,
+  _enableTracking: !0
+};
+function getShouldDebug(storeInfo) {
+  const info = {
+    storeInstance: storeInfo.store
+  };
+  return [...storeInfo.trackers].some(tracker => tracker.component && (0, import_useStoreDebug.shouldDebug)(tracker.component, info));
+}