@lvce-editor/server 0.4.4 → 0.6.0

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

@@ -1,299 +0,0 @@
-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
-    const viewletState = module.create(
-      viewlet.id,
-      viewlet.uri,
-      viewlet.left,
-      viewlet.top,
-      viewlet.width,
-      viewlet.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) {
-      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) {
-        return [
-          ['Viewlet.create', viewlet.id],
-          ...commands,
-          ['Viewlet.show', viewlet.id],
-        ]
-      }
-      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/3d96d42/packages/renderer-worker/src/parts/ViewletModule/ViewletModule.js

@@ -1,56 +0,0 @@
-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')
-    default:
-      throw new Error(`unknown module "${moduleId}"`)
-  }
-}

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

@@ -1,47 +0,0 @@
-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 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'

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

@@ -1,123 +0,0 @@
-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) => {
-  console.log({ 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/3d96d42/packages/renderer-worker/src/parts/ViewletProblems/ViewletProblems.js

@@ -1,81 +0,0 @@
-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) => {
-  console.log({ 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]

package/static/3d96d42/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.ipc.js

@@ -1,30 +0,0 @@
-import * as ViewletQuickPick from './ViewletQuickPick.js'
-import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as LazyCommand from '../LazyCommand/LazyCommand.js'
-
-// prettier-ignore
-const Imports = {
-  FocusFirst: () => import('./ViewletQuickPickFocusFirst.js'),
-  FocusIndex: () => import('./ViewletQuickPickFocusIndex.js'),
-  FocusLast: () => import('./ViewletQuickPickFocusLast.js'),
-  FocusNext: () => import('./ViewletQuickPickFocusNext.js'),
-  FocusPrevious: () => import('./ViewletQuickPickFocusPrevious.js'),
-}
-
-// prettier-ignore
-export const Commands = {
-  'QuickPick.focusFirst': LazyCommand.create('QuickPick', Imports.FocusFirst, 'focusFirst'),
-  'QuickPick.focusIndex': LazyCommand.create('QuickPick', Imports.FocusIndex, 'focusIndex'),
-  'QuickPick.focusLast': LazyCommand.create('QuickPick', Imports.FocusLast, 'focusLast'),
-  'QuickPick.focusNext': LazyCommand.create('QuickPick', Imports.FocusNext, 'focusNext'),
-  'QuickPick.focusPrevious': LazyCommand.create('QuickPick', Imports.FocusPrevious, 'focusPrevious'),
-  'QuickPick.handleBeforeInput': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.handleBeforeInput),
-  'QuickPick.handleBlur': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.handleBlur),
-  'QuickPick.handleInput': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.handleInput),
-  'QuickPick.handleWheel': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.handleWheel),
-  'QuickPick.selectCurrentIndex': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.selectCurrentIndex),
-  'QuickPick.selectIndex': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.selectIndex),
-  'QuickPick.selectItem': Viewlet.wrapViewletCommand('QuickPick', ViewletQuickPick.selectItem),
-}
-
-export * from './ViewletQuickPick.js'