@lvce-editor/server 0.12.0 → 0.13.0

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

@@ -1,485 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Command from '../Command/Command.js'
-import * as Css from '../Css/Css.js'
-import { CancelationError } from '../Errors/CancelationError.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as NameAnonymousFunction from '../NameAnonymousFunction/NameAnonymousFunction.js'
-import * as PrettyError from '../PrettyError/PrettyError.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as SaveState from '../SaveState/SaveState.js'
-import * as ViewletStates from '../ViewletStates/ViewletStates.js'
-
-export const state = {
-  pendingModules: Object.create(null),
-}
-
-const ViewletState = {
-  Default: 0,
-  ModuleLoaded: 1,
-  ContentLoaded: 2,
-  RendererProcessViewletLoaded: 3,
-  ContentRendered: 4,
-  Appended: 5,
-}
-
-const kCreate = 'Viewlet.create'
-const kAppend = 'Viewlet.append'
-const kSendMultiple = 'Viewlet.sendMultiple'
-const kLoadModule = 'Viewlet.loadModule'
-const kLoad = 'Viewlet.load'
-const kSetBounds = 'Viewlet.setBounds'
-const kAppendViewlet = 'Viewlet.appendViewlet'
-const kHandleError = 'Viewlet.handleError'
-const kDispose = 'Viewlet.dispose'
-
-// TODO maybe wrapViewletCommand should accept module instead of id string
-// then check if instance.factory matches module -> only compare reference (int) instead of string
-// should be faster
-const wrapViewletCommand = (id, fn) => {
-  Assert.string(id)
-  Assert.fn(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
-    }
-    if (activeInstance.factory && activeInstance.factory.hasFunctionalRender) {
-      const oldState = activeInstance.state
-      const newState = await fn(oldState, ...args)
-      if (!newState) {
-        console.log({ fn })
-      }
-      Assert.object(newState)
-      // console.log({ fn, newState })
-      if (oldState === newState) {
-        return
-      }
-      const commands = render(activeInstance.factory, oldState, newState)
-      ViewletStates.setState(id, newState)
-      await RendererProcess.invoke(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands)
-    } else {
-      return fn(activeInstance.state, ...args)
-    }
-  }
-  NameAnonymousFunction.nameAnonymousFunction(wrappedViewletCommand, fn.name)
-  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 */ kSendMultiple, /* commands */ commands)
-  }
-  NameAnonymousFunction.nameAnonymousFunction(wrappedViewletCommand, fn.name)
-  return wrappedViewletCommand
-}
-
-const wrapViewletCommandLazy = (id, key, importFn) => {
-  const lazyCommand = async (...args) => {
-    const module = await importFn()
-    const fn = module[key]
-    if (typeof fn !== 'function') {
-      throw new Error(`${id}.${key} is not a function`)
-    }
-    const activeInstance = ViewletStates.getInstance(id)
-    if (!activeInstance) {
-      console.info(`cannot execute viewlet command ${id}.${fn.name}: no active instance for ${id}`)
-      return
-    }
-    if (activeInstance.factory && activeInstance.factory.hasFunctionalRender) {
-      const oldState = activeInstance.state
-      const newState = await fn(oldState, ...args)
-      if (!newState) {
-        console.log({ fn })
-      }
-      Assert.object(newState)
-      // console.log({ fn, newState })
-      if (oldState === newState) {
-        return
-      }
-      const commands = render(activeInstance.factory, oldState, newState)
-      ViewletStates.setState(id, newState)
-      await RendererProcess.invoke(/* Viewlet.sendMultiple */ kSendMultiple, /* commands */ commands)
-    } else {
-      return fn(activeInstance.state, ...args)
-    }
-  }
-  NameAnonymousFunction.nameAnonymousFunction(lazyCommand, `${id}/lazy/${key}`)
-  return lazyCommand
-}
-
-/**
- *
- * @param {()=>any} getModule
- * @returns
- */
-export const create = (getModule, id, parentId, uri, x, y, width, height) => {
-  Assert.fn(getModule)
-  Assert.string(id)
-  Assert.string(parentId)
-  Assert.string(uri)
-  Assert.number(x)
-  Assert.number(y)
-  Assert.number(width)
-  Assert.number(height)
-  return {
-    type: 0,
-    getModule,
-    id,
-    parentId,
-    uri,
-    x,
-    y,
-    width,
-    height,
-  }
-}
-
-const getInstanceSavedState = (savedState, id) => {
-  if (savedState && savedState.instances && savedState.instances[id]) {
-    return savedState.instances[id]
-  }
-  return undefined
-}
-
-const getRenderCommands = (module, oldState, newState, name = module.name) => {
-  if (Array.isArray(module.render)) {
-    const commands = []
-    for (const item of module.render) {
-      if (!item.isEqual(oldState, newState)) {
-        const command = item.apply(oldState, newState)
-        if (command[0] !== 'Viewlet.send' && command[0] !== 'Viewlet.ariaAnnounce') {
-          command.unshift('Viewlet.send', name)
-        }
-        commands.push(command)
-      }
-    }
-    return commands
-  }
-  if (module.render) {
-    return module.render(oldState, newState)
-  }
-  return []
-}
-
-const registerWrappedCommand = (moduleName, key, wrappedCommand) => {
-  if (key.startsWith(moduleName)) {
-    Command.register(key, wrappedCommand)
-  } else {
-    // TODO rename editorText to editor
-    if (moduleName === 'EditorText') {
-      Command.register(`Editor.${key}`, wrappedCommand)
-    } else {
-      Command.register(`${moduleName}.${key}`, wrappedCommand)
-    }
-  }
-}
-
-const maybeRegisterWrappedCommands = (module) => {
-  if (module.Commands) {
-    for (const [key, value] of Object.entries(module.Commands)) {
-      const wrappedCommand = wrapViewletCommand(module.name, value)
-      registerWrappedCommand(module.name, key, wrappedCommand)
-    }
-  }
-  if (module.CommandsWithSideEffects) {
-    for (const [key, value] of Object.entries(module.CommandsWithSideEffects)) {
-      const wrappedCommand = wrapViewletCommandWithSideEffect(module.name, value)
-      registerWrappedCommand(module.name, key, wrappedCommand)
-    }
-  }
-  if (module.LazyCommands) {
-    for (const [key, value] of Object.entries(module.LazyCommands)) {
-      const wrappedCommand = wrapViewletCommandLazy(module.name, key, value)
-      registerWrappedCommand(module.name, 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 (...params) => {
-        const instance = ViewletStates.getInstance(module.name)
-        const newState = await value(instance.state, ...params)
-        if (!newState) {
-          throw new Error('newState must be defined')
-        }
-        if (module.shouldApplyNewstate && !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 */ kSendMultiple, /* commands */ commands)
-      }
-      GlobalEventBus.addListener(key, handleUpdate)
-    }
-  }
-}
-
-const actuallyLoadModule = async (getModule, id) => {
-  const module = await getModule(id)
-  await RendererProcess.invoke(/* Viewlet.load */ kLoadModule, /* id */ id)
-  if (module.Css) {
-    // this is a memory leak but it is not too important
-    // because javascript modules also cannot be unloaded
-    if (Array.isArray(module.Css)) {
-      await Css.loadCssStyleSheets(module.Css)
-    } else {
-      await Css.loadCssStyleSheet(module.Css)
-    }
-  }
-  maybeRegisterWrappedCommands(module)
-  maybeRegisterEvents(module)
-  return module
-}
-
-const loadModule = (getModule, id) => {
-  if (!(id in state.pendingModules)) {
-    state.pendingModules[id] = actuallyLoadModule(getModule, id)
-  }
-  return state.pendingModules[id]
-}
-
-// TODO add lots of unit tests for this
-
-export const backgroundLoad = async ({ getModule, id, x, y, width, height, props }) => {
-  const module = await loadModule(getModule, id)
-  const viewletState = module.create(id, '', y, x, width, height)
-  const { title, uri } = await module.backgroundLoadContent(viewletState, props)
-  return {
-    title,
-    uri,
-  }
-}
-/**
- *
- * @param {{getModule:()=>any, type:number, id:string, disposed:boolean }} viewlet
- * @returns
- */
-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')
-    throw new Error('viewlet must be empty')
-  }
-  let state = ViewletState.Default
-  let module
-  try {
-    viewlet.type = 1
-    if (viewlet.disposed) {
-      return
-    }
-
-    module = await loadModule(viewlet.getModule, viewlet.id)
-    if (viewlet.disposed) {
-      return
-    }
-    state = ViewletState.ModuleLoaded
-    let x = viewlet.x
-    let y = viewlet.y
-    let width = viewlet.width
-    let height = viewlet.height
-    if (module.getPosition) {
-      const position = module.getPosition()
-      x = position.x
-      y = position.y
-      width = position.width
-      height = position.height
-    }
-
-    const viewletState = module.create(viewlet.id, viewlet.uri, x, y, width, height)
-
-    const oldVersion = viewletState.version === undefined ? undefined : ++viewletState.version
-    let instanceSavedState
-    if (restore) {
-      const stateToSave = await SaveState.getSavedState()
-      instanceSavedState = getInstanceSavedState(stateToSave, viewlet.id)
-    } else if (restoreState) {
-      instanceSavedState = restoreState
-    }
-    const args = viewlet.args || []
-    let newState = await module.loadContent(viewletState, instanceSavedState, ...args)
-    if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
-      await module.show(newState)
-    }
-    const extraCommands = []
-
-    if (module.getChildren) {
-      const children = module.getChildren(newState)
-      for (const child of children) {
-        const childModule = await loadModule(viewlet.getModule, child.id)
-        // TODO get position of child module
-        const oldState = childModule.create('', '', child.x, child.y, child.width, child.height)
-        let instanceSavedState
-        if (restore) {
-          const stateToSave = await SaveState.getSavedState()
-          instanceSavedState = getInstanceSavedState(stateToSave, child.id)
-        } else if (restoreState) {
-          instanceSavedState = restoreState
-        }
-        const newState = await childModule.loadContent(oldState, instanceSavedState)
-        const childInstance = {
-          state: newState,
-          factory: childModule,
-        }
-        ViewletStates.set(childModule.name, childInstance)
-        const commands = getRenderCommands(childModule, oldState, newState)
-        extraCommands.push([kCreate, childModule.name])
-        extraCommands.push(...commands)
-        extraCommands.push([kAppend, viewlet.id, childModule.name])
-        if (childModule.contentLoadedEffects) {
-          await childModule.contentLoadedEffects(newState)
-        }
-      }
-    }
-    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) {
-    } else {
-      await RendererProcess.invoke(/* Viewlet.loadModule */ kLoadModule, /* 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,
-      })
-    }
-    const commands = [[kCreate, viewlet.id]]
-    if (viewletState !== newState && module.contentLoaded) {
-      const additionalExtraCommands = await module.contentLoaded(newState)
-      Assert.array(additionalExtraCommands)
-      commands.push(...additionalExtraCommands)
-    }
-
-    if (module.hasFunctionalRender) {
-      const renderCommands = getRenderCommands(module, viewletState, newState)
-      commands.push(...renderCommands)
-      if (viewlet.show === false) {
-        const allCommands = [
-          ...commands,
-          ...extraCommands,
-          // ['Viewlet.show', viewlet.id],
-        ]
-        if (viewlet.setBounds !== false) {
-          allCommands.splice(1, 0, [kSetBounds, viewlet.id, x, y, width, height])
-        }
-        if (module.contentLoadedEffects) {
-          module.contentLoadedEffects(newState)
-        }
-        return allCommands
-      }
-      // console.log('else', viewlet.id, { commands })
-      commands.push(...extraCommands)
-      await RendererProcess.invoke(/* Viewlet.sendMultiple */ kSendMultiple, /* 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 && viewlet.show !== false) {
-      await RendererProcess.invoke(/* Viewlet.append */ kAppendViewlet, /* parentId */ viewlet.parentId, /* id */ viewlet.id, /* focus */ focus)
-    }
-    state = ViewletState.Appended
-
-    if (viewlet.disposed) {
-      // TODO unload the module from renderer process
-      return
-    }
-    return commands
-  } catch (error) {
-    if (error && error instanceof CancelationError) {
-      return
-    }
-    viewlet.type = 4
-    console.log({ stack: error.stack })
-    const prettyError = await PrettyError.prepare(error)
-    PrettyError.print(prettyError)
-    try {
-      if (module && module.handleError) {
-        return await module.handleError(error)
-      }
-      const commands = []
-      if (state < ViewletState.RendererProcessViewletLoaded) {
-        await RendererProcess.invoke(/* Viewlet.loadModule */ kLoadModule, /* id */ viewlet.id)
-      }
-      commands.push([kCreate, viewlet.id, viewlet.parentId])
-      commands.push([kSetBounds, viewlet.id, viewlet.x, viewlet.y, viewlet.width, viewlet.height])
-      commands.push([/* viewlet.handleError */ kHandleError, /* id */ viewlet.id, /* parentId */ viewlet.parentId, /* message */ `${error}`])
-      return commands
-    } 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 */ kDispose, /* 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, name = module.name) => {
-  return getRenderCommands(module, oldState, newState, name)
-}

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

@@ -1,38 +0,0 @@
-import * as Path from '../Path/Path.js'
-import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
-
-const mapExtToEditorType = {
-  '.png': ViewletModuleId.EditorImage,
-  '.svg': ViewletModuleId.EditorImage,
-  '.avif': ViewletModuleId.EditorImage,
-  '.gif': ViewletModuleId.EditorImage,
-  '.ico': ViewletModuleId.EditorImage,
-  '.webp': ViewletModuleId.EditorImage,
-  '.jpg': ViewletModuleId.EditorImage,
-  '.jpeg': ViewletModuleId.EditorImage,
-  '.pdf': ViewletModuleId.Pdf,
-  '.mp3': ViewletModuleId.Audio,
-  '.mp4': ViewletModuleId.Video,
-  '.ogg': ViewletModuleId.Audio,
-}
-
-export const getId = (uri) => {
-  const fileExtension = Path.fileExtension(uri)
-  const type = mapExtToEditorType[fileExtension]
-  if (type) {
-    return type
-  }
-  if (uri === 'app://keybindings') {
-    return ViewletModuleId.KeyBindings
-  }
-  if (uri.startsWith('extension-detail://')) {
-    return ViewletModuleId.ExtensionDetail
-  }
-  if (uri.startsWith('simple-browser://')) {
-    return ViewletModuleId.SimpleBrowser
-  }
-  if (uri.startsWith('diff://')) {
-    return ViewletModuleId.DiffEditor
-  }
-  return ViewletModuleId.EditorText
-}

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

@@ -1,80 +0,0 @@
-import * as ViewletModuleId from '../ViewletModuleId/ViewletModuleId.js'
-
-export const load = (moduleId) => {
-  switch (moduleId) {
-    case ViewletModuleId.ActivityBar:
-      return import('../ViewletActivityBar/ViewletActivityBar.ipc.js')
-    case ViewletModuleId.Audio:
-      return import('../ViewletAudio/ViewletAudio.ipc.js')
-    case ViewletModuleId.Clock:
-      return import('../ViewletClock/ViewletClock.ipc.js')
-    case ViewletModuleId.DebugConsole:
-      return import('../ViewletDebugConsole/ViewletDebugConsole.ipc.js')
-    case ViewletModuleId.Dialog:
-      return import('../ViewletDialog/ViewletDialog.ipc.js')
-    case ViewletModuleId.DiffEditor:
-      return import('../ViewletDiffEditor/ViewletDiffEditor.ipc.js')
-    case ViewletModuleId.EditorCompletion:
-      return import('../ViewletEditorCompletion/ViewletEditorCompletion.ipc.js')
-    case ViewletModuleId.EditorImage:
-      return import('../ViewletEditorImage/ViewletEditorImage.ipc.js')
-    case ViewletModuleId.EditorPlainText:
-      return import('../ViewletEditorPlainText/ViewletEditorPlainText.ipc.js')
-    case ViewletModuleId.EditorText:
-      return import('../ViewletEditorText/ViewletEditorText.ipc.js')
-    case ViewletModuleId.Explorer:
-      return import('../ViewletExplorer/ViewletExplorer.ipc.js')
-    case ViewletModuleId.ExtensionDetail:
-      return import('../ViewletExtensionDetail/ViewletExtensionDetail.ipc.js')
-    case ViewletModuleId.Extensions:
-      return import('../ViewletExtensions/ViewletExtensions.ipc.js')
-    case ViewletModuleId.FindWidget:
-      return import('../ViewletFindWidget/ViewletFindWidget.ipc.js')
-    case ViewletModuleId.Implementations:
-      return import('../ViewletImplementations/ViewletImplementations.ipc.js')
-    case ViewletModuleId.KeyBindings:
-      return import('../ViewletKeyBindings/ViewletKeyBindings.ipc.js')
-    case ViewletModuleId.Layout:
-      return import('../ViewletLayout/ViewletLayout.ipc.js')
-    case ViewletModuleId.Main:
-      return import('../ViewletMain/ViewletMain.ipc.js')
-    case ViewletModuleId.Noop:
-      return import('../ViewletNoop/ViewletNoop.ipc.js')
-    case ViewletModuleId.Output:
-      return import('../ViewletOutput/ViewletOutput.ipc.js')
-    case ViewletModuleId.Panel:
-      return import('../ViewletPanel/ViewletPanel.ipc.js')
-    case ViewletModuleId.Pdf:
-      return import('../ViewletPdf/ViewletPdf.ipc.js')
-    case ViewletModuleId.Problems:
-      return import('../ViewletProblems/ViewletProblems.ipc.js')
-    case ViewletModuleId.QuickPick:
-      return import('../ViewletQuickPick/ViewletQuickPick.ipc.js')
-    case ViewletModuleId.References:
-      return import('../ViewletReferences/ViewletReferences.ipc.js')
-    case ViewletModuleId.RunAndDebug:
-      return import('../ViewletRunAndDebug/ViewletRunAndDebug.ipc.js')
-    case ViewletModuleId.Search:
-      return import('../ViewletSearch/ViewletSearch.ipc.js')
-    case ViewletModuleId.SideBar:
-      return import('../ViewletSideBar/ViewletSideBar.ipc.js')
-    case ViewletModuleId.SimpleBrowser:
-      return import('../ViewletSimpleBrowser/ViewletSimpleBrowser.ipc.js')
-    case ViewletModuleId.SourceControl:
-      return import('../ViewletSourceControl/ViewletSourceControl.ipc.js')
-    case ViewletModuleId.StatusBar:
-      return import('../ViewletStatusBar/ViewletStatusBar.ipc.js')
-    case ViewletModuleId.Terminal:
-      return import('../ViewletTerminal/ViewletTerminal.ipc.js')
-    case ViewletModuleId.TitleBar:
-      return import('../ViewletTitleBar/ViewletTitleBar.ipc.js')
-    case ViewletModuleId.TitleBarButtons:
-      return import('../ViewletTitleBarButtons/ViewletTitleBarButtons.ipc.js')
-    case ViewletModuleId.TitleBarMenuBar:
-      return import('../ViewletTitleBarMenuBar/ViewletTitleBarMenuBar.ipc.js')
-    case ViewletModuleId.Video:
-      return import('../ViewletVideo/ViewletVideo.ipc.js')
-    default:
-      throw new Error(`unknown module ${moduleId}`)
-  }
-}

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

@@ -1,83 +0,0 @@
-export const ActivityBar = 'ActivityBar'
-
-export const Audio = 'Audio'
-
-export const Clock = 'Clock'
-
-export const Counter = 'Counter'
-
-export const DebugConsole = 'Debug Console'
-
-export const Dialog = 'Dialog'
-
-export const DiffEditor = 'DiffEditor'
-
-export const EditorCompletion = 'EditorCompletion'
-
-export const EditorImage = 'EditorImage'
-
-export const EditorPlainText = 'EditorPlainText'
-
-export const EditorText = 'EditorText'
-
-export const Explorer = 'Explorer'
-
-export const ExtensionDetail = 'ExtensionDetail'
-
-export const Extensions = 'Extensions'
-
-export const FindWidget = 'FindWidget'
-
-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 None = ''
-
-export const Noop = 'Noop'
-
-export const Output = 'Output'
-
-export const Panel = 'Panel'
-
-export const Pdf = 'Pdf'
-
-export const Problems = 'Problems'
-
-export const QuickPick = 'QuickPick'
-
-export const References = 'References'
-
-export const RunAndDebug = 'Run And Debug'
-
-export const Search = 'Search'
-
-export const SideBar = 'SideBar'
-
-export const SimpleBrowser = 'SimpleBrowser'
-
-export const SourceControl = 'Source Control'
-
-export const StatusBar = 'StatusBar'
-
-export const Terminal = 'Terminal'
-
-export const TitleBar = 'TitleBar'
-
-export const TitleBarButtons = 'TitleBarButtons'
-
-export const TitleBarMenuBar = 'TitleBarMenuBar'
-
-export const TodoList = 'TodoList'
-
-export const Video = 'Video'