@domino-sdk/relay 0.14.1 → 0.15.0

package/dist/react/index.js

@@ -0,0 +1,833 @@
+import {
+  createBrowserRelayClient
+} from "../chunk-CQ5YSQQE.js";
+import {
+  RelayError
+} from "../chunk-YZJOZL4V.js";
+import "../chunk-CJARNIVP.js";
+import "../chunk-I2CCMGN6.js";
+import "../chunk-FUQYKTOJ.js";
+
+// src/react/provider.tsx
+import { useState as useState3 } from "react";
+
+// src/react/context.ts
+import { createContext, useContext } from "react";
+var ClientContext = createContext(null);
+function useRelay() {
+  const client = useContext(ClientContext);
+  if (!client) {
+    throw new Error("Domino hooks require <RelayProvider>");
+  }
+  return client;
+}
+
+// src/react/experience.tsx
+import {
+  createContext as createContext2,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useMemo,
+  useRef,
+  useState as useState2
+} from "react";
+
+// src/react/role-delivery.ts
+function sanitizeDeliveries(deliveries) {
+  return deliveries.map(({ quest, status }) => ({ quest, status }));
+}
+function completionMark(quests) {
+  return quests.filter((q) => q.completed || q.completionCount > 0).map((q) => `${q.quest}:${Math.max(q.completionCount, 1)}`).sort().join(",");
+}
+function hasPending(deliveries) {
+  return deliveries.some((d) => d.status === "pending");
+}
+function roleDeliveryLabel(deliveries, quest) {
+  const mine = deliveries.filter((d) => d.quest === quest);
+  if (!mine.length) {
+    return null;
+  }
+  if (hasPending(mine)) {
+    return "Role delivery pending";
+  }
+  return mine.some((d) => d.status === "failed") ? "Role delivery failed" : "Role granted";
+}
+var PENDING_POLL_MS = 5e3;
+var RETRY_DELAYS_MS = [1e3, 4e3];
+function watchRoleDeliveries(options) {
+  const schedule = options.schedule ?? ((run2, ms) => {
+    const timer = setTimeout(run2, ms);
+    return () => clearTimeout(timer);
+  });
+  let active = true;
+  let reading = false;
+  let failures = 0;
+  let resting = false;
+  let cancel = () => {
+  };
+  async function run() {
+    cancel();
+    if (!active || reading) {
+      return;
+    }
+    reading = true;
+    resting = false;
+    try {
+      const next = sanitizeDeliveries(await options.read());
+      if (!active) {
+        return;
+      }
+      failures = 0;
+      options.onChange(next);
+      if (hasPending(next)) {
+        cancel = schedule(run, PENDING_POLL_MS);
+      }
+    } catch {
+      if (!active) {
+        return;
+      }
+      const delay = RETRY_DELAYS_MS[failures];
+      failures += 1;
+      if (delay === void 0) {
+        failures = 0;
+        resting = true;
+      } else {
+        cancel = schedule(run, delay);
+      }
+    } finally {
+      reading = false;
+    }
+  }
+  void run();
+  return {
+    wake() {
+      if (resting) {
+        void run();
+      }
+    },
+    dispose() {
+      active = false;
+      cancel();
+    }
+  };
+}
+
+// src/react/status.ts
+function isFinished(view) {
+  return view.availability.kind === "completed" || view.completion.kind !== "keyed" && view.completed;
+}
+function isAutomatic(view) {
+  return view.trigger.kind === "automatic";
+}
+function runsSilently(view) {
+  return view.trigger.kind === "automatic" && (view.completion.kind === "keyed" || Boolean(view.trigger.observation));
+}
+function completionCountLabel(view) {
+  if (view.completion.kind !== "keyed" || view.completionCount < 1) {
+    return null;
+  }
+  return view.completionCount === 1 ? "Completed once" : `Completed ${view.completionCount.toLocaleString()} times`;
+}
+function canRepeat(view) {
+  return view.completion.kind === "keyed" && view.attempt?.status === "accepted" && canSubmit(view);
+}
+function visibleQuests(quests) {
+  return quests.filter((q) => q.visibility !== "hidden");
+}
+function questStatus(view) {
+  if (isFinished(view)) {
+    return { tone: "done", label: "Completed" };
+  }
+  if (view.lifecycle === "paused") {
+    return {
+      tone: "off",
+      label: "Paused",
+      detail: "This activity is paused for now."
+    };
+  }
+  if (view.lifecycle === "archived") {
+    return {
+      tone: "off",
+      label: "Closed",
+      detail: "This activity is no longer running."
+    };
+  }
+  const availability = view.availability;
+  if (view.streak && availability.kind !== "locked") {
+    const streak = view.streak;
+    if (streak.milestone.status === "budget-exhausted") {
+      return {
+        tone: "attention",
+        label: "Milestone reached",
+        detail: "Your qualifying days are saved. This milestone's reward budget was exhausted."
+      };
+    }
+    const deadline = new Intl.DateTimeFormat("en", {
+      timeZone: streak.timeZone,
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      timeZoneName: "short"
+    }).format(streak.nextBoundary);
+    return {
+      tone: streak.todayQualified ? "waiting" : "open",
+      label: `${streak.current} / ${streak.goal} days`,
+      detail: streak.todayQualified ? `Today counts. Your next community day starts ${deadline}. Best streak: ${streak.best} days.` : `Complete today's activity before ${deadline} ${streak.current ? "to keep your streak" : "to start your streak"}. Best streak: ${streak.best} days.`
+    };
+  }
+  if (runsSilently(view) && availability.kind !== "locked") {
+    return {
+      tone: "waiting",
+      label: "Automatic",
+      detail: view.completion.kind === "keyed" ? [
+        completionCountLabel(view),
+        "This counts by itself each time you qualify."
+      ].filter(Boolean).join(". ") : "This updates by itself when you qualify."
+    };
+  }
+  if (isAutomatic(view) && availability.kind !== "locked") {
+    return {
+      tone: "waiting",
+      label: "In progress",
+      detail: "This updates by itself when you qualify."
+    };
+  }
+  switch (availability.kind) {
+    case "completed":
+      return { tone: "done", label: "Completed" };
+    case "locked":
+      return {
+        tone: "locked",
+        label: "Locked",
+        detail: `Complete ${list(availability.missing.map((m) => m.title))} first.`
+      };
+    case "checking":
+      return {
+        tone: "waiting",
+        label: "Checking",
+        detail: "Your submission is being verified."
+      };
+    case "needs-review":
+      return {
+        tone: "waiting",
+        label: "In review",
+        detail: "A person is reviewing your submission."
+      };
+    case "retryable":
+      return {
+        tone: "attention",
+        label: "Didn't go through",
+        detail: "Verification couldn't run. Try again. Nothing was lost."
+      };
+    case "staff-required":
+      return {
+        tone: "waiting",
+        label: "Waiting for staff",
+        detail: "A staff member confirms this activity for you."
+      };
+    case "automatic":
+      return {
+        tone: "waiting",
+        label: "In progress",
+        detail: "This updates by itself when you qualify."
+      };
+    case "available":
+      return view.attempt?.status === "rejected" ? {
+        tone: "attention",
+        label: "Try again",
+        detail: view.attempt.reason ?? "That submission wasn't accepted."
+      } : { tone: "open", label: "Ready" };
+  }
+}
+function canSubmit(view) {
+  return !isFinished(view) && !isAutomatic(view) && view.lifecycle === "active" && view.availability.kind === "available";
+}
+function progressOf(quests) {
+  const counted = quests.filter(
+    (q) => q.lifecycle !== "archived" && q.completion.kind !== "keyed"
+  );
+  return {
+    total: counted.length,
+    done: counted.filter(isFinished).length
+  };
+}
+function list(items) {
+  return new Intl.ListFormat("en", { type: "conjunction" }).format(
+    items.map((item) => `\u201C${item}\u201D`)
+  );
+}
+
+// src/react/use-role-deliveries.ts
+import { useEffect, useState } from "react";
+function useRoleDeliveries(relay, member, completions) {
+  const [state, setState] = useState(null);
+  useEffect(() => {
+    if (!member || !completions) {
+      return;
+    }
+    const watch = watchRoleDeliveries({
+      read: async () => (await relay.me.rewardDeliveries()).deliveries,
+      onChange: (deliveries) => setState({ member, deliveries })
+    });
+    const wake = () => {
+      if (document.visibilityState === "visible") {
+        watch.wake();
+      }
+    };
+    window.addEventListener("focus", wake);
+    document.addEventListener("visibilitychange", wake);
+    return () => {
+      watch.dispose();
+      window.removeEventListener("focus", wake);
+      document.removeEventListener("visibilitychange", wake);
+    };
+  }, [relay, member, completions]);
+  return member && completions && state?.member === member ? state.deliveries : [];
+}
+
+// src/react/experience.tsx
+import { jsx } from "react/jsx-runtime";
+var Context = createContext2(null);
+function ExperienceProvider({ children }) {
+  const relay = useRelay();
+  const [experience, setExperience] = useState2({
+    status: "loading"
+  });
+  const [owner, setOwner] = useState2(null);
+  const [member, setMember] = useState2(null);
+  const observer = useRef(null);
+  useEffect2(() => {
+    const subscription = relay.quests.observe((observation) => {
+      if (observation.kind === "session" || observation.kind === "ready") {
+        const principal = observation.session?.principal;
+        setMember(principal?.kind === "member" ? principal.member : null);
+      } else if (observation.kind === "loading") {
+        setMember(null);
+      }
+      if (observation.kind === "ready") {
+        setOwner(observation.progress.member);
+      }
+      setExperience((previous) => {
+        switch (observation.kind) {
+          case "loading":
+            return { status: "loading" };
+          case "session":
+            return observation.session?.principal.kind === "member" ? previous : { status: "signed-out" };
+          case "ready":
+            return {
+              status: "ready",
+              // Hidden quests never reach the UI, on any poll.
+              quests: visibleQuests(observation.progress.quests),
+              collections: observation.progress.collections.map(
+                (collection) => ({
+                  ...collection,
+                  quests: visibleQuests(collection.quests)
+                })
+              ),
+              stale: null
+            };
+          case "error":
+            return previous.status === "ready" ? { ...previous, stale: observation.error.message } : { status: "error", message: observation.error.message };
+        }
+      });
+    });
+    observer.current = subscription;
+    return () => subscription.dispose();
+  }, [relay]);
+  const mine = experience.status === "ready" && member !== null && member === owner;
+  const deliveries = useRoleDeliveries(
+    relay,
+    mine ? member : null,
+    mine ? completionMark([
+      ...experience.quests,
+      ...experience.collections.flatMap((c) => c.quests)
+    ]) : ""
+  );
+  const value = useMemo(
+    () => ({
+      experience,
+      member: mine ? member : null,
+      deliveries,
+      refresh: async () => observer.current?.refresh()
+    }),
+    [experience, mine, member, deliveries]
+  );
+  return /* @__PURE__ */ jsx(Context, { value, children });
+}
+function useExperience() {
+  const value = useContext2(Context);
+  if (!value) {
+    throw new Error("useExperience requires <RelayProvider>");
+  }
+  return value;
+}
+
+// src/react/provider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function RelayProvider({
+  client,
+  baseUrl = "/relay",
+  children
+}) {
+  const [value] = useState3(
+    () => client ?? createBrowserRelayClient({ baseUrl })
+  );
+  return /* @__PURE__ */ jsx2(ClientContext, { value, children: /* @__PURE__ */ jsx2(ExperienceProvider, { children }) });
+}
+
+// src/react/quest-groups.ts
+function questGroups(experience, order = []) {
+  const placed = new Set(
+    experience.collections.flatMap((c) => c.quests.map((q) => q.quest))
+  );
+  const rank = (view) => {
+    const index = order.indexOf(view.key ?? view.quest);
+    const fallback = index === -1 ? order.indexOf(view.quest) : index;
+    return fallback === -1 ? order.length : fallback;
+  };
+  const unplaced = experience.quests.filter((q) => !placed.has(q.quest)).sort((a, b) => rank(a) - rank(b));
+  return [
+    ...experience.collections,
+    ...unplaced.length ? [{ id: "unplaced", title: "", quests: unplaced }] : []
+  ].map((group) => ({
+    ...group,
+    quests: group.quests.filter((q) => q.lifecycle !== "archived")
+  })).filter((group) => group.quests.length > 0);
+}
+
+// src/react/use-quest.ts
+import { useCallback, useEffect as useEffect3, useState as useState4 } from "react";
+function useQuest(observed) {
+  const relay = useRelay();
+  const { refresh } = useExperience();
+  const [latest, setLatest] = useState4(null);
+  const [draft, setDraft] = useState4(null);
+  const [notice, setNotice] = useState4(null);
+  const [error, setError] = useState4(null);
+  const [busy, setBusy] = useState4(false);
+  const [discardedAttempt, setDiscardedAttempt] = useState4(null);
+  const [saved, setSaved] = useState4("none");
+  const [receipt, setReceipt] = useState4(null);
+  useEffect3(() => setLatest(null), [observed.release]);
+  const view = latest ?? observed;
+  const { quest, release } = view;
+  const completed = isFinished(view) || isAutomatic(view);
+  const attempt = view.attempt?.id;
+  useEffect3(() => {
+    let active = true;
+    relay.quests.open(view).then((controller) => controller.status()).then((status) => {
+      if (!active) {
+        return;
+      }
+      setSaved(
+        completed || status.kind === "empty" || status.kind === "submitted" ? "none" : status.kind === "needs-review" ? "outdated" : "interrupted"
+      );
+    }).catch(() => {
+    });
+    return () => {
+      active = false;
+    };
+  }, [relay, quest, release, completed, attempt, busy]);
+  const run = useCallback(
+    async (action) => {
+      setBusy(true);
+      setError(null);
+      setNotice(null);
+      try {
+        const result = await action();
+        if (result.kind === "quest-updated") {
+          setLatest(result.latest);
+          setDraft(result.draft);
+          setNotice("quest-updated");
+        } else {
+          setDraft(null);
+          setReceipt(result.attempt.id);
+          setNotice("received");
+        }
+        await refresh();
+      } catch (cause) {
+        setError(
+          cause instanceof Error ? cause.message : "Something went wrong."
+        );
+      } finally {
+        setBusy(false);
+      }
+    },
+    [refresh]
+  );
+  return {
+    /** The newest known version of the quest. Render this, not the prop. */
+    view,
+    /** Input recovered after the quest changed. Prefill the form with it. */
+    draft,
+    notice,
+    error,
+    busy,
+    saved,
+    /** The attempt the last "received" notice is about. */
+    receipt,
+    startingFresh: view.attempt?.id === discardedAttempt && view.attempt?.status === "failed",
+    restart: async () => {
+      setBusy(true);
+      setError(null);
+      try {
+        await (await relay.quests.open(view)).discard();
+        setDiscardedAttempt(view.attempt?.id ?? null);
+        setSaved("none");
+        setDraft(null);
+        setNotice(null);
+      } catch (cause) {
+        setError(
+          cause instanceof Error ? cause.message : "Could not start a new submission."
+        );
+      } finally {
+        setBusy(false);
+      }
+    },
+    submit: (input) => run(async () => {
+      if (view.connections.length) {
+        const accounts = await relay.auth.accounts();
+        const missing = view.connections.find(
+          (provider) => !accounts.some(
+            (account) => account.provider === provider && account.configured && account.status === "connected"
+          )
+        );
+        if (missing) {
+          throw new Error(`Connect ${missing} before verifying.`);
+        }
+      }
+      const controller = await relay.quests.open(view);
+      if (controller.kind === "claim" && input.kind === "claim") {
+        return controller.submit();
+      }
+      if (controller.kind === "quiz" && input.kind === "quiz") {
+        return controller.submit(input.answers);
+      }
+      if (controller.kind === "photo" && input.kind === "photo") {
+        return controller.submit(input.file);
+      }
+      throw new Error("This activity changed. Reload and try again.");
+    }),
+    /** Finish an interrupted submission, or reopen an outdated draft. */
+    resume: () => run(async () => (await relay.quests.open(view)).resume()),
+    /**
+     * Re-run verification that failed to run. Never creates a new attempt.
+     * Domino refuses this for automatic quests, so never offer it for them.
+     */
+    retry: () => run(async () => {
+      if (isAutomatic(view)) {
+        throw new Error("This activity updates by itself.");
+      }
+      return {
+        kind: "submitted",
+        attempt: await relay.quests.retry(view)
+      };
+    })
+  };
+}
+
+// src/react/auth.ts
+import { useEffect as useEffect4, useState as useState5 } from "react";
+function useSignInMethods() {
+  const relay = useRelay();
+  const [methods, setMethods] = useState5(null);
+  useEffect4(() => {
+    let active = true;
+    relay.auth.providers().then((result) => {
+      if (!active) {
+        return;
+      }
+      setMethods({
+        providers: result.providers.filter((p) => p.configured).map((p) => p.provider),
+        email: result.email
+      });
+    }).catch(() => active && setMethods({ providers: [], email: true }));
+    return () => {
+      active = false;
+    };
+  }, [relay]);
+  return methods;
+}
+function useSignIn() {
+  const relay = useRelay();
+  const [challenge, setChallenge] = useState5(null);
+  const [busy, setBusy] = useState5(false);
+  const [error, setError] = useState5(null);
+  async function run(task, fallback) {
+    setBusy(true);
+    setError(null);
+    try {
+      await task();
+    } catch (cause) {
+      setError(
+        cause instanceof Error && cause.message ? cause.message : fallback
+      );
+    } finally {
+      setBusy(false);
+    }
+  }
+  return {
+    busy,
+    error,
+    /** True once a code was sent and the form should ask for it. */
+    codeSent: challenge !== null,
+    sendCode: (email) => run(async () => {
+      setChallenge((await relay.auth.emailStart(email)).challenge);
+    }, "Couldn't send a code. Check the address and try again."),
+    verifyCode: (code) => run(async () => {
+      if (!challenge) {
+        throw new Error("Request a new code first.");
+      }
+      await relay.auth.emailVerify(challenge, code.trim());
+      setChallenge(null);
+    }, "That code didn't work. Check it, or request a new one."),
+    startOver: () => {
+      setChallenge(null);
+      setError(null);
+    },
+    withProvider: (provider) => run(async () => {
+      const { url } = await relay.auth.start(provider, "sign-in");
+      window.location.assign(url);
+    }, "Couldn't start sign-in. Try again.")
+  };
+}
+function useSignOut() {
+  const relay = useRelay();
+  const [busy, setBusy] = useState5(false);
+  return {
+    busy,
+    signOut: async () => {
+      setBusy(true);
+      try {
+        await relay.auth.signOut();
+      } finally {
+        setBusy(false);
+      }
+    }
+  };
+}
+
+// src/react/accounts.ts
+import { useCallback as useCallback2, useEffect as useEffect5, useState as useState6 } from "react";
+var CHANGED = "relay-accounts-changed";
+function isConnected(accounts, provider) {
+  return Boolean(
+    accounts?.some(
+      (account) => account.provider === provider && account.configured && account.status === "connected"
+    )
+  );
+}
+function useAccounts() {
+  const relay = useRelay();
+  const { member } = useExperience();
+  const [accounts, setAccounts] = useState6(null);
+  const [error, setError] = useState6(null);
+  const [busy, setBusy] = useState6(false);
+  const refresh = useCallback2(async () => {
+    try {
+      setAccounts(await relay.auth.accounts());
+      setError(null);
+    } catch (cause) {
+      setError(
+        cause instanceof Error && cause.message ? cause.message : "Could not load connected accounts."
+      );
+    }
+  }, [relay]);
+  useEffect5(() => {
+    if (!member) {
+      setAccounts(null);
+      return;
+    }
+    const update = () => void refresh();
+    update();
+    window.addEventListener("focus", update);
+    window.addEventListener(CHANGED, update);
+    return () => {
+      window.removeEventListener("focus", update);
+      window.removeEventListener(CHANGED, update);
+    };
+  }, [member, refresh]);
+  async function run(task, fallback) {
+    setBusy(true);
+    setError(null);
+    try {
+      await task();
+    } catch (cause) {
+      setError(
+        cause instanceof Error && cause.message ? cause.message : fallback
+      );
+    } finally {
+      setBusy(false);
+    }
+  }
+  return {
+    /** Null until read, and while nobody is signed in. */
+    accounts,
+    error,
+    busy,
+    refresh,
+    isConnected: (provider) => isConnected(accounts, provider),
+    connect: (provider) => run(async () => {
+      const { url } = await relay.auth.start(provider, "connect");
+      window.location.assign(url);
+    }, "Couldn't start connecting. Try again."),
+    disconnect: (provider) => run(async () => {
+      await relay.auth.disconnect(provider);
+      window.dispatchEvent(new Event(CHANGED));
+    }, "Couldn't disconnect. Try again.")
+  };
+}
+
+// src/react/referrals.ts
+import { useCallback as useCallback3, useEffect as useEffect6, useRef as useRef2, useState as useState7 } from "react";
+var PENDING = "domino:pending-referral";
+var CODE = /^[a-zA-Z0-9_-]{1,100}$/;
+function captureReferralCode(param = "ref") {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const code = new URL(window.location.href).searchParams.get(param);
+  try {
+    if (code && CODE.test(code)) {
+      window.sessionStorage.setItem(PENDING, code);
+    }
+    return window.sessionStorage.getItem(PENDING);
+  } catch {
+    return code && CODE.test(code) ? code : null;
+  }
+}
+function forgetReferralCode() {
+  try {
+    window.sessionStorage.removeItem(PENDING);
+  } catch {
+  }
+}
+function useInvitation(param = "ref") {
+  const relay = useRelay();
+  const { member } = useExperience();
+  const [state, setState] = useState7(() => {
+    const code = captureReferralCode(param);
+    return code ? { status: "pending", code } : { status: "none" };
+  });
+  const started = useRef2(null);
+  const accept = useCallback3(
+    async (code) => {
+      setState({ status: "accepting", code });
+      try {
+        await relay.referrals.accept({ code, actionId: `accept-${code}` });
+        forgetReferralCode();
+        setState({ status: "accepted", code });
+      } catch (cause) {
+        const refused = cause instanceof RelayError && cause.status >= 400 && cause.status < 500;
+        if (refused) {
+          forgetReferralCode();
+        }
+        setState({
+          status: refused ? "rejected" : "failed",
+          code,
+          reason: cause instanceof Error && cause.message ? cause.message : "That invitation code couldn't be used."
+        });
+      }
+    },
+    [relay]
+  );
+  useEffect6(() => {
+    if (member && state.status === "pending" && started.current !== `${member}:${state.code}`) {
+      started.current = `${member}:${state.code}`;
+      void accept(state.code);
+    }
+  }, [member, state, accept]);
+  return { invitation: state, accept };
+}
+function useReferralSummary(options = {}) {
+  const relay = useRelay();
+  const { member } = useExperience();
+  const [summary, setSummary] = useState7(null);
+  const [error, setError] = useState7(null);
+  const refresh = useCallback3(async () => {
+    try {
+      setSummary(await relay.referrals.summary());
+      setError(null);
+    } catch (cause) {
+      setError(
+        cause instanceof Error && cause.message ? cause.message : "Could not load your invitations."
+      );
+    }
+  }, [relay]);
+  useEffect6(() => {
+    setSummary(null);
+    if (member) {
+      void refresh();
+    }
+  }, [member, refresh]);
+  let link = null;
+  if (summary && typeof window !== "undefined") {
+    const url = new URL(options.path ?? "/", window.location.origin);
+    url.searchParams.set(options.param ?? "ref", summary.code);
+    link = url.toString();
+  }
+  return { summary, link, error, refresh };
+}
+
+// src/react/leaderboards.ts
+import { useCallback as useCallback4, useEffect as useEffect7, useState as useState8 } from "react";
+function useLeaderboard(board, options = {}) {
+  const relay = useRelay();
+  const { member } = useExperience();
+  const { limit = 25, intervalMs = 3e4 } = options;
+  const [state, setState] = useState8({ status: "loading" });
+  const refresh = useCallback4(async () => {
+    try {
+      const page = await relay.leaderboards.standings(board, { limit });
+      setState({ status: "ready", page, stale: null });
+    } catch (cause) {
+      const message = cause instanceof Error && cause.message ? cause.message : "Could not load the leaderboard.";
+      setState(
+        (previous) => previous.status === "ready" ? { ...previous, stale: message } : { status: "error", message }
+      );
+    }
+  }, [relay, board, limit]);
+  useEffect7(() => {
+    void refresh();
+    const timer = setInterval(() => {
+      if (document.visibilityState === "visible") {
+        void refresh();
+      }
+    }, intervalMs);
+    return () => clearInterval(timer);
+  }, [refresh, member, intervalMs]);
+  return { ...state, refresh };
+}
+export {
+  PENDING_POLL_MS,
+  RETRY_DELAYS_MS,
+  RelayProvider,
+  canRepeat,
+  canSubmit,
+  captureReferralCode,
+  completionCountLabel,
+  completionMark,
+  hasPending,
+  isAutomatic,
+  isConnected,
+  isFinished,
+  progressOf,
+  questGroups,
+  questStatus,
+  roleDeliveryLabel,
+  runsSilently,
+  sanitizeDeliveries,
+  useAccounts,
+  useExperience,
+  useInvitation,
+  useLeaderboard,
+  useQuest,
+  useReferralSummary,
+  useRelay,
+  useSignIn,
+  useSignInMethods,
+  useSignOut,
+  visibleQuests,
+  watchRoleDeliveries
+};