@lvce-editor/server 0.10.3 → 0.10.5

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletList/ViewletList.js

@@ -1,10 +1,11 @@
 import * as Assert from '../Assert/Assert.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
 export const ITEM_HEIGHT = 62
 
 const MINIMUM_SLIDER_SIZE = 20
 
-export const name = 'List'
+export const name = ViewletModuleId.List
 
 export const create = (id, uri, left, top, width, height) => {
   return {

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletLocations/ViewletLocations.js

@@ -1,7 +1,8 @@
 import * as Command from '../Command/Command.js'
 import * as IconTheme from '../IconTheme/IconTheme.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
-export const name = 'Locations'
+export const name = ViewletModuleId.Locations
 
 export const create = (id, uri) => {
   return {
@@ -107,8 +108,6 @@ export const loadContent = async (state, getReferences) => {
   }
 }
 
-export const contentLoaded = () => {}
-
 export const dispose = (state) => {
   return {
     ...state,

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletMain/ViewletMain.js

@@ -11,6 +11,7 @@ import * as ViewletManager from '../ViewletManager/ViewletManager.js'
 import * as ViewletMap from '../ViewletMap/ViewletMap.js'
 import * as ViewletModule from '../ViewletModule/ViewletModule.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 import * as Workspace from '../Workspace/Workspace.js'
 
 const COLUMN_WIDTH = 9 // TODO compute this automatically once
@@ -94,7 +95,7 @@ const hydrateLazy = async () => {
   )
 }
 
-export const name = 'Main'
+export const name = ViewletModuleId.Main
 
 export const create = (id, uri, left, top, width, height) => {
   return {
@@ -166,6 +167,7 @@ const getRestoredEditors = async (savedState) => {
 }
 
 export const loadContent = async (state, savedState) => {
+  console.log({ savedState })
   // TODO get restored editors from saved state
   const editors = await getRestoredEditors(savedState)
   // @ts-ignore
@@ -176,9 +178,25 @@ 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,
+    // },
+  ]
+}
+
+// TODO content loaded should return commands which
+// get picked up by viewletlayout and sent to renderer process
 export const contentLoaded = async (state) => {
   if (state.editors.length === 0) {
-    return
+    return []
   }
   const editor = Arrays.last(state.editors)
   const top = state.top + TAB_HEIGHT
@@ -186,29 +204,42 @@ export const contentLoaded = async (state) => {
   const width = state.width
   const height = state.height - TAB_HEIGHT
   const id = ViewletMap.getId(editor.uri)
-  const instance = ViewletManager.create(
-    ViewletModule.load,
-    id,
-    'Main',
-    editor.uri,
-    left,
-    top,
-    width,
-    height
-  )
   const tabLabel = Workspace.pathBaseName(editor.uri)
   const tabTitle = getTabTitle(editor.uri)
-  RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'Main',
-    /* method */ 'openViewlet',
-    /* tabLabel */ tabLabel,
-    /* tabTitle */ tabTitle
+  const commands = [
+    [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'Main',
+      /* method */ 'openViewlet',
+      /* tabLabel */ tabLabel,
+      /* tabTitle */ tabTitle,
+    ],
+  ]
+
+  // // TODO race condition: Viewlet may have been resized before it has loaded
+  // // @ts-ignore
+  const extraCommands = await ViewletManager.load(
+    {
+      getModule: ViewletModule.load,
+      id,
+      // @ts-ignore
+      parentId: 'Main',
+      uri: editor.uri,
+      left,
+      top,
+      width,
+      height,
+      show: false,
+      focus: false,
+      type: 0,
+      setBounds: false,
+    },
+    /* focus */ false,
+    /* restore */ true
   )
-  // TODO race condition: Viewlet may have been resized before it has loaded
-  // @ts-ignore
-
-  await ViewletManager.load(instance, /* focus */ false, /* restore */ true)
+  commands.push(...extraCommands)
+  commands.push(['Viewlet.appendViewlet', 'Main', id])
+  return commands
 }
 
 export const openUri = async (state, uri, focus = true) => {
@@ -264,7 +295,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 +565,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 +576,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 +590,7 @@ export const resize = (state, dimensions) => {
     commands,
   }
 }
+
+export const hasFunctionalRender = true
+
+export const render = []

package/static/{372bf21 → d5c500f}/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)
+    }
+  }
+  if (module.CommandsWithSideEffects) {
+    for (const [key, value] of Object.entries(module.CommandsWithSideEffects)) {
+      const wrappedCommand = wrapViewletCommandWithSideEffect(
+        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)
+}
+
+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,
@@ -257,21 +330,25 @@ export const load = async (viewlet, focus = false, restore = false) => {
         factory: module,
       })
     }
-
+    const commands = []
     if (viewletState !== newState && module.contentLoaded) {
-      await module.contentLoaded(newState)
+      const additionalExtraCommands = await module.contentLoaded(newState)
+      console.log({ additionalExtraCommands })
+      Assert.array(additionalExtraCommands)
+      commands.push(...additionalExtraCommands)
     }
 
     if (module.hasFunctionalRender) {
-      const commands = getRenderCommands(module, viewletState, newState)
+      const renderCommands = getRenderCommands(module, viewletState, newState)
+      commands.push(...renderCommands)
       if (viewlet.show === false) {
         const allCommands = [
           ['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,
@@ -281,6 +358,9 @@ export const load = async (viewlet, focus = false, restore = false) => {
             height,
           ])
         }
+        if (module.contentLoadedEffects) {
+          module.contentLoadedEffects(newState)
+        }
         return allCommands
       }
       // console.log('else', viewlet.id, { commands })
@@ -290,7 +370,6 @@ export const load = async (viewlet, focus = false, restore = false) => {
         /* commands */ commands
       )
     }
-
     if (module.contentLoadedEffects) {
       module.contentLoadedEffects(newState)
     }
@@ -324,31 +403,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 +417,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/{372bf21 → d5c500f}/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/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletModuleId/ViewletModuleId.js

@@ -2,6 +2,8 @@ export const ActivityBar = 'ActivityBar'
 
 export const Clock = 'Clock'
 
+export const Counter = 'Counter'
+
 export const DebugConsole = 'Debug Console'
 
 export const EditorCompletion = 'EditorCompletion'
@@ -20,10 +22,18 @@ export const ExtensionDetail = 'ExtensionDetail'
 
 export const Extensions = 'Extensions'
 
+export const Iframe = 'Iframe'
+
 export const Implementations = 'Implementations'
 
 export const KeyBindings = 'KeyBindings'
 
+export const Layout = 'Layout'
+
+export const List = 'List'
+
+export const Locations = 'Locations'
+
 export const Main = 'Main'
 
 export const Noop = 'Noop'
@@ -57,3 +67,5 @@ export const TitleBar = 'TitleBar'
 export const TitleBarButtons = 'TitleBarButtons'
 
 export const TitleBarMenuBar = 'TitleBarMenuBar'
+
+export const TodoList = 'TodoList'

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletNoop/ViewletNoop.js

@@ -9,8 +9,6 @@ export const loadContent = async (state) => {
   return state
 }
 
-export const contentLoaded = async (state) => {}
-
 export const dispose = (state) => {
   return {
     ...state,

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletOutput/ViewletOutput.js

@@ -1,8 +1,9 @@
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as SharedProcess from '../SharedProcess/SharedProcess.js'
 import * as ExtensionHostOutputChannel from '../ExtensionHost/ExtensionHostOutput.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
-export const name = 'Output'
+export const name = ViewletModuleId.Output
 
 export const create = () => {
   return {
@@ -46,13 +47,15 @@ export const loadContent = async (state) => {
 }
 
 export const contentLoaded = async (state) => {
-  await RendererProcess.invoke(
-    /* Viewlet.invoke */ 'Viewlet.send',
-    /* id */ 'Output',
-    /* method */ 'setOptions',
-    /* options */ state.options,
-    /* selectedOptionIndex */ state.selectedIndex
-  )
+  return [
+    [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'Output',
+      /* method */ 'setOptions',
+      /* options */ state.options,
+      /* selectedOptionIndex */ state.selectedIndex,
+    ],
+  ]
 }
 
 export const setOutputChannel = async (state, option) => {

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletPanel/ViewletPanel.js

@@ -1,8 +1,9 @@
 import * as Command from '../Command/Command.js'
 import * as ViewletManager from '../ViewletManager/ViewletManager.js'
 import * as ViewletModule from '../ViewletModule/ViewletModule.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
-export const name = 'Panel'
+export const name = ViewletModuleId.Panel
 
 export const create = () => {
   return {
@@ -25,16 +26,6 @@ export const loadContent = async (state) => {
   }
 }
 
-export const contentLoaded = async (state) => {
-  // await RendererProcess.invoke(
-  //   /* Viewlet.send */ 'Viewlet.send',
-  //   /* id */ 'Panel',
-  //   /* method */ 'setTabs',
-  //   /* tabs */ state.views
-  // )
-  // await openViewlet(state, state.currentViewlet)
-}
-
 export const dispose = (state) => {
   return {
     ...state,

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletProblems/ViewletProblems.js

@@ -1,7 +1,8 @@
 import * as ExtensionHostDiagnostic from '../ExtensionHost/ExtensionHostDiagnostic.js'
 import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
-export const name = 'Problems'
+export const name = ViewletModuleId.Problems
 
 export const create = () => {
   return {
@@ -31,8 +32,6 @@ export const loadContent = async (state) => {
   }
 }
 
-export const contentLoaded = async (state) => {}
-
 export const focusIndex = (state, index) => {
   return {
     ...state,

package/static/{372bf21 → d5c500f}/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.js

@@ -1,10 +1,11 @@
 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'
+import * as QuickPickReturnValue from '../QuickPickReturnValue/QuickPickReturnValue.js'
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
 
 // TODO send open signal to renderer process before items are ready
 // that way user can already type while items are still loading
@@ -24,7 +25,7 @@ const QuickPickState = {
   Finished: 2,
 }
 
-export const name = 'QuickPick'
+export const name = ViewletModuleId.QuickPick
 
 export const create = (id, uri, top, left, width, height) => {
   return {
@@ -155,8 +156,6 @@ export const loadContent = async (state) => {
   }
 }
 
-export const contentLoaded = () => {}
-
 export const dispose = (state) => {
   return state
 }
@@ -206,8 +205,8 @@ export const selectIndex = async (state, index, button = /* left */ 0) => {
   Assert.string(selectPickResult.command)
   const { command } = selectPickResult
   switch (command) {
-    case 'hide':
-      await Viewlet.closeWidget('QuickPick')
+    case QuickPickReturnValue.Hide:
+      await Viewlet.closeWidget(ViewletModuleId.QuickPick)
       return state
     default:
       return state