@xyo-network/react-node 2.45.0-rc.16 → 2.45.0-rc.18

package/src/hooks/useModule.tsx

@@ -1,5 +1,46 @@
-import { Module, ModuleWrapper } from '@xyo-network/module'
+import { useAsyncEffect } from '@xylabs/react-shared'
+import { Module } from '@xyo-network/module-model'
+import { useState } from 'react'
 
-import { createUseModuleHook } from './useNode'
+import { useProvidedWrappedNode } from './useProvidedNode'
 
-export const useModule = createUseModuleHook<Module, ModuleWrapper>((module) => ModuleWrapper.tryWrap(module))
+export const useModule = <TModule extends Module = Module>(nameOrAddress?: string): [TModule | undefined, Error | undefined] => {
+  const [node, nodeError] = useProvidedWrappedNode()
+  const [module, setModule] = useState<TModule>()
+  const [error, setError] = useState<Error>()
+  useAsyncEffect(
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    async (mounted) => {
+      try {
+        if (nodeError) {
+          console.log(`Setting NodeError [${nodeError.message}]`)
+          setError(nodeError)
+          setModule(undefined)
+        } else {
+          if (node) {
+            const module: TModule | undefined = nameOrAddress ? await node.resolve<TModule>(nameOrAddress) : (await node.resolve<TModule>()).pop()
+            if (mounted()) {
+              console.log(`Setting Module [${module?.address}]`)
+              setModule(module)
+              setError(undefined)
+            }
+          } else {
+            console.log('Setting All to undefined')
+            setError(undefined)
+            setModule(undefined)
+          }
+        }
+      } catch (ex) {
+        if (mounted()) {
+          const error = ex as Error
+          console.log(`Setting Error [${error.message}]`)
+          setError(error)
+          setModule(undefined)
+        }
+      }
+    },
+    [nameOrAddress, node, nodeError],
+  )
+
+  return [module, error]
+}

package/src/hooks/useModules.ts

@@ -2,10 +2,10 @@ import { useAsyncEffect } from '@xylabs/react-shared'
 import { Module, ModuleFilter } from '@xyo-network/module'
 import { useState } from 'react'
 
-import { useProvidedNode } from './useProvidedNode'
+import { useProvidedWrappedNode } from './useProvidedNode'
 
 export const useModules = <T extends Module = Module>(filter?: ModuleFilter) => {
-  const [node] = useProvidedNode(true)
+  const [node] = useProvidedWrappedNode()
   const [modules, setModules] = useState<T[]>()
 
   useAsyncEffect(

package/src/hooks/useNode.tsx

@@ -1,82 +1,19 @@
-/* eslint-disable react-hooks/rules-of-hooks */
-import { useAsyncEffect } from '@xylabs/react-shared'
-import { Account } from '@xyo-network/account'
-import { Module, ModuleWrapper } from '@xyo-network/module'
-import { NodeModule, NodeWrapper } from '@xyo-network/node'
-import { useState } from 'react'
+import { NodeModule } from '@xyo-network/node'
 
-import { useProvidedNode } from './useProvidedNode'
+import { useModule } from './useModule'
+import { useProvidedWrappedNode } from './useProvidedNode'
 
-export type WrapFunc<TModule extends Module = Module, TWrapper extends ModuleWrapper = ModuleWrapper> = (
-  module?: TModule,
-  account?: Account,
-) => TWrapper | undefined
+export const useNode = (nameOrAddress?: string): [NodeModule | undefined, Error | undefined] => {
+  const [providedNode, providedNodeError] = useProvidedWrappedNode()
+  const [node, nodeError] = useModule<NodeModule>(nameOrAddress)
 
-export type NodeFunc = () => [NodeModule | undefined, Error | undefined]
-
-export const createUseModuleHook = <
-  TModule extends Module = Module,
-  TWrapper extends ModuleWrapper = ModuleWrapper,
-  TWrapFunc extends WrapFunc<TModule, TWrapper> = WrapFunc<TModule, TWrapper>,
->(
-  wrapFunc: TWrapFunc,
-) => {
-  function use(name?: string): [TModule | undefined, Error | undefined]
-  function use(name: string | undefined, wrap: true | Account): [TWrapper | undefined, Error | undefined]
-  function use(wrap: true | Account): [TWrapper | undefined, Error | undefined]
-  function use(address: string): [TModule | undefined, Error | undefined]
-  function use(address: string, wrap: true | Account): [TWrapper | undefined, Error | undefined]
-  function use(
-    nameOrAddressOrWrapOrAccount?: string | boolean | Account,
-    wrap: boolean | Account = false,
-  ): [TWrapper | TModule | undefined, Error | undefined] {
-    const [node, nodeError] = useProvidedNode()
-    const shouldWrap = typeof nameOrAddressOrWrapOrAccount === 'boolean' ? nameOrAddressOrWrapOrAccount : wrap
-    const account = typeof nameOrAddressOrWrapOrAccount === 'object' ? nameOrAddressOrWrapOrAccount : typeof wrap === 'boolean' ? undefined : wrap
-    const nameOrAddress = typeof nameOrAddressOrWrapOrAccount === 'string' ? nameOrAddressOrWrapOrAccount : undefined
-    const [module, setModule] = useState<TModule | TWrapper>()
-    const [error, setError] = useState<Error>()
-    useAsyncEffect(
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      async (mounted) => {
-        try {
-          if (nodeError) {
-            console.log(`Setting NodeError [${nodeError.message}]`)
-            setError(nodeError)
-            setModule(undefined)
-          } else {
-            const wrappedNode = NodeWrapper.tryWrap(node)
-            if (wrappedNode) {
-              const module: TModule | undefined = nameOrAddress
-                ? await wrappedNode?.resolve<TModule>(nameOrAddress)
-                : (await wrappedNode.resolve<TModule>()).pop()
-              const finalModule = shouldWrap ? wrapFunc(module, account) : module
-              if (mounted()) {
-                console.log(`Setting Module [${finalModule?.address}]`)
-                setModule(finalModule)
-                setError(undefined)
-              }
-            } else {
-              console.log('Setting All to undefined')
-              setError(undefined)
-              setModule(undefined)
-            }
-          }
-        } catch (ex) {
-          if (mounted()) {
-            const error = ex as Error
-            console.log(`Setting Error [${error.message}]`)
-            setError(error)
-            setModule(undefined)
-          }
-        }
-      },
-      [wrap, node, nameOrAddress, nodeError, shouldWrap, account],
-    )
-
-    return [module, error]
+  if (nameOrAddress) {
+    if (providedNode) {
+      return [node, nodeError]
+    } else {
+      return [providedNode, providedNodeError]
+    }
+  } else {
+    return [providedNode, providedNodeError]
   }
-  return use
 }
-
-export const useNode = createUseModuleHook<NodeModule, NodeWrapper>((module) => NodeWrapper.tryWrap(module))

package/src/hooks/useProvidedNode.tsx

@@ -1,31 +1,31 @@
-import { Account } from '@xyo-network/account'
+import { AccountInstance } from '@xyo-network/account-model'
 import { NodeModule, NodeWrapper } from '@xyo-network/node'
 import { useContext, useEffect, useState } from 'react'
 
 import { NodeContext } from '../contexts'
 
-function useProvidedNodeFunc(wrap?: undefined): [NodeModule | undefined, Error | undefined]
-function useProvidedNodeFunc(wrap: false): [NodeModule | undefined, Error | undefined]
-function useProvidedNodeFunc(wrap: true | Account): [NodeWrapper | undefined, Error | undefined]
-function useProvidedNodeFunc(wrap: boolean | Account | undefined): [NodeModule | NodeWrapper | undefined, Error | undefined] {
+export const useProvidedNode = (): [NodeModule | undefined] => {
   const { node } = useContext(NodeContext)
+
+  return [node]
+}
+
+export const useProvidedWrappedNode = (account?: AccountInstance): [NodeWrapper | undefined, Error | undefined] => {
+  const [node] = useProvidedNode()
   const [wrappedNode, setWrappedNode] = useState<NodeWrapper>()
   const [error, setError] = useState<Error>()
 
   useEffect(() => {
     try {
       if (node) {
-        const account = typeof wrap === 'boolean' ? undefined : wrap
-        const wrappedNode = wrap ? NodeWrapper.wrap(node, account) : undefined
-        setWrappedNode(wrappedNode)
+        setWrappedNode(NodeWrapper.wrap(node, account))
         setError(undefined)
       }
     } catch (ex) {
+      setWrappedNode(undefined)
       setError(ex as Error)
     }
-  }, [node, wrap])
+  }, [node, account])
 
-  return [wrap ? wrappedNode : wrappedNode?.module, error]
+  return [wrappedNode, error]
 }
-
-export const useProvidedNode = useProvidedNodeFunc

package/src/hooks/useWrappedModule.tsx

@@ -0,0 +1,37 @@
+/* eslint-disable react-hooks/rules-of-hooks */
+import { AccountInstance } from '@xyo-network/account-model'
+import { ModuleWrapper } from '@xyo-network/module'
+import { useEffect, useState } from 'react'
+
+import { useModule } from './useModule'
+
+export interface WrapperStatic<TModuleWrapper extends ModuleWrapper = ModuleWrapper> {
+  wrap: (module?: TModuleWrapper['module'], account?: AccountInstance) => TModuleWrapper
+}
+
+export const WrappedModuleHookFactory = <TModuleWrapper extends ModuleWrapper = ModuleWrapper>(wrapperObject: WrapperStatic<TModuleWrapper>) => {
+  return (nameOrAddress?: string, account?: AccountInstance): [TModuleWrapper | undefined, Error | undefined] => {
+    const [module, moduleError] = useModule<TModuleWrapper['module']>(nameOrAddress)
+
+    const [wrapper, setWrapper] = useState<TModuleWrapper>()
+    const [error, setError] = useState<Error>()
+    useEffect(() => {
+      if (module) {
+        try {
+          const wrapper = wrapperObject.wrap(module, account) as TModuleWrapper
+          setWrapper(wrapper)
+        } catch (ex) {
+          setWrapper(undefined)
+          setError(ex as Error)
+        }
+      } else {
+        setWrapper(undefined)
+        setError(moduleError)
+      }
+    }, [module, account, moduleError])
+
+    return [wrapper, error]
+  }
+}
+
+export const useWrappedModule = WrappedModuleHookFactory(ModuleWrapper)