@lvce-editor/server 0.11.7 → 0.11.8

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

@@ -1,322 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as ViewletModule from '../ViewletModule/ViewletModule.js'
-
-export const state = {
-  instances: Object.create(null),
-  currentSideBarView: undefined,
-  currentPanelView: undefined,
-  modules: Object.create(null),
-}
-
-export const mount = ($Parent, state) => {
-  $Parent.replaceChildren(state.$Viewlet)
-}
-
-export const create = (id) => {
-  const module = state.modules[id]
-  if (state.instances[id] && state.instances[id].state.$Viewlet.isConnected) {
-    state.instances[id].state.$Viewlet.remove()
-  }
-  state.instances[id] = {
-    state: module.create(),
-    factory: module,
-  }
-}
-
-export const loadModule = async (id) => {
-  const module = await ViewletModule.load(id)
-  state.modules[id] = 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`)
-    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) => {
-  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')
-  }
-}
-
-const specialIds = [
-  'TitleBar',
-  'SideBar',
-  'Main',
-  'ActivityBar',
-  'StatusBar',
-  'Panel',
-]
-
-const isSpecial = (id) => {
-  return specialIds.includes(id)
-}
-
-const createPlaceholder = (viewletId, parentId, top, left, width, height) => {
-  const $PlaceHolder = document.createElement('div')
-  $PlaceHolder.className = `Viewlet ${viewletId}`
-  $PlaceHolder.style.top = `${top}px`
-  $PlaceHolder.style.left = `${left}px`
-  $PlaceHolder.style.width = `${width}px`
-  $PlaceHolder.style.height = `${height}px`
-  if (isSpecial(viewletId)) {
-    $PlaceHolder.id = viewletId
-  }
-  const parentInstance = state.instances[parentId]
-  const $Parent = parentInstance.state.$Viewlet
-  $Parent.append($PlaceHolder)
-  state.instances[viewletId] = {
-    state: {
-      $Viewlet: $PlaceHolder,
-    },
-  }
-}
-
-// TODO this code is bad
-export const sendMultiple = (commands) => {
-  for (const command of commands) {
-    const [_, viewletId, method, ...args] = command
-    if (_ === 'Viewlet.ariaAnnounce') {
-      ariaAnnounce(viewletId)
-    } else if (_ === 'Viewlet.setBounds') {
-      setBounds(viewletId, method, ...args)
-    } else if (_ === 'Viewlet.create') {
-      create(viewletId)
-    } else if (_ === 'Viewlet.append') {
-      append(viewletId, method, ...args)
-    } else if (_ === 'Viewlet.dispose') {
-      dispose(viewletId)
-    } else if (_ === 'Viewlet.createPlaceholder') {
-      createPlaceholder(viewletId, method, ...args)
-    } else if (_ === 'Viewlet.handleError') {
-      handleError(viewletId, method, ...args)
-    } else if (_ === 'Viewlet.focus') {
-      focus(viewletId)
-    } else if (_ === 'Viewlet.appendViewlet') {
-      appendViewlet(viewletId, method, ...args)
-    } else {
-      invoke(viewletId, method, ...args)
-    }
-  }
-}
-
-export const dispose = (id) => {
-  try {
-    Assert.string(id)
-    const instance = state.instances[id]
-    if (!instance) {
-      console.warn(`viewlet instance ${id} not found and cannot be disposed`)
-      return
-    }
-    if (instance.factory.dispose) {
-      instance.factory.dispose(instance.state)
-    }
-    if (instance.state.$Viewlet && instance.state.$Viewlet.isConnected) {
-      instance.state.$Viewlet.remove()
-    }
-    delete state.instances[id]
-  } catch (error) {
-    throw new Error(`Failed to dispose ${id}`)
-  }
-}
-
-/**
- * @deprecated
- */
-export const replace = () => {
-  // TODO maybe check if viewlet can be recycled
-}
-
-export const handleError = (id, parentId, message) => {
-  console.info(`[viewlet-error] ${id}: ${message}`)
-  const instance = state.instances[id]
-  if (instance && instance.state.$Viewlet.isConnected) {
-    instance.state.$Viewlet.remove()
-  }
-  if (instance && instance.factory && instance.factory.handleError) {
-    instance.factory.handleError(instance.state, message)
-    return
-  }
-  if (instance && instance.state.$Viewlet) {
-    instance.state.$Viewlet.textContent = `${message}`
-  }
-  // 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)
-    return
-  }
-}
-
-/**
- * @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.factory.focus(childInstance.state)
-  }
-}
-
-const ariaAnnounce = async (message) => {
-  const AriaAlert = await import('../AriaAlert/AriaAlert.js')
-  AriaAlert.alert(message)
-}
-
-const append = (parentId, childId, referenceNodes) => {
-  const parentInstance = state.instances[parentId]
-  const $Parent = parentInstance.state.$Viewlet
-  const childInstance = state.instances[childId]
-  const $Child = childInstance.state.$Viewlet
-  if (referenceNodes) {
-    // TODO this might be too inefficient
-    if (childId === referenceNodes[0]) {
-      $Parent.prepend($Child)
-      return
-    }
-    for (let i = 0; i < referenceNodes.length; i++) {
-      const id = referenceNodes[i]
-      if (id === childId) {
-        for (let j = i - 1; j >= 0; j--) {
-          const beforeId = referenceNodes[j]
-          if (state.instances[beforeId]) {
-            const $ReferenceNode = state.instances[beforeId].state.$Viewlet
-            $ReferenceNode.after($Child)
-            return
-          }
-        }
-        for (let j = i + 1; j < referenceNodes.length; j++) {
-          const afterId = referenceNodes[j]
-          if (state.instances[afterId]) {
-            const $ReferenceNode = state.instances[afterId].state.$Viewlet
-            $ReferenceNode.before($Child)
-            return
-          }
-        }
-      }
-    }
-    $Parent.append($Child)
-  } else {
-    $Parent.append($Child)
-  }
-}
-
-const appendToBody = (childId) => {
-  const $Parent = document.body
-  const childInstance = state.instances[childId]
-  const $Child = childInstance.state.$Viewlet
-  $Parent.append($Child)
-}
-
-const getFn = (command) => {
-  switch (command) {
-    case 'Viewlet.create':
-      return create
-    case 'Viewlet.send':
-      return invoke
-    case 'Viewlet.show':
-      return show
-    case 'Viewlet.dispose':
-      return dispose
-    case 'Viewlet.setBounds':
-      return setBounds
-    case 'Viewlet.ariaAnnounce':
-      return ariaAnnounce
-    case 'Viewlet.append':
-      return append
-    case 'Viewlet.appendToBody':
-      return appendToBody
-    case 'Viewlet.createPlaceholder':
-      return createPlaceholder
-    case 'Viewlet.focus':
-      return focus
-    case 'Viewlet.appendViewlet':
-      return appendViewlet
-    default:
-      throw new Error(`unknown command ${command}`)
-  }
-}
-
-export const executeCommands = (commands) => {
-  for (const [command, ...args] of commands) {
-    const fn = getFn(command)
-    fn(...args)
-  }
-}
-
-export const show = (id) => {
-  const instance = state.instances[id]
-  const $Viewlet = instance.state.$Viewlet
-  const $Workbench = document.getElementById('Workbench')
-  $Workbench.append($Viewlet)
-  if (instance.factory.focus) {
-    instance.factory.focus(instance.state)
-  }
-}
-
-export const setBounds = (id, left, top, width, height) => {
-  const instance = state.instances[id]
-  if (!instance) {
-    return
-  }
-  const $Viewlet = instance.state.$Viewlet
-  $Viewlet.style.left = `${left}px`
-  $Viewlet.style.top = `${top}px`
-  $Viewlet.style.width = `${width}px`
-  $Viewlet.style.height = `${height}px`
-}

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

@@ -1,207 +0,0 @@
-import * as AriaRoles from '../AriaRoles/AriaRoles.js'
-import * as Assert from '../Assert/Assert.js'
-import * as Focus from '../Focus/Focus.js'
-import * as RendererWorker from '../RendererWorker/RendererWorker.js'
-import * as WheelEventType from '../WheelEventType/WheelEventType.js'
-
-const handleWheel = (event) => {
-  switch (event.deltaMode) {
-    case WheelEventType.DomDeltaLine:
-      RendererWorker.send(
-        /* ViewletExtensions.handleWheel */ 873,
-        /* deltaY */ event.deltaY
-      )
-      break
-    case WheelEventType.DomDeltaPixel:
-      RendererWorker.send(
-        /* ViewletExtensions.handleWheel */ 873,
-        /* deltaY */ event.deltaY
-      )
-      break
-    default:
-      break
-  }
-}
-
-const handleContextMenu = (event) => {
-  event.preventDefault()
-  const $Target = event.target
-  // const index = FindIndex.findIndex(state.$Extensions, $Target)
-  // if (index === -1) {
-  //   return
-  // }
-  // const extension = state.extensions[index]
-  // RendererWorker.send(
-  //   /* Extensions.handleContextMenu */ 'Extensions.handleContextMenu',
-  //   /* x */ event.clientX,
-  //   /* y */ event.clientY,
-  //   /* extensionId */ extension.id
-  // )
-}
-
-const getNodeIndex = ($Node) => {
-  let index = 0
-  while (($Node = $Node.previousElementSibling)) {
-    index++
-  }
-  return index
-}
-
-const handleFocus = (event) => {
-  const $Target = event.target
-  $Target.classList.add('FocusOutline')
-  // TODO maybe have one focus listener inside Viewlet.js instead of each viewlet
-  Focus.setFocus('ViewletList')
-
-  // RendererWorker.send(/* ViewletExtensions.focusIndex */ 868, /* index */ -1)
-}
-
-const handleScrollBarMouseDown = (event) => {
-  const $Target = event.target
-  if ($Target.className === 'ScrollBarThumb') {
-    window.addEventListener('mousemove', handleScrollBarThumbMouseMove)
-    window.addEventListener('mouseup', handleScrollBarThumbMouseUp)
-  } else {
-    const y = event.clientY
-    RendererWorker.send(/* ViewletList.handleScrollBarClick */ 878, /* y */ y)
-  }
-}
-
-const handleScrollBarThumbMouseMove = (event) => {
-  const y = event.clientY
-  RendererWorker.send(/* ViewletList.handleScrollBarMouseMove */ 877, /* y */ y)
-}
-
-const handleScrollBarThumbMouseUp = () => {
-  window.removeEventListener('mousemove', handleScrollBarThumbMouseMove)
-  window.removeEventListener('mouseup', handleScrollBarThumbMouseUp)
-}
-
-export const create = ({ create$ListItem, render$ListItem, handleClick }) => {
-  const $List = document.createElement('div')
-  $List.className = 'ExtensionList'
-  $List.tabIndex = 0
-  $List.ariaLabel = 'Extensions'
-  // @ts-ignore
-  $List.role = AriaRoles.List
-  $List.oncontextmenu = handleContextMenu
-  $List.onclick = handleClick
-  $List.onfocus = handleFocus
-
-  const $ScrollBarThumb = document.createElement('div')
-  $ScrollBarThumb.className = 'ScrollBarThumb'
-
-  const $ScrollBar = document.createElement('div')
-  $ScrollBar.className = 'ScrollBarSmall'
-  $ScrollBar.onmousedown = handleScrollBarMouseDown
-  $ScrollBar.append($ScrollBarThumb)
-
-  const $Viewlet = document.createElement('div')
-  $Viewlet.className = 'Viewlet List'
-  $Viewlet.append($List, $ScrollBar)
-  $Viewlet.addEventListener('wheel', handleWheel, { passive: true })
-
-  return {
-    $Viewlet,
-    $List,
-    $ScrollBarThumb,
-    create$ListItem,
-    render$ListItem,
-  }
-}
-
-// TODO possibly use aria active descendant instead
-export const setFocusedIndex = (state, oldFocusedIndex, newFocusedIndex) => {
-  Assert.object(state)
-  Assert.number(oldFocusedIndex)
-  Assert.number(newFocusedIndex)
-  const { $List } = state
-  if (oldFocusedIndex !== -1) {
-    $List.children[oldFocusedIndex].classList.remove('Focused')
-  }
-  if (newFocusedIndex === -1) {
-    $List.removeAttribute('aria-activedescendant')
-    $List.classList.add('FocusOutline')
-  } else {
-    $List.setAttribute(
-      'aria-activedescendant',
-      $List.children[newFocusedIndex].id
-    )
-    $List.classList.remove('FocusOutline')
-    $List.children[newFocusedIndex].classList.add('Focused')
-  }
-}
-
-const render$ListLess = ({
-  $List,
-  create$ListItem,
-  render$ListItem,
-  items,
-}) => {
-  for (let i = 0; i < $List.children.length; i++) {
-    render$ListItem($List.children[i], items[i])
-  }
-  const fragment = document.createDocumentFragment()
-  for (let i = $List.children.length; i < items.length; i++) {
-    const $Extension = create$ListItem()
-    render$ListItem($Extension, items[i])
-    fragment.append($Extension)
-  }
-  $List.append(fragment)
-}
-
-const render$ListEqual = ({ $List, render$ListItem, items }) => {
-  for (let i = 0; i < items.length; i++) {
-    render$ListItem($List.children[i], items[i])
-  }
-}
-
-const render$ListMore = ({ $List, render$ListItem, items }) => {
-  for (let i = 0; i < items.length; i++) {
-    render$ListItem($List.children[i], items[i])
-  }
-  const diff = $List.children.length - items.length
-  for (let i = 0; i < diff; i++) {
-    $List.lastChild.remove()
-  }
-}
-
-const render$List = (state) => {
-  const { $List, items } = state
-  if ($List.children.length < items.length) {
-    render$ListLess(state)
-  } else if ($List.children.length === items.length) {
-    render$ListEqual(state)
-  } else {
-    render$ListMore(state)
-  }
-}
-
-export const setNegativeMargin = (state, negativeMargin) => {
-  const { $List } = state
-  $List.style.top = `${negativeMargin}px`
-  // Assert.number(negativeMargin)
-  // const { $NegativeMargin } = state
-  // $NegativeMargin.style.marginTop = `${negativeMargin}px`
-}
-
-// TODO a more efficient approach would be
-export const setItems = (state, items) => {
-  Assert.object(state)
-  Assert.array(items)
-  state.items = items
-  render$List(state)
-}
-
-export const dispose = (state) => {}
-
-export const setContentHeight = (state, height) => {
-  const { $ExtensionList } = state
-  $ExtensionList.style.height = `${height}px`
-}
-
-export const setScrollBar = (state, scrollBarY, scrollBarHeight) => {
-  const { $ScrollBarThumb } = state
-  $ScrollBarThumb.style.top = `${scrollBarY}px`
-  $ScrollBarThumb.style.height = `${scrollBarHeight}px`
-}

package/static/ba33e2b/packages/renderer-process/src/parts/ViewletDiffEditor/ViewletDiffEditor.js

@@ -1,78 +0,0 @@
-import * as ViewletSash from '../ViewletSash/ViewletSash.js'
-import * as ViewletDiffEditorEvents from './ViewletDiffEditorEvents.js'
-
-export const create = () => {
-  const $ContentLeft = document.createElement('div')
-  $ContentLeft.className = 'DiffEditorContentLeft'
-  const $ContentRight = document.createElement('div')
-  $ContentRight.className = 'DiffEditorContentRight'
-
-  const $Sash = ViewletSash.create()
-
-  const $ScrollBarThumb = document.createElement('div')
-  $ScrollBarThumb.className = 'ScrollBarThumb'
-
-  const $ScrollBar = document.createElement('div')
-  $ScrollBar.className = 'ScrollBar'
-  $ScrollBar.onpointerdown = ViewletDiffEditorEvents.handleScrollBarPointerDown
-  $ScrollBar.append($ScrollBarThumb)
-
-  const $Viewlet = document.createElement('div')
-  $Viewlet.className = 'Viewlet DiffEditor'
-  $Viewlet.append($ContentLeft, $Sash, $ContentRight, $ScrollBar)
-  $Viewlet.addEventListener('wheel', ViewletDiffEditorEvents.handleWheel, {
-    passive: true,
-  })
-
-  return {
-    $Viewlet,
-    $ContentLeft,
-    $ContentRight,
-    $ScrollBar,
-    $ScrollBarThumb,
-  }
-}
-
-const create$Line = (line) => {
-  const $Line = document.createElement('div')
-  $Line.className = 'EditorRow'
-  $Line.textContent = line
-  return $Line
-}
-
-const setContent = ($Content, lines) => {
-  $Content.replaceChildren(...lines.map(create$Line))
-}
-
-export const setContentLeft = (state, lines) => {
-  const { $ContentLeft } = state
-  setContent($ContentLeft, lines)
-}
-
-export const setContentRight = (state, lines) => {
-  const { $ContentRight } = state
-  setContent($ContentRight, lines)
-}
-
-export const setChanges = (state, changes) => {
-  const { $ContentLeft, $ContentRight } = state
-  const { changesLeft, changesRight } = changes
-  for (const change of changesLeft) {
-    if (change.type === 'delete') {
-      const $Row = $ContentLeft.children[change.index]
-      if ($Row) {
-        $Row.classList.add('Deletion')
-      }
-    }
-  }
-  for (const change of changesRight) {
-    if (change.type === 'insert') {
-      const $Row = $ContentRight.children[change.index]
-      if ($Row) {
-        $Row.classList.add('Insertion')
-      }
-    }
-  }
-}
-
-export * from '../ViewletScrollable/ViewletScrollable.js'

package/static/ba33e2b/packages/renderer-process/src/parts/ViewletEditorCompletion/ViewletEditorCompletion.js

@@ -1,100 +0,0 @@
-import * as AriaRoles from '../AriaRoles/AriaRoles.js'
-import * as Focus from '../Focus/Focus.js'
-import * as Label from '../Label/Label.js'
-import * as Widget from '../Widget/Widget.js'
-import * as ViewletEditorCompletionEvents from './ViewletEditorCompletionEvents.js'
-
-const create$CompletionItem = (item, index) => {
-  const $CompletionItemText = Label.create(item.label)
-
-  const $Icon = document.createElement('div')
-  $Icon.className = 'ColoredMaskIcon'
-  $Icon.style.webkitMaskImage = `url('${item.icon}')`
-
-  const $CompletionItem = document.createElement('div')
-  // @ts-ignore
-  $CompletionItem.role = AriaRoles.Option
-  $CompletionItem.id = `CompletionItem-${index}`
-  $CompletionItem.className = `EditorCompletionItem`
-  $CompletionItem.append($Icon, $CompletionItemText)
-  return $CompletionItem
-}
-
-export const create = () => {
-  // TODO recycle nodes
-  const $Viewlet = document.createElement('div')
-  $Viewlet.className = 'Viewlet EditorCompletion'
-  $Viewlet.id = 'Completions'
-  // @ts-ignore
-  $Viewlet.role = AriaRoles.ListBox
-  $Viewlet.ariaLabel = 'Suggest'
-  $Viewlet.onmousedown = ViewletEditorCompletionEvents.handleMousedown
-  $Viewlet.addEventListener(
-    'wheel',
-    ViewletEditorCompletionEvents.handleWheel,
-    {
-      passive: true,
-    }
-  )
-  return {
-    $Viewlet,
-  }
-}
-
-// TODO show should be passed active cursor position
-// this would make this function easier to test as it would avoid dependency on globals of other files
-
-export const setItems = (state, items, reason, focusedIndex) => {
-  const { $Viewlet } = state
-  Focus.setAdditionalFocus('editorCompletions')
-  if (items.length === 0) {
-    if (reason === /* automatically */ 0) {
-      return
-    }
-    $Viewlet.textContent = 'No Results'
-    Widget.append($Viewlet)
-    return
-  }
-  // TODO recycle nodes
-  $Viewlet.replaceChildren(...items.map(create$CompletionItem))
-  Widget.append($Viewlet)
-  setFocusedIndex(state, 0, 0)
-  // TODO set right aria attributes on $EditorInput
-}
-
-export const dispose = (state) => {
-  Widget.remove(state.$Viewlet)
-  // state.$EditorInput.removeAttribute('aria-activedescendant')
-  Focus.removeAdditionalFocus('editorCompletions')
-}
-
-// TODO should pass maybe oldIndex to be removed
-// but keeping $ActiveItem in state also works
-export const setFocusedIndex = (state, oldIndex, newIndex) => {
-  const $Viewlet = state.$Viewlet
-  if (oldIndex !== -1) {
-    const $OldItem = $Viewlet.children[oldIndex]
-    $OldItem.classList.remove('Focused')
-  }
-  if (newIndex !== -1) {
-    const $NewItem = $Viewlet.children[newIndex]
-    $NewItem.classList.add('Focused')
-  }
-  Focus.setAdditionalFocus('editorCompletions')
-  // state.$EditorInput.setAttribute('aria-activedescendant', $NewItem.id) // TODO use idl once supported
-}
-
-export const showLoading = (state, x, y) => {
-  const { $Viewlet } = state
-  $Viewlet.style.transform = `translate(${x}px, ${y}px)`
-  const $Loading = document.createElement('div')
-  $Loading.textContent = 'Loading'
-  $Viewlet.append($Loading)
-  Widget.append($Viewlet)
-  Focus.setAdditionalFocus('editorCompletions')
-}
-
-export const handleError = (state, error) => {
-  const { $Viewlet } = state
-  $Viewlet.textContent = `${error}`
-}