hyperstack-react 0.3.15 → 0.4.0

package/dist/index.d.ts

@@ -4,10 +4,6 @@ export { AccountCategory, AccountMeta, AccountResolutionOptions, AccountResoluti
 import { UseBoundStore, StoreApi } from 'zustand';
 
 type ViewMode = 'state' | 'list';
-interface NetworkConfig {
-    name: string;
-    websocketUrl: string;
-}
 interface TransactionDefinition<TParams = unknown> {
     build: (params: TParams) => {
         instruction: string;
@@ -18,10 +14,14 @@ interface TransactionDefinition<TParams = unknown> {
         key?: string | ((params: TParams) => string);
     }>;
 }
+/**
+ * Global configuration for HyperstackProvider.
+ *
+ * Note: WebSocket URL is no longer configured here. The URL is:
+ * 1. Embedded in the stack definition (stack.url)
+ * 2. Optionally overridden per-hook via useHyperstack(stack, { url: '...' })
+ */
 interface HyperstackConfig {
-    websocketUrl?: string;
-    network?: 'devnet' | 'mainnet' | 'localnet' | NetworkConfig;
-    apiKey?: string;
     autoConnect?: boolean;
     wallet?: WalletAdapter;
     reconnectIntervals?: number[];
@@ -29,6 +29,13 @@ interface HyperstackConfig {
     maxEntriesPerView?: number | null;
     flushIntervalMs?: number;
 }
+/**
+ * Options for useHyperstack hook
+ */
+interface UseHyperstackOptions {
+    /** Override the stack's embedded URL (useful for local development) */
+    url?: string;
+}
 interface ViewHookOptions {
     enabled?: boolean;
     initialData?: unknown;
@@ -73,15 +80,9 @@ interface ListViewHook<T> {
 }
 
 interface HyperstackContextValue {
-    getOrCreateClient: <TStack extends StackDefinition>(stack: TStack) => Promise<HyperStack<TStack>>;
+    getOrCreateClient: <TStack extends StackDefinition>(stack: TStack, urlOverride?: string) => Promise<HyperStack<TStack>>;
     getClient: <TStack extends StackDefinition>(stack: TStack | undefined) => HyperStack<TStack> | null;
-    config: {
-        websocketUrl: string;
-        autoConnect?: boolean;
-        reconnectIntervals?: number[];
-        maxReconnectAttempts?: number;
-        maxEntriesPerView?: number | null;
-    };
+    config: HyperstackConfig;
 }
 declare function HyperstackProvider({ children, fallback, ...config }: HyperstackConfig & {
     children: ReactNode;
@@ -185,7 +186,7 @@ type StackClient<TStack extends StackDefinition> = {
     isLoading: boolean;
     error: Error | null;
 };
-declare function useHyperstack<TStack extends StackDefinition>(stack: TStack): StackClient<TStack>;
+declare function useHyperstack<TStack extends StackDefinition>(stack: TStack, options?: UseHyperstackOptions): StackClient<TStack>;
 
 export { HyperstackProvider, ZustandAdapter, useConnectionState, useEntity, useHyperstack, useHyperstackContext, useInstructionMutation, useView };
-export type { HyperStackStore, HyperstackConfig, ListParams, ListParamsBase, ListParamsMultiple, ListParamsSingle, ListViewHook, MutationStatus, NetworkConfig, StateViewHook, TransactionDefinition, UseMutationOptions, UseMutationResult, UseMutationReturn, ViewHookOptions, ViewHookResult, ViewMode };
+export type { HyperStackStore, HyperstackConfig, ListParams, ListParamsBase, ListParamsMultiple, ListParamsSingle, ListViewHook, MutationStatus, StateViewHook, TransactionDefinition, UseHyperstackOptions, UseMutationOptions, UseMutationResult, UseMutationReturn, ViewHookOptions, ViewHookResult, ViewMode };

package/dist/index.esm.js

@@ -8267,66 +8267,36 @@ class HyperStack {
 }
 
 const HyperstackContext = createContext(null);
-function resolveNetworkConfig(network, websocketUrl) {
-    if (websocketUrl) {
-        return {
-            name: 'custom',
-            websocketUrl
-        };
-    }
-    if (typeof network === 'object') {
-        return network;
-    }
-    if (network === 'mainnet') {
-        return {
-            name: 'mainnet',
-            websocketUrl: 'wss://mainnet.hyperstack.xyz',
-        };
-    }
-    if (network === 'devnet') {
-        return {
-            name: 'devnet',
-            websocketUrl: 'ws://localhost:8080',
-        };
-    }
-    if (network === 'localnet') {
-        return {
-            name: 'localnet',
-            websocketUrl: 'ws://localhost:8080',
-        };
-    }
-    throw new Error('Must provide either network or websocketUrl');
-}
 function HyperstackProvider({ children, fallback = null, ...config }) {
-    const networkConfig = resolveNetworkConfig(config.network, config.websocketUrl);
     const clientsRef = useRef(new Map());
     const connectingRef = useRef(new Map());
-    const getOrCreateClient = useCallback(async (stack) => {
-        const existing = clientsRef.current.get(stack.name);
+    const getOrCreateClient = useCallback(async (stack, urlOverride) => {
+        const cacheKey = urlOverride ? `${stack.name}:${urlOverride}` : stack.name;
+        const existing = clientsRef.current.get(cacheKey);
         if (existing) {
             return existing.client;
         }
-        const connecting = connectingRef.current.get(stack.name);
+        const connecting = connectingRef.current.get(cacheKey);
         if (connecting) {
             return connecting;
         }
         const connectionPromise = HyperStack.connect(stack, {
-            url: networkConfig.websocketUrl,
+            url: urlOverride,
             autoReconnect: config.autoConnect,
             reconnectIntervals: config.reconnectIntervals,
             maxReconnectAttempts: config.maxReconnectAttempts,
             maxEntriesPerView: config.maxEntriesPerView,
         }).then((client) => {
-            clientsRef.current.set(stack.name, {
+            clientsRef.current.set(cacheKey, {
                 client,
                 disconnect: () => client.disconnect()
             });
-            connectingRef.current.delete(stack.name);
+            connectingRef.current.delete(cacheKey);
             return client;
         });
-        connectingRef.current.set(stack.name, connectionPromise);
+        connectingRef.current.set(cacheKey, connectionPromise);
         return connectionPromise;
-    }, [networkConfig.websocketUrl, config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView]);
+    }, [config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView]);
     const getClient = useCallback((stack) => {
         if (!stack)
             return null;
@@ -8345,13 +8315,7 @@ function HyperstackProvider({ children, fallback = null, ...config }) {
     const value = {
         getOrCreateClient,
         getClient,
-        config: {
-            websocketUrl: networkConfig.websocketUrl,
-            autoConnect: config.autoConnect,
-            reconnectIntervals: config.reconnectIntervals,
-            maxReconnectAttempts: config.maxReconnectAttempts,
-            maxEntriesPerView: config.maxEntriesPerView,
-        }
+        config,
     };
     return (React.createElement(HyperstackContext.Provider, { value: value }, children));
 }
@@ -8699,21 +8663,22 @@ function useInstructionMutation(execute) {
     };
 }
 
-function useHyperstack(stack) {
+function useHyperstack(stack, options) {
     const { getOrCreateClient, getClient } = useHyperstackContext();
+    const urlOverride = options?.url;
     const [client, setClient] = useState(getClient(stack));
     const [isLoading, setIsLoading] = useState(!client);
     const [error, setError] = useState(null);
     useEffect(() => {
         const existingClient = getClient(stack);
-        if (existingClient) {
+        if (existingClient && !urlOverride) {
             setClient(existingClient);
             setIsLoading(false);
             return;
         }
         setIsLoading(true);
         setError(null);
-        getOrCreateClient(stack)
+        getOrCreateClient(stack, urlOverride)
             .then((newClient) => {
             setClient(newClient);
             setIsLoading(false);
@@ -8722,7 +8687,7 @@ function useHyperstack(stack) {
             setError(err instanceof Error ? err : new Error(String(err)));
             setIsLoading(false);
         });
-    }, [stack, getOrCreateClient, getClient]);
+    }, [stack, getOrCreateClient, getClient, urlOverride]);
     const views = useMemo(() => {
         const result = {};
         for (const [viewName, viewGroup] of Object.entries(stack.views)) {