@lvce-editor/server 0.0.41 → 0.1.0

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.ipc.js

@@ -1,7 +1,10 @@
 import * as TitleBarMenuBar from './TitleBarMenuBar.js'
+import * as MenuIpc from '../Menu/Menu.ipc.js'
 
 // prettier-ignore
 export const Commands = {
+  ...MenuIpc.Commands,
+
   'TitleBarMenuBar.toggleIndex': TitleBarMenuBar.toggleIndex,
   'TitleBarMenuBar.hydrate': TitleBarMenuBar.hydrate,
   'TitleBarMenuBar.focus': TitleBarMenuBar.focus,
@@ -19,4 +22,5 @@ export const Commands = {
   'TitleBarMenuBar.handleKeyEnter': TitleBarMenuBar.handleKeyEnter,
   'TitleBarMenuBar.handleKeyEscape': TitleBarMenuBar.handleKeyEscape,
   'TitleBarMenuBar.handleKeyArrowLeft': TitleBarMenuBar.handleKeyArrowLeft,
+
 }

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/Viewlet/Viewlet.js

@@ -195,7 +195,7 @@ export const setState = async (id, newState) => {
   const instance = ViewletStates.getInstance(id)
   if (instance && instance.factory && instance.factory.hasFunctionalRender) {
     const oldState = instance.state
-    const commands = instance.factory.render(oldState, newState)
+    const commands = ViewletManager.render(instance.factory, oldState, newState)
     instance.state = newState
     await RendererProcess.invoke(
       /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/Viewlet/ViewletExtensionsList.js

@@ -101,10 +101,10 @@ const getIcon = (extension) => {
   if (!extension || !extension.path || !extension.icon) {
     return ''
   }
-  if (Platform.getPlatform() === 'remote') {
+  if (Platform.platform === 'remote') {
     return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
   }
-  if (Platform.getPlatform() === 'electron') {
+  if (Platform.platform === 'electron') {
     return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
   }
   return ''

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/ViewletActivityBar/ViewletActivityBar.js

@@ -3,6 +3,7 @@ import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
 import * as Layout from '../Layout/Layout.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as ActivityBarItemFlags from '../ActivityBarItemFlags/ActvityBarItemFlags.js'
 
 const ACTIVITY_BAR_ITEM_HEIGHT = 48
 
@@ -42,7 +43,7 @@ const getVisibleActivityBarItems = (state) => {
     id: 'Additional Views',
     icon: 'icons/ellipsis.svg',
     enabled: true,
-    flags: /* Button */ 2,
+    flags: ActivityBarItemFlags.Button,
     keyShortCuts: '',
   }
   const visibleItems = [
@@ -81,35 +82,35 @@ const getActivityBarItems = () => {
       id: 'Explorer',
       icon: 'icons/files.svg',
       enabled: true,
-      flags: /* Tab */ 1,
+      flags: ActivityBarItemFlags.Tab,
       keyShortcuts: 'Control+Shift+E',
     },
     {
       id: 'Search',
       icon: 'icons/search.svg',
       enabled: true,
-      flags: /* Tab */ 1,
+      flags: ActivityBarItemFlags.Tab,
       keyShortcuts: 'Control+Shift+F',
     },
     {
       id: 'Source Control',
       icon: 'icons/source-control.svg',
       enabled: true,
-      flags: /* Tab */ 1,
+      flags: ActivityBarItemFlags.Tab,
       keyShortcuts: 'Control+Shift+G',
     },
     {
       id: 'Run and Debug',
       icon: 'icons/debug-alt-2.svg',
       enabled: true,
-      flags: /* Tab */ 1,
+      flags: ActivityBarItemFlags.Tab,
       keyShortcuts: 'Control+Shift+D',
     },
     {
       id: 'Extensions',
       icon: 'icons/extensions.svg',
       enabled: true,
-      flags: /* Tab */ 1,
+      flags: ActivityBarItemFlags.Tab,
       keyShortcuts: 'Control+Shift+X',
     },
     // Bottom
@@ -117,7 +118,7 @@ const getActivityBarItems = () => {
       id: 'Settings',
       icon: 'icons/settings-gear.svg',
       enabled: true,
-      flags: /* Button */ 2,
+      flags: ActivityBarItemFlags.Button,
       keyShortcuts: '',
     },
   ]
@@ -171,39 +172,50 @@ const findIndex = (activityBarItems, id) => {
   return -1
 }
 
+const handleClickSettings = async (state, x, y, viewletId) => {
+  console.log('is settings')
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'settings'
+  )
+  return state
+}
+
+const handleClickAdditionalViews = async (state, x, y, viewletId) => {
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'activity-bar-additional-views'
+  )
+  return state
+}
+
+const handleClickOther = async (state, x, y, viewletId) => {
+  if (Layout.isSideBarVisible()) {
+    await Command.execute(
+      /* SideBar.showOrHideViewlet */ 'SideBar.showOrHideViewlet',
+      /* id */ viewletId
+    )
+  } else {
+    // TODO should show side bar with viewletId
+    await Layout.showSideBar()
+  }
+  return state
+}
+
 export const handleClick = async (state, index, x, y) => {
   const viewletId = state.activityBarItems[index].id
   switch (viewletId) {
     case 'Settings':
-      console.log('is settings')
-      await Command.execute(
-        /* ContextMenu.show */ 'ContextMenu.show',
-        /* x */ x,
-        /* y */ y,
-        /* id */ 'settings'
-      )
-      break
+      return handleClickSettings(state, x, y, viewletId)
     case 'Additional Views':
-      await Command.execute(
-        /* ContextMenu.show */ 'ContextMenu.show',
-        /* x */ x,
-        /* y */ y,
-        /* id */ 'activity-bar-additional-views'
-      )
-      break
+      return handleClickAdditionalViews(state, x, y, viewletId)
     default:
-      if (Layout.isSideBarVisible()) {
-        await Command.execute(
-          /* SideBar.showOrHideViewlet */ 'SideBar.showOrHideViewlet',
-          /* id */ viewletId
-        )
-      } else {
-        // TODO should show side bar with viewletId
-        await Layout.showSideBar()
-      }
-      break
+      return handleClickOther(state, x, y, viewletId)
   }
-  return state
 }
 
 export const handleSideBarViewletChange = async (state, id, ...args) => {

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/ViewletEditorText/ViewletEditorText.js

@@ -166,6 +166,11 @@ export const resize = (state, dimensions) => {
 
 export const hasFunctionalRender = true
 
-export const render = (oldState, newState) => {
-  return Editor.render(oldState, newState)
+export const render = Editor.render
+
+export const focus = (state) => {
+  return {
+    ...state,
+    focused: true,
+  }
 }

package/static/1a57391/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorer.ipc.js

@@ -0,0 +1,46 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletExplorer from './ViewletExplorer.js'
+
+// prettier-ignore
+export const Commands = {
+  'Explorer.acceptNewFile':             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.acceptNewFile),
+  'Explorer.acceptRename':              Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.acceptRename),
+  'Explorer.cancelNewFile':             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.cancelNewFile),
+  'Explorer.cancelRename':              Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.cancelRename),
+  'Explorer.collapseAll':               Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.collapseAll),
+  'Explorer.copyPath':                  Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.copyPath),
+  'Explorer.copyRelativePath':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.copyRelativePath),
+  'Explorer.expandAll':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.expandAll),
+  'Explorer.expandRecursively':         Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.expandRecursively),
+  'Explorer.focus':                     Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focus),
+  'Explorer.focusFirst':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusFirst),
+  'Explorer.focusIndex':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusIndex),
+  'Explorer.focusLast':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusLast),
+  'Explorer.focusNext':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusNext),
+  'Explorer.focusNone':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusNone),
+  'Explorer.focusPrevious':             Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.focusPrevious),
+  'Explorer.getFocusedDirent':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.getFocusedDirent),
+  'Explorer.handleArrowLeft':           Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleArrowLeft),
+  'Explorer.handleArrowRight':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleArrowRight),
+  'Explorer.handleBlur':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleBlur),
+  'Explorer.handleClick':               Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClick),
+  'Explorer.handleClickCurrent':        Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleClickCurrent),
+  'Explorer.handleContextMenuKeyboard': Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleContextMenuKeyboard),
+  'Explorer.handleContextMenuMouse':    Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleContextMenuMouse),
+  'Explorer.handleCopy':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleCopy),
+  'Explorer.handleMouseEnter':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleMouseEnter),
+  'Explorer.handleMouseLeave':          Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleMouseLeave),
+  'Explorer.handlePaste':               Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handlePaste),
+  'Explorer.handleWheel':               Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.handleWheel),
+  'Explorer.newFile':                   Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.newFile),
+  'Explorer.newFolder':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.newFolder),
+  'Explorer.openContainingFolder':      Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.openContainingFolder),
+  'Explorer.removeDirent':              Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.removeDirent),
+  'Explorer.renameDirent':              Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.renameDirent),
+  'Explorer.revealItem':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.revealItem),
+  'Explorer.scrollDown':                Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.scrollDown),
+  'Explorer.scrollUp':                  Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.scrollUp),
+  'Explorer.setDeltaY':                 Viewlet.wrapViewletCommand('Explorer', ViewletExplorer.setDeltaY),
+}
+
+export * from './ViewletExplorer.js'

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/ViewletExplorer/ViewletExplorer.js

@@ -1,5 +1,7 @@
 import * as Assert from '../Assert/Assert.js'
 import * as Command from '../Command/Command.js'
+import * as Compare from '../Compare/Compare.js'
+import * as DirentType from '../DirentType/DirentType.js'
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as IconTheme from '../IconTheme/IconTheme.js'
@@ -49,7 +51,7 @@ const compareDirentType = (direntA, direntB) => {
 }
 
 const compareDirentName = (direntA, direntB) => {
-  return direntA.name.localeCompare(direntB.name)
+  return Compare.compareString(direntA.name, direntB.name)
 }
 
 const compareDirent = (direntA, direntB) => {
@@ -240,10 +242,22 @@ export const handleWheel = (state, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY)
 }
 
-export const handleContextMenu = async (state, x, y, index, button) => {
-  if (button === -1) {
-    index = state.focusedIndex
+export const handleContextMenuKeyboard = async (state, index) => {
+  const x = state.left
+  const y = state.top + (index - state.minLineY + 1) * state.itemHeight
+  await Command.execute(
+    /* ContextMenu.show */ 'ContextMenu.show',
+    /* x */ x,
+    /* y */ y,
+    /* id */ 'explorer'
+  )
+  return {
+    ...state,
+    focusedIndex: index,
   }
+}
+
+export const handleContextMenuMouse = async (state, x, y, index) => {
   await Command.execute(
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
@@ -498,7 +512,11 @@ export const copyRelativePath = async (state) => {
   const dirent = getFocusedDirent(state)
   const relativePath = dirent.path.slice(1)
   // TODO handle error
-  await Command.execute(/* ClipBoard.writeText */ 241, /* text */ relativePath)
+  await Command.execute(
+    /* ClipBoard.writeText */ 'ClipBoard.writeText',
+    /* text */ relativePath
+  )
+  return state
 }
 
 export const copyPath = async (state) => {
@@ -506,7 +524,11 @@ export const copyPath = async (state) => {
   // TODO windows paths
   // TODO handle error
   const path = dirent.path
-  await Command.execute(/* ClipBoard.writeText */ 241, /* text */ path)
+  await Command.execute(
+    /* ClipBoard.writeText */ 'ClipBoard.writeText',
+    /* text */ path
+  )
+  return state
 }
 
 const getContaingingFolder = (root, dirents, focusedIndex, pathSeparator) => {
@@ -599,11 +621,10 @@ const acceptDirent = async (state, type) => {
   // TODO better handle error
   try {
     switch (type) {
-      case 'file':
+      case DirentType.File:
         await FileSystem.writeFile(absolutePath, '')
         break
-      case 'folder':
-      case 'directory':
+      case DirentType.Directory:
         await FileSystem.mkdir(absolutePath)
         break
       default:
@@ -666,11 +687,11 @@ const acceptDirent = async (state, type) => {
 
 // TODO much duplicate logic with acceptNewFolder
 export const acceptNewFile = (state) => {
-  return acceptDirent(state, 'file')
+  return acceptDirent(state, DirentType.File)
 }
 
 export const acceptNewFolder = (state) => {
-  return acceptDirent(state, 'directory')
+  return acceptDirent(state, DirentType.Directory)
 }
 
 // TODO much copy paste with newFIle command
@@ -755,17 +776,16 @@ export const handleClick = async (state, index) => {
   }
   // TODO dirent type should be numeric
   switch (dirent.type) {
-    case 'file':
+    case DirentType.File:
       return handleClickFile(state, dirent, actualIndex)
     // TODO decide on one name
-    case 'folder':
-    case 'directory':
+    case DirentType.Directory:
       return handleClickDirectory(state, dirent, actualIndex)
-    case 'directory-expanding':
+    case DirentType.DirectoryExpanding:
       return handleClickDirectoryExpanding(state, dirent, actualIndex)
-    case 'directory-expanded':
+    case DirentType.DirectoryExpanded:
       return handleClickDirectoryExpanded(state, dirent, actualIndex)
-    case 'symlink':
+    case DirentType.Symlink:
       return handleClickSymLink(state, dirent, state.focusedIndex)
     default:
       break
@@ -868,7 +888,7 @@ const handleClickSymLink = async (state, dirent, index) => {
   const realPath = await FileSystem.getRealPath(dirent.path)
   const type = await FileSystem.stat(realPath)
   switch (type) {
-    case 'file':
+    case DirentType.File:
       return handleClickFile(state, dirent, index)
     default:
       throw new Error(`unsupported file type ${type}`)
@@ -891,13 +911,13 @@ export const handleArrowRight = async (state) => {
   }
   const dirent = state.dirents[state.focusedIndex]
   switch (dirent.type) {
-    case 'file':
+    case DirentType.File:
       return state
-    case 'directory':
+    case DirentType.Directory:
       return handleClickDirectory(state, dirent, state.focusedIndex)
-    case 'directory-expanded':
+    case DirentType.DirectoryExpanded:
       return handleArrowRightDirectoryExpanded(state, dirent)
-    case 'symlink':
+    case DirentType.Symlink:
       return handleClickSymLink(state, dirent, state.focusedIndex)
     default:
       throw new Error(`unsupported file type ${dirent.type}`)
@@ -921,10 +941,10 @@ export const handleArrowLeft = (state) => {
   }
   const dirent = state.dirents[state.focusedIndex]
   switch (dirent.type) {
-    case 'directory':
-    case 'file':
+    case DirentType.Directory:
+    case DirentType.File:
       return focusParentFolder(state)
-    case 'directory-expanded':
+    case DirentType.DirectoryExpanded:
       return handleClickDirectoryExpanded(state, dirent, state.focusedIndex)
     default:
       // TODO handle expanding directory and cancel file system call to read child dirents
@@ -1411,6 +1431,46 @@ export const revealItem = async (state, uri) => {
   return revealItemVisible(state, index)
 }
 
+export const expandRecursively = async (state) => {
+  const { dirents, focusedIndex, pathSeparator, root } = state
+  const dirent = dirents[focusedIndex]
+  if (
+    dirent.type !== DirentType.Directory &&
+    dirent.type !== DirentType.DirectoryExpanding
+  ) {
+    return state
+  }
+  // TODO this is very inefficient
+  const getChildDirentsRecursively = async (dirent) => {
+    switch (dirent.type) {
+      case DirentType.File:
+        return [dirent]
+      case DirentType.Directory:
+        const childDirents = await getChildDirents(root, pathSeparator, dirent)
+        const all = [dirent]
+        for (const childDirent of childDirents) {
+          const childAll = await getChildDirentsRecursively(childDirent)
+          all.push(...childAll)
+        }
+        return all
+      default:
+        return []
+    }
+  }
+  // TODO race condition: what if folder is being collapse while it is recursively expanding?
+  // TODO race condition: what if folder is being deleted while it is recursively expanding?
+  // TODO race condition: what if a new file/folder is created while the folder is recursively expanding?
+  const childDirents = await getChildDirentsRecursively(dirent)
+  const startIndex = focusedIndex
+  const endIndex = getParentEndIndex(dirents, focusedIndex)
+  const newDirents = [
+    ...dirents.slice(0, startIndex),
+    ...childDirents,
+    ...dirents.slice(endIndex),
+  ]
+  return { ...state, dirents: newDirents }
+}
+
 export const shouldApplyNewState = (newState, fn) => {
   if (newState.root !== Workspace.state.workspacePath) {
     console.log(

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/ViewletExtensions/ViewletExtensions.js

@@ -2,9 +2,9 @@ import * as Command from '../Command/Command.js'
 import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
 import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js' // TODO use Command.execute instead
 import * as ExtensionsMarketplace from '../ExtensionMarketplace/ExtensionMarketplace.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Assert from '../Assert/Assert.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 
 export const ITEM_HEIGHT = 62
 
@@ -50,6 +50,7 @@ export const create = (id, uri, left, top, width, height) => {
     top,
     left,
     finalDeltaY: 2728,
+    error: '',
   }
 }
 
@@ -127,10 +128,10 @@ const getIcon = (extension) => {
   if (!extension || !extension.path || !extension.icon) {
     return ''
   }
-  if (Platform.getPlatform() === 'remote') {
+  if (Platform.platform === 'remote') {
     return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
   }
-  if (Platform.getPlatform() === 'electron') {
+  if (Platform.platform === 'electron') {
     return `/remote/${extension.path}/${extension.icon}` // TODO support windows paths
   }
   return ''
@@ -337,15 +338,11 @@ export const handleInput = async (state, value) => {
     // TODO handle out of order responses (a bit complicated)
     // for now just assume everything comes back in order
   } catch (error) {
-    ErrorHandling.handleError(error)
-    // console.error(error)
-    // TODO show error in viewlet
-    await RendererProcess.invoke(
-      /* viewletSend */ 'Viewlet.send',
-      /* id */ 'Extensions',
-      /* method */ 'setError',
-      /* error */ `Failed to load extensions from marketplace: ${error}`
-    )
+    ErrorHandling.printError(error)
+    return {
+      ...state,
+      error: `Failed to load extensions from marketplace: ${error}`,
+    }
   }
 }
 
@@ -552,14 +549,19 @@ export const handleDisable = async (state, id) => {
   )
 }
 
+const handleContextMenuMouse = (state, x, y) => {}
+
+const handleContextMenuIndex = (state, index) => {}
+
 // TODO pass index instead
-export const handleContextMenu = async (state, x, y, extensionId) => {
+export const handleContextMenu = async (state, x, y, index) => {
   await Command.execute(
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,
     /* y */ y,
     /* id */ 'manageExtension'
   )
+  return state
 }
 
 export const openSuggest = async (state) => {
@@ -791,10 +793,25 @@ const renderScrollBarY = {
   },
 }
 
+const renderError = {
+  isEqual(oldState, newState) {
+    return oldState.error === newState.error
+  },
+  apply(oldState, newState) {
+    return [
+      /* viewletSend */ 'Viewlet.send',
+      /* id */ 'Extensions',
+      /* method */ 'setError',
+      /* error */ newState.error,
+    ]
+  },
+}
+
 export const render = [
   renderHeight,
   renderFocusedIndex,
   renderScrollBarY,
   renderNegativeMargin,
   renderExtensions,
+  renderError,
 ]

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/ViewletMain/ViewletMain.js

@@ -270,7 +270,7 @@ export const openUri = async (state, uri) => {
   )
   // @ts-ignore
 
-  return ViewletManager.load(instance)
+  return ViewletManager.load(instance, true)
 }
 
 export const save = () => {

package/static/{d4a8cd1 → 1a57391}/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -150,6 +150,9 @@ export const load = async (viewlet, focus = false) => {
     const oldVersion =
       viewletState.version === undefined ? undefined : ++viewletState.version
     let newState = await module.loadContent(viewletState)
+    if (focus && module.focus) {
+      newState = await module.focus(newState)
+    }
     if (viewletState.version !== oldVersion) {
       newState = viewletState
       console.log('version mismatch')