@lvce-editor/server 0.4.4 → 0.6.0

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -0,0 +1,323 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as Assert from '../Assert/Assert.js'
+import { CancelationError } from '../Errors/CancelationError.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as Command from '../Command/Command.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as ViewletModule from '../ViewletModule/ViewletModule.js'
+
+const ViewletState = {
+  Default: 0,
+  ModuleLoaded: 1,
+  ContentLoaded: 2,
+  RendererProcessViewletLoaded: 3,
+  ContentRendered: 4,
+  Appended: 5,
+}
+
+/**
+ *
+ * @param {()=>any} getModule
+ * @returns
+ */
+export const create = (
+  getModule,
+  id,
+  parentId,
+  uri,
+  left,
+  top,
+  width,
+  height
+) => {
+  Assert.fn(getModule)
+  Assert.string(id)
+  Assert.string(parentId)
+  Assert.string(uri)
+  Assert.number(left)
+  Assert.number(top)
+  Assert.number(width)
+  Assert.number(height)
+  return {
+    type: 0,
+    getModule,
+    id,
+    parentId,
+    uri,
+    left,
+    top,
+    width,
+    height,
+  }
+}
+
+// TODO add lots of unit tests for this
+/**
+ *
+ * @param {{getModule:()=>any, type:number, id:string, disposed:boolean }} viewlet
+ * @returns
+ */
+export const load = async (viewlet, focus = false) => {
+  // console.time(`load/${viewlet.id}`)
+  if (viewlet.type !== 0) {
+    console.log('viewlet must be empty')
+    throw new Error('viewlet must be empty')
+  }
+  let state = ViewletState.Default
+  let module
+  try {
+    viewlet.type = 1
+    if (viewlet.disposed) {
+      return
+    }
+
+    module = await viewlet.getModule(viewlet.id)
+    if (viewlet.disposed) {
+      return
+    }
+    if (module.Commands) {
+      for (const [key, value] of Object.entries(module.Commands)) {
+        Command.register(key, value)
+      }
+    }
+    state = ViewletState.ModuleLoaded
+
+    let left = viewlet.left
+    let top = viewlet.top
+    let width = viewlet.width
+    let height = viewlet.height
+    if (module.getPosition) {
+      const position = module.getPosition()
+      left = position.left
+      top = position.top
+      width = position.width
+      height = position.height
+    }
+
+    const viewletState = module.create(
+      viewlet.id,
+      viewlet.uri,
+      left,
+      top,
+      width,
+      height
+    )
+
+    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')
+      // TODO not sure if Object.assign is a good idea
+      // Object.assign(viewletState, newState)
+    }
+    if (viewlet.disposed) {
+      return
+    }
+    state = ViewletState.ContentLoaded
+
+    if (viewlet.show === false) {
+      await RendererProcess.invoke(
+        /* Viewlet.load */ 'Viewlet.loadModule',
+        /* id */ viewlet.id
+      )
+    } else {
+      await RendererProcess.invoke(
+        /* Viewlet.load */ 'Viewlet.load',
+        /* id */ viewlet.id
+      )
+    }
+    if (viewlet.disposed) {
+      // TODO unload the module from renderer process
+      return
+    }
+    // TODO race condition: viewlet state may have been updated again in the mean time
+    state = ViewletState.RendererProcessViewletLoaded
+
+    outer: if (module.shouldApplyNewState) {
+      for (let i = 0; i < 2; i++) {
+        if (module.shouldApplyNewState(newState)) {
+          ViewletStates.set(viewlet.id, {
+            state: newState,
+            factory: module,
+          })
+          break outer
+        }
+        newState = await module.loadContent(viewletState)
+      }
+      throw new Error('viewlet could not be updated')
+    } else {
+      ViewletStates.set(viewlet.id, {
+        state: newState,
+        factory: module,
+      })
+    }
+
+    if (viewletState !== newState && module.contentLoaded) {
+      await module.contentLoaded(newState)
+    }
+
+    if (module.hasFunctionalRender) {
+      let commands = []
+      if (Array.isArray(module.render)) {
+        for (const item of module.render) {
+          if (!item.isEqual(viewletState, newState)) {
+            commands.push(item.apply(viewletState, newState))
+          }
+        }
+      } else {
+        commands = module.render(viewletState, newState)
+      }
+      if (viewlet.show === false) {
+        const allCommands = [
+          ['Viewlet.create', viewlet.id],
+          ...commands,
+          ['Viewlet.show', viewlet.id],
+        ]
+        if (module.getPosition) {
+          allCommands.splice(1, 0, [
+            'Viewlet.setBounds',
+            viewlet.id,
+            left,
+            top,
+            width,
+            height,
+          ])
+        }
+        return allCommands
+      }
+      await RendererProcess.invoke(
+        /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
+        /* commands */ commands
+      )
+    }
+
+    if (module.contentLoadedEffects) {
+      module.contentLoadedEffects(newState)
+    }
+    if (viewlet.disposed) {
+      // TODO unload the module from renderer process
+      return
+    }
+    state = ViewletState.ContentRendered
+    if (viewlet.parentId) {
+      await RendererProcess.invoke(
+        /* Viewlet.append */ 'Viewlet.appendViewlet',
+        /* parentId */ viewlet.parentId,
+        /* id */ viewlet.id,
+        /* focus */ focus
+      )
+    }
+    state = ViewletState.Appended
+
+    // TODO race condition
+    // outer: if (module.shouldApplyNewState) {
+    //   for (let i = 0; i < 2; i++) {
+    //     if (module.shouldApplyNewState(newState)) {
+    //       Viewlet.state.instances[viewlet.id] = {
+    //         state: newState,
+    //         factory: module,
+    //       }
+    //       break outer
+    //     }
+    //     newState = await module.loadContent(viewletState)
+    //   }
+    //   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 (!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
+    }
+  } catch (error) {
+    if (error && error instanceof CancelationError) {
+      return
+    }
+    viewlet.type = 4
+    console.error(error)
+    try {
+      if (module && module.handleError) {
+        return await module.handleError(error)
+      }
+      if (state < ViewletState.RendererProcessViewletLoaded) {
+        await RendererProcess.invoke(
+          /* Viewlet.load */ 'Viewlet.load',
+          /* id */ viewlet.id
+        )
+      }
+      if (state < ViewletState.Appended && viewlet.parentId) {
+        await RendererProcess.invoke(
+          /* Viewlet.append */ 'Viewlet.appendViewlet',
+          /* parentId */ viewlet.parentId,
+          /* id */ viewlet.id
+        )
+      }
+      await RendererProcess.invoke(
+        /* viewlet.handleError */ 'Viewlet.handleError',
+        /* id */ viewlet.id,
+        /* parentId */ viewlet.parentId,
+        /* message */ `${error}`
+      )
+    } catch (error) {
+      console.error(error)
+      // this is really bad
+      // probably can only show an alert at this point
+    }
+  }
+  // console.timeEnd(`load/${viewlet.id}`)
+}
+
+export const dispose = async (id) => {
+  state[id].disposed = true
+  delete Viewlet.state.instances[id]
+  delete state[id]
+  await RendererProcess.invoke(
+    /* Viewlet.dispose */ 'Viewlet.dispose',
+    /* id */ id
+  )
+}
+
+export const mutate = async (id, fn) => {
+  // TODO handle race conditions here
+  const viewletState = state[id]
+  await fn(state)
+}
+
+export const render = (module, oldState, newState) => {
+  if (Array.isArray(module.render)) {
+    const commands = []
+    for (const item of module.render) {
+      if (!item.isEqual(oldState, newState)) {
+        commands.push(item.apply(oldState, newState))
+      }
+    }
+    return commands
+  }
+  return module.render(oldState, newState)
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletMap/ViewletMap.js

@@ -0,0 +1,24 @@
+import * as Path from '../Path/Path.js'
+
+const mapExtToEditorType = {
+  '.png': 'EditorImage',
+  '.svg': 'EditorImage',
+  '.avif': 'EditorImage',
+  '.gif': 'EditorImage',
+  '.ico': 'EditorImage',
+  '.webp': 'EditorImage',
+  '.jpg': 'EditorImage',
+  '.jpeg': 'EditorImage',
+}
+
+export const getId = (uri) => {
+  const fileExtension = Path.fileExtension(uri)
+  const type = mapExtToEditorType[fileExtension]
+  if (type) {
+    return type
+  }
+  if (uri === 'app://keybindings') {
+    return 'KeyBindings'
+  }
+  return 'EditorText'
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletModule/ViewletModule.js

@@ -0,0 +1,60 @@
+import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
+
+export const load = (moduleId) => {
+  switch (moduleId) {
+    case ViewletModuleId.Explorer:
+      return import('../ViewletExplorer/ViewletExplorer.ipc.js')
+    case ViewletModuleId.RunAndDebug:
+      return import('../ViewletRunAndDebug/ViewletRunAndDebug.ipc.js')
+    case ViewletModuleId.Search:
+      return import('../ViewletSearch/ViewletSearch.ipc.js')
+    case ViewletModuleId.SourceControl:
+      return import('../ViewletSourceControl/ViewletSourceControl.ipc.js')
+    case ViewletModuleId.Terminal:
+      return import('../ViewletTerminal/ViewletTerminal.ipc.js')
+    case ViewletModuleId.DebugConsole:
+      return import('../ViewletDebugConsole/ViewletDebugConsole.ipc.js')
+    case ViewletModuleId.Extensions:
+      return import('../ViewletExtensions/ViewletExtensions.ipc.js')
+    case ViewletModuleId.Output:
+      return import('../ViewletOutput/ViewletOutput.ipc.js')
+    case ViewletModuleId.Problems:
+      return import('../ViewletProblems/ViewletProblems.ipc.js')
+    case ViewletModuleId.Noop:
+      return import('../ViewletNoop/ViewletNoop.ipc.js')
+    case ViewletModuleId.EditorText:
+      return import('../ViewletEditorText/ViewletEditorText.ipc.js')
+    case ViewletModuleId.EditorPlainText:
+      return import('../ViewletEditorPlainText/ViewletEditorPlainText.ipc.js')
+    case ViewletModuleId.EditorImage:
+      return import('../ViewletEditorImage/ViewletEditorImage.ipc.js')
+    case ViewletModuleId.Clock:
+      return import('../ViewletClock/ViewletClock.ipc.js')
+    case ViewletModuleId.ActivityBar:
+      return import('../ViewletActivityBar/ViewletActivityBar.ipc.js')
+    case ViewletModuleId.Panel:
+      return import('../ViewletPanel/ViewletPanel.ipc.js')
+    case ViewletModuleId.SideBar:
+      return import('../ViewletSideBar/ViewletSideBar.ipc.js')
+    case ViewletModuleId.TitleBar:
+      return import('../ViewletTitleBar/ViewletTitleBar.ipc.js')
+    case ViewletModuleId.StatusBar:
+      return import('../ViewletStatusBar/ViewletStatusBar.ipc.js')
+    case ViewletModuleId.Main:
+      return import('../ViewletMain/ViewletMain.ipc.js')
+    case ViewletModuleId.EditorCompletion:
+      return import('../ViewletEditorCompletion/ViewletEditorCompletion.ipc.js')
+    case ViewletModuleId.References:
+      return import('../ViewletReferences/ViewletReferences.ipc.js')
+    case ViewletModuleId.Implementations:
+      return import('../ViewletImplementations/ViewletImplementations.ipc.js')
+    case ViewletModuleId.QuickPick:
+      return import('../ViewletQuickPick/ViewletQuickPick.ipc.js')
+    case ViewletModuleId.KeyBindings:
+      return import('../ViewletKeyBindings/ViewletKeyBindings.ipc.js')
+    case ViewletModuleId.EditorFindWidget:
+      return import('../ViewletEditorFindWidget/ViewletEditorFindWidget.ipc.js')
+    default:
+      throw new Error(`unknown module "${moduleId}"`)
+  }
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletModuleId/ViewletModuleId.js

@@ -0,0 +1,51 @@
+export const ActivityBar = 'ActivityBar'
+
+export const Clock = 'Clock'
+
+export const DebugConsole = 'Debug Console'
+
+export const EditorCompletion = 'EditorCompletion'
+
+export const EditorImage = 'EditorImage'
+
+export const EditorPlainText = 'EditorPlainText'
+
+export const EditorText = 'EditorText'
+
+export const Explorer = 'Explorer'
+
+export const Extensions = 'Extensions'
+
+export const Implementations = 'Implementations'
+
+export const KeyBindings = 'KeyBindings'
+
+export const Main = 'Main'
+
+export const Noop = 'Noop'
+
+export const Output = 'Output'
+
+export const Panel = 'Panel'
+
+export const Problems = 'Problems'
+
+export const QuickPick = 'QuickPick'
+
+export const References = 'References'
+
+export const RunAndDebug = 'RunAndDebug'
+
+export const Search = 'Search'
+
+export const SideBar = 'SideBar'
+
+export const SourceControl = 'Source Control'
+
+export const StatusBar = 'StatusBar'
+
+export const Terminal = 'Terminal'
+
+export const TitleBar = 'TitleBar'
+
+export const EditorFindWidget = 'EditorFindWidget'

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletPanel/ViewletPanel.js

@@ -0,0 +1,122 @@
+import * as Command from '../Command/Command.js'
+import * as ViewletManager from '../ViewletManager/ViewletManager.js'
+import * as ViewletModule from '../ViewletModule/ViewletModule.js'
+
+export const name = 'Panel'
+
+export const create = () => {
+  return {
+    currentId: '',
+    currentViewlet: undefined,
+    views: [],
+    disposed: false,
+    focusedIndex: -1,
+    selectedIndex: -1,
+  }
+}
+
+export const loadContent = async (state) => {
+  const cachedViewlet = await getCachedViewlet()
+  return {
+    ...state,
+    views: ['Problems', 'Output', 'Debug Console', 'Terminal'],
+    currentViewlet: cachedViewlet,
+    selectedIndex: 0,
+  }
+}
+
+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,
+    disposed: true,
+  }
+}
+
+const getCachedViewlet = async () => {
+  const cachedViewlet = await Command.execute(
+    /* LocalStorage.getJson */ 'LocalStorage.getJson',
+    /* key */ 'panelViewlet'
+  )
+  return cachedViewlet
+}
+
+// TODO this function is a bit messy
+export const openViewlet = async (state, id) => {
+  if (!id) {
+    return
+  }
+  // TODO pending state
+  if (state.currentId === id) {
+    return
+  }
+  // TODO current viewlet should be disposed if it exists
+  state.currentId = id
+  const child = ViewletManager.create(
+    ViewletModule.load,
+    id,
+    'Panel',
+    '',
+    0,
+    0,
+    0,
+    0
+  )
+  await ViewletManager.load(child)
+}
+
+export const selectIndex = async (state, index) => {
+  await openViewlet(state, state.views[index])
+  return {
+    ...state,
+    selectedIndex: index,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderTabs = {
+  isEqual(oldState, newState) {
+    return oldState.views === newState.views
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'Panel',
+      /* method */ 'setTabs',
+      /* tabs */ newState.views,
+    ]
+  },
+}
+
+const renderSelectedIndex = {
+  isEqual(oldState, newState) {
+    return oldState.selectedIndex === newState.selectedIndex
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'Panel',
+      /* method */ 'setSelectedIndex',
+      /* unFocusIndex */ oldState.selectedIndex,
+      /* focusIndex */ newState.selectedIndex,
+    ]
+  },
+}
+
+export const render = [renderTabs, renderSelectedIndex]
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  return state
+}

package/static/fbac85f/packages/renderer-worker/src/parts/ViewletProblems/ViewletProblems.js

@@ -0,0 +1,80 @@
+import * as ExtensionHostDiagnostic from '../ExtensionHost/ExtensionHostDiagnostic.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+
+export const name = 'Problems'
+
+export const create = () => {
+  return {
+    problems: [],
+    disposed: false,
+    focusedIndex: -2,
+  }
+}
+
+const toProblem = (diagnostic) => {
+  return diagnostic.message
+}
+
+export const loadContent = async (state) => {
+  const instance = ViewletStates.getInstance('EditorText')
+  if (!instance) {
+    return state
+  }
+  const editor = instance.state
+  const diagnostics = await ExtensionHostDiagnostic.executeDiagnosticProvider(
+    editor
+  )
+  const problems = diagnostics.map(toProblem)
+  return {
+    ...state,
+    problems,
+  }
+}
+
+export const contentLoaded = async (state) => {}
+
+export const focusIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderProblems = {
+  isEqual(oldState, newState) {
+    return oldState.problems === newState.problems
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'Problems',
+      /* method */ 'setProblems',
+      /* problems */ newState.problems,
+    ]
+  },
+}
+
+const renderFocusedIndex = {
+  isEqual(oldState, newState) {
+    return oldState.focusedIndex === newState.focusedIndex
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'Problems',
+      /* method */ 'setFocusedIndex',
+      /* focusedIndex */ newState.focusedIndex,
+    ]
+  },
+}
+
+export const render = [renderProblems, renderFocusedIndex]