react-native-hox 0.0.1-beta → 0.0.1

package/dist/index.js

@@ -1,11 +1,21 @@
 'use strict';
 
-var react = require('react');
+var useSyncExternalStoreExports = require('use-sync-external-store/shim/with-selector');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var useSyncExternalStoreExports__default = /*#__PURE__*/_interopDefault(useSyncExternalStoreExports);
 
 // src/createModel.ts
 
 // src/config.ts
+var cachedDefaultWebStorage;
+var hasCachedDefaultWebStorage = false;
 function getDefaultWebStorage() {
+  if (hasCachedDefaultWebStorage) {
+    return cachedDefaultWebStorage;
+  }
+  hasCachedDefaultWebStorage = true;
   try {
     const anyGlobal = globalThis;
     const storage = anyGlobal == null ? void 0 : anyGlobal.localStorage;
@@ -15,57 +25,32 @@ function getDefaultWebStorage() {
     const testKey = "__react_native_hox_test__";
     storage.setItem(testKey, "1");
     storage.removeItem(testKey);
-    return {
+    cachedDefaultWebStorage = {
       getItem: (key) => storage.getItem(key),
       setItem: (key, value) => storage.setItem(key, value),
       removeItem: (key) => storage.removeItem(key)
     };
+    return cachedDefaultWebStorage;
   } catch {
+    cachedDefaultWebStorage = void 0;
     return void 0;
   }
 }
-var config = {
-  storage: getDefaultWebStorage()
-};
-var setup = (options) => {
-  Object.assign(config, options);
-};
-var getConfig = () => config;
 
 // src/vanilla.ts
 var createStore = (initialState) => {
   let state = initialState;
   const listeners = /* @__PURE__ */ new Set();
-  const getState = () => state;
-  const setState = (partial, replace = false) => {
+  const setState = (partial, replace) => {
     const nextState = typeof partial === "function" ? partial(state) : partial;
-    if (Object.is(nextState, state)) {
-      return;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
     }
-    const previousState = state;
-    const isNextObject = typeof nextState === "object" && nextState !== null;
-    const isPrevObject = typeof previousState === "object" && previousState !== null;
-    const shouldReplace = replace || !isNextObject || !isPrevObject;
-    if (shouldReplace) {
-      state = nextState;
-    } else {
-      const patch = nextState;
-      const prevObj = previousState;
-      let changed = false;
-      for (const [key, value] of Object.entries(patch)) {
-        if (!Object.is(prevObj[key], value)) {
-          changed = true;
-          break;
-        }
-      }
-      if (!changed) {
-        return;
-      }
-      state = Object.assign({}, previousState, nextState);
-    }
-    const currentListeners = new Set(listeners);
-    currentListeners.forEach((listener) => listener(state, previousState));
   };
+  const getState = () => state;
+  const getInitialState = () => initialState;
   const subscribe = (listener) => {
     listeners.add(listener);
     return () => listeners.delete(listener);
@@ -73,11 +58,11 @@ var createStore = (initialState) => {
   const destroy = () => {
     listeners.clear();
   };
-  return { getState, setState, subscribe, destroy };
+  return { getState, getInitialState, setState, subscribe, destroy };
 };
 
 // src/utils.ts
-var shallow = (objA, objB) => {
+function shallow(objA, objB) {
   if (Object.is(objA, objB)) {
     return true;
   }
@@ -95,7 +80,7 @@ var shallow = (objA, objB) => {
     }
   }
   return true;
-};
+}
 function debounce(func, wait) {
   let timeout;
   let lastArgs;
@@ -107,6 +92,7 @@ function debounce(func, wait) {
     timeout = setTimeout(() => {
       func.apply(context, args);
       lastArgs = void 0;
+      timeout = void 0;
     }, wait);
   };
   debounced.flush = () => {
@@ -114,164 +100,173 @@ function debounce(func, wait) {
       clearTimeout(timeout);
       func.apply(context, lastArgs);
       lastArgs = void 0;
+      timeout = void 0;
     }
   };
   debounced.cancel = () => {
     clearTimeout(timeout);
     lastArgs = void 0;
+    timeout = void 0;
   };
   return debounced;
 }
 
 // src/createModel.ts
+var { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports__default.default;
+var identity = (v) => v;
+function isInvalidHookCallError(error) {
+  return error instanceof Error && /Invalid hook call|Hooks can only be called/i.test(error.message);
+}
 function createModel(initialState, options) {
+  var _a;
   const initialValue = typeof initialState === "function" ? initialState() : initialState;
   const store = createStore(initialValue);
-  setupModelSideEffects(store, options);
-  const model = bindStore(store);
-  model.setState = store.setState;
-  model.getState = store.getState;
-  model.destroy = store.destroy;
-  model.reset = () => store.setState(initialValue, true);
-  return model;
-}
-function bindStore(store) {
-  const subscribe = (onStoreChange) => store.subscribe(() => onStoreChange());
-  const useModel = ((selector, equalityFn = shallow) => {
-    const selectorRef = react.useRef(selector);
-    selectorRef.current = selector;
-    const equalityRef = react.useRef(equalityFn);
-    equalityRef.current = equalityFn;
-    const hasSelectionRef = react.useRef(false);
-    const lastStateRef = react.useRef(null);
-    const lastSelectionRef = react.useRef(null);
-    const getSelection = () => {
-      const state = store.getState();
-      const selectorFn = selectorRef.current;
-      const nextSelection = selectorFn ? selectorFn(state) : state;
-      if (hasSelectionRef.current) {
-        if (Object.is(state, lastStateRef.current)) {
-          return lastSelectionRef.current;
-        }
-        if (equalityRef.current(lastSelectionRef.current, nextSelection)) {
-          lastStateRef.current = state;
-          return lastSelectionRef.current;
-        }
-      }
-      hasSelectionRef.current = true;
-      lastStateRef.current = state;
-      lastSelectionRef.current = nextSelection;
-      return nextSelection;
-    };
-    return react.useSyncExternalStore(subscribe, getSelection, getSelection);
-  });
-  Object.defineProperty(useModel, "data", {
+  const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : console;
+  setupModelSideEffects(store, options, logger);
+  let isDestroyed = false;
+  const setState = (partial, replace) => {
+    var _a2;
+    if (isDestroyed && ((_a2 = options == null ? void 0 : options.strict) == null ? void 0 : _a2.forbidSetStateAfterDestroy)) {
+      const error = new Error("[react-native-hox] model \u5DF2\u9500\u6BC1\uFF0C\u65E0\u6CD5\u518D\u8C03\u7528 setState\u3002");
+      logger.error(error);
+      throw error;
+    }
+    store.setState(partial, replace);
+  };
+  const destroy = () => {
+    isDestroyed = true;
+    store.destroy();
+  };
+  const reset = () => store.setState(initialValue, true);
+  const subscribe = createSubscribe(store);
+  const data = {
+    getState: store.getState,
+    setState,
+    subscribe,
+    destroy,
+    reset
+  };
+  Object.defineProperty(data, "state", {
     get: () => store.getState()
   });
-  useModel.getState = store.getState;
-  useModel.setState = store.setState;
-  useModel.destroy = store.destroy;
-  useModel.reset = () => {
+  const hook = createModelHook(store);
+  const model = {
+    getState: hook,
+    useState: hook,
+    use: hook,
+    // Add 'use' alias
+    setState,
+    reset,
+    destroy,
+    data
+  };
+  const modelFn = function(selector, equalityFn) {
+    return hook(selector, equalityFn);
   };
-  useModel.useState = useModel;
-  useModel.use = useModel;
-  const baseSubscribe = store.subscribe;
-  useModel.subscribe = (arg1, arg2, arg3) => {
+  Object.assign(modelFn, model);
+  return modelFn;
+}
+function createSubscribe(store) {
+  return ((arg1, arg2, arg3) => {
     var _a;
     if (typeof arg1 === "function" && typeof arg2 !== "function") {
-      return baseSubscribe(arg1);
+      return store.subscribe(arg1);
     }
     const selector = arg1;
     const listener = arg2;
     const options = arg3 != null ? arg3 : {};
     const equalityFn = (_a = options.equalityFn) != null ? _a : Object.is;
-    let prevSelected = selector(store.getState());
+    let lastSelected = selector(store.getState());
     if (options.fireImmediately) {
-      listener(prevSelected, prevSelected);
+      listener(lastSelected, lastSelected);
     }
-    return baseSubscribe((nextState, prevState) => {
+    return store.subscribe((nextState) => {
       const nextSelected = selector(nextState);
-      const prevSelectedFromPrevState = selector(prevState);
-      if (equalityFn(prevSelectedFromPrevState, nextSelected)) {
+      if (equalityFn(lastSelected, nextSelected)) {
         return;
       }
-      prevSelected = nextSelected;
-      listener(nextSelected, prevSelectedFromPrevState);
+      const prevSelected = lastSelected;
+      lastSelected = nextSelected;
+      listener(nextSelected, prevSelected);
     });
-  };
+  });
+}
+function createModelHook(store) {
+  const useModel = ((selector, equalityFn = shallow) => {
+    try {
+      return useSyncExternalStoreWithSelector(
+        store.subscribe,
+        store.getState,
+        store.getInitialState,
+        selector != null ? selector : identity,
+        equalityFn
+      );
+    } catch (error) {
+      if (isInvalidHookCallError(error)) {
+        throw new Error(
+          "[react-native-hox] \u4F60\u6B63\u5728\u7EC4\u4EF6\u5916\u8C03\u7528 Hook \u8BFB\u53D6\u72B6\u6001\uFF1B\u8BF7\u5728\u7EC4\u4EF6\u5185\u4F7F\u7528 `model()` / `model.use()` / `model.getState()` / `model.useState()`\uFF0C\u7EC4\u4EF6\u5916\u8BF7\u4F7F\u7528 `model.data.getState()` / `model.data.state`\u3002"
+        );
+      }
+      throw error;
+    }
+  });
   return useModel;
 }
-function setupModelSideEffects(store, options) {
-  var _a, _b, _c;
-  const { storage } = getConfig();
+function setupModelSideEffects(store, options, logger) {
+  var _a, _b, _c, _d;
   const persist = typeof (options == null ? void 0 : options.persist) === "string" ? { key: options.persist } : options == null ? void 0 : options.persist;
   const persistKey = persist == null ? void 0 : persist.key;
-  const syncEnabled = !!(options == null ? void 0 : options.sync);
+  const storage = (_a = persist == null ? void 0 : persist.storage) != null ? _a : getDefaultWebStorage();
   if (!persistKey) {
-    if (syncEnabled) {
-      console.warn(
-        "[react-native-hox] `sync` \u9700\u8981 `persist` \u63D0\u4F9B key \u624D\u80FD\u5EFA\u7ACB\u901A\u9053"
-      );
-    }
     return;
   }
-  const beforePersist = (_a = persist == null ? void 0 : persist.beforePersist) != null ? _a : ((s) => s);
-  const beforeRecover = (_b = persist == null ? void 0 : persist.beforeRecover) != null ? _b : ((v) => v);
-  const debounceMs = (_c = persist == null ? void 0 : persist.debounce) != null ? _c : 100;
+  const beforePersist = (_b = persist == null ? void 0 : persist.beforePersist) != null ? _b : ((s) => s);
+  const beforeRecover = (_c = persist == null ? void 0 : persist.beforeRecover) != null ? _c : ((v) => v);
+  const debounceMs = (_d = persist == null ? void 0 : persist.debounce) != null ? _d : 100;
   if (!storage) {
-    console.warn(
-      "[react-native-hox] \u672A\u914D\u7F6E storage\uFF0Cpersist \u5C06\u4E0D\u4F1A\u751F\u6548\uFF1B\u8BF7\u5148\u8C03\u7528 setup({ storage })"
+    logger.warn(
+      "[react-native-hox] persist \u5DF2\u5F00\u542F\u4F46 storage \u4E0D\u53EF\u7528\uFF1AWeb \u9700\u8981 localStorage \u53EF\u7528\uFF1BReact Native/Node \u8BF7\u5728 persist.storage \u4F20\u5165 AsyncStorage/MMKV \u7B49\u3002"
     );
+    return;
   }
-  let channel;
-  const instanceId = Math.random().toString(36).slice(2);
-  let suppressBroadcast = false;
-  if (storage) {
-    Promise.resolve(storage.getItem(persistKey)).then((val) => {
-      if (!val) return;
-      try {
-        const parsed = JSON.parse(val);
-        const recovered = beforeRecover(parsed);
-        suppressBroadcast = true;
-        store.setState(recovered, true);
-      } catch (e) {
-        console.error("[react-native-hox] Failed to parse stored value:", e);
-      } finally {
-        suppressBroadcast = false;
-      }
-    });
-  }
-  if (syncEnabled && typeof BroadcastChannel !== "undefined") {
-    channel = new BroadcastChannel(`hox-sync-${persistKey}`);
-    channel.onmessage = (event) => {
-      const payload = event.data;
-      const nextState = (payload == null ? void 0 : payload.__hox) ? payload.state : payload;
-      const source = (payload == null ? void 0 : payload.__hox) ? payload.source : void 0;
-      if (source && source === instanceId) {
-        return;
-      }
-      suppressBroadcast = true;
-      store.setState(nextState, true);
-      suppressBroadcast = false;
-    };
-  }
-  const save = debounce((state, s) => {
-    if (!s) return;
+  let isDestroyed = false;
+  Promise.resolve().then(() => storage.getItem(persistKey)).then((val) => {
+    if (isDestroyed) return;
+    if (!val) return;
+    try {
+      const parsed = JSON.parse(val);
+      const recovered = beforeRecover(parsed);
+      store.setState(recovered, false);
+    } catch (e) {
+      logger.error("[react-native-hox] Failed to parse stored value:", e);
+    }
+  }).catch((e) => {
+    logger.error("[react-native-hox] Recover failed:", e);
+  });
+  const save = debounce((state) => {
+    if (isDestroyed) return;
     try {
       const prepared = beforePersist(state);
-      s.setItem(persistKey, JSON.stringify(prepared));
+      const result = storage.setItem(persistKey, JSON.stringify(prepared));
+      Promise.resolve(result).catch((e) => {
+        logger.error("[react-native-hox] Save failed:", e);
+      });
     } catch (e) {
-      console.error("[react-native-hox] Save failed:", e);
+      logger.error("[react-native-hox] Save failed:", e);
     }
   }, debounceMs);
-  store.subscribe((state) => {
-    save(state, storage);
-    if (channel && !suppressBroadcast) {
-      channel.postMessage({ __hox: true, source: instanceId, state });
-    }
+  const unsubscribe = store.subscribe((state) => {
+    save(state);
   });
+  const originalDestroy = store.destroy;
+  store.destroy = () => {
+    unsubscribe();
+    save.flush();
+    isDestroyed = true;
+    save.cancel();
+    originalDestroy();
+  };
 }
 
 exports.createModel = createModel;
-exports.setup = setup;
 exports.shallow = shallow;