@choksheak/react-utils 0.4.7 → 0.4.8

package/chunk-UNDIVFP5.cjs

@@ -0,0 +1,221 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk5PDGU37Ecjs = require('./chunk-5PDGU37E.cjs');
+
+// src/sharedState.ts
+var _timeConstants = require('@choksheak/ts-utils/timeConstants');
+var _react = require('react');
+var SharedStateConfig = {
+  /**
+   * Default duration for storage expiration in milliseconds. Initial value
+   * is 30 days, but can be changed to anything.
+   */
+  storeExpiryMs: 30 * _timeConstants.MS_PER_DAY,
+  /**
+   * True to load from storage only on mount, false (default) to load in
+   * the top level scope when the shared state is defined.
+   */
+  lazyLoad: false,
+  /** Default to log to console. */
+  log: (...args) => console.log("[sharedState]", ...args)
+};
+function configureSharedState(config) {
+  Object.assign(SharedStateConfig, config);
+}
+function createPubSubStore() {
+  const dataByKey = /* @__PURE__ */ new Map();
+  const subscribersByKey = /* @__PURE__ */ new Map();
+  function notify(key, next, prev) {
+    const subscribers = subscribersByKey.get(key);
+    if (!subscribers) return;
+    const copy = Array.from(subscribers.values());
+    for (const subscriber of copy) {
+      try {
+        subscriber(next, prev);
+      } catch (e) {
+        console.error(`Error invoking subscriber:`, e);
+      }
+    }
+  }
+  return {
+    // This could be undefined if T includes undefined, else it should never
+    // return undefined because the user has to always specify the default value.
+    get(key) {
+      return dataByKey.get(key);
+    },
+    set(key, value) {
+      const prev = dataByKey.get(key);
+      if (prev === value) return;
+      dataByKey.set(key, value);
+      notify(key, value, prev);
+    },
+    delete(key) {
+      dataByKey.delete(key);
+    },
+    setNoNotify(key, value) {
+      dataByKey.set(key, value);
+    },
+    // Subscribe to changes of a specific key
+    subscribe(key, subscriber) {
+      let subscribers = subscribersByKey.get(key);
+      if (!subscribers) {
+        subscribers = /* @__PURE__ */ new Set();
+        subscribersByKey.set(key, subscribers);
+      }
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+        if (subscribers.size === 0) subscribersByKey.delete(key);
+      };
+    }
+  };
+}
+function getOrCreatePubSubStore() {
+  if (typeof window !== "undefined") {
+    const t = window.globalThis;
+    return t.reactUtilsPubSubStore || (t.reactUtilsPubSubStore = createPubSubStore());
+  }
+  return createPubSubStore();
+}
+var pubSubStore = getOrCreatePubSubStore();
+var STORAGE_KEY = "state";
+var stateKey = 0;
+function getNextStateKey() {
+  if (typeof window !== "undefined") {
+    const t = window.globalThis;
+    t.reactUtilsStateKey = (_nullishCoalesce(t.reactUtilsStateKey, () => ( 0))) + 1;
+    return t.reactUtilsStateKey;
+  }
+  return ++stateKey;
+}
+function sharedState(defaultValue, options) {
+  let readyResolve = () => {
+  };
+  const readyPromise = new Promise((resolve) => {
+    readyResolve = resolve;
+  });
+  const resolveReadyPromise = readyResolve;
+  const log = _optionalChain([options, 'optionalAccess', _ => _.log]) || SharedStateConfig.log;
+  const pubSubKey = String(getNextStateKey());
+  if (log && _optionalChain([options, 'optionalAccess', _2 => _2.name])) {
+    log(`${options.name} -> ${pubSubKey}`);
+  }
+  const storageAdapter = _chunk5PDGU37Ecjs.getStorageAdapter.call(void 0, 
+    options,
+    SharedStateConfig.storeExpiryMs
+  );
+  pubSubStore.setNoNotify(pubSubKey, defaultValue);
+  const lazyLoad = _optionalChain([options, 'optionalAccess', _3 => _3.lazyLoad]);
+  const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateConfig.lazyLoad;
+  function completeInit(stored) {
+    const value = stored !== void 0 ? stored : defaultValue;
+    pubSubStore.set(pubSubKey, value);
+    obj.initDone = true;
+    resolveReadyPromise();
+  }
+  const obj = {
+    name: _optionalChain([options, 'optionalAccess', _4 => _4.name]),
+    defaultValue,
+    pubSubKey,
+    /** Allow users to await for the completion of data init. */
+    readyPromise,
+    storeExpiryMs: SharedStateConfig.storeExpiryMs,
+    lazy,
+    storageAdapter,
+    initStarted: false,
+    initDone: false,
+    /** `subscribe` function required by useSyncExternalStore. */
+    subscribe(subscriber) {
+      return pubSubStore.subscribe(pubSubKey, () => subscriber());
+    },
+    /** Returns true if there is a backing store. */
+    hasStore() {
+      return Boolean(storageAdapter);
+    },
+    /**
+     * Set a value directly into the store. Does nothing if there is no
+     * backing store.
+     *
+     * Warning: If you want to set the value properly, you should use
+     * `setValue()` instead which also updates the in-memory copy.
+     */
+    setInStore(value) {
+      return _optionalChain([storageAdapter, 'optionalAccess', _5 => _5.set, 'call', _6 => _6(STORAGE_KEY, value)]);
+    },
+    /**
+     * Get a value directly from the store. Returns undefined if there is no
+     * backing store.
+     */
+    getFromStore() {
+      return _optionalChain([storageAdapter, 'optionalAccess', _7 => _7.get, 'call', _8 => _8(STORAGE_KEY)]);
+    },
+    /**
+     * Get the value of the shared state.
+     *  `getSnapshot` function — must return same ref if value unchanged.
+     * Note that this would return the default value if data init from store is
+     * not completed yet.
+     */
+    getSnapshot() {
+      return pubSubStore.get(pubSubKey);
+    },
+    /** Set the value of the shared state. */
+    setValue(next) {
+      if (typeof next === "function") {
+        const prev = pubSubStore.get(pubSubKey);
+        next = next(prev);
+      }
+      pubSubStore.set(pubSubKey, next);
+      void obj.setInStore(next);
+    },
+    /**
+     * Remove the value of the shared state. Actually this just sets the value
+     * back to the given default value.
+     */
+    delete() {
+      pubSubStore.set(pubSubKey, defaultValue);
+      return _optionalChain([storageAdapter, 'optionalAccess', _9 => _9.set, 'call', _10 => _10(STORAGE_KEY, defaultValue)]);
+    },
+    /** Initial default handling. */
+    initDefaultValueOnce() {
+      if (obj.initDone || obj.initStarted) return;
+      obj.initStarted = true;
+      const maybePromise = obj.getFromStore();
+      if (maybePromise instanceof Promise) {
+        return maybePromise.then(completeInit);
+      } else {
+        const stored = maybePromise;
+        completeInit(stored);
+      }
+    }
+  };
+  if (!lazy) {
+    obj.initDefaultValueOnce();
+  }
+  return obj;
+}
+function useSharedState(state) {
+  void state.initDefaultValueOnce();
+  const value = _react.useSyncExternalStore.call(void 0, 
+    (onStoreChange) => state.subscribe(onStoreChange),
+    () => state.getSnapshot(),
+    // getServerSnapshot is needed to prevent SSR dev errors in nextjs.
+    () => state.getSnapshot()
+  );
+  return [value, state.setValue];
+}
+function useSharedStateValue(state) {
+  return useSharedState(state)[0];
+}
+function useSharedStateSetter(state) {
+  void state.initDefaultValueOnce();
+  return state.setValue;
+}
+
+
+
+
+
+
+
+
+exports.SharedStateConfig = SharedStateConfig; exports.configureSharedState = configureSharedState; exports.sharedState = sharedState; exports.useSharedState = useSharedState; exports.useSharedStateValue = useSharedStateValue; exports.useSharedStateSetter = useSharedStateSetter;

package/chunk-WXLUEDBO.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/useDeepMemo.ts
+var _lodashes = require('lodash-es');
+var _react = require('react');
+function useDeepMemo(value) {
+  const [state, setState] = _react.useState.call(void 0, value);
+  return _react.useMemo.call(void 0, () => {
+    if (_lodashes.isEqual.call(void 0, state, value)) {
+      return state;
+    }
+    setState(value);
+    return value;
+  }, [state, value]);
+}
+
+
+
+exports.useDeepMemo = useDeepMemo;

package/{useDeepMemo.mjs → chunk-YTXGK6BR.js}

@@ -1,3 +1,4 @@
+// src/useDeepMemo.ts
 import { isEqual } from "lodash-es";
 import { useMemo, useState } from "react";
 function useDeepMemo(value) {
@@ -10,6 +11,7 @@ function useDeepMemo(value) {
     return value;
   }, [state, value]);
 }
+
 export {
   useDeepMemo
 };