@xyo-network/os-react-runtime 7.2.1 → 7.3.1

package/src/modules/Dapp/modules/Window/hooks/menu/useBuildDappMenuResource.ts

@@ -1,39 +0,0 @@
-import { usePromise } from '@xylabs/react-promise'
-import type { XyOsContext } from '@xyo-network/os-model'
-import type { DappMenuResourceViews } from '@xyo-network/os-runtime'
-import { DappMenuResource } from '@xyo-network/os-runtime'
-
-import {
-  ResourceHooks, useCleanUpResource, useSyncExternalPayloadStore,
-} from '../../../../../resource/index.ts'
-
-export const useBuildDappMenuResource = (xyOsContext?: XyOsContext | null) => {
-  const resource = usePromise(async () => {
-    if (xyOsContext) {
-      const resource = new DappMenuResource(xyOsContext)
-      await resource.start()
-      return resource
-    }
-  }, [xyOsContext])
-
-  useCleanUpResource(resource[0])
-
-  return resource
-}
-
-export const useMenuResourceViews = (resource?: DappMenuResource) => {
-  const menuItemSelections = useSyncExternalPayloadStore('menuItemSelections', resource)
-  const menuConfigs = useSyncExternalPayloadStore('menuConfigs', resource)
-  const menuItems = useSyncExternalPayloadStore('menuItems', resource)
-  const menuItemsVisible = useSyncExternalPayloadStore('menuItemsVisible', resource)
-
-  return {
-    menuConfigs,
-    menuItemSelections,
-    menuItems,
-    menuItemsVisible,
-    resource,
-  }
-}
-
-export const DappMenuResourceHooks = new ResourceHooks<DappMenuResourceViews, DappMenuResource>(useBuildDappMenuResource, useMenuResourceViews)

package/src/modules/Dapp/modules/Window/hooks/menu/useDappMenu.ts

@@ -1,71 +0,0 @@
-import type { DappName, XyOsContext } from '@xyo-network/os-model'
-import {
-  useEffect, useRef, useState,
-} from 'react'
-import { useNavigate, useParams } from 'react-router-dom'
-
-import type { DappMenuProperties } from '../../types/index.ts'
-import { DappPathHelpers } from '../lib/index.ts'
-import { useDappMenuDependencies } from './useDappMenuDependencies.ts'
-
-/**
- * Use the passed in dapp Node to resolve menu related modules and return the menu related items
- */
-
-export const useDappMenu = (context?: XyOsContext | null, dappName?: DappName): DappMenuProperties => {
-  const [error, setError] = useState<Error>()
-  const params = useParams()
-  const navigate = useNavigate()
-  const {
-    defaultPath, menuConfigs, menuItemsVisible, menuSelection, resourceError,
-  } = useDappMenuDependencies(context)
-  const activePath = menuSelection ?? defaultPath
-
-  // Keep track of the current path
-  // If links are clicked within a dapp, the path will change so we need to keep track of it
-  const currentPathRef = useRef<string>(undefined)
-
-  // Initialize the current path
-  useEffect(() => {
-    if (params && currentPathRef.current === undefined) {
-      currentPathRef.current = params.path ?? ''
-    }
-  }, [])
-
-  // Reset the current path when the dappNode goes away (e.g. when the dapp is closed)
-  useEffect(() => {
-    if (context === null) {
-      currentPathRef.current = undefined
-    }
-  }, [context])
-
-  // Update the current path when new menuSelections are made without invoking onPathChange (i.e. clicking link within a dapp)
-  useEffect(() => {
-    if (menuSelection) {
-      currentPathRef.current = menuSelection
-    }
-  }, [menuSelection])
-
-  useEffect(() => {
-    if (resourceError) setError(resourceError)
-  }, [resourceError])
-
-  // Callback to invoke when the path changes.  Main purpose is the keep the url in sync with the menu selection
-  const onPathChange = (path: string) => {
-    const pathIsInUnchanged = DappPathHelpers.detectDuplicateSelections(currentPathRef.current, path, defaultPath)
-    if (pathIsInUnchanged) return
-
-    // navigate to the new path so listeners on the route can react
-    const destinationPath = DappPathHelpers.deriveDestinationPath(path, defaultPath, dappName)
-    void navigate(destinationPath)
-    currentPathRef.current = path
-  }
-
-  return {
-    activePath,
-    error,
-    menuConfig: menuConfigs?.[0],
-    menuItems: menuItemsVisible,
-    onPathChange,
-  }
-}

package/src/modules/Dapp/modules/Window/hooks/menu/useDappMenuCaller.ts

@@ -1,22 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { XyOsContext } from '@xyo-network/os-model'
-import { DappMenuCaller } from '@xyo-network/os-runtime'
-import { useMemo } from 'react'
-
-import { useXyOsUiContext } from '../../../../../XyOsUi/index.ts'
-
-type DappMenuCallerHookOptions = {
-  ignoreProvidedNode?: boolean
-}
-
-export const useDappMenuCaller = (context?: XyOsContext | null, { ignoreProvidedNode }: DappMenuCallerHookOptions = {}) => {
-  const xyOs = useXyOsUiContext()
-
-  return useMemo(() => {
-    const resolvedProvidedNode = ignoreProvidedNode ? null : xyOs
-    if (context || resolvedProvidedNode) {
-      const finalContext = assertEx(context ?? xyOs, () => 'no node was found in context or passed as argument')
-      return new DappMenuCaller(finalContext)
-    }
-  }, [ignoreProvidedNode, context, xyOs])
-}

package/src/modules/Dapp/modules/Window/hooks/menu/useDappMenuDependencies.ts

@@ -1,16 +0,0 @@
-import type { XyOsContext } from '@xyo-network/os-model'
-import { useMemo } from 'react'
-
-import { DappMenuResourceHooks } from './useBuildDappMenuResource.ts'
-
-export const useDappMenuDependencies = (context?: XyOsContext | null) => {
-  const {
-    menuConfigs, menuItemSelections, menuItemsVisible, resourceError,
-  } = DappMenuResourceHooks.resourceViewsFromContext(context)
-  const defaultPath = useMemo(() => menuConfigs?.[0]?.defaultPath, [menuConfigs])
-  const menuSelection = menuItemSelections?.[0]?.path
-
-  return {
-    defaultPath, menuConfigs, menuItemsVisible, menuSelection, resourceError,
-  }
-}

package/src/modules/Dapp/modules/Window/hooks/route/helpers/RoutingNodes.md

@@ -1,7 +0,0 @@
-# Manage the dapp based off the route params and intent type
- 
-This hook centralizes the logic for managing the dapp based off the route.  It reacts to changes in the route params and performs the following:
- 
- 1. Launch or close the dapp based off changes to the `dappName` route params
- 1. Update the menu archivist based off changes in the the `path` route param
- 1. Update the dapp archivist with injectable params based off changes in the query params

package/src/modules/Dapp/modules/Window/hooks/route/helpers/index.ts

@@ -1,4 +0,0 @@
-export * from './useManageDappInjectableParamsFromRoute.tsx'
-export * from './useManageDappIntentRequest.tsx'
-export * from './useManageDappPathFromRoute.tsx'
-export * from './useManageDappStateFromRoute.tsx'

package/src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappInjectableParamsFromRoute.tsx

@@ -1,55 +0,0 @@
-import { usePromise } from '@xylabs/react-promise'
-import { assertEx, findAs } from '@xylabs/sdk-js'
-import type { ArchivistInstance, ArchivistModuleEventData } from '@xyo-network/archivist-model'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import { asOptionalDappInjectableParams, type XyOsContext } from '@xyo-network/os-model'
-import { DappCaller } from '@xyo-network/os-runtime'
-import { useNavigate, useSearchParams } from 'react-router-dom'
-
-/** Update the dapp archivist with injectable params based off changes in the query params */
-export const useManageDappInjectableParamsFromRoute = (context?: XyOsContext | null) => {
-  const [queryParams] = useSearchParams()
-  const navigate = useNavigate()
-
-  const [, callerError] = usePromise(async () => {
-    if (context && queryParams) {
-      const dappCaller = new DappCaller(context)
-      const pathname = globalThis.location.pathname
-      await dappCaller.setDappInjectableRouteParams(queryParams, pathname)
-    }
-  }, [context, queryParams])
-
-  // Update the route if the dapp inserts a new injectable params payload and the path is different
-  const [, listenerError] = usePromise(async () => {
-    let archivist: ArchivistInstance | undefined
-    const listener = ({ payloads }: ArchivistModuleEventData['inserted']) => {
-      const injectableParams = findAs(payloads, asOptionalDappInjectableParams)
-      if (injectableParams && context) {
-        const pathname = globalThis.location.pathname
-        if (pathname !== injectableParams.path) {
-          void navigate(injectableParams.path)
-        }
-      }
-    }
-
-    try {
-      if (context) {
-        const mod = assertEx(await context?.root.resolve('DappArchivist'), () => 'DappArchivist not found')
-        archivist = asArchivistInstance(mod, () => 'DappArchivist not is not an Archivist', { required: true })
-
-        archivist.on('inserted', listener)
-      }
-    } catch (e) {
-      console.error(e)
-      throw e
-    }
-
-    return () => {
-      archivist?.off('inserted', listener)
-    }
-    // disabling because navigate reference changes unnecessarily for this use case
-    // see - https://stackoverflow.com/a/75329664/2803259
-  }, [context])
-
-  return [callerError, listenerError]
-}

package/src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappIntentRequest.tsx

@@ -1,68 +0,0 @@
-import { useAtomicPromise, usePromise } from '@xylabs/react-promise'
-import { findAs } from '@xylabs/sdk-js'
-import type { ArchivistInstance, ArchivistModuleEventData } from '@xyo-network/archivist-model'
-import type {
-  DappId, DappIntent, XyOsContext,
-} from '@xyo-network/os-model'
-import { asOptionalDappIntent, DappIntentTypes } from '@xyo-network/os-model'
-import { DappIntentCaller } from '@xyo-network/os-runtime'
-import { useEffect, useState } from 'react'
-
-import { useSendDappIntent } from '../../../../../../intent/index.ts'
-import { useDappCaller } from '../../../../../useDappCaller.ts'
-
-// React to new intents inserted into the dapp archivist
-export const useManageDappIntentRequest = (context?: XyOsContext | null, dappId?: DappId) => {
-  const dappCaller = useDappCaller(context)
-  const sendIntent = useSendDappIntent()
-  const [intentPayload, setIntentPayload] = useState<DappIntent>()
-  const [handleIntentError, setHandleIntentError] = useState<Error>()
-  const [dappArchivist, setDappArchivist] = useState<ArchivistInstance>()
-
-  usePromise(async () => {
-    if (context && dappCaller) {
-      const archivist = await dappCaller.getDappArchivist()
-      if (archivist) setDappArchivist(archivist)
-    }
-  }, [context, dappCaller])
-
-  useAtomicPromise(
-    'manageDappIntent',
-    async () => {
-      if (context && intentPayload?.targetDappId && dappId && sendIntent) {
-        try {
-          const minimizeIntent = DappIntentCaller.buildIntent(DappIntentCaller.OsDappName, DappIntentTypes.Minimize, dappId)
-          await sendIntent(minimizeIntent)
-          await sendIntent(intentPayload)
-        } catch (e) {
-          console.error(e)
-          setHandleIntentError(e as Error)
-        }
-        setIntentPayload(undefined)
-      }
-    },
-    [context, dappId, intentPayload, sendIntent],
-  )
-
-  useEffect(() => {
-    // catch the intent sent by the dapp and mirror it inside the os intent archivist
-    const listener = ({ payloads }: ArchivistModuleEventData['inserted']) => {
-      // only dapps with an active context should react to the new intents
-      if (context) {
-        const intentPayload = findAs(payloads, asOptionalDappIntent)
-        if (intentPayload) {
-          setIntentPayload(intentPayload)
-        }
-      }
-    }
-    dappArchivist?.off('inserted', listener)
-    if (dappArchivist && context) {
-      dappArchivist.on('inserted', listener)
-    }
-    return () => {
-      dappArchivist?.off('inserted', listener)
-    }
-  }, [context, dappArchivist])
-
-  return handleIntentError
-}

package/src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappPathFromRoute.tsx

@@ -1,75 +0,0 @@
-import { usePromise } from '@xylabs/react-promise'
-import type { XyOsContext } from '@xyo-network/os-model'
-import {
-  useCallback, useEffect, useRef,
-} from 'react'
-import { useNavigate, useParams } from 'react-router-dom'
-
-import { DappPathHelpers } from '../../lib/index.ts'
-import { useDappMenuCaller, useDappMenuDependencies } from '../../menu/index.ts'
-
-/**
- * Update the menu archivist based off changes in the the `path` route param
- *
- * Test Cases:
- *
- * 1. Clicking sidebar menu
- * 2. Clicking sidebar menu twice
- * 3. Navigating directly to a path on dApp load
- * 4. Navigating directly to a path from within the dApp by clicking a link
- * 5. Navigating directly to a path from within the dApp by clicking back
- */
-
-/** React to changes in the `path` route param */
-export const useManageDappPathFromRoute = (context?: XyOsContext | null, dappName?: string) => {
-  const params = useParams()
-  const { path: pathParam } = params
-  const dappMenuCaller = useDappMenuCaller(context, { ignoreProvidedNode: true })
-  const { menuSelection, defaultPath } = useDappMenuDependencies(context)
-  const navigate = useNavigate()
-
-  // keep track of the current path and avoid making pathParam a dependency
-  const currentPathRef = useRef<string>(undefined)
-
-  // Update the menu archivist based off the params
-  const updateMenuArchivist = useCallback(
-    async (pathParam?: string) => {
-      currentPathRef.current = pathParam
-      // ensure the dappNode is active before updating the menu
-      if (context && dappMenuCaller) {
-        const currentPath = await dappMenuCaller?.currentNavSelection()
-        const updatedPath = DappPathHelpers.derivePathForNavSelection(pathParam, currentPath?.[0]?.path, defaultPath)
-
-        if (updatedPath) {
-          await dappMenuCaller.makeNavItemSelection(updatedPath)
-        }
-      }
-    },
-    [dappMenuCaller, context, defaultPath],
-  )
-
-  // Sync the route when the menu archivist updates (no pathParam dependency)
-  useEffect(() => {
-    if (context && menuSelection) {
-      const pathIsInUnchanged = DappPathHelpers.detectDuplicateSelections(currentPathRef.current ?? '', menuSelection, defaultPath)
-      if (pathIsInUnchanged) return
-
-      // navigate to the new path so listeners on the route can react
-      const destinationPath = DappPathHelpers.deriveDestinationPath(menuSelection, defaultPath, dappName)
-      void navigate(destinationPath)
-      currentPathRef.current = menuSelection === defaultPath ? undefined : menuSelection
-    }
-    // disabling because navigate reference changes unnecessarily for this use case
-    // see - https://stackoverflow.com/a/75329664/2803259
-  }, [dappName, context, defaultPath, menuSelection])
-
-  // Sync the menu archivist when the route changes (no menuSelection dependency)
-  const [, updateErrors] = usePromise(async () => {
-    if (context && pathParam !== currentPathRef.current) {
-      await updateMenuArchivist(pathParam)
-      currentPathRef.current = pathParam
-    }
-  }, [context, pathParam, updateMenuArchivist])
-
-  return updateErrors
-}

package/src/modules/Dapp/modules/Window/hooks/route/helpers/useManageDappStateFromRoute.tsx

@@ -1,51 +0,0 @@
-import { usePromise } from '@xylabs/react-promise'
-import type { DappIntent } from '@xyo-network/os-model'
-import { DappIntentTypes } from '@xyo-network/os-model'
-import { DappIntentCaller, NameTransforms } from '@xyo-network/os-runtime'
-import { useRef } from 'react'
-import { useParams } from 'react-router-dom'
-
-import { useDappIntentCaller, useSendDappIntent } from '../../../../../../intent/index.ts'
-
-/** Launch or close the dapp based off changes to the `dappName` route param */
-export const useManageDappStateFromRoute = (intentPayload?: DappIntent) => {
-  const params = useParams()
-  const { dappName: dappNameParam } = params
-  const sendIntent = useSendDappIntent()
-  const intentCaller = useDappIntentCaller()
-
-  // refs to track the dappName param and the last intent sent
-  const dappNameParamRef = useRef<string>(undefined)
-  const intentRef = useRef<DappIntent>(undefined)
-
-  // auto-close the dapp if it was launched and the route param goes undefined (i.e. back button clicked)
-  usePromise(async () => {
-    const launched = intentPayload?.intent === DappIntentTypes.Launch
-    const dappNameParamRemoved = !!dappNameParamRef.current && dappNameParam === undefined
-    // The last intent was Launch and the dappName param was removed
-    if (launched && dappNameParamRemoved && sendIntent) {
-      const closeIntent = DappIntentCaller.buildIntent(DappIntentCaller.OsDappName, DappIntentTypes.Close)
-      await sendIntent(closeIntent)
-    }
-
-    // sync back the dappNameParamRef for future checks
-    dappNameParamRef.current = dappNameParam
-  }, [dappNameParam, intentPayload, sendIntent])
-
-  // auto-launch the dapp if the route param matches the dapp name
-  usePromise(async () => {
-    if (dappNameParam && sendIntent && intentCaller) {
-      const dappNameParamDeSlugged = new NameTransforms(dappNameParam).deSlug()
-      // no intents have been sent yet and the dappName param is set so we need to auto launch the dapp
-      const autoLaunchNeeded = intentRef.current === undefined && dappNameParam
-
-      if (autoLaunchNeeded) {
-        const launchIntent = DappIntentCaller.buildIntent(DappIntentCaller.OsDappName, DappIntentTypes.Launch, dappNameParamDeSlugged)
-        await sendIntent(launchIntent)
-        // sync back the intentRef to ensure the auto launch only happens once
-        intentRef.current = launchIntent
-        return
-      }
-    }
-  }, [dappNameParam, sendIntent, intentCaller, intentPayload?.intent])
-}

package/src/modules/Dapp/modules/Window/hooks/route/index.ts

@@ -1 +0,0 @@
-export * from './helpers/index.ts'

package/src/modules/Dapp/modules/Window/hooks/useDebugClick.ts

@@ -1,61 +0,0 @@
-import {
-  useCallback, useEffect, useRef, useState,
-} from 'react'
-import { useNavigate, useSearchParams } from 'react-router-dom'
-
-export const useDebugClick = () => {
-  const [params, setParams] = useSearchParams()
-  const [debugOpen, setDebugOpen] = useState(false)
-  const openFromClick = useRef(false)
-  const closeFromClick = useRef(false)
-  const initialized = useRef(false)
-  const navigate = useNavigate()
-
-  const openDebug = useCallback(() => {
-    openFromClick.current = true
-    closeFromClick.current = false
-    setParams((params) => {
-      params.set('debug', 'true')
-      return new URLSearchParams(params)
-    })
-    setDebugOpen(true)
-  }, [setParams])
-
-  const closeDebug = useCallback(() => {
-    openFromClick.current = false
-    closeFromClick.current = true
-    initialized.current = false
-    void navigate(-1)
-    setDebugOpen(false)
-  }, [navigate])
-
-  // Auto Open Logic (on forward click) - not working
-  // useEffect(() => {
-  //   // Was closed, open wasn't clicked, and debug is in the query params
-  //   const openedFromRoute = !openFromClick.current && !closeFromClick.current && params.has('debug')
-  //   if (openedFromRoute) {
-  //     // openDebug()
-  //   }
-  // }, [openDebug, params])
-
-  // Auto Close Logic (on back click)
-  useEffect(() => {
-    // Was opened, close wasn't clicked, and debug is in the query params
-    const initialOpen = openFromClick.current && !closeFromClick.current && params.has('debug')
-    // Was opened, close wasn't clicked, and debug is missing in the query params
-    const backButtonClicked = openFromClick.current && !closeFromClick.current && !params.has('debug')
-    if (initialOpen) {
-      // using the ref to avoid setting debugOpen to false on the first render
-      if (initialized.current === false) {
-        initialized.current = true
-      }
-    } else if (backButtonClicked) {
-      initialized.current = false
-      closeDebug()
-    }
-  }, [params, closeDebug])
-
-  return {
-    closeDebug, debugOpen, openDebug,
-  }
-}

package/src/modules/Dapp/modules/Window/hooks/useDecomposeDapp.tsx

@@ -1,21 +0,0 @@
-import type { RegisteredReactDapp } from '@xyo-network/os-react-model'
-import { useMemo } from 'react'
-
-import { NodeManifest } from '../NodeManifest.tsx'
-
-export const useDecomposeDapp = (dapp?: RegisteredReactDapp) => {
-  const DappComponent = useMemo(() => dapp?.params.modes?.window?.component ?? NodeManifest, []) as React.FC<{
-    name?: string
-  }>
-  const name = dapp?.config.name
-  const version = dapp?.config.version
-  const scrollable = dapp?.params.modes?.window?.scrollable ?? true
-
-  return {
-    DappComponent,
-    dapp,
-    name,
-    scrollable,
-    version,
-  }
-}

package/src/modules/Dapp/modules/Window/hooks/useExposedNode.ts

@@ -1,6 +0,0 @@
-import { useXyOsUiContext } from '../../../../XyOsUi/index.ts'
-
-export const useExposedNode = () => {
-  const xyOS = useXyOsUiContext()
-  return xyOS?.exposedNode
-}

package/src/modules/Dapp/modules/Window/hooks/useSkipLoadingScreen.tsx

@@ -1,17 +0,0 @@
-import { useMemo } from 'react'
-import { useSearchParams } from 'react-router-dom'
-
-import { detectCustomer } from './lib/index.ts'
-
-const PARAMS_TO_TARGET = ['username', 'utm_source'] as const
-
-export const useSkipLoadingScreen = () => {
-  const [params] = useSearchParams()
-  const customer = detectCustomer()
-  return useMemo(() => {
-    const hasTargetParams = PARAMS_TO_TARGET.some(param => params.has(param))
-    const isCustomer = !!customer
-
-    return hasTargetParams || isCustomer
-  }, [customer, params])
-}

package/src/modules/Dapp/modules/Window/hooks/useSyncOsRegisteredAccessInterfaces.tsx

@@ -1,36 +0,0 @@
-import { usePromise } from '@xylabs/react-promise'
-import type { ArchivistModuleEventData } from '@xyo-network/archivist-model'
-import type { XyOsContext } from '@xyo-network/os-model'
-import { useWeakArchivistFromNode } from '@xyo-network/react-archivist'
-
-import { useDappCaller } from '../../../useDappCaller.ts'
-
-/**
- * Syncs the registered access interfaces from the Os with the DappArchivist
- * @param dappNode The dapp node
- */
-export const useSyncOsRegisteredAccessInterfaces = (context?: XyOsContext | null) => {
-  const [registeredInterfacesArchivist] = useWeakArchivistFromNode('RegisteredDappInterfacesArchivist')
-  const dappCaller = useDappCaller(context)
-
-  usePromise(async () => {
-    const listener = async ({ payloads }: ArchivistModuleEventData['inserted']) => {
-      if (context && dappCaller) {
-        await dappCaller.addPayloadsToDappArchivist(payloads)
-      }
-    }
-    if (context && dappCaller) {
-      // Add all registered interfaces to the dapp archivist
-      const registeredInterfaces = await registeredInterfacesArchivist?.deref()?.all()
-      if (registeredInterfaces) {
-        await dappCaller.addPayloadsToDappArchivist(registeredInterfaces)
-      }
-      // Listen for new interfaces and add them to the dapp archivist
-      registeredInterfacesArchivist?.deref()?.on('inserted', listener)
-    }
-
-    return () => {
-      registeredInterfacesArchivist?.deref()?.off('inserted', listener)
-    }
-  }, [dappCaller, context, registeredInterfacesArchivist])
-}

package/src/modules/Dapp/modules/Window/index.ts

@@ -1,7 +0,0 @@
-export * from './AppBar.tsx'
-export * from './Chrome.tsx'
-export * from './components/index.ts'
-export * from './DappWindow.tsx'
-export * from './hooks/index.ts'
-export * from './Rendered.tsx'
-export * from './types/index.ts'

package/src/modules/Dapp/modules/Window/types/DappMenuProperties.ts

@@ -1,9 +0,0 @@
-import type { DappNavItem, DappNavMenuConfig } from '@xyo-network/os-model'
-
-export interface DappMenuProperties {
-  activePath?: string
-  error?: Error
-  menuConfig?: DappNavMenuConfig
-  menuItems?: DappNavItem[]
-  onPathChange: (path: string) => void
-}

package/src/modules/Dapp/modules/Window/types/DappWindowProps.ts

@@ -1,14 +0,0 @@
-import type { RegisteredReactDapp, XyOsUiContext } from '@xyo-network/os-react-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-import type { DappState } from '../../../lib/index.ts'
-import type { DappMenuProperties } from './DappMenuProperties.ts'
-
-export interface DappWindowProps {
-  context?: XyOsUiContext | null
-  dapp?: RegisteredReactDapp
-  dappMenuProperties?: DappMenuProperties
-  dappState?: DappState
-  dappWallet?: WalletInstance
-  errors?: (Error | undefined)[]
-}

package/src/modules/Dapp/modules/Window/types/index.ts

@@ -1,2 +0,0 @@
-export * from './DappMenuProperties.ts'
-export * from './DappWindowProps.ts'