@lvce-editor/server 0.0.28 → 0.0.31

package/static/f9b8874/packages/renderer-process/src/parts/Viewlet/TreeView.js

@@ -1,296 +0,0 @@
-import { findIndex } from '../../shared/findIndex.js'
-import * as Main from '../Main/Main.js'
-import * as Renderer from '../Renderer/Renderer.js'
-import * as RendererTree from '../Renderer/RendererTree.js'
-import * as Context from '../Context/Context.js'
-import * as Command from '../Command/Command.js'
-
-// class Dirent {
-//   constructor(name, type) {
-//     this.name = name
-//     this.type = type
-//   }
-// }
-
-// class File extends Dirent {
-//   constructor(name) {
-//     super(name, 1)
-//   }
-// }
-
-// class Directory extends Dirent {
-//   constructor(name) {
-//     super(name, 2)
-//     this.children = []
-//   }
-
-//   addChild(child) {
-//     this.children.push(child)
-//   }
-
-//   removeChild(child) {
-//     const index = this.children.indexOf(child)
-//     this.children.splice(index, 1)
-//   }
-
-//   getChild(index) {
-//     return this.children[index]
-//   }
-// }
-
-// const root = {
-//   type: 'directory',
-//   name: '',
-//   children: [],
-// }
-
-// root.children.push({
-//   type: 'file',
-//   name: 'abc.txt',
-//   children: [],
-// })
-
-// root.addChild(new Directory('b.txt'))
-
-const getAbsolutePath = (dirent) => {
-  if (!dirent) {
-    return ''
-  }
-  return getAbsolutePath(dirent.parent) + '/' + dirent.name
-}
-
-let activeTreeView
-
-const toTreeItem = (level) => (dirent) => ({
-  name: dirent.name,
-  level,
-  type: dirent.type,
-  children: [],
-  expanded: false,
-})
-
-export const create = (props) => {
-  let $Focused
-
-  const state = {
-    root: props.root,
-    items: [],
-    activeIndex: -1,
-    state: 'default', // default | loading | disposed
-  }
-
-  const internal = {
-    focusNext() {},
-    focusPrevious() {},
-    focusNextPage() {},
-    focusPreviousPage() {},
-    focusFirst() {},
-    focusLast() {},
-    focusNth() {},
-  }
-
-  // const focus = (element) => {
-  // if (activeElement) {
-  //   activeElement.removeAttribute('data-focused')
-  // }
-  // activeElement = element
-  // activeElement.dataset.focused = 'true'
-  // }
-
-  const focus = ($Element) => {
-    if ($Focused === $Element) {
-      return
-    }
-    if ($Focused) {
-      $Focused.classList.remove('Focused')
-    }
-    $Focused = $Element
-    $Element.classList.add('Focused')
-  }
-
-  const handleMouseDown = async (event) => {
-    if (event.button !== 0) {
-      return
-    }
-    const $Target = event.target
-    const index = findIndex($Viewlet, $Target)
-    if (index === -1) {
-      return
-    }
-    focus($Viewlet.children[index])
-    const dirent = state.items[index]
-    switch (dirent.type) {
-      case 'file':
-        props.handleClick(dirent)
-        break
-      case 'directory':
-        // dirent.expanded = !dirent.expanded
-        if (dirent.expanded) {
-          let endIndex = index
-          while (++endIndex < state.items.length) {
-            if (state.items[endIndex].level === dirent.level) {
-              break
-            }
-          }
-          state.items.splice(index + 1, endIndex - index)
-          // TODO only update from index of dirent
-          Renderer.render($Viewlet, RendererTree, state.items)
-        } else {
-          state.state = 'loading'
-          // TODO cancel this if tree is disposed
-          const newChildren = await props.getChildren(
-            `${state.root}/${dirent.name}`
-          )
-
-          const treeItems = newChildren.map(toTreeItem(dirent.level + 1))
-          state.items.splice(index + 1, 0, ...treeItems)
-
-          // TODO only update from index of dirent
-          Renderer.render($Viewlet, RendererTree, state.items)
-
-          // $Viewlet.insertBefore(fragment, $Viewlet.children[index + 1])
-          // if (state.state === 'disposed') {
-          //   return
-          // }
-          // state.items = newChildren.map(toTreeItem(1))
-          // state.state = 'default'
-        }
-        dirent.expanded = !dirent.expanded
-        // @ts-ignore
-        $Viewlet.children[index].ariaExpanded = dirent.expanded
-
-        break
-      default:
-        break
-    }
-    // focus(event.target)
-  }
-
-  const handleKeyDown = (event) => {
-    // if (!activeElement) {
-    //   return
-    // }
-    // switch (event.key) {
-    //   case 'ArrowUp':
-    //     if (activeElement.previousSibling) {
-    //       focus(activeElement.previousSibling)
-    //     }
-    //     break
-    //   case 'ArrowDown':
-    //     if (activeElement.nextSibling) {
-    //       focus(activeElement.nextSibling)
-    //     }
-    //     break
-    //   case ' ':
-    //   case 'Enter':
-    //     handleClick(activeElement)
-    //   default:
-    //     break
-    // }
-  }
-
-  const handleContextMenu = (event) => {
-    event.preventDefault()
-    const $Target = event.target
-    const index = findIndex($Viewlet, $Target)
-    if (index === -1) {
-      return
-    }
-    props.handleContextMenu(state.items[index], event.clientX, event.clientY)
-  }
-
-  const handleFocus = () => {
-    Context.setFocus('tree')
-  }
-
-  const $Viewlet = document.createElement('div')
-  $Viewlet.className = 'ListItems Viewlet'
-  $Viewlet.tabIndex = 0
-  $Viewlet.dataset.viewletId = 'Explorer'
-  $Viewlet.setAttribute('role', 'tree')
-  $Viewlet.ariaLabel = 'Files Explorer'
-  $Viewlet.addEventListener('keydown', handleKeyDown)
-  $Viewlet.addEventListener('mousedown', handleMouseDown)
-  $Viewlet.addEventListener('contextmenu', handleContextMenu)
-  $Viewlet.addEventListener('focus', handleFocus)
-
-  const update = async () => {
-    state.state = 'loading'
-    // TODO cancel this if tree is disposed
-    const newChildren = await props.getChildren(state.root)
-    if (state.state === 'disposed') {
-      return
-    }
-    state.items = newChildren.map(toTreeItem(1))
-    state.state = 'default'
-  }
-
-  const render = () => {
-    // TODO many objects created here, might cause garbage collection
-    // const items = state.dirents.map((dirent) => ({
-    //   name: dirent.name,
-    //   level: 1,
-    // }))
-    Renderer.render($Viewlet, RendererTree, state.items)
-    return $Viewlet
-  }
-
-  const dispose = () => {
-    state.state = 'disposed'
-  }
-
-  return {
-    update,
-    render,
-    dispose,
-    get root() {
-      return ''
-    },
-    set root(value) {
-      state.root = value
-      update().then(render)
-    },
-  }
-}
-
-// TODO separate commands from ui implementation
-
-const treeViewFocusDown = () => {
-  if (!activeTreeView) {
-    return
-  }
-  activeTreeView.focusNext()
-}
-
-const treeViewFocusUp = () => {
-  if (!activeTreeView) {
-    return
-  }
-  // TODO operate on state, don't call functions (doesn't scale)
-  activeTreeView.focusPrevious()
-}
-
-const treeViewFocusPageUp = () => {}
-
-const treeViewFocusPageDown = () => {}
-
-const treeViewCollapse = () => {
-  if (!activeTreeView) {
-    return
-  }
-  activeTreeView.collapse()
-}
-
-const treeViewCollapseAll = () => {
-  if (!activeTreeView) {
-    return
-  }
-  activeTreeView.collapseAll()
-}
-
-export const __initialize__ = () => {
-  Command.register(3000, treeViewFocusDown)
-  Command.register(3001, treeViewFocusUp)
-  Command.register(3002, treeViewCollapse)
-  Command.register(3003, treeViewCollapseAll)
-}

package/static/f9b8874/packages/renderer-process/src/parts/Viewlet/TreeViewClass.js

@@ -1,30 +0,0 @@
-class TreeView {
-  constructor(props) {
-    this.props = props
-    this.$Viewlet = document.createElement('div')
-    this.$Viewlet.className = 'ListItems Viewlet'
-    this.$Viewlet.tabIndex = 0
-    this.$Viewlet.dataset.viewletId = 'Explorer'
-    this.$Viewlet.setAttribute('role', 'tree')
-    this.$Viewlet.addEventListener('keydown', this.handleKeyDown.bind(this))
-    this.$Viewlet.addEventListener('mousedown', this.handleMouseDown.bind(this))
-    this.$Viewlet.addEventListener(
-      'contextmenu',
-      this.handleContextMenu.bind(this)
-    )
-  }
-
-  handleKeyDown() {}
-
-  handleMouseDown() {
-    const index = -1
-    this.props.handleClick(index)
-  }
-
-  handleContextMenu() {
-    const index = -1
-    this.props.handleContextMenu(index)
-  }
-}
-
-export const createTreeView = () => new TreeView()

package/static/f9b8874/packages/renderer-process/src/parts/Viewlet/Viewlet.js

@@ -1,222 +0,0 @@
-import * as ActiveViewlet from './ActiveViewlet.js'
-
-export const state = {
-  instances: Object.create(null),
-  currentSideBarView: undefined,
-  currentPanelView: undefined,
-  modules: Object.create(null),
-}
-
-const get = (id) => {
-  switch (id) {
-    case 'Explorer':
-      return import('./ViewletExplorer.js')
-    case 'Run and Debug':
-      return import('./ViewletRunAndDebug.js')
-    case 'Search':
-      return import('./ViewletSearch.js')
-    case 'Source Control':
-      return import('./ViewletSourceControl.js')
-    case 'Terminal':
-      return import('./ViewletTerminal.js')
-    case 'Extensions':
-      return import('./ViewletExtensions.js')
-    case 'Debug Console':
-      return import('./ViewletDebugConsole.js')
-    case 'Output':
-      return import('./ViewletOutput.js')
-    case 'Problems':
-      return import('./ViewletProblems.js')
-    case 'Empty':
-      return import('./ViewletEmpty.js')
-    case 'EditorText':
-      return import('./ViewletEditorText.js')
-    case 'EditorPlainText':
-      return import('./ViewletEditorPlainText.js')
-    case 'EditorImage':
-      return import('./ViewletEditorImage.js')
-    case 'Clock':
-      return import('./ViewletClock.js')
-    case 'SideBar':
-      return import('./ViewletSideBar.js')
-    case 'Panel':
-      return import('./ViewletPanel.js')
-    case 'ActivityBar':
-      return import('./ViewletActivityBar.js')
-    case 'ImagePreview':
-      return import('../ImagePreview/ImagePreview.js')
-    case 'QuickPick':
-      return import('./ViewletQuickPick.js')
-    case 'StatusBar':
-      return import('./ViewletStatusBar.js')
-    case 'TitleBar':
-      return import('./ViewletTitleBar.js')
-    case 'Main':
-      return import('./ViewletMain.js')
-    case 'EditorCompletion':
-      return import('./ViewletEditorCompletion.js')
-    case 'References':
-      return import('./ViewletReferences.js')
-    case 'Implementations':
-      return import('./ViewletImplementations.js')
-    default:
-      throw new Error(`unknown viewlet ${id}`)
-  }
-}
-
-export const mount = ($Parent, state) => {
-  while ($Parent.firstChild) {
-    $Parent.firstChild.remove()
-  }
-  $Parent.append(state.$Viewlet)
-}
-
-export const load = async (id, ...args) => {
-  const module = await get(id)
-  state.modules[id] = module
-  state.instances[id] = {
-    state: module.create(...args),
-    factory: module,
-  }
-}
-
-export const invoke = (viewletId, method, ...args) => {
-  const instance = state.instances[viewletId]
-  if (!instance) {
-    console.warn(`viewlet instance ${viewletId} not found`)
-    return
-  }
-  if (typeof instance.factory[method] !== 'function') {
-    console.warn(`method ${method} in ${viewletId} not implemented`)
-    console.log(instance.factory)
-    return
-  }
-  return instance.factory[method](instance.state, ...args)
-}
-
-export const focus = (viewletId) => {
-  const instance = state.instances[viewletId]
-  if (instance && instance.factory && instance.factory.focus) {
-    instance.factory.focus(instance.state)
-  } else {
-    // TODO push focusContext
-  }
-}
-
-/**
- * @deprecated
- */
-export const refresh = (viewletId, viewletContext) => {
-  console.log('REFRESH', viewletId)
-  const instance = state.instances[viewletId]
-  if (instance) {
-    instance.factory.refresh(instance.state, viewletContext)
-  } else {
-    // console.warn('no instance yet of ' + viewletId)
-    state.refreshContext[viewletId] = viewletContext
-  }
-}
-
-// TODO handle error when viewlet creation fails
-
-// TODO remove send -> use invoke instead
-export const send = (viewletId, method, ...args) => {
-  const instance = state.instances[viewletId]
-  if (instance) {
-    instance.factory[method](...args)
-  } else {
-    // TODO
-    console.warn('instance not present')
-  }
-}
-
-export const sendMultiple = (commands) => {
-  for (const command of commands) {
-    const [_, viewletId, method, ...args] = command
-    invoke(viewletId, method, ...args)
-  }
-}
-
-/**
- * @deprecated
- */
-export const dispose = (id) => {
-  ActiveViewlet.deleteState(id)
-  const instance = state.instances[id]
-  try {
-    instance.factory.dispose(instance.state)
-    if (instance.state.$Viewlet && instance.state.$Viewlet.isConnected) {
-      instance.state.$Viewlet.remove()
-    }
-  } catch (error) {
-    console.error(error)
-  }
-  delete state.instances[id]
-}
-
-/**
- * @deprecated
- */
-export const replace = () => {
-  // TODO maybe check if viewlet can be recycled
-}
-
-export const handleError = (id, parentId, message) => {
-  console.log(`[viewlet-error] ${id}: ${message}`)
-  const instance = state.instances[id]
-  if (instance && instance.factory && instance.factory.handleError) {
-    instance.factory.handleError(instance.state, message)
-    return
-  }
-  // TODO error should bubble up to until highest possible component
-  const parentInstance = state.instances[parentId]
-  if (
-    parentInstance &&
-    parentInstance.factory &&
-    parentInstance.factory.handleError
-  ) {
-    parentInstance.factory.handleError(instance.state, message)
-    console.log('parent instance', parentInstance)
-    return
-  }
-  if (
-    instance &&
-    instance.state.$Viewlet &&
-    instance.state.$Viewlet.isConnected
-  ) {
-    instance.state.$Viewlet.textContent = `${message}`
-  }
-}
-
-/**
- * @deprecated
- */
-export const hydrate = (id, ...args) => {
-  const module = state.modules[id]
-  const instanceState = module.create(...args)
-  state.instances[id] = { state: instanceState, factory: module }
-}
-
-/**
- * @deprecated
- */
-export const appendViewlet = (parentId, childId, focus) => {
-  if (parentId === 'Widget') {
-    // TODO
-    return
-  }
-  const parentInstanceState = state.instances[parentId] // TODO must ensure that parent is already created
-  const parentModule = parentInstanceState.factory
-  const childInstance = state.instances[childId]
-  if (!childInstance) {
-    throw new Error('child instance must be defined to be appended to parent')
-  }
-  parentModule.appendViewlet(
-    parentInstanceState.state,
-    childInstance.factory.name,
-    childInstance.state.$Viewlet
-  )
-  if (focus) {
-    childInstance.factory.focus(childInstance.state)
-  }
-}