@taskon/widget-react 0.0.1-beta.5 → 0.0.1-beta.7

package/dist/chunks/TaskOnProvider-xUeP2Nro.js

@@ -1,1243 +0,0 @@
-import { p as preloadWidgetLocale, b as useWidgetLocale, e as createContextScope, f as useComposedRefs, g as createSlot, P as Primitive, B as Branch, h as useControllableState, j as Presence, k as composeEventHandlers, l as useCallbackRef, R as Root, m as Portal, n as dispatchDiscreteCustomEvent, o as useLayoutEffect2, q as TaskOnContext } from "./ThemeProvider-Bt4UZ33y.js";
-import { c as createLocaleLoader } from "./createLocaleLoader-BameiEhU.js";
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import * as React from "react";
-import React__default, { useState, useRef, useEffect, useMemo, useCallback } from "react";
-import { createTaskOnClient, createUserApi, createChainApi, createCommunityTaskApi } from "@taskon/core";
-import { c as createEthereumAdapter, W as WalletContext, b as useToastState, T as ToastContext } from "./useToast-CaRkylKe.js";
-import * as ReactDOM from "react-dom";
-import '../TaskOnProvider.css';const TOKEN_STORAGE_KEY = "taskon_user_token";
-function isBrowser() {
-  return typeof window !== "undefined";
-}
-function getStoredToken() {
-  if (!isBrowser()) {
-    return null;
-  }
-  try {
-    return localStorage.getItem(TOKEN_STORAGE_KEY);
-  } catch {
-    return null;
-  }
-}
-function setStoredToken(token) {
-  if (!isBrowser()) {
-    return;
-  }
-  try {
-    localStorage.setItem(TOKEN_STORAGE_KEY, token);
-  } catch {
-  }
-}
-function removeStoredToken() {
-  if (!isBrowser()) {
-    return;
-  }
-  try {
-    localStorage.removeItem(TOKEN_STORAGE_KEY);
-  } catch {
-  }
-}
-function useClientInit({
-  apiKey,
-  baseURL,
-  setUserInfo,
-  setUserToken
-}) {
-  const [client, setClient] = useState(null);
-  const userApiRef = useRef(null);
-  const [isInitializing, setIsInitializing] = useState(true);
-  const isInitializedRef = useRef(false);
-  const configRef = useRef({ apiKey, baseURL });
-  configRef.current = { apiKey, baseURL };
-  const settersRef = useRef({ setUserInfo, setUserToken });
-  settersRef.current = { setUserInfo, setUserToken };
-  useEffect(() => {
-    if (isInitializedRef.current) {
-      return;
-    }
-    isInitializedRef.current = true;
-    const init = async () => {
-      try {
-        const { apiKey: apiKey2, baseURL: baseURL2 } = configRef.current;
-        const { setUserInfo: setUserInfo2, setUserToken: setUserToken2 } = settersRef.current;
-        const taskOnClient = createTaskOnClient({
-          apiKey: apiKey2,
-          baseURL: baseURL2,
-          // Unified auth error handler - called when any API returns auth error
-          onAuthError: () => {
-            taskOnClient.setUserToken(null);
-            settersRef.current.setUserInfo(null);
-            settersRef.current.setUserToken(null);
-            removeStoredToken();
-          }
-        });
-        const userApi = createUserApi(taskOnClient);
-        setClient(taskOnClient);
-        userApiRef.current = userApi;
-        const storedToken = getStoredToken();
-        if (storedToken) {
-          try {
-            taskOnClient.setUserToken(storedToken);
-            const info = await userApi.getInfo();
-            setUserInfo2(info);
-            setUserToken2(storedToken);
-          } catch {
-            taskOnClient.setUserToken(null);
-          }
-        }
-      } finally {
-        setIsInitializing(false);
-      }
-    };
-    init();
-  }, []);
-  return {
-    client,
-    userApiRef,
-    isInitializing
-  };
-}
-const registry = /* @__PURE__ */ new Map();
-const builtInLocaleImports = {
-  CommunityTask: {
-    ko: () => import("./communitytask-ko-BD0hzQSi.js").then((module) => ({
-      default: module.default
-    })),
-    ja: () => import("./communitytask-ja-CmW6nP-L.js").then((module) => ({
-      default: module.default
-    })),
-    ru: () => import("./communitytask-ru-DhySaZL8.js").then((module) => ({
-      default: module.default
-    })),
-    es: () => import("./communitytask-es-1zawvXEX.js").then((module) => ({
-      default: module.default
-    }))
-  },
-  Quest: {
-    ko: () => import("./quest-ko-CSmRWgK_.js").then((module) => ({
-      default: module.default
-    })),
-    ja: () => import("./quest-ja-Dxd2vqBF.js").then((module) => ({
-      default: module.default
-    })),
-    ru: () => import("./quest-ru-CkEKv1_F.js").then((module) => ({
-      default: module.default
-    })),
-    es: () => import("./quest-es-D-b5xcme.js").then((module) => ({
-      default: module.default
-    }))
-  },
-  TaskWidget: {
-    ko: () => import("./taskwidget-ko-EHgXFV4B.js").then((module) => ({
-      default: module.default
-    })),
-    ja: () => import("./taskwidget-ja-CqSu-yWA.js").then((module) => ({
-      default: module.default
-    })),
-    ru: () => import("./taskwidget-ru-CMbLQDK4.js").then((module) => ({
-      default: module.default
-    })),
-    es: () => import("./taskwidget-es-Do9b3Mqw.js").then((module) => ({
-      default: module.default
-    }))
-  },
-  LeaderboardWidget: {
-    ko: () => import("./leaderboardwidget-ko-f1cLO9ic.js").then((module) => ({
-      default: module.default
-    })),
-    ja: () => import("./leaderboardwidget-ja-Bj6gz6y1.js").then((module) => ({
-      default: module.default
-    }))
-  },
-  UserCenterWidget: {
-    ko: () => import("./usercenter-ko-xAEYxqLg.js").then((module) => ({
-      default: module.default
-    })),
-    ja: () => import("./usercenter-ja-B2465c1O.js").then((module) => ({
-      default: module.default
-    }))
-  }
-};
-async function preloadBuiltInWidgetLocale(widget, locale) {
-  if (locale === "en") return;
-  const localeLoader = builtInLocaleImports[widget][locale];
-  if (!localeLoader) return;
-  await preloadWidgetLocale(widget, locale, () => localeLoader());
-}
-const builtInPreloaders = {
-  CommunityTask: (locale) => preloadBuiltInWidgetLocale("CommunityTask", locale),
-  Quest: (locale) => preloadBuiltInWidgetLocale("Quest", locale),
-  TaskWidget: (locale) => preloadBuiltInWidgetLocale("TaskWidget", locale),
-  LeaderboardWidget: (locale) => preloadBuiltInWidgetLocale("LeaderboardWidget", locale),
-  UserCenterWidget: (locale) => preloadBuiltInWidgetLocale("UserCenterWidget", locale)
-};
-async function preloadWidgets(widgets, locale) {
-  const preloadPromises = widgets.map((name) => {
-    const preloadFn = registry.get(name) ?? builtInPreloaders[name];
-    if (!preloadFn) {
-      if (process.env.NODE_ENV !== "production") {
-        console.warn(
-          `[widget-react] Widget "${name}" not found in registry. Make sure this widget has a preload loader configured.`
-        );
-      }
-      return null;
-    }
-    return preloadFn(locale);
-  }).filter(Boolean);
-  await Promise.all(preloadPromises);
-}
-const loading = "Loading...";
-const error = "Something went wrong";
-const retry = "Retry";
-const success = "Success";
-const cancel = "Cancel";
-const confirm = "Confirm";
-const enMessages = {
-  loading,
-  error,
-  retry,
-  success,
-  cancel,
-  confirm
-};
-const loadMessages = createLocaleLoader(enMessages, {
-  ko: () => import("./common-ko-80ezXsMG.js").then((m) => ({ default: m.default })),
-  ja: () => import("./common-ja-DWhTaFHb.js").then((m) => ({ default: m.default }))
-});
-function useCommonLocale() {
-  return useWidgetLocale({
-    widgetId: "Common",
-    defaultMessages: enMessages,
-    loadMessages
-  });
-}
-const SUPPORTED_LOCALES = ["en", "ko", "ja", "ru", "es"];
-const DEFAULT_LOCALE = "en";
-function detectLocale() {
-  if (typeof window === "undefined") {
-    return DEFAULT_LOCALE;
-  }
-  const browserLang = navigator.language.split("-")[0];
-  if (SUPPORTED_LOCALES.includes(browserLang)) {
-    return browserLang;
-  }
-  return DEFAULT_LOCALE;
-}
-function useLocaleManager({
-  configLocale,
-  preloadLocales
-}) {
-  const [isPreloading, setIsPreloading] = useState(
-    () => preloadLocales !== void 0 && preloadLocales.length > 0
-  );
-  const preloadLocalesRef = useRef(preloadLocales);
-  preloadLocalesRef.current = preloadLocales;
-  const locale = useMemo(() => {
-    return configLocale ?? detectLocale();
-  }, [configLocale]);
-  useEffect(() => {
-    const widgets = preloadLocalesRef.current;
-    if (!widgets || widgets.length === 0) {
-      setIsPreloading(false);
-      return;
-    }
-    if (locale === "en") {
-      setIsPreloading(false);
-      return;
-    }
-    let isMounted = true;
-    preloadWidgets(widgets, locale).finally(() => {
-      if (isMounted) {
-        setIsPreloading(false);
-      }
-    });
-    return () => {
-      isMounted = false;
-    };
-  }, [locale]);
-  return {
-    locale,
-    isPreloading
-  };
-}
-const LOGIN_METHOD_MAP = {
-  evm_wallet: {
-    apiMethod: "loginWithEvm",
-    buildParams: (value, sign, timestamp) => ({ address: value, sign, timestamp })
-  },
-  email: {
-    apiMethod: "loginWithEmail",
-    buildParams: (value, sign, timestamp) => ({ email: value, sign, timestamp })
-  },
-  discord: {
-    apiMethod: "loginWithSns",
-    buildParams: (value, sign, timestamp) => ({ type: "Discord", token: value, sign, timestamp })
-  },
-  twitter: {
-    apiMethod: "loginWithSns",
-    buildParams: (value, sign, timestamp) => ({ type: "Twitter", token: value, sign, timestamp })
-  },
-  telegram: {
-    apiMethod: "loginWithSns",
-    buildParams: (value, sign, timestamp) => ({ type: "Telegram", token: value, sign, timestamp })
-  }
-};
-function useAuth({
-  client,
-  userApiRef,
-  setUserInfo,
-  setUserToken
-}) {
-  const setToken = useCallback(
-    (token) => {
-      if (!client) {
-        throw new Error("TaskOn client not initialized");
-      }
-      client.setUserToken(token);
-      setUserToken(token);
-      setStoredToken(token);
-    },
-    [client, setUserToken]
-  );
-  const login = useCallback(
-    async (params) => {
-      const userApi = userApiRef.current;
-      if (!userApi) {
-        throw new Error("TaskOn client not initialized");
-      }
-      const { method, value, sign, timestamp } = params;
-      const methodConfig = LOGIN_METHOD_MAP[method];
-      if (!methodConfig) {
-        throw new Error(`Unsupported login method: ${method}`);
-      }
-      const apiParams = methodConfig.buildParams(value, sign, timestamp);
-      const result = await userApi[methodConfig.apiMethod](apiParams);
-      setToken(result.token);
-      try {
-        const info = await userApi.getInfo();
-        setUserInfo(info);
-      } catch {
-      }
-    },
-    [userApiRef, setToken, setUserInfo]
-  );
-  const logout = useCallback(() => {
-    if (client) {
-      client.setUserToken(null);
-    }
-    setUserInfo(null);
-    setUserToken(null);
-    removeStoredToken();
-  }, [client, setUserInfo, setUserToken]);
-  return { login, logout };
-}
-function WalletProvider({
-  children,
-  config
-}) {
-  const [state, setState] = useState({
-    adapter: (config == null ? void 0 : config.evmAdapter) ?? null,
-    address: null,
-    chainId: null
-  });
-  useEffect(() => {
-    if ((config == null ? void 0 : config.evmAdapter) || (config == null ? void 0 : config.disableAutoDetect)) return;
-    const ethereumAdapter = createEthereumAdapter();
-    if (ethereumAdapter) {
-      setState((prev) => ({
-        ...prev,
-        adapter: ethereumAdapter
-      }));
-    }
-  }, [config == null ? void 0 : config.evmAdapter, config == null ? void 0 : config.disableAutoDetect]);
-  const contextValue = useMemo(
-    () => ({
-      evmAdapter: state.adapter,
-      evmAddress: state.address,
-      evmChainId: state.chainId,
-      isEvmConnected: state.address !== null,
-      isDetecting: false,
-      // Actions - delegate to adapter
-      connectEvm: async () => {
-        if (!state.adapter) return null;
-        try {
-          const address = await state.adapter.connect();
-          setState((prev) => {
-            var _a, _b;
-            return {
-              ...prev,
-              address,
-              chainId: ((_b = (_a = state.adapter) == null ? void 0 : _a.getChainId) == null ? void 0 : _b.call(_a)) ?? null
-            };
-          });
-          return address;
-        } catch {
-          return null;
-        }
-      },
-      disconnectEvm: async () => {
-        var _a;
-        await ((_a = state.adapter) == null ? void 0 : _a.disconnect());
-        setState((prev) => ({
-          ...prev,
-          address: null
-        }));
-      },
-      signEvmMessage: async (message) => {
-        if (!state.adapter) return null;
-        try {
-          return await state.adapter.signMessage(message);
-        } catch {
-          return null;
-        }
-      }
-    }),
-    [state]
-  );
-  return /* @__PURE__ */ jsx(WalletContext.Provider, { value: contextValue, children });
-}
-function createCollection(name) {
-  const PROVIDER_NAME2 = name + "CollectionProvider";
-  const [createCollectionContext, createCollectionScope2] = createContextScope(PROVIDER_NAME2);
-  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(
-    PROVIDER_NAME2,
-    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
-  );
-  const CollectionProvider = (props) => {
-    const { scope, children } = props;
-    const ref = React__default.useRef(null);
-    const itemMap = React__default.useRef(/* @__PURE__ */ new Map()).current;
-    return /* @__PURE__ */ jsx(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
-  };
-  CollectionProvider.displayName = PROVIDER_NAME2;
-  const COLLECTION_SLOT_NAME = name + "CollectionSlot";
-  const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
-  const CollectionSlot = React__default.forwardRef(
-    (props, forwardedRef) => {
-      const { scope, children } = props;
-      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
-      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
-      return /* @__PURE__ */ jsx(CollectionSlotImpl, { ref: composedRefs, children });
-    }
-  );
-  CollectionSlot.displayName = COLLECTION_SLOT_NAME;
-  const ITEM_SLOT_NAME = name + "CollectionItemSlot";
-  const ITEM_DATA_ATTR = "data-radix-collection-item";
-  const CollectionItemSlotImpl = createSlot(ITEM_SLOT_NAME);
-  const CollectionItemSlot = React__default.forwardRef(
-    (props, forwardedRef) => {
-      const { scope, children, ...itemData } = props;
-      const ref = React__default.useRef(null);
-      const composedRefs = useComposedRefs(forwardedRef, ref);
-      const context = useCollectionContext(ITEM_SLOT_NAME, scope);
-      React__default.useEffect(() => {
-        context.itemMap.set(ref, { ref, ...itemData });
-        return () => void context.itemMap.delete(ref);
-      });
-      return /* @__PURE__ */ jsx(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
-    }
-  );
-  CollectionItemSlot.displayName = ITEM_SLOT_NAME;
-  function useCollection2(scope) {
-    const context = useCollectionContext(name + "CollectionConsumer", scope);
-    const getItems = React__default.useCallback(() => {
-      const collectionNode = context.collectionRef.current;
-      if (!collectionNode) return [];
-      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
-      const items = Array.from(context.itemMap.values());
-      const orderedItems = items.sort(
-        (a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current)
-      );
-      return orderedItems;
-    }, [context.collectionRef, context.itemMap]);
-    return getItems;
-  }
-  return [
-    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
-    useCollection2,
-    createCollectionScope2
-  ];
-}
-var VISUALLY_HIDDEN_STYLES = Object.freeze({
-  // See: https://github.com/twbs/bootstrap/blob/main/scss/mixins/_visually-hidden.scss
-  position: "absolute",
-  border: 0,
-  width: 1,
-  height: 1,
-  padding: 0,
-  margin: -1,
-  overflow: "hidden",
-  clip: "rect(0, 0, 0, 0)",
-  whiteSpace: "nowrap",
-  wordWrap: "normal"
-});
-var NAME = "VisuallyHidden";
-var VisuallyHidden = React.forwardRef(
-  (props, forwardedRef) => {
-    return /* @__PURE__ */ jsx(
-      Primitive.span,
-      {
-        ...props,
-        ref: forwardedRef,
-        style: { ...VISUALLY_HIDDEN_STYLES, ...props.style }
-      }
-    );
-  }
-);
-VisuallyHidden.displayName = NAME;
-var PROVIDER_NAME = "ToastProvider";
-var [Collection, useCollection, createCollectionScope] = createCollection("Toast");
-var [createToastContext] = createContextScope("Toast", [createCollectionScope]);
-var [ToastProviderProvider, useToastProviderContext] = createToastContext(PROVIDER_NAME);
-var ToastProvider$1 = (props) => {
-  const {
-    __scopeToast,
-    label = "Notification",
-    duration = 5e3,
-    swipeDirection = "right",
-    swipeThreshold = 50,
-    children
-  } = props;
-  const [viewport, setViewport] = React.useState(null);
-  const [toastCount, setToastCount] = React.useState(0);
-  const isFocusedToastEscapeKeyDownRef = React.useRef(false);
-  const isClosePausedRef = React.useRef(false);
-  if (!label.trim()) {
-    console.error(
-      `Invalid prop \`label\` supplied to \`${PROVIDER_NAME}\`. Expected non-empty \`string\`.`
-    );
-  }
-  return /* @__PURE__ */ jsx(Collection.Provider, { scope: __scopeToast, children: /* @__PURE__ */ jsx(
-    ToastProviderProvider,
-    {
-      scope: __scopeToast,
-      label,
-      duration,
-      swipeDirection,
-      swipeThreshold,
-      toastCount,
-      viewport,
-      onViewportChange: setViewport,
-      onToastAdd: React.useCallback(() => setToastCount((prevCount) => prevCount + 1), []),
-      onToastRemove: React.useCallback(() => setToastCount((prevCount) => prevCount - 1), []),
-      isFocusedToastEscapeKeyDownRef,
-      isClosePausedRef,
-      children
-    }
-  ) });
-};
-ToastProvider$1.displayName = PROVIDER_NAME;
-var VIEWPORT_NAME = "ToastViewport";
-var VIEWPORT_DEFAULT_HOTKEY = ["F8"];
-var VIEWPORT_PAUSE = "toast.viewportPause";
-var VIEWPORT_RESUME = "toast.viewportResume";
-var ToastViewport$1 = React.forwardRef(
-  (props, forwardedRef) => {
-    const {
-      __scopeToast,
-      hotkey = VIEWPORT_DEFAULT_HOTKEY,
-      label = "Notifications ({hotkey})",
-      ...viewportProps
-    } = props;
-    const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
-    const getItems = useCollection(__scopeToast);
-    const wrapperRef = React.useRef(null);
-    const headFocusProxyRef = React.useRef(null);
-    const tailFocusProxyRef = React.useRef(null);
-    const ref = React.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);
-    const hotkeyLabel = hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
-    const hasToasts = context.toastCount > 0;
-    React.useEffect(() => {
-      const handleKeyDown = (event) => {
-        var _a;
-        const isHotkeyPressed = hotkey.length !== 0 && hotkey.every((key) => event[key] || event.code === key);
-        if (isHotkeyPressed) (_a = ref.current) == null ? void 0 : _a.focus();
-      };
-      document.addEventListener("keydown", handleKeyDown);
-      return () => document.removeEventListener("keydown", handleKeyDown);
-    }, [hotkey]);
-    React.useEffect(() => {
-      const wrapper = wrapperRef.current;
-      const viewport = ref.current;
-      if (hasToasts && wrapper && viewport) {
-        const handlePause = () => {
-          if (!context.isClosePausedRef.current) {
-            const pauseEvent = new CustomEvent(VIEWPORT_PAUSE);
-            viewport.dispatchEvent(pauseEvent);
-            context.isClosePausedRef.current = true;
-          }
-        };
-        const handleResume = () => {
-          if (context.isClosePausedRef.current) {
-            const resumeEvent = new CustomEvent(VIEWPORT_RESUME);
-            viewport.dispatchEvent(resumeEvent);
-            context.isClosePausedRef.current = false;
-          }
-        };
-        const handleFocusOutResume = (event) => {
-          const isFocusMovingOutside = !wrapper.contains(event.relatedTarget);
-          if (isFocusMovingOutside) handleResume();
-        };
-        const handlePointerLeaveResume = () => {
-          const isFocusInside = wrapper.contains(document.activeElement);
-          if (!isFocusInside) handleResume();
-        };
-        wrapper.addEventListener("focusin", handlePause);
-        wrapper.addEventListener("focusout", handleFocusOutResume);
-        wrapper.addEventListener("pointermove", handlePause);
-        wrapper.addEventListener("pointerleave", handlePointerLeaveResume);
-        window.addEventListener("blur", handlePause);
-        window.addEventListener("focus", handleResume);
-        return () => {
-          wrapper.removeEventListener("focusin", handlePause);
-          wrapper.removeEventListener("focusout", handleFocusOutResume);
-          wrapper.removeEventListener("pointermove", handlePause);
-          wrapper.removeEventListener("pointerleave", handlePointerLeaveResume);
-          window.removeEventListener("blur", handlePause);
-          window.removeEventListener("focus", handleResume);
-        };
-      }
-    }, [hasToasts, context.isClosePausedRef]);
-    const getSortedTabbableCandidates = React.useCallback(
-      ({ tabbingDirection }) => {
-        const toastItems = getItems();
-        const tabbableCandidates = toastItems.map((toastItem) => {
-          const toastNode = toastItem.ref.current;
-          const toastTabbableCandidates = [toastNode, ...getTabbableCandidates(toastNode)];
-          return tabbingDirection === "forwards" ? toastTabbableCandidates : toastTabbableCandidates.reverse();
-        });
-        return (tabbingDirection === "forwards" ? tabbableCandidates.reverse() : tabbableCandidates).flat();
-      },
-      [getItems]
-    );
-    React.useEffect(() => {
-      const viewport = ref.current;
-      if (viewport) {
-        const handleKeyDown = (event) => {
-          var _a, _b, _c;
-          const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
-          const isTabKey = event.key === "Tab" && !isMetaKey;
-          if (isTabKey) {
-            const focusedElement = document.activeElement;
-            const isTabbingBackwards = event.shiftKey;
-            const targetIsViewport = event.target === viewport;
-            if (targetIsViewport && isTabbingBackwards) {
-              (_a = headFocusProxyRef.current) == null ? void 0 : _a.focus();
-              return;
-            }
-            const tabbingDirection = isTabbingBackwards ? "backwards" : "forwards";
-            const sortedCandidates = getSortedTabbableCandidates({ tabbingDirection });
-            const index = sortedCandidates.findIndex((candidate) => candidate === focusedElement);
-            if (focusFirst(sortedCandidates.slice(index + 1))) {
-              event.preventDefault();
-            } else {
-              isTabbingBackwards ? (_b = headFocusProxyRef.current) == null ? void 0 : _b.focus() : (_c = tailFocusProxyRef.current) == null ? void 0 : _c.focus();
-            }
-          }
-        };
-        viewport.addEventListener("keydown", handleKeyDown);
-        return () => viewport.removeEventListener("keydown", handleKeyDown);
-      }
-    }, [getItems, getSortedTabbableCandidates]);
-    return /* @__PURE__ */ jsxs(
-      Branch,
-      {
-        ref: wrapperRef,
-        role: "region",
-        "aria-label": label.replace("{hotkey}", hotkeyLabel),
-        tabIndex: -1,
-        style: { pointerEvents: hasToasts ? void 0 : "none" },
-        children: [
-          hasToasts && /* @__PURE__ */ jsx(
-            FocusProxy,
-            {
-              ref: headFocusProxyRef,
-              onFocusFromOutsideViewport: () => {
-                const tabbableCandidates = getSortedTabbableCandidates({
-                  tabbingDirection: "forwards"
-                });
-                focusFirst(tabbableCandidates);
-              }
-            }
-          ),
-          /* @__PURE__ */ jsx(Collection.Slot, { scope: __scopeToast, children: /* @__PURE__ */ jsx(Primitive.ol, { tabIndex: -1, ...viewportProps, ref: composedRefs }) }),
-          hasToasts && /* @__PURE__ */ jsx(
-            FocusProxy,
-            {
-              ref: tailFocusProxyRef,
-              onFocusFromOutsideViewport: () => {
-                const tabbableCandidates = getSortedTabbableCandidates({
-                  tabbingDirection: "backwards"
-                });
-                focusFirst(tabbableCandidates);
-              }
-            }
-          )
-        ]
-      }
-    );
-  }
-);
-ToastViewport$1.displayName = VIEWPORT_NAME;
-var FOCUS_PROXY_NAME = "ToastFocusProxy";
-var FocusProxy = React.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeToast, onFocusFromOutsideViewport, ...proxyProps } = props;
-    const context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);
-    return /* @__PURE__ */ jsx(
-      VisuallyHidden,
-      {
-        tabIndex: 0,
-        ...proxyProps,
-        ref: forwardedRef,
-        style: { position: "fixed" },
-        onFocus: (event) => {
-          var _a;
-          const prevFocusedElement = event.relatedTarget;
-          const isFocusFromOutsideViewport = !((_a = context.viewport) == null ? void 0 : _a.contains(prevFocusedElement));
-          if (isFocusFromOutsideViewport) onFocusFromOutsideViewport();
-        }
-      }
-    );
-  }
-);
-FocusProxy.displayName = FOCUS_PROXY_NAME;
-var TOAST_NAME = "Toast";
-var TOAST_SWIPE_START = "toast.swipeStart";
-var TOAST_SWIPE_MOVE = "toast.swipeMove";
-var TOAST_SWIPE_CANCEL = "toast.swipeCancel";
-var TOAST_SWIPE_END = "toast.swipeEnd";
-var Toast = React.forwardRef(
-  (props, forwardedRef) => {
-    const { forceMount, open: openProp, defaultOpen, onOpenChange, ...toastProps } = props;
-    const [open, setOpen] = useControllableState({
-      prop: openProp,
-      defaultProp: defaultOpen ?? true,
-      onChange: onOpenChange,
-      caller: TOAST_NAME
-    });
-    return /* @__PURE__ */ jsx(Presence, { present: forceMount || open, children: /* @__PURE__ */ jsx(
-      ToastImpl,
-      {
-        open,
-        ...toastProps,
-        ref: forwardedRef,
-        onClose: () => setOpen(false),
-        onPause: useCallbackRef(props.onPause),
-        onResume: useCallbackRef(props.onResume),
-        onSwipeStart: composeEventHandlers(props.onSwipeStart, (event) => {
-          event.currentTarget.setAttribute("data-swipe", "start");
-        }),
-        onSwipeMove: composeEventHandlers(props.onSwipeMove, (event) => {
-          const { x, y } = event.detail.delta;
-          event.currentTarget.setAttribute("data-swipe", "move");
-          event.currentTarget.style.setProperty("--radix-toast-swipe-move-x", `${x}px`);
-          event.currentTarget.style.setProperty("--radix-toast-swipe-move-y", `${y}px`);
-        }),
-        onSwipeCancel: composeEventHandlers(props.onSwipeCancel, (event) => {
-          event.currentTarget.setAttribute("data-swipe", "cancel");
-          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
-          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
-          event.currentTarget.style.removeProperty("--radix-toast-swipe-end-x");
-          event.currentTarget.style.removeProperty("--radix-toast-swipe-end-y");
-        }),
-        onSwipeEnd: composeEventHandlers(props.onSwipeEnd, (event) => {
-          const { x, y } = event.detail.delta;
-          event.currentTarget.setAttribute("data-swipe", "end");
-          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
-          event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
-          event.currentTarget.style.setProperty("--radix-toast-swipe-end-x", `${x}px`);
-          event.currentTarget.style.setProperty("--radix-toast-swipe-end-y", `${y}px`);
-          setOpen(false);
-        })
-      }
-    ) });
-  }
-);
-Toast.displayName = TOAST_NAME;
-var [ToastInteractiveProvider, useToastInteractiveContext] = createToastContext(TOAST_NAME, {
-  onClose() {
-  }
-});
-var ToastImpl = React.forwardRef(
-  (props, forwardedRef) => {
-    const {
-      __scopeToast,
-      type = "foreground",
-      duration: durationProp,
-      open,
-      onClose,
-      onEscapeKeyDown,
-      onPause,
-      onResume,
-      onSwipeStart,
-      onSwipeMove,
-      onSwipeCancel,
-      onSwipeEnd,
-      ...toastProps
-    } = props;
-    const context = useToastProviderContext(TOAST_NAME, __scopeToast);
-    const [node, setNode] = React.useState(null);
-    const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));
-    const pointerStartRef = React.useRef(null);
-    const swipeDeltaRef = React.useRef(null);
-    const duration = durationProp || context.duration;
-    const closeTimerStartTimeRef = React.useRef(0);
-    const closeTimerRemainingTimeRef = React.useRef(duration);
-    const closeTimerRef = React.useRef(0);
-    const { onToastAdd, onToastRemove } = context;
-    const handleClose = useCallbackRef(() => {
-      var _a;
-      const isFocusInToast = node == null ? void 0 : node.contains(document.activeElement);
-      if (isFocusInToast) (_a = context.viewport) == null ? void 0 : _a.focus();
-      onClose();
-    });
-    const startTimer = React.useCallback(
-      (duration2) => {
-        if (!duration2 || duration2 === Infinity) return;
-        window.clearTimeout(closeTimerRef.current);
-        closeTimerStartTimeRef.current = (/* @__PURE__ */ new Date()).getTime();
-        closeTimerRef.current = window.setTimeout(handleClose, duration2);
-      },
-      [handleClose]
-    );
-    React.useEffect(() => {
-      const viewport = context.viewport;
-      if (viewport) {
-        const handleResume = () => {
-          startTimer(closeTimerRemainingTimeRef.current);
-          onResume == null ? void 0 : onResume();
-        };
-        const handlePause = () => {
-          const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - closeTimerStartTimeRef.current;
-          closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
-          window.clearTimeout(closeTimerRef.current);
-          onPause == null ? void 0 : onPause();
-        };
-        viewport.addEventListener(VIEWPORT_PAUSE, handlePause);
-        viewport.addEventListener(VIEWPORT_RESUME, handleResume);
-        return () => {
-          viewport.removeEventListener(VIEWPORT_PAUSE, handlePause);
-          viewport.removeEventListener(VIEWPORT_RESUME, handleResume);
-        };
-      }
-    }, [context.viewport, duration, onPause, onResume, startTimer]);
-    React.useEffect(() => {
-      if (open && !context.isClosePausedRef.current) startTimer(duration);
-    }, [open, duration, context.isClosePausedRef, startTimer]);
-    React.useEffect(() => {
-      onToastAdd();
-      return () => onToastRemove();
-    }, [onToastAdd, onToastRemove]);
-    const announceTextContent = React.useMemo(() => {
-      return node ? getAnnounceTextContent(node) : null;
-    }, [node]);
-    if (!context.viewport) return null;
-    return /* @__PURE__ */ jsxs(Fragment, { children: [
-      announceTextContent && /* @__PURE__ */ jsx(
-        ToastAnnounce,
-        {
-          __scopeToast,
-          role: "status",
-          "aria-live": type === "foreground" ? "assertive" : "polite",
-          children: announceTextContent
-        }
-      ),
-      /* @__PURE__ */ jsx(ToastInteractiveProvider, { scope: __scopeToast, onClose: handleClose, children: ReactDOM.createPortal(
-        /* @__PURE__ */ jsx(Collection.ItemSlot, { scope: __scopeToast, children: /* @__PURE__ */ jsx(
-          Root,
-          {
-            asChild: true,
-            onEscapeKeyDown: composeEventHandlers(onEscapeKeyDown, () => {
-              if (!context.isFocusedToastEscapeKeyDownRef.current) handleClose();
-              context.isFocusedToastEscapeKeyDownRef.current = false;
-            }),
-            children: /* @__PURE__ */ jsx(
-              Primitive.li,
-              {
-                tabIndex: 0,
-                "data-state": open ? "open" : "closed",
-                "data-swipe-direction": context.swipeDirection,
-                ...toastProps,
-                ref: composedRefs,
-                style: { userSelect: "none", touchAction: "none", ...props.style },
-                onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
-                  if (event.key !== "Escape") return;
-                  onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(event.nativeEvent);
-                  if (!event.nativeEvent.defaultPrevented) {
-                    context.isFocusedToastEscapeKeyDownRef.current = true;
-                    handleClose();
-                  }
-                }),
-                onPointerDown: composeEventHandlers(props.onPointerDown, (event) => {
-                  if (event.button !== 0) return;
-                  pointerStartRef.current = { x: event.clientX, y: event.clientY };
-                }),
-                onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
-                  if (!pointerStartRef.current) return;
-                  const x = event.clientX - pointerStartRef.current.x;
-                  const y = event.clientY - pointerStartRef.current.y;
-                  const hasSwipeMoveStarted = Boolean(swipeDeltaRef.current);
-                  const isHorizontalSwipe = ["left", "right"].includes(context.swipeDirection);
-                  const clamp = ["left", "up"].includes(context.swipeDirection) ? Math.min : Math.max;
-                  const clampedX = isHorizontalSwipe ? clamp(0, x) : 0;
-                  const clampedY = !isHorizontalSwipe ? clamp(0, y) : 0;
-                  const moveStartBuffer = event.pointerType === "touch" ? 10 : 2;
-                  const delta = { x: clampedX, y: clampedY };
-                  const eventDetail = { originalEvent: event, delta };
-                  if (hasSwipeMoveStarted) {
-                    swipeDeltaRef.current = delta;
-                    handleAndDispatchCustomEvent(TOAST_SWIPE_MOVE, onSwipeMove, eventDetail, {
-                      discrete: false
-                    });
-                  } else if (isDeltaInDirection(delta, context.swipeDirection, moveStartBuffer)) {
-                    swipeDeltaRef.current = delta;
-                    handleAndDispatchCustomEvent(TOAST_SWIPE_START, onSwipeStart, eventDetail, {
-                      discrete: false
-                    });
-                    event.target.setPointerCapture(event.pointerId);
-                  } else if (Math.abs(x) > moveStartBuffer || Math.abs(y) > moveStartBuffer) {
-                    pointerStartRef.current = null;
-                  }
-                }),
-                onPointerUp: composeEventHandlers(props.onPointerUp, (event) => {
-                  const delta = swipeDeltaRef.current;
-                  const target = event.target;
-                  if (target.hasPointerCapture(event.pointerId)) {
-                    target.releasePointerCapture(event.pointerId);
-                  }
-                  swipeDeltaRef.current = null;
-                  pointerStartRef.current = null;
-                  if (delta) {
-                    const toast = event.currentTarget;
-                    const eventDetail = { originalEvent: event, delta };
-                    if (isDeltaInDirection(delta, context.swipeDirection, context.swipeThreshold)) {
-                      handleAndDispatchCustomEvent(TOAST_SWIPE_END, onSwipeEnd, eventDetail, {
-                        discrete: true
-                      });
-                    } else {
-                      handleAndDispatchCustomEvent(
-                        TOAST_SWIPE_CANCEL,
-                        onSwipeCancel,
-                        eventDetail,
-                        {
-                          discrete: true
-                        }
-                      );
-                    }
-                    toast.addEventListener("click", (event2) => event2.preventDefault(), {
-                      once: true
-                    });
-                  }
-                })
-              }
-            )
-          }
-        ) }),
-        context.viewport
-      ) })
-    ] });
-  }
-);
-var ToastAnnounce = (props) => {
-  const { __scopeToast, children, ...announceProps } = props;
-  const context = useToastProviderContext(TOAST_NAME, __scopeToast);
-  const [renderAnnounceText, setRenderAnnounceText] = React.useState(false);
-  const [isAnnounced, setIsAnnounced] = React.useState(false);
-  useNextFrame(() => setRenderAnnounceText(true));
-  React.useEffect(() => {
-    const timer = window.setTimeout(() => setIsAnnounced(true), 1e3);
-    return () => window.clearTimeout(timer);
-  }, []);
-  return isAnnounced ? null : /* @__PURE__ */ jsx(Portal, { asChild: true, children: /* @__PURE__ */ jsx(VisuallyHidden, { ...announceProps, children: renderAnnounceText && /* @__PURE__ */ jsxs(Fragment, { children: [
-    context.label,
-    " ",
-    children
-  ] }) }) });
-};
-var TITLE_NAME = "ToastTitle";
-var ToastTitle = React.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeToast, ...titleProps } = props;
-    return /* @__PURE__ */ jsx(Primitive.div, { ...titleProps, ref: forwardedRef });
-  }
-);
-ToastTitle.displayName = TITLE_NAME;
-var DESCRIPTION_NAME = "ToastDescription";
-var ToastDescription = React.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeToast, ...descriptionProps } = props;
-    return /* @__PURE__ */ jsx(Primitive.div, { ...descriptionProps, ref: forwardedRef });
-  }
-);
-ToastDescription.displayName = DESCRIPTION_NAME;
-var ACTION_NAME = "ToastAction";
-var ToastAction = React.forwardRef(
-  (props, forwardedRef) => {
-    const { altText, ...actionProps } = props;
-    if (!altText.trim()) {
-      console.error(
-        `Invalid prop \`altText\` supplied to \`${ACTION_NAME}\`. Expected non-empty \`string\`.`
-      );
-      return null;
-    }
-    return /* @__PURE__ */ jsx(ToastAnnounceExclude, { altText, asChild: true, children: /* @__PURE__ */ jsx(ToastClose, { ...actionProps, ref: forwardedRef }) });
-  }
-);
-ToastAction.displayName = ACTION_NAME;
-var CLOSE_NAME = "ToastClose";
-var ToastClose = React.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeToast, ...closeProps } = props;
-    const interactiveContext = useToastInteractiveContext(CLOSE_NAME, __scopeToast);
-    return /* @__PURE__ */ jsx(ToastAnnounceExclude, { asChild: true, children: /* @__PURE__ */ jsx(
-      Primitive.button,
-      {
-        type: "button",
-        ...closeProps,
-        ref: forwardedRef,
-        onClick: composeEventHandlers(props.onClick, interactiveContext.onClose)
-      }
-    ) });
-  }
-);
-ToastClose.displayName = CLOSE_NAME;
-var ToastAnnounceExclude = React.forwardRef((props, forwardedRef) => {
-  const { __scopeToast, altText, ...announceExcludeProps } = props;
-  return /* @__PURE__ */ jsx(
-    Primitive.div,
-    {
-      "data-radix-toast-announce-exclude": "",
-      "data-radix-toast-announce-alt": altText || void 0,
-      ...announceExcludeProps,
-      ref: forwardedRef
-    }
-  );
-});
-function getAnnounceTextContent(container) {
-  const textContent = [];
-  const childNodes = Array.from(container.childNodes);
-  childNodes.forEach((node) => {
-    if (node.nodeType === node.TEXT_NODE && node.textContent) textContent.push(node.textContent);
-    if (isHTMLElement(node)) {
-      const isHidden = node.ariaHidden || node.hidden || node.style.display === "none";
-      const isExcluded = node.dataset.radixToastAnnounceExclude === "";
-      if (!isHidden) {
-        if (isExcluded) {
-          const altText = node.dataset.radixToastAnnounceAlt;
-          if (altText) textContent.push(altText);
-        } else {
-          textContent.push(...getAnnounceTextContent(node));
-        }
-      }
-    }
-  });
-  return textContent;
-}
-function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
-  const currentTarget = detail.originalEvent.currentTarget;
-  const event = new CustomEvent(name, { bubbles: true, cancelable: true, detail });
-  if (handler) currentTarget.addEventListener(name, handler, { once: true });
-  if (discrete) {
-    dispatchDiscreteCustomEvent(currentTarget, event);
-  } else {
-    currentTarget.dispatchEvent(event);
-  }
-}
-var isDeltaInDirection = (delta, direction, threshold = 0) => {
-  const deltaX = Math.abs(delta.x);
-  const deltaY = Math.abs(delta.y);
-  const isDeltaX = deltaX > deltaY;
-  if (direction === "left" || direction === "right") {
-    return isDeltaX && deltaX > threshold;
-  } else {
-    return !isDeltaX && deltaY > threshold;
-  }
-};
-function useNextFrame(callback = () => {
-}) {
-  const fn = useCallbackRef(callback);
-  useLayoutEffect2(() => {
-    let raf1 = 0;
-    let raf2 = 0;
-    raf1 = window.requestAnimationFrame(() => raf2 = window.requestAnimationFrame(fn));
-    return () => {
-      window.cancelAnimationFrame(raf1);
-      window.cancelAnimationFrame(raf2);
-    };
-  }, [fn]);
-}
-function isHTMLElement(node) {
-  return node.nodeType === node.ELEMENT_NODE;
-}
-function getTabbableCandidates(container) {
-  const nodes = [];
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
-    acceptNode: (node) => {
-      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
-      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
-      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-    }
-  });
-  while (walker.nextNode()) nodes.push(walker.currentNode);
-  return nodes;
-}
-function focusFirst(candidates) {
-  const previouslyFocusedElement = document.activeElement;
-  return candidates.some((candidate) => {
-    if (candidate === previouslyFocusedElement) return true;
-    candidate.focus();
-    return document.activeElement !== previouslyFocusedElement;
-  });
-}
-var Provider = ToastProvider$1;
-var Viewport = ToastViewport$1;
-var Root2 = Toast;
-var Description = ToastDescription;
-function getToastIcon(type) {
-  switch (type) {
-    case "success":
-      return "✓";
-    case "error":
-      return "✕";
-    case "warning":
-      return "⚠";
-    case "info":
-    default:
-      return "ℹ";
-  }
-}
-function ToastItem({ toast, onOpenChange }) {
-  return /* @__PURE__ */ jsxs(
-    Root2,
-    {
-      className: `taskon-toast taskon-toast--${toast.type}`,
-      duration: toast.duration ?? 3e3,
-      onOpenChange,
-      children: [
-        /* @__PURE__ */ jsx("div", { className: "taskon-toast-icon", children: getToastIcon(toast.type) }),
-        /* @__PURE__ */ jsx(Description, { className: "taskon-toast-message", children: toast.message })
-      ]
-    }
-  );
-}
-function ToastViewport({
-  toasts,
-  onRemove
-}) {
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    toasts.map((toast) => /* @__PURE__ */ jsx(
-      ToastItem,
-      {
-        toast,
-        onOpenChange: (open) => {
-          if (!open) {
-            onRemove(toast.id);
-          }
-        }
-      },
-      toast.id
-    )),
-    /* @__PURE__ */ jsx(Viewport, { className: "taskon-toast-viewport" })
-  ] });
-}
-const ToastProvider = Provider;
-function TaskOnProvider({
-  config,
-  children,
-  preloadLocales
-}) {
-  const [userInfo, setUserInfo] = useState(null);
-  const [userToken, setUserToken] = useState(null);
-  const [chains, setChains] = useState([]);
-  const [communityInfo, setCommunityInfo] = useState(null);
-  const toastState = useToastState();
-  const { locale } = useLocaleManager({
-    configLocale: config.locale,
-    preloadLocales
-  });
-  const { client, userApiRef, isInitializing } = useClientInit({
-    apiKey: config.apiKey,
-    baseURL: config.baseURL,
-    setUserInfo,
-    setUserToken
-  });
-  const { login, logout } = useAuth({
-    client,
-    userApiRef,
-    setUserInfo,
-    setUserToken
-  });
-  const requestLogin = useCallback(() => {
-    var _a;
-    (_a = config.onRequestLogin) == null ? void 0 : _a.call(config);
-  }, [config]);
-  const refreshUserInfo = useCallback(async () => {
-    const userApi = userApiRef.current;
-    if (!userApi) return;
-    try {
-      const info = await userApi.getInfo();
-      setUserInfo(info);
-    } catch {
-    }
-  }, [userApiRef]);
-  useEffect(() => {
-    if (!client) return;
-    const loadChains = async () => {
-      try {
-        const chainApi = createChainApi(client);
-        const chainList = await chainApi.getChainInfo();
-        setChains(chainList);
-      } catch {
-      }
-    };
-    loadChains();
-  }, [client]);
-  useEffect(() => {
-    if (!client) return;
-    const loadCommunityInfo = async () => {
-      try {
-        const communityTaskApi = createCommunityTaskApi(client);
-        const info = await communityTaskApi.getCommunityInfo();
-        setCommunityInfo(info);
-      } catch {
-      }
-    };
-    loadCommunityInfo();
-  }, [client]);
-  const contextValue = useMemo(
-    () => ({
-      config,
-      client,
-      isInitializing,
-      locale,
-      userId: (userInfo == null ? void 0 : userInfo.id) ?? null,
-      userInfo,
-      userToken,
-      isLoggedIn: userInfo !== null && userToken !== null,
-      login,
-      logout,
-      requestLogin,
-      refreshUserInfo,
-      chains,
-      communityInfo
-    }),
-    [config, client, isInitializing, locale, userInfo, userToken, login, logout, requestLogin, refreshUserInfo, chains, communityInfo]
-  );
-  return /* @__PURE__ */ jsx(TaskOnContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(ToastContext.Provider, { value: toastState, children: /* @__PURE__ */ jsxs(ToastProvider, { children: [
-    /* @__PURE__ */ jsx(WalletProvider, { config: config.walletConfig, children }),
-    /* @__PURE__ */ jsx(
-      ToastViewport,
-      {
-        toasts: toastState.toasts,
-        onRemove: toastState.removeToast
-      }
-    )
-  ] }) }) });
-}
-export {
-  TaskOnProvider as T,
-  useCommonLocale as u
-};