deepspace 0.4.2 → 0.4.3

package/dist/index.js

@@ -4888,6 +4888,9 @@ async function request(method, endpoint, body, options) {
   } catch {
   }
   const controller = new AbortController();
+  const abortFromCaller = () => controller.abort();
+  if (options?.signal?.aborted) controller.abort();
+  else options?.signal?.addEventListener("abort", abortFromCaller, { once: true });
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const res = await fetch(url, {
@@ -4924,6 +4927,7 @@ async function request(method, endpoint, body, options) {
     };
   } finally {
     clearTimeout(timeout);
+    options?.signal?.removeEventListener("abort", abortFromCaller);
   }
 }
 var integration = {
@@ -5017,8 +5021,364 @@ function decodeAiStreamChunk(chunk) {
   }
 }
 
+// src/client/status.ts
+import { useCallback as useCallback26, useEffect as useEffect20, useMemo as useMemo15, useRef as useRef17, useState as useState17 } from "react";
+
+// src/client/status-core.ts
+var ASYNC_RESOURCE_DEFAULTS = {
+  retry: 0,
+  retryDelayMs: 2e3,
+  slowAfterMs: 1e4
+};
+function isAsyncResourceSlow(input) {
+  return input.slowAfterMs > 0 && input.now - input.startedAt >= input.slowAfterMs;
+}
+function getPagedResourceCooldownMs(input) {
+  const failureCount = Math.max(1, input.failureCount);
+  return Math.min(input.maxRetryDelayMs, input.retryDelayMs * 2 ** (failureCount - 1));
+}
+function canAutoLoadPagedResource(input) {
+  return input.hasMore && !input.isLoading && input.cooldownUntil <= input.now;
+}
+function clampPagedResourceItems(input) {
+  if (input.maxItemsPerPage <= 0 || input.items.length <= input.maxItemsPerPage) {
+    return { items: input.items, droppedItemCount: 0 };
+  }
+  return {
+    items: input.items.slice(0, input.maxItemsPerPage),
+    droppedItemCount: input.items.length - input.maxItemsPerPage
+  };
+}
+function deriveLoadState(input) {
+  const auth = input.auth;
+  if (auth) {
+    if (!auth.isLoaded) return "loading";
+    if (auth.requireSignedIn && !auth.isSignedIn) return "signedOut";
+    if (auth.requireUser && auth.isSignedIn && auth.userLoading) return "loading";
+  }
+  const statuses = [...input.queries ?? [], ...input.resources ?? []];
+  if (statuses.some((item) => item.status === "error" || item.error)) return "error";
+  if (statuses.some((item) => item.status === "loading" || item.status === "idle")) return "loading";
+  if (input.empty) return "empty";
+  return "ready";
+}
+
+// src/client/status.ts
+function useAuthStatus(options = {}) {
+  const auth = useAuth();
+  const status = deriveLoadState({
+    auth: {
+      isLoaded: auth.isLoaded,
+      isSignedIn: auth.isSignedIn,
+      requireSignedIn: options.requireSignedIn
+    }
+  });
+  return {
+    ...auth,
+    status,
+    isReady: status === "ready"
+  };
+}
+function useAuthProfileReady(options = {}) {
+  const auth = useAuth();
+  const { user, isLoading: userLoading, refetch } = useUser();
+  const status = deriveLoadState({
+    auth: {
+      isLoaded: auth.isLoaded,
+      isSignedIn: auth.isSignedIn,
+      requireSignedIn: options.requireSignedIn,
+      requireUser: options.requireUser,
+      userLoading
+    }
+  });
+  return {
+    ...auth,
+    user,
+    userLoading,
+    refetchUser: refetch,
+    status,
+    isReady: status === "ready"
+  };
+}
+var useAuthReady = useAuthProfileReady;
+function useAsyncResource(fetcher, deps, options = {}) {
+  const enabled = options.enabled ?? true;
+  const keepPreviousData = options.keepPreviousData ?? true;
+  const retry = options.retry ?? ASYNC_RESOURCE_DEFAULTS.retry;
+  const retryDelayMs = options.retryDelayMs ?? ASYNC_RESOURCE_DEFAULTS.retryDelayMs;
+  const slowAfterMs = options.slowAfterMs ?? ASYNC_RESOURCE_DEFAULTS.slowAfterMs;
+  const [state, setState] = useState17(() => ({
+    status: enabled ? "loading" : "idle",
+    data: options.initialData ?? null,
+    error: null,
+    isRefreshing: false,
+    isSlow: false,
+    retryCount: 0
+  }));
+  const requestIdRef = useRef17(0);
+  const [reloadTick, setReloadTick] = useState17(0);
+  const reload = useCallback26(() => {
+    setReloadTick((tick) => tick + 1);
+  }, []);
+  useEffect20(() => {
+    if (!enabled) {
+      setState((prev) => ({ ...prev, status: "idle", isRefreshing: false, isSlow: false, retryCount: 0 }));
+      return;
+    }
+    const requestId = ++requestIdRef.current;
+    const controller = new AbortController();
+    let retryTimer = null;
+    let slowTimer = null;
+    setState((prev) => {
+      const hasData = keepPreviousData && prev.data != null;
+      return {
+        ...prev,
+        status: hasData ? "ready" : "loading",
+        error: null,
+        isRefreshing: hasData,
+        isSlow: false,
+        data: hasData ? prev.data : options.initialData ?? null,
+        retryCount: 0
+      };
+    });
+    if (slowAfterMs > 0) {
+      const startedAt = Date.now();
+      slowTimer = setTimeout(() => {
+        if (requestIdRef.current !== requestId || controller.signal.aborted) return;
+        setState((prev) => ({
+          ...prev,
+          isSlow: isAsyncResourceSlow({ startedAt, now: Date.now(), slowAfterMs })
+        }));
+      }, slowAfterMs);
+    }
+    const wait = (ms) => new Promise((resolve) => {
+      retryTimer = setTimeout(resolve, ms);
+    });
+    const load = async () => {
+      let attempt = 0;
+      while (!controller.signal.aborted) {
+        try {
+          const data = await fetcher(controller.signal);
+          if (requestIdRef.current !== requestId || controller.signal.aborted) return;
+          if (slowTimer) clearTimeout(slowTimer);
+          setState({ status: "ready", data, error: null, isRefreshing: false, isSlow: false, retryCount: attempt });
+          return;
+        } catch (err) {
+          if (requestIdRef.current !== requestId || controller.signal.aborted) return;
+          const message = err instanceof Error ? err.message : "Request failed";
+          if (attempt < retry) {
+            attempt += 1;
+            setState((prev) => ({
+              ...prev,
+              error: message,
+              retryCount: attempt,
+              isRefreshing: keepPreviousData && prev.data != null
+            }));
+            await wait(retryDelayMs);
+            continue;
+          }
+          if (slowTimer) clearTimeout(slowTimer);
+          setState((prev) => ({
+            status: keepPreviousData && prev.data != null ? "ready" : "error",
+            data: keepPreviousData ? prev.data : null,
+            error: message,
+            isRefreshing: false,
+            isSlow: false,
+            retryCount: attempt
+          }));
+          return;
+        }
+      }
+    };
+    load();
+    return () => {
+      if (retryTimer) clearTimeout(retryTimer);
+      if (slowTimer) clearTimeout(slowTimer);
+      controller.abort();
+    };
+  }, [enabled, keepPreviousData, retry, retryDelayMs, slowAfterMs, reloadTick, ...deps]);
+  return useMemo15(() => ({ ...state, reload }), [state, reload]);
+}
+function usePagedResource(fetchPage, deps, options = {}) {
+  const enabled = options.enabled ?? true;
+  const initialItems = options.initialItems ?? [];
+  const pageSize = options.pageSize ?? 20;
+  const maxItemsPerPage = options.maxItemsPerPage ?? pageSize;
+  const keepPreviousData = options.keepPreviousData ?? true;
+  const autoRetryOnError = options.autoRetryOnError ?? false;
+  const retryDelayMs = options.retryDelayMs ?? ASYNC_RESOURCE_DEFAULTS.retryDelayMs;
+  const maxRetryDelayMs = options.maxRetryDelayMs ?? 3e4;
+  const hasInitialItems = initialItems.length > 0;
+  const [state, setState] = useState17(() => ({
+    status: enabled ? hasInitialItems ? "ready" : "loading" : "idle",
+    items: initialItems,
+    error: null,
+    warning: null,
+    hasMore: true,
+    isLoadingInitial: enabled && !hasInitialItems,
+    isLoadingMore: false,
+    isRefreshing: false
+  }));
+  const requestIdRef = useRef17(0);
+  const controllerRef = useRef17(null);
+  const loadingRef = useRef17(false);
+  const nextPageRef = useRef17(hasInitialItems ? 2 : 1);
+  const failedPageRef = useRef17(null);
+  const failureCountRef = useRef17(0);
+  const cooldownUntilRef = useRef17(0);
+  const autoRetryTimerRef = useRef17(null);
+  const clearAutoRetryTimer = useCallback26(() => {
+    if (autoRetryTimerRef.current) {
+      clearTimeout(autoRetryTimerRef.current);
+      autoRetryTimerRef.current = null;
+    }
+  }, []);
+  const resetCooldown = useCallback26(() => {
+    failureCountRef.current = 0;
+    cooldownUntilRef.current = 0;
+  }, []);
+  const setFailureCooldown = useCallback26(() => {
+    failureCountRef.current += 1;
+    const delay = getPagedResourceCooldownMs({
+      failureCount: failureCountRef.current,
+      retryDelayMs,
+      maxRetryDelayMs
+    });
+    cooldownUntilRef.current = Date.now() + delay;
+    return delay;
+  }, [maxRetryDelayMs, retryDelayMs]);
+  const startLoad = useCallback26(async (page, mode) => {
+    if (!enabled || loadingRef.current) return;
+    if (mode === "auto" && !canAutoLoadPagedResource({
+      hasMore: true,
+      isLoading: false,
+      now: Date.now(),
+      cooldownUntil: cooldownUntilRef.current
+    })) {
+      return;
+    }
+    clearAutoRetryTimer();
+    loadingRef.current = true;
+    const requestId = ++requestIdRef.current;
+    controllerRef.current?.abort();
+    const controller = new AbortController();
+    controllerRef.current = controller;
+    setState((prev) => {
+      const hasItems = prev.items.length > 0;
+      return {
+        ...prev,
+        status: hasItems && mode !== "refresh" ? "ready" : "loading",
+        error: mode === "auto" && prev.error ? prev.error : null,
+        warning: null,
+        isLoadingInitial: !hasItems && mode !== "refresh",
+        isLoadingMore: hasItems && mode !== "refresh",
+        isRefreshing: mode === "refresh" && hasItems,
+        items: mode === "refresh" && !keepPreviousData ? [] : prev.items
+      };
+    });
+    try {
+      const result = await fetchPage({ page, pageSize, signal: controller.signal });
+      if (requestIdRef.current !== requestId || controller.signal.aborted) return;
+      const { items: pageItems, droppedItemCount } = clampPagedResourceItems({
+        items: result.items,
+        maxItemsPerPage
+      });
+      resetCooldown();
+      failedPageRef.current = null;
+      nextPageRef.current = page + 1;
+      setState((prev) => ({
+        status: "ready",
+        items: page === 1 || mode === "refresh" ? pageItems : [...prev.items, ...pageItems],
+        error: null,
+        warning: droppedItemCount > 0 ? `The last API page returned ${result.items.length} items; only ${pageItems.length} were kept. Request a smaller page from the API instead of fetching the whole feed.` : null,
+        hasMore: droppedItemCount > 0 || (result.hasMore ?? result.items.length >= pageSize),
+        isLoadingInitial: false,
+        isLoadingMore: false,
+        isRefreshing: false
+      }));
+    } catch (err) {
+      if (requestIdRef.current !== requestId || controller.signal.aborted) return;
+      const message = err instanceof Error ? err.message : "Request failed";
+      failedPageRef.current = page;
+      const cooldownMs = setFailureCooldown();
+      setState((prev) => {
+        const hasItems = prev.items.length > 0;
+        return {
+          ...prev,
+          status: hasItems ? "ready" : "error",
+          error: message,
+          warning: prev.warning,
+          hasMore: hasItems ? prev.hasMore : false,
+          isLoadingInitial: false,
+          isLoadingMore: false,
+          isRefreshing: false
+        };
+      });
+      if (autoRetryOnError) {
+        autoRetryTimerRef.current = setTimeout(() => {
+          autoRetryTimerRef.current = null;
+          void startLoad(page, "auto");
+        }, cooldownMs);
+      }
+    } finally {
+      if (requestIdRef.current === requestId) {
+        loadingRef.current = false;
+        controllerRef.current = null;
+      }
+    }
+  }, [autoRetryOnError, clearAutoRetryTimer, enabled, fetchPage, keepPreviousData, pageSize, resetCooldown, setFailureCooldown]);
+  const loadMore = useCallback26(() => {
+    if (!state.hasMore || state.isLoadingInitial || state.isLoadingMore || state.isRefreshing) return;
+    void startLoad(nextPageRef.current, "auto");
+  }, [startLoad, state.hasMore, state.isLoadingInitial, state.isLoadingMore, state.isRefreshing]);
+  const retry = useCallback26(() => {
+    const page = failedPageRef.current ?? nextPageRef.current;
+    void startLoad(page, "manual");
+  }, [startLoad]);
+  const refresh = useCallback26(() => {
+    failedPageRef.current = null;
+    resetCooldown();
+    nextPageRef.current = 1;
+    void startLoad(1, "refresh");
+  }, [resetCooldown, startLoad]);
+  useEffect20(() => {
+    requestIdRef.current += 1;
+    controllerRef.current?.abort();
+    clearAutoRetryTimer();
+    loadingRef.current = false;
+    failedPageRef.current = null;
+    resetCooldown();
+    nextPageRef.current = hasInitialItems ? 2 : 1;
+    setState({
+      status: enabled ? hasInitialItems ? "ready" : "loading" : "idle",
+      items: initialItems,
+      error: null,
+      warning: null,
+      hasMore: true,
+      isLoadingInitial: enabled && !hasInitialItems,
+      isLoadingMore: false,
+      isRefreshing: false
+    });
+    if (enabled && !hasInitialItems) {
+      void startLoad(1, "auto");
+    }
+    return () => {
+      requestIdRef.current += 1;
+      controllerRef.current?.abort();
+      clearAutoRetryTimer();
+      loadingRef.current = false;
+    };
+  }, [enabled, pageSize, maxItemsPerPage, keepPreviousData, autoRetryOnError, retryDelayMs, maxRetryDelayMs, ...deps]);
+  return useMemo15(() => ({
+    ...state,
+    loadMore,
+    retry,
+    refresh
+  }), [loadMore, refresh, retry, state]);
+}
+
 // src/client/subscriptions/useSubscription.ts
-import { useCallback as useCallback26, useEffect as useEffect20, useState as useState17 } from "react";
+import { useCallback as useCallback27, useEffect as useEffect21, useState as useState18 } from "react";
 
 // src/shared/subscription.ts
 var ENTITLED_STATUSES = /* @__PURE__ */ new Set([
@@ -5049,7 +5409,7 @@ async function authedJson(path, init) {
   return data;
 }
 function useSubscription() {
-  const [state, setState] = useState17({
+  const [state, setState] = useState18({
     tier: "free",
     status: "none",
     interval: null,
@@ -5058,9 +5418,9 @@ function useSubscription() {
     trialEndsAt: null,
     plans: []
   });
-  const [isLoading, setLoading] = useState17(true);
-  const [error, setError] = useState17(null);
-  const refresh = useCallback26(async () => {
+  const [isLoading, setLoading] = useState18(true);
+  const [error, setError] = useState18(null);
+  const refresh = useCallback27(async () => {
     setLoading(true);
     try {
       const r = await authedJson("/_deepspace/subscriptions/me");
@@ -5080,15 +5440,15 @@ function useSubscription() {
       setLoading(false);
     }
   }, []);
-  useEffect20(() => {
+  useEffect21(() => {
     refresh();
   }, [refresh]);
   const entitled = isEntitled(state.tier, state.status);
-  const hasTier = useCallback26(
+  const hasTier = useCallback27(
     (slug) => state.tier === slug && isEntitled(state.tier, state.status),
     [state.tier, state.status]
   );
-  const isAtLeast = useCallback26(
+  const isAtLeast = useCallback27(
     (slug) => {
       if (!isEntitled(state.tier, state.status)) return false;
       const targetRank = state.plans.find((p) => p.slug === slug)?.rank;
@@ -5098,7 +5458,7 @@ function useSubscription() {
     },
     [state.plans, state.tier, state.status]
   );
-  const subscribe = useCallback26(
+  const subscribe = useCallback27(
     async (planSlug, opts) => {
       const result = await authedJson("/_deepspace/subscriptions/checkout", {
         method: "POST",
@@ -5118,7 +5478,7 @@ function useSubscription() {
     },
     [refresh]
   );
-  const openPortal = useCallback26(
+  const openPortal = useCallback27(
     async (returnUrl) => {
       return authedJson("/_deepspace/subscriptions/portal", {
         method: "POST",
@@ -5187,7 +5547,7 @@ function PricingTable(props) {
 }
 
 // src/client/charges/useCheckout.ts
-import { useCallback as useCallback27, useEffect as useEffect21, useMemo as useMemo15, useState as useState18 } from "react";
+import { useCallback as useCallback28, useEffect as useEffect22, useMemo as useMemo16, useState as useState19 } from "react";
 async function authedJson2(path, init) {
   const token = await getAuthToken();
   const res = await fetch(path, {
@@ -5206,10 +5566,10 @@ async function authedJson2(path, init) {
   return data;
 }
 function useCheckout(opts) {
-  const [purchases, setPurchases] = useState18([]);
-  const [isLoading, setLoading] = useState18(true);
-  const [error, setError] = useState18(null);
-  const refresh = useCallback27(async () => {
+  const [purchases, setPurchases] = useState19([]);
+  const [isLoading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const refresh = useCallback28(async () => {
     setLoading(true);
     try {
       const r = await authedJson2(
@@ -5223,10 +5583,10 @@ function useCheckout(opts) {
       setLoading(false);
     }
   }, []);
-  useEffect21(() => {
+  useEffect22(() => {
     refresh();
   }, [refresh]);
-  const chargeOnce = useCallback27(
+  const chargeOnce = useCallback28(
     async (chargeOpts) => {
       setError(null);
       const common = {
@@ -5260,11 +5620,11 @@ function useCheckout(opts) {
     },
     []
   );
-  const ownsProduct = useCallback27(
+  const ownsProduct = useCallback28(
     (productId) => purchases.some((p) => p.productId === productId),
     [purchases]
   );
-  const owned = useMemo15(
+  const owned = useMemo16(
     () => !!opts?.productId && purchases.some((p) => p.productId === opts.productId),
     [opts?.productId, purchases]
   );
@@ -5516,13 +5876,14 @@ var buttonVariants = cva(
   }
 );
 var Button = React11.forwardRef(
-  ({ className, variant, size, asChild = false, loading = false, disabled, children, ...props }, ref) => {
+  ({ className, variant, size, asChild = false, loading = false, disabled, children, type, ...props }, ref) => {
     const Comp = asChild ? Slot : "button";
     return /* @__PURE__ */ jsxs6(
       Comp,
       {
         className: cn(buttonVariants({ variant, size, className })),
         ref,
+        type: asChild ? void 0 : type ?? "button",
         disabled: disabled || loading,
         ...props,
         children: [
@@ -6111,9 +6472,9 @@ AlertDescription.displayName = "AlertDescription";
 import {
   createContext as createContext4,
   useContext as useContext6,
-  useState as useState19,
-  useCallback as useCallback28,
-  useEffect as useEffect22
+  useState as useState20,
+  useCallback as useCallback29,
+  useEffect as useEffect23
 } from "react";
 import { jsx as jsx28, jsxs as jsxs10 } from "react/jsx-runtime";
 function CheckCircleIcon({ className }) {
@@ -6160,14 +6521,14 @@ function ToastProvider({
   position = "bottom-right",
   maxToasts = 5
 }) {
-  const [toasts, setToasts] = useState19([]);
-  const dismiss = useCallback28((id) => {
+  const [toasts, setToasts] = useState20([]);
+  const dismiss = useCallback29((id) => {
     setToasts((prev) => prev.filter((t) => t.id !== id));
   }, []);
-  const dismissAll = useCallback28(() => {
+  const dismissAll = useCallback29(() => {
     setToasts([]);
   }, []);
-  const addToast = useCallback28(
+  const addToast = useCallback29(
     (options) => {
       const id = Math.random().toString(36).slice(2);
       const duration = options.duration ?? 5e3;
@@ -6181,23 +6542,23 @@ function ToastProvider({
     },
     [dismiss, maxToasts]
   );
-  const toast = useCallback28(
+  const toast = useCallback29(
     (options) => addToast(options),
     [addToast]
   );
-  const success = useCallback28(
+  const success = useCallback29(
     (title, description) => addToast({ type: "success", title, description }),
     [addToast]
   );
-  const error = useCallback28(
+  const error = useCallback29(
     (title, description) => addToast({ type: "error", title, description }),
     [addToast]
   );
-  const warning = useCallback28(
+  const warning = useCallback29(
     (title, description) => addToast({ type: "warning", title, description }),
     [addToast]
   );
-  const info = useCallback28(
+  const info = useCallback29(
     (title, description) => addToast({ type: "info", title, description }),
     [addToast]
   );
@@ -6234,8 +6595,8 @@ var TOAST_CONFIG = {
 };
 function ToastItem({ toast, onDismiss }) {
   const { Icon: Icon2, accent, icon } = TOAST_CONFIG[toast.type];
-  const [exiting, setExiting] = useState19(false);
-  useEffect22(() => {
+  const [exiting, setExiting] = useState20(false);
+  useEffect23(() => {
     if (exiting) {
       const timer = setTimeout(onDismiss, 150);
       return () => clearTimeout(timer);
@@ -6828,6 +7189,7 @@ var SearchInput = React25.forwardRef(
 );
 SearchInput.displayName = "SearchInput";
 export {
+  ASYNC_RESOURCE_DEFAULTS,
   Alert,
   AlertDescription,
   AlertTitle,
@@ -6955,6 +7317,8 @@ export {
   authClient,
   badgeVariants,
   buttonVariants,
+  canAutoLoadPagedResource,
+  clampPagedResourceItems,
   clearAuthToken,
   clearDeepSpaceTheme,
   clientBuild,
@@ -6963,6 +7327,7 @@ export {
   createEncoder,
   decodeAiStreamChunk,
   decodeReactError,
+  deriveLoadState,
   detectEnvironment,
   dispatch,
   encode,
@@ -6980,6 +7345,7 @@ export {
   getConversationParticipantIds,
   getEnvironmentConfig,
   getMessageType,
+  getPagedResourceCooldownMs,
   getPlatformWorkerUrl,
   getThreadCounts,
   getUserColor,
@@ -6988,6 +7354,7 @@ export {
   handleSyncMessage,
   hasContent,
   integration,
+  isAsyncResourceSlow,
   isDMConversation,
   isDarkColor,
   isImageFile,
@@ -7005,7 +7372,11 @@ export {
   signOut,
   toConnectionStatus,
   toUint8Array,
+  useAsyncResource,
   useAuth,
+  useAuthProfileReady,
+  useAuthReady,
+  useAuthStatus,
   useAuthUser,
   useCanvas,
   useChannelMembers,
@@ -7022,6 +7393,7 @@ export {
   useJobs,
   useMessages,
   useMutations,
+  usePagedResource,
   usePlatform,
   usePlatformWS,
   usePosts,