@lvce-editor/server 0.10.2 → 0.10.4

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletMain/ViewletMain.js

@@ -12,6 +12,7 @@ import * as ViewletMap from '../ViewletMap/ViewletMap.js'
 import * as ViewletModule from '../ViewletModule/ViewletModule.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 import * as Workspace from '../Workspace/Workspace.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
 const COLUMN_WIDTH = 9 // TODO compute this automatically once
 
@@ -176,6 +177,20 @@ export const loadContent = async (state, savedState) => {
   }
 }
 
+export const getChildren = (state) => {
+  const { editors } = state
+  if (editors.length === 0) {
+    return []
+  }
+  const editor = editors[0]
+  console.log({ editor })
+  return [
+    // {
+    //   id: ViewletModuleId.MainTabs,
+    // },
+  ]
+}
+
 export const contentLoaded = async (state) => {
   if (state.editors.length === 0) {
     return
@@ -264,7 +279,8 @@ export const openUri = async (state, uri, focus = true) => {
   )
   // @ts-ignore
 
-  return ViewletManager.load(instance, focus)
+  await ViewletManager.load(instance, focus)
+  return state
 }
 
 export const save = () => {
@@ -533,6 +549,7 @@ export const closeTabsLeft = async (state) => {
 }
 
 export const resize = (state, dimensions) => {
+  const { editors } = state
   const top = dimensions.top + TAB_HEIGHT
   const left = dimensions.left
   const width = dimensions.width
@@ -543,7 +560,7 @@ export const resize = (state, dimensions) => {
     width,
     height,
   }
-  const editor = state.editors[0]
+  const editor = editors[0]
   let commands = []
   if (editor) {
     const id = ViewletMap.getId(editor.uri)
@@ -557,3 +574,7 @@ export const resize = (state, dimensions) => {
     commands,
   }
 }
+
+export const hasFunctionalRender = true
+
+export const render = []

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -54,6 +54,33 @@ const wrapViewletCommand = (id, fn) => {
   return wrappedViewletCommand
 }
 
+const wrapViewletCommandWithSideEffect = (id, fn) => {
+  const wrappedViewletCommand = async (...args) => {
+    // TODO get actual focused instance
+    const activeInstance = ViewletStates.getInstance(id)
+    if (!activeInstance) {
+      console.info(
+        `cannot execute viewlet command ${id}.${fn.name}: no active instance for ${id}`
+      )
+      return
+    }
+    const oldState = activeInstance.state
+    const { newState, commands } = await fn(oldState, ...args)
+    Assert.object(newState)
+    // console.log({ fn, newState })
+    if (oldState !== newState) {
+      commands.push(...render(activeInstance.factory, oldState, newState))
+      ViewletStates.setState(id, newState)
+    }
+    await RendererProcess.invoke(
+      /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
+      /* commands */ commands
+    )
+  }
+  NameAnonymousFunction.nameAnonymousFunction(wrappedViewletCommand, fn.name)
+  return wrappedViewletCommand
+}
+
 /**
  *
  * @param {()=>any} getModule
@@ -111,12 +138,47 @@ const getRenderCommands = (module, oldState, newState) => {
 }
 
 const maybeRegisterWrappedCommands = (module) => {
-  if (!module.Commands) {
-    return
+  if (module.Commands) {
+    for (const [key, value] of Object.entries(module.Commands)) {
+      const wrappedCommand = wrapViewletCommand(module.name, value)
+      Command.register(key, wrappedCommand)
+    }
   }
-  for (const [key, value] of Object.entries(module.Commands)) {
-    const wrappedCommand = wrapViewletCommand(module.name, value)
-    Command.register(key, wrappedCommand)
+  if (module.CommandsWithSideEffects) {
+    for (const [key, value] of Object.entries(module.CommandsWithSideEffects)) {
+      const wrappedCommand = wrapViewletCommandWithSideEffect(
+        module.name,
+        value
+      )
+      Command.register(key, wrappedCommand)
+    }
+  }
+}
+
+const maybeRegisterEvents = (module) => {
+  if (module.Events) {
+    // TODO remove event listeners when viewlet is disposed
+    for (const [key, value] of Object.entries(module.Events)) {
+      const handleUpdate = async () => {
+        const instance = ViewletStates.getInstance(module.name)
+        const newState = await value(instance.state)
+        if (!newState) {
+          throw new Error('newState must be defined')
+        }
+        if (!module.shouldApplyNewState(newState)) {
+          console.log('[viewlet manager] return', newState)
+
+          return
+        }
+        const commands = render(instance.factory, instance.state, newState)
+        instance.state = newState
+        await RendererProcess.invoke(
+          /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
+          /* commands */ commands
+        )
+      }
+      GlobalEventBus.addListener(key, handleUpdate)
+    }
   }
 }
 
@@ -126,7 +188,12 @@ const maybeRegisterWrappedCommands = (module) => {
  * @param {{getModule:()=>any, type:number, id:string, disposed:boolean }} viewlet
  * @returns
  */
-export const load = async (viewlet, focus = false, restore = false) => {
+export const load = async (
+  viewlet,
+  focus = false,
+  restore = false,
+  restoreState = undefined
+) => {
   // console.time(`load/${viewlet.id}`)
   if (viewlet.type !== 0) {
     console.log('viewlet must be empty')
@@ -145,6 +212,7 @@ export const load = async (viewlet, focus = false, restore = false) => {
       return
     }
     maybeRegisterWrappedCommands(module)
+    maybeRegisterEvents(module)
     state = ViewletState.ModuleLoaded
 
     let left = viewlet.left
@@ -174,6 +242,8 @@ export const load = async (viewlet, focus = false, restore = false) => {
     if (restore) {
       const stateToSave = await SaveState.getSavedState()
       instanceSavedState = getInstanceSavedState(stateToSave, viewlet.id)
+    } else if (restoreState) {
+      instanceSavedState = restoreState
     }
     let newState = await module.loadContent(viewletState, instanceSavedState)
 
@@ -181,20 +251,23 @@ export const load = async (viewlet, focus = false, restore = false) => {
 
     if (module.getChildren) {
       const children = module.getChildren(newState)
-      const childModules = await Promise.all(
-        children.map((child) => child.id).map(viewlet.getModule)
-      )
-
-      for (const childModule of childModules) {
+      for (const child of children) {
+        const childModule = await viewlet.getModule(child.id)
         await RendererProcess.invoke(
           /* Viewlet.load */ 'Viewlet.loadModule',
-          /* id */ childModule.name
+          /* id */ child.id
         )
         maybeRegisterWrappedCommands(childModule)
-      }
-
-      for (const childModule of childModules) {
-        const oldState = childModule.create()
+        maybeRegisterEvents(childModule)
+        // TODO get position of child module
+        const oldState = childModule.create(
+          '',
+          '',
+          child.left,
+          child.top,
+          child.width,
+          child.height
+        )
         const newState = await childModule.loadContent(oldState)
         const childInstance = {
           state: newState,
@@ -269,9 +342,9 @@ export const load = async (viewlet, focus = false, restore = false) => {
           ['Viewlet.create', viewlet.id],
           ...commands,
           ...extraCommands,
-          ['Viewlet.show', viewlet.id],
+          // ['Viewlet.show', viewlet.id],
         ]
-        if (module.getPosition) {
+        if (viewlet.setBounds !== false) {
           allCommands.splice(1, 0, [
             'Viewlet.setBounds',
             viewlet.id,
@@ -324,31 +397,6 @@ export const load = async (viewlet, focus = false, restore = false) => {
     //   throw new Error('viewlet could not be updated')
     // }
 
-    if (module.events) {
-      // TODO remove event listeners when viewlet is disposed
-      for (const [key, value] of Object.entries(module.events)) {
-        const handleUpdate = async () => {
-          const instance = ViewletStates.getInstance(viewlet.id)
-          const newState = await value(instance.state)
-          if (!newState) {
-            throw new Error('newState must be defined')
-          }
-          if (!module.shouldApplyNewState(newState)) {
-            console.log('[viewlet manager] return', newState)
-
-            return
-          }
-          const commands = render(instance.factory, instance.state, newState)
-          instance.state = newState
-          await RendererProcess.invoke(
-            /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
-            /* commands */ commands
-          )
-        }
-        GlobalEventBus.addListener(key, handleUpdate)
-      }
-    }
-
     if (viewlet.disposed) {
       // TODO unload the module from renderer process
       return
@@ -363,25 +411,28 @@ export const load = async (viewlet, focus = false, restore = false) => {
       if (module && module.handleError) {
         return await module.handleError(error)
       }
+      const commands = []
       if (state < ViewletState.RendererProcessViewletLoaded) {
         await RendererProcess.invoke(
           /* Viewlet.load */ 'Viewlet.load',
           /* id */ viewlet.id
         )
       }
+      commands.push(['Viewlet.create', viewlet.id])
       if (state < ViewletState.Appended && viewlet.parentId) {
-        await RendererProcess.invoke(
+        commands.push([
           /* Viewlet.append */ 'Viewlet.appendViewlet',
           /* parentId */ viewlet.parentId,
-          /* id */ viewlet.id
-        )
+          /* id */ viewlet.id,
+        ])
       }
-      await RendererProcess.invoke(
+      commands.push([
         /* viewlet.handleError */ 'Viewlet.handleError',
         /* id */ viewlet.id,
         /* parentId */ viewlet.parentId,
-        /* message */ `${error}`
-      )
+        /* message */ `${error}`,
+      ])
+      return commands
     } catch (error) {
       console.error(error)
       // this is really bad

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletModule/ViewletModule.js

@@ -60,6 +60,8 @@ export const load = (moduleId) => {
       return import('../ViewletTitleBarButtons/ViewletTitleBarButtons.ipc.js')
     case ViewletModuleId.TitleBarMenuBar:
       return import('../ViewletTitleBarMenuBar/ViewletTitleBarMenuBar.ipc.js')
+    case ViewletModuleId.Layout:
+      return import('../ViewletLayout/ViewletLayout.ipc.js')
     case ViewletModuleId.SimpleBrowser:
       return import('../ViewletSimpleBrowser/ViewletSimpleBrowser.ipc.js')
     default:

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletModuleId/ViewletModuleId.js

@@ -24,6 +24,8 @@ export const Implementations = 'Implementations'
 
 export const KeyBindings = 'KeyBindings'
 
+export const Layout = 'Layout'
+
 export const Main = 'Main'
 
 export const Noop = 'Noop'

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.js

@@ -1,7 +1,6 @@
 import * as Assert from '../Assert/Assert.js'
 import * as BeforeInput from '../BeforeInput/BeforeInput.js'
 import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
-import * as Layout from '../Layout/Layout.js'
 import * as QuickPickEntries from '../QuickPickEntries/QuickPickEntries.js'
 import * as QuickPickEveryThing from '../QuickPickEntriesEverything/QuickPickEntriesEverything.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletSideBar/ViewletSideBar.ipc.js

@@ -5,7 +5,6 @@ export const Commands =  {
   'SideBar.focus': ViewletSideBar.focus,
   'SideBar.openViewlet': ViewletSideBar.openViewlet,
   'SideBar.show': ViewletSideBar.openViewlet,
-  'SideBar.showOrHideViewlet': ViewletSideBar.showOrHideViewlet,
 }
 
 export * from './ViewletSideBar.js'

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletSideBar/ViewletSideBar.js

@@ -1,13 +1,13 @@
-import * as Assert from '../Assert/Assert.js'
 import * as Command from '../Command/Command.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as Layout from '../Layout/Layout.js'
-import * as LifeCycle from '../LifeCycle/LifeCycle.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
 import * as ViewletManager from '../ViewletManager/ViewletManager.js'
 import * as ViewletModule from '../ViewletModule/ViewletModule.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 
+const SIDE_BAR_TITLE_AREA_HEIGHT = 35
+
 export const name = 'SideBar'
 
 export const create = (id, uri, left, top, width, height) => {
@@ -17,6 +17,7 @@ export const create = (id, uri, left, top, width, height) => {
     top,
     width,
     height,
+    titleAreaHeight: SIDE_BAR_TITLE_AREA_HEIGHT,
   }
 }
 
@@ -35,68 +36,22 @@ export const loadContent = async (state, savedState) => {
   }
 }
 
-export const loadContentEffects = () => {
-  LifeCycle.once(LifeCycle.PHASE_TWELVE, hydrateLazy)
-  GlobalEventBus.addListener('Layout.hideSideBar', handleSideBarClose)
-}
+// export const loadContentEffects = () => {
+//   LifeCycle.once(LifeCycle.PHASE_TWELVE, hydrateLazy)
+//   GlobalEventBus.addListener('Layout.hideSideBar', handleSideBarClose)
+// }
 
 // TODO
-export const loadChildren = () => {
+export const getChildren = (state) => {
+  const { top, left, width, height, titleAreaHeight, currentViewletId } = state
   return [
     {
-      id: 'Explorer',
+      id: currentViewletId,
+      ...getContentDimensions(state),
     },
   ]
 }
 
-export const contentLoaded = async (state) => {
-  if (state.currentViewletId) {
-    await openViewlet(state, state.currentViewletId)
-  }
-}
-
-const getSideBarViewlet = async () => {
-  const cachedViewlet = await Command.execute(
-    /* LocalStorage.getJson */ 'LocalStorage.getJson',
-    /* key */ 'sideBarPanel'
-  )
-  if (cachedViewlet) {
-    return cachedViewlet
-  }
-
-  // TODO what if explorer has been deactivated
-  // probably need to check activity bar items
-  // but activity bar already has a dependency on sidebar
-  return 'Explorer'
-}
-
-const hydrateLazy = () => () => {
-  // TODO update file icons in explorer
-}
-
-const SIDE_BAR_TITLE_AREA_HEIGHT = 35
-
-// TODO add test for this
-export const showOrHideViewlet = async (state, viewletId) => {
-  Assert.object(state)
-  Assert.string(viewletId)
-  if (Layout.isSideBarVisible()) {
-    // TODO don't depend on sidebar directly
-    if (state.currentViewletId === viewletId) {
-      await Layout.hideSideBar()
-    } else {
-      state.currentViewletId = viewletId
-      await openViewlet(state, viewletId)
-    }
-  } else {
-    console.log('show side bar')
-    state.currentViewletId = viewletId
-    // TODO race condition: what if sidebar should be hidden again
-    // while sidebar is opening?
-    await Layout.showSideBar()
-  }
-}
-
 const getContentDimensions = (dimensions) => {
   return {
     left: dimensions.left,
@@ -113,38 +68,62 @@ export const openViewlet = async (state, id, focus = false) => {
   //   console.log('dispose current viewlet', state.currentViewletId)
   //   Viewlet.dispose(state.currentViewletId)
   // }
-  // state.currentViewletId = id
+  const { currentViewletId } = state
+  state.currentViewletId = id
+
   const childDimensions = getContentDimensions(state)
-  // TODO race condition (check if disposed after created)
-  const viewlet = ViewletManager.create(
-    ViewletModule.load,
+
+  const commands = await ViewletManager.load({
+    getModule: ViewletModule.load,
     id,
-    'SideBar',
-    'builtin://',
-    childDimensions.left,
-    childDimensions.top,
-    childDimensions.width,
-    childDimensions.height
-  )
-
-  // if (state.currentViewletId !== id) {
-  //   console.log('return')
-
-  //   return
-  // }
-  // // TODO activity and sidebar changes should ideally be rendered at the same time
-  // // but this works for now
-  // RendererProcess.send([
-  //   /* Viewlet.appendViewlet */ 3029,
-  //   /* parentId */ 'SideBar',
-  //   /* childId */ id,
-  //   /* focus */ focus,
-  // ])
-  GlobalEventBus.emitEvent('SideBar.viewletChange', id)
-  // await Viewlet.refresh(id)
-  // TODO add keybinding to title
-  // @ts-ignore
-  await ViewletManager.load(viewlet, focus, /* restore */ true)
+    type: 0,
+    // @ts-ignore
+    uri: '',
+    show: false,
+    focus: false,
+    setBounds: false,
+    top: childDimensions.top,
+    left: childDimensions.left,
+    width: childDimensions.width,
+    height: childDimensions.height,
+  })
+  if (commands) {
+    commands.unshift(['Viewlet.dispose', currentViewletId])
+    commands.push(['Viewlet.append', ViewletModuleId.SideBar, id])
+    const activityBar = ViewletStates.getInstance(ViewletModuleId.ActivityBar)
+    if (activityBar) {
+      const oldState = activityBar.state
+      const newState = activityBar.factory.handleSideBarViewletChange(
+        oldState,
+        id
+      )
+      const extraCommands = ViewletManager.render(
+        activityBar.factory,
+        oldState,
+        newState
+      )
+      activityBar.state = newState
+      commands.push(...extraCommands)
+    }
+    await RendererProcess.invoke('Viewlet.sendMultiple', commands)
+  }
+
+  // // TODO race condition (check if disposed after created)
+  // const viewlet = ViewletManager.create(
+  //   ViewletModule.load,
+  //   id,
+  //   'SideBar',
+  //   'builtin://',
+  //   childDimensions.left,
+  //   childDimensions.top,
+  //   childDimensions.width,
+  //   childDimensions.height
+  // )
+
+  // // TODO add keybinding to title
+  // // @ts-ignore
+  // await ViewletManager.load(viewlet, focus, /* restore */ true)
+  return { ...state }
 }
 
 const handleSideBarClose = (state) => {
@@ -196,7 +175,24 @@ export const focus = async (state) => {
   //   newState
   // )
   // currentViewlet.state = newState
-  // console.log({ commands })
   return state
   // console.log({ currentViewletId })
 }
+
+export const hasFunctionalRender = true
+
+const renderTitle = {
+  isEqual(oldState, newState) {
+    return false
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'SideBar',
+      /* method */ 'setTitle',
+      /* name */ newState.currentViewletId,
+    ]
+  },
+}
+
+export const render = [renderTitle]

package/static/{16e597c → a06e404}/packages/renderer-worker/src/parts/ViewletStates/ViewletStates.js

@@ -2,6 +2,10 @@ import * as Assert from '../Assert/Assert.js'
 
 export const state = {
   instances: Object.create(null),
+  /**
+   * @type {any}
+   */
+  focusedInstance: undefined,
 }
 
 export const set = (key, value) => {
@@ -50,3 +54,11 @@ export const setState = (key, newState) => {
 export const reset = () => {
   state.instances = Object.create(null)
 }
+
+export const getFocusedInstance = () => {
+  return state.focusedInstance
+}
+
+export const setFocusedInstance = (state, instance) => {
+  state.focusedIndex = instance
+}