hyperstack-react 0.3.15 → 0.4.0

package/dist/index.js

@@ -8269,66 +8269,36 @@ class HyperStack {
 }
 
 const HyperstackContext = React.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 = React.useRef(new Map());
     const connectingRef = React.useRef(new Map());
-    const getOrCreateClient = React.useCallback(async (stack) => {
-        const existing = clientsRef.current.get(stack.name);
+    const getOrCreateClient = React.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 = React.useCallback((stack) => {
         if (!stack)
             return null;
@@ -8347,13 +8317,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));
 }
@@ -8701,21 +8665,22 @@ function useInstructionMutation(execute) {
     };
 }
 
-function useHyperstack(stack) {
+function useHyperstack(stack, options) {
     const { getOrCreateClient, getClient } = useHyperstackContext();
+    const urlOverride = options?.url;
     const [client, setClient] = React.useState(getClient(stack));
     const [isLoading, setIsLoading] = React.useState(!client);
     const [error, setError] = React.useState(null);
     React.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);
@@ -8724,7 +8689,7 @@ function useHyperstack(stack) {
             setError(err instanceof Error ? err : new Error(String(err)));
             setIsLoading(false);
         });
-    }, [stack, getOrCreateClient, getClient]);
+    }, [stack, getOrCreateClient, getClient, urlOverride]);
     const views = React.useMemo(() => {
         const result = {};
         for (const [viewName, viewGroup] of Object.entries(stack.views)) {