@liberfi.io/hooks 0.1.1

package/dist/index.js

@@ -0,0 +1,885 @@
+'use strict';
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var reactQuery = require('@tanstack/react-query');
+var useConstant = require('use-constant');
+var core = require('@liberfi.io/core');
+var useDebounce = require('use-debounce');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/version.ts
+if (typeof window !== "undefined") {
+  window.__LIBERFI_VERSION__ = window.__LIBERFI_VERSION__ || {};
+  window.__LIBERFI_VERSION__["@liberfi.io/hooks"] = "0.1.0";
+}
+var version_default = "0.1.0";
+var APIClientContext = React.createContext(
+  {}
+);
+function APIClientProvider({
+  client,
+  subscribeClient,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(APIClientContext.Provider, { value: { client, subscribeClient }, children });
+}
+function useAPIClient() {
+  const context = React.useContext(APIClientContext);
+  if (!context) {
+    throw new Error("useAPIClient must be used within an APIClientProvider");
+  }
+  return context;
+}
+function finalStretchTokensQueryKey(params) {
+  return [
+    "finalStretchTokens",
+    params.chain,
+    params.sortBy ?? "",
+    params.sortDirection ?? "",
+    JSON.stringify((params.keywords ?? []).sort()),
+    JSON.stringify((params.excludeKeywords ?? []).sort()),
+    JSON.stringify(params.filters ?? [])
+  ];
+}
+async function fetchFinalStretchTokens(client, { chain, ...options }) {
+  return await client.getFinalStretchTokens(chain, options);
+}
+function useFinalStretchTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: finalStretchTokensQueryKey(params),
+    queryFn: async () => fetchFinalStretchTokens(client, params),
+    ...options
+  });
+}
+function migratedTokensQueryKey(params) {
+  return [
+    "migratedTokens",
+    params.chain,
+    params.sortBy ?? "",
+    params.sortDirection ?? "",
+    JSON.stringify((params.keywords ?? []).sort()),
+    JSON.stringify((params.excludeKeywords ?? []).sort()),
+    JSON.stringify(params.filters ?? [])
+  ];
+}
+async function fetchMigratedTokens(client, { chain, ...options }) {
+  return await client.getMigratedTokens(chain, options);
+}
+function useMigratedTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: migratedTokensQueryKey(params),
+    queryFn: async () => fetchMigratedTokens(client, params),
+    ...options
+  });
+}
+function newTokensQueryKey(params) {
+  return [
+    "newTokens",
+    params.chain,
+    params.sortBy ?? "",
+    params.sortDirection ?? "",
+    JSON.stringify((params.keywords ?? []).sort()),
+    JSON.stringify((params.excludeKeywords ?? []).sort()),
+    JSON.stringify(params.filters ?? [])
+  ];
+}
+async function fetchNewTokens(client, { chain, ...options }) {
+  return await client.getNewTokens(chain, options);
+}
+function useNewTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: newTokensQueryKey(params),
+    queryFn: async () => fetchNewTokens(client, params),
+    ...options
+  });
+}
+async function fetchPresignedUploadUrl(client) {
+  return await client.getPresignedUploadUrl();
+}
+function usePresignedUploadUrlQuery(options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: ["presignedUploadUrl"],
+    queryFn: async () => fetchPresignedUploadUrl(client),
+    staleTime: 0,
+    ...options
+  });
+}
+function searchTokensQueryKey(params) {
+  return [
+    "searchTokens",
+    params.cursor ?? "",
+    params.limit ? `${params.limit}` : "",
+    params.direction ?? "",
+    JSON.stringify((params.chains ?? []).sort()),
+    params.keyword ?? "",
+    JSON.stringify(params.filters ?? []),
+    params.sortBy ?? "",
+    params.sortDirection ?? ""
+  ];
+}
+async function fetchSearchTokens(client, params) {
+  return await client.searchTokens(params);
+}
+function useSearchTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: searchTokensQueryKey(params),
+    queryFn: async () => fetchSearchTokens(client, params),
+    ...options
+  });
+}
+async function sendTx(client, params) {
+  return await client.sendTx(params);
+}
+function useSendTxMutation(options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => sendTx(client, params),
+    ...options
+  });
+}
+function stockTokensQueryKey(params) {
+  return [
+    "stockTokens",
+    params.chain,
+    params.sortBy ?? "",
+    params.sortDirection ?? "",
+    JSON.stringify((params.keywords ?? []).sort()),
+    JSON.stringify((params.excludeKeywords ?? []).sort()),
+    JSON.stringify(params.filters ?? [])
+  ];
+}
+async function fetchStockTokens(client, { chain, ...options }) {
+  return await client.getStockTokens(chain, options);
+}
+function useStockTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: stockTokensQueryKey(params),
+    queryFn: async () => fetchStockTokens(client, params),
+    ...options
+  });
+}
+function swapRouteQueryKey(params) {
+  return [
+    "swapRoute",
+    params.chain,
+    params.userAddress,
+    params.input,
+    params.output,
+    params.mode,
+    params.amount,
+    params.slippage ? `${params.slippage}` : "",
+    params.priorityFee ?? "",
+    params.tipFee ?? "",
+    params.isAntiMev !== void 0 ? `${params.isAntiMev}` : ""
+  ];
+}
+async function fetchSwapRoute(client, params) {
+  return await client.swapRoute(params);
+}
+function useSwapRouteQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: swapRouteQueryKey(params),
+    queryFn: async () => fetchSwapRoute(client, params),
+    ...options
+  });
+}
+function tokenCandlesQueryKey(params) {
+  return [
+    "tokenCandles",
+    params.chain,
+    params.address,
+    params.resolution,
+    params.after?.toString() ?? "",
+    params.before?.toString() ?? "",
+    params.limit ? `${params.limit}` : ""
+  ];
+}
+async function fetchTokenCandles(client, { chain, address, resolution, ...options }) {
+  return await client.getTokenCandles(chain, address, resolution, options);
+}
+function useTokenCandlesQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenCandlesQueryKey(params),
+    queryFn: async () => fetchTokenCandles(client, params),
+    ...options
+  });
+}
+function tokenHoldersQueryKey(params) {
+  return [
+    "tokenHolders",
+    params.chain,
+    params.address,
+    params.cursor ?? "",
+    params.limit ? `${params.limit}` : "",
+    params.direction ?? ""
+  ];
+}
+async function fetchTokenHolders(client, { chain, address, ...options }) {
+  return await client.getTokenHolders(chain, address, options);
+}
+function useTokenHoldersQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenHoldersQueryKey(params),
+    queryFn: async () => fetchTokenHolders(client, params),
+    ...options
+  });
+}
+function tokenMarketDataQueryKey(params) {
+  return ["tokenMarketData", params.chain, params.address];
+}
+async function fetchTokenMarketData(client, { chain, address }) {
+  return await client.getTokenMarketData(chain, address);
+}
+function useTokenMarketDataQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenMarketDataQueryKey(params),
+    queryFn: async () => fetchTokenMarketData(client, params),
+    ...options
+  });
+}
+function tokenQueryKey(params) {
+  return ["token", params.chain, params.address];
+}
+async function fetchToken(client, { chain, address }) {
+  return await client.getToken(chain, address);
+}
+function useTokenQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenQueryKey(params),
+    queryFn: async () => fetchToken(client, params),
+    ...options
+  });
+}
+function tokenSecurityQueryKey(params) {
+  return ["tokenSecurity", params.chain, params.address];
+}
+async function fetchTokenSecurity(client, { chain, address }) {
+  return await client.getTokenSecurity(chain, address);
+}
+function useTokenSecurityQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenSecurityQueryKey(params),
+    queryFn: async () => fetchTokenSecurity(client, params),
+    ...options
+  });
+}
+function tokensQueryKey(params) {
+  return ["tokens", params.chain, params.addresses.sort().join(",")];
+}
+async function fetchTokens(client, { chain, addresses }) {
+  return await client.getTokens(chain, addresses);
+}
+function useTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokensQueryKey(params),
+    queryFn: async () => fetchTokens(client, params),
+    ...options
+  });
+}
+function tokenStatsQueryKey(params) {
+  return ["tokenStats", params.chain, params.address];
+}
+async function fetchTokenStats(client, { chain, address }) {
+  return await client.getTokenStats(chain, address);
+}
+function useTokenStatsQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenStatsQueryKey(params),
+    queryFn: async () => fetchTokenStats(client, params),
+    ...options
+  });
+}
+function tokenTradeActivitiesQueryKey(params) {
+  return [
+    "tokenTradeActivities",
+    params.chain,
+    params.address,
+    params.before?.toString() ?? "",
+    params.after?.toString() ?? "",
+    params.beforeBlockHeight ? `${params.beforeBlockHeight}` : "",
+    params.afterBlockHeight ? `${params.afterBlockHeight}` : "",
+    params.type ?? "",
+    params.poolAddress ?? ""
+  ];
+}
+async function fetchTokenTradeActivities(client, { chain, address, ...options }) {
+  return await client.getTokenTradeActivities(chain, address, options);
+}
+function useTokenTradeActivitiesQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: tokenTradeActivitiesQueryKey(params),
+    queryFn: async () => fetchTokenTradeActivities(client, params),
+    ...options
+  });
+}
+function trendingTokensQueryKey(params) {
+  return [
+    "trendingTokens",
+    params.chain,
+    params.resolution,
+    params.sortBy ?? "",
+    params.sortDirection ?? "",
+    JSON.stringify((params.keywords ?? []).sort()),
+    JSON.stringify((params.excludeKeywords ?? []).sort()),
+    JSON.stringify(params.filters ?? [])
+  ];
+}
+async function fetchTrendingTokens(client, { chain, resolution, ...options }) {
+  return await client.getTrendingTokens(chain, resolution, options);
+}
+function useTrendingTokensQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: trendingTokensQueryKey(params),
+    queryFn: async () => fetchTrendingTokens(client, params),
+    ...options
+  });
+}
+function txSuccessQueryKey(params) {
+  return [
+    "txSuccess",
+    params.chain,
+    params.txHash,
+    params.timeout ? `${params.timeout}` : ""
+  ];
+}
+async function fetchTxSuccess(client, { chain, txHash, timeout }) {
+  return await client.checkTxSuccess(chain, txHash, timeout);
+}
+function useTxSuccessQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: txSuccessQueryKey(params),
+    queryFn: async () => fetchTxSuccess(client, params),
+    ...options
+  });
+}
+function walletPortfoliosQueryKey(params) {
+  return ["walletPortfolios", params.chain, params.address];
+}
+async function fetchWalletPortfolios(client, { chain, address }) {
+  return await client.getWalletPortfolios(chain, address);
+}
+function useWalletPortfoliosQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: walletPortfoliosQueryKey(params),
+    queryFn: async () => fetchWalletPortfolios(client, params),
+    ...options
+  });
+}
+function walletTradeActivitiesQueryKey(params) {
+  return [
+    "walletTradeActivities",
+    params.chain,
+    params.address,
+    params.before?.toString() ?? "",
+    params.after?.toString() ?? "",
+    params.beforeBlockHeight ? `${params.beforeBlockHeight}` : "",
+    params.afterBlockHeight ? `${params.afterBlockHeight}` : "",
+    params.type ?? "",
+    params.poolAddress ?? ""
+  ];
+}
+async function fetchWalletTradeActivities(client, { chain, address, ...options }) {
+  return await client.getWalletTradeActivities(chain, address, options);
+}
+function useWalletTradeActivitiesQuery(params, options = {}) {
+  const { client } = useAPIClient();
+  return reactQuery.useQuery({
+    queryKey: walletTradeActivitiesQueryKey(params),
+    queryFn: async () => fetchWalletTradeActivities(client, params),
+    ...options
+  });
+}
+var WalletConnectorContext = React.createContext({});
+
+// src/wallet/useWalletConnector.ts
+function useWalletConnector() {
+  const context = React.useContext(WalletConnectorContext);
+  if (!context) {
+    throw new Error(
+      "useWalletConnector must be used within a WalletConnectorProvider"
+    );
+  }
+  return context;
+}
+function useWallets() {
+  const context = React.useContext(WalletConnectorContext);
+  if (!context) {
+    throw new Error("useWallets must be used within a WalletConnectorProvider");
+  }
+  const { wallets } = context;
+  return wallets;
+}
+function WalletConnectorProvider({
+  children,
+  ...value
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(WalletConnectorContext.Provider, { value, children });
+}
+var useBoolean = (initialValue = false) => {
+  const [value, setValue] = React.useState(initialValue);
+  const setTrue = React.useCallback(() => setValue(true), []);
+  const setFalse = React.useCallback(() => setValue(false), []);
+  const toggle = React.useCallback(() => setValue((v) => !v), []);
+  return [value, { setTrue, setFalse, toggle }];
+};
+var useSafeLayoutEffect = globalThis?.document ? React.useLayoutEffect : React.useEffect;
+
+// src/useCallbackRef.ts
+function useCallbackRef(fn, deps = []) {
+  const ref = React.useRef(fn);
+  useSafeLayoutEffect(() => {
+    ref.current = fn;
+  });
+  return React.useCallback(((...args) => ref.current?.(...args)), deps);
+}
+function useIsMounted() {
+  const isMounted = React.useRef(false);
+  React.useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return React.useCallback(() => isMounted.current, []);
+}
+var initialSize = {
+  width: void 0,
+  height: void 0
+};
+function useResizeObserver(options) {
+  const { ref, box = "content-box" } = options;
+  const [{ width, height }, setSize] = React.useState(initialSize);
+  const isMounted = useIsMounted();
+  const previousSize = React.useRef({ ...initialSize });
+  const onResize = React.useRef(void 0);
+  onResize.current = options.onResize;
+  React.useEffect(() => {
+    if (!ref.current) return;
+    if (typeof window === "undefined" || !("ResizeObserver" in window)) return;
+    const observer = new ResizeObserver(([entry]) => {
+      const boxProp = box === "border-box" ? "borderBoxSize" : box === "device-pixel-content-box" ? "devicePixelContentBoxSize" : "contentBoxSize";
+      const newWidth = extractSize(entry, boxProp, "inlineSize");
+      const newHeight = extractSize(entry, boxProp, "blockSize");
+      const hasChanged = previousSize.current.width !== newWidth || previousSize.current.height !== newHeight;
+      if (hasChanged) {
+        const newSize = { width: newWidth, height: newHeight };
+        previousSize.current.width = newWidth;
+        previousSize.current.height = newHeight;
+        if (onResize.current) {
+          onResize.current(newSize);
+        } else {
+          if (isMounted()) {
+            setSize(newSize);
+          }
+        }
+      }
+    });
+    observer.observe(ref.current, { box });
+    return () => {
+      observer.disconnect();
+    };
+  }, [box, ref, isMounted]);
+  return { width, height };
+}
+function extractSize(entry, box, sizeType) {
+  if (!entry[box]) {
+    if (box === "contentBoxSize") {
+      return entry.contentRect[sizeType === "inlineSize" ? "width" : "height"];
+    }
+    return void 0;
+  }
+  const boxSize = Array.isArray(entry[box]) ? entry[box][0] : entry[box];
+  return boxSize[sizeType];
+}
+var _GlobalTimer = class _GlobalTimer {
+  constructor() {
+    /** setTimeout id */
+    __publicField(this, "timeoutId", null);
+    /** subscription map */
+    __publicField(this, "subscribers", /* @__PURE__ */ new Map());
+    /** is timer running */
+    __publicField(this, "isRunning", false);
+    /** internal update interval for smoothness */
+    __publicField(this, "internalInterval", 200);
+  }
+  /**
+   * Get the singleton instance of the timer
+   * @returns Timer instance
+   */
+  static getInstance() {
+    if (!_GlobalTimer.instance) {
+      _GlobalTimer.instance = new _GlobalTimer();
+    }
+    return _GlobalTimer.instance;
+  }
+  /**
+   * Subscribe to the timer
+   * @param callback tick callback
+   * @param interval interval in milliseconds to execute the callback
+   * @returns unsubscribe function
+   */
+  subscribe(callback, interval = 1e3) {
+    this.subscribers.set(callback, {
+      interval,
+      lastExecuted: Date.now()
+    });
+    if (!this.isRunning) {
+      this.start();
+    }
+    return () => {
+      this.subscribers.delete(callback);
+      if (this.subscribers.size === 0) {
+        this.stop();
+      }
+    };
+  }
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.scheduleNext();
+  }
+  scheduleNext() {
+    this.timeoutId = setTimeout(() => {
+      const now = Date.now();
+      this.subscribers.forEach((config, callback) => {
+        if (now - config.lastExecuted >= config.interval) {
+          callback({ delta: now - config.lastExecuted, now });
+          config.lastExecuted = now;
+        }
+      });
+      if (this.isRunning) {
+        this.scheduleNext();
+      }
+    }, this.internalInterval);
+  }
+  stop() {
+    this.isRunning = false;
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+};
+/** singleton instance */
+__publicField(_GlobalTimer, "instance");
+var GlobalTimer = _GlobalTimer;
+function useTick(callback, interval = 1e3) {
+  const callbackRef = useCallbackRef(callback);
+  React.useEffect(
+    () => GlobalTimer.getInstance().subscribe(callbackRef, interval),
+    [interval]
+  );
+}
+function useTickAge(birthday = Date.now(), interval = 1e3) {
+  const birthdayRef = React.useRef(
+    birthday instanceof Date ? birthday.getTime() : birthday
+  );
+  birthdayRef.current = birthday instanceof Date ? birthday.getTime() : birthday;
+  const [age, setAge] = React.useState(Math.max(0, Date.now() - birthdayRef.current));
+  const tickAge = React.useCallback(
+    ({ now }) => setAge(Math.max(0, now - birthdayRef.current)),
+    []
+  );
+  useTick(tickAge, interval);
+  return age;
+}
+var useUpdatedRef = (val) => {
+  const latestRef = React.useRef(val);
+  latestRef.current = val;
+  return latestRef;
+};
+var useMemoizedFn = (fn) => {
+  const fnRef = React.useRef(fn);
+  fnRef.current = React.useMemo(() => fn, [fn]);
+  const memoizedFn = React.useRef(void 0);
+  if (!memoizedFn.current) {
+    memoizedFn.current = function(...args) {
+      return fnRef.current.apply(this, args);
+    };
+  }
+  return memoizedFn.current;
+};
+var useAudioPlayer = (src, options = {}) => {
+  const { volume = 1, loop, autoPlay } = options;
+  const audioRef = React.useRef(null);
+  const [status, setStatus] = React.useState("idle");
+  const onPlay = () => {
+    setStatus("play");
+  };
+  const onPlaying = () => {
+    setStatus("playing");
+  };
+  const onPause = () => {
+    setStatus("paused");
+  };
+  const onEnded = () => {
+    setStatus("ended");
+  };
+  const onError = () => {
+    setStatus("error");
+  };
+  const element = React.useMemo(() => {
+    return React__default.default.createElement("audio", {
+      controls: false,
+      ref: audioRef,
+      autoPlay,
+      src,
+      style: { display: "none" },
+      onPlay,
+      onPlaying,
+      onPause,
+      onEnded,
+      onError
+    });
+  }, [autoPlay, src, onPlay, onPlaying, onPause, onEnded, onError]);
+  React.useEffect(() => {
+    const el = audioRef.current;
+    if (!el) {
+      return;
+    }
+    el.loop = loop ?? false;
+    el.volume = Math.max(0, Math.min(1, volume));
+    return () => {
+      audioRef.current?.pause();
+      audioRef.current = null;
+    };
+  }, [loop, volume]);
+  return [element, audioRef, status];
+};
+var useEventEmitter = () => {
+  return useConstant__default.default(() => {
+    let ee = core.SimpleDI.get("EE");
+    if (!ee) {
+      ee = new core.EventEmitter();
+      core.SimpleDI.registerByName("EE", ee);
+    }
+    return ee;
+  });
+};
+
+// src/utils/json.ts
+function parseJSON(value) {
+  try {
+    return value === "undefined" ? void 0 : JSON.parse(value ?? "");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/useSessionStorage.ts
+function useSessionStorage(key, initialValue) {
+  const readValue = React.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      return item ? parseJSON(item) : initialValue;
+    } catch (error) {
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = React.useState(readValue);
+  const setValue = (value) => {
+    try {
+      const newValue = value instanceof Function ? value(storedValue) : value;
+      window.sessionStorage.setItem(key, JSON.stringify(newValue));
+      setStoredValue(newValue);
+    } catch (error) {
+    }
+  };
+  React.useEffect(() => {
+    setStoredValue(readValue());
+  }, []);
+  React.useEffect(() => {
+    if (typeof window == "undefined") {
+      return;
+    }
+    window.addEventListener?.("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener?.("storage", handleStorageChange);
+    };
+  });
+  const handleStorageChange = React.useCallback(
+    (event) => {
+      if (event?.key && event.key !== key) {
+        return;
+      }
+      setStoredValue(readValue());
+    },
+    [key, readValue]
+  );
+  return [storedValue, setValue];
+}
+function useLocalStorage(key, initialValue, options = {
+  parseJSON
+}) {
+  const readValue = React.useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? options.parseJSON(item) : initialValue;
+    } catch (error) {
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = React.useState(readValue);
+  const setValue = React.useCallback(
+    (value) => {
+      try {
+        const newValue = value instanceof Function ? value(storedValue) : value;
+        window.localStorage.setItem(key, JSON.stringify(newValue));
+        window.dispatchEvent(new Event("storage"));
+        setStoredValue(() => newValue);
+      } catch (error) {
+      }
+    },
+    [storedValue]
+  );
+  React.useEffect(() => {
+    setStoredValue(readValue());
+  }, []);
+  React.useEffect(() => {
+    const handleStorageChange = (event) => {
+      if (event?.key && event.key !== key) {
+        return;
+      }
+      setStoredValue(readValue());
+    };
+    window?.addEventListener?.("storage", handleStorageChange);
+    return () => {
+      window?.removeEventListener?.("storage", handleStorageChange);
+    };
+  }, [key]);
+  return [storedValue, setValue];
+}
+var useSimpleDI = () => {
+  return {
+    get: core.SimpleDI.get,
+    // getOr: SimpleDI.getOr<T>(name, SimpleDI.get<T>(name)),
+    register: core.SimpleDI.register
+  };
+};
+
+Object.defineProperty(exports, "useConstant", {
+  enumerable: true,
+  get: function () { return useConstant__default.default; }
+});
+exports.APIClientContext = APIClientContext;
+exports.APIClientProvider = APIClientProvider;
+exports.WalletConnectorContext = WalletConnectorContext;
+exports.WalletConnectorProvider = WalletConnectorProvider;
+exports.fetchFinalStretchTokens = fetchFinalStretchTokens;
+exports.fetchMigratedTokens = fetchMigratedTokens;
+exports.fetchNewTokens = fetchNewTokens;
+exports.fetchPresignedUploadUrl = fetchPresignedUploadUrl;
+exports.fetchSearchTokens = fetchSearchTokens;
+exports.fetchStockTokens = fetchStockTokens;
+exports.fetchSwapRoute = fetchSwapRoute;
+exports.fetchToken = fetchToken;
+exports.fetchTokenCandles = fetchTokenCandles;
+exports.fetchTokenHolders = fetchTokenHolders;
+exports.fetchTokenMarketData = fetchTokenMarketData;
+exports.fetchTokenSecurity = fetchTokenSecurity;
+exports.fetchTokenStats = fetchTokenStats;
+exports.fetchTokenTradeActivities = fetchTokenTradeActivities;
+exports.fetchTokens = fetchTokens;
+exports.fetchTrendingTokens = fetchTrendingTokens;
+exports.fetchTxSuccess = fetchTxSuccess;
+exports.fetchWalletPortfolios = fetchWalletPortfolios;
+exports.fetchWalletTradeActivities = fetchWalletTradeActivities;
+exports.finalStretchTokensQueryKey = finalStretchTokensQueryKey;
+exports.migratedTokensQueryKey = migratedTokensQueryKey;
+exports.newTokensQueryKey = newTokensQueryKey;
+exports.parseJSON = parseJSON;
+exports.searchTokensQueryKey = searchTokensQueryKey;
+exports.sendTx = sendTx;
+exports.stockTokensQueryKey = stockTokensQueryKey;
+exports.swapRouteQueryKey = swapRouteQueryKey;
+exports.tokenCandlesQueryKey = tokenCandlesQueryKey;
+exports.tokenHoldersQueryKey = tokenHoldersQueryKey;
+exports.tokenMarketDataQueryKey = tokenMarketDataQueryKey;
+exports.tokenQueryKey = tokenQueryKey;
+exports.tokenSecurityQueryKey = tokenSecurityQueryKey;
+exports.tokenStatsQueryKey = tokenStatsQueryKey;
+exports.tokenTradeActivitiesQueryKey = tokenTradeActivitiesQueryKey;
+exports.tokensQueryKey = tokensQueryKey;
+exports.trendingTokensQueryKey = trendingTokensQueryKey;
+exports.txSuccessQueryKey = txSuccessQueryKey;
+exports.useAPIClient = useAPIClient;
+exports.useAudioPlayer = useAudioPlayer;
+exports.useBoolean = useBoolean;
+exports.useCallbackRef = useCallbackRef;
+exports.useEventEmitter = useEventEmitter;
+exports.useFinalStretchTokensQuery = useFinalStretchTokensQuery;
+exports.useIsMounted = useIsMounted;
+exports.useLocalStorage = useLocalStorage;
+exports.useMemoizedFn = useMemoizedFn;
+exports.useMigratedTokensQuery = useMigratedTokensQuery;
+exports.useNewTokensQuery = useNewTokensQuery;
+exports.usePresignedUploadUrlQuery = usePresignedUploadUrlQuery;
+exports.useResizeObserver = useResizeObserver;
+exports.useSafeLayoutEffect = useSafeLayoutEffect;
+exports.useSearchTokensQuery = useSearchTokensQuery;
+exports.useSendTxMutation = useSendTxMutation;
+exports.useSessionStorage = useSessionStorage;
+exports.useSimpleDI = useSimpleDI;
+exports.useStockTokensQuery = useStockTokensQuery;
+exports.useSwapRouteQuery = useSwapRouteQuery;
+exports.useTick = useTick;
+exports.useTickAge = useTickAge;
+exports.useTokenCandlesQuery = useTokenCandlesQuery;
+exports.useTokenHoldersQuery = useTokenHoldersQuery;
+exports.useTokenMarketDataQuery = useTokenMarketDataQuery;
+exports.useTokenQuery = useTokenQuery;
+exports.useTokenSecurityQuery = useTokenSecurityQuery;
+exports.useTokenStatsQuery = useTokenStatsQuery;
+exports.useTokenTradeActivitiesQuery = useTokenTradeActivitiesQuery;
+exports.useTokensQuery = useTokensQuery;
+exports.useTrendingTokensQuery = useTrendingTokensQuery;
+exports.useTxSuccessQuery = useTxSuccessQuery;
+exports.useUpdatedRef = useUpdatedRef;
+exports.useWalletConnector = useWalletConnector;
+exports.useWalletPortfoliosQuery = useWalletPortfoliosQuery;
+exports.useWalletTradeActivitiesQuery = useWalletTradeActivitiesQuery;
+exports.useWallets = useWallets;
+exports.version = version_default;
+exports.walletPortfoliosQueryKey = walletPortfoliosQueryKey;
+exports.walletTradeActivitiesQueryKey = walletTradeActivitiesQueryKey;
+Object.keys(useDebounce).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return useDebounce[k]; }
+  });
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map