@lvce-editor/server 0.0.28 → 0.0.31

package/static/f9b8874/packages/renderer-worker/src/parts/TestFrameWork/TestFrameWork.js

@@ -1,264 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-export { create as Locator } from './Locator.js'
-
-export const getTmpDir = async () => {
-  return `memfs://`
-}
-
-const querySelectorByText = (root, text) => {
-  let node
-  const elements = []
-  const walk = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null)
-  while ((node = walk.nextNode())) {
-    // @ts-ignore
-    if (node.nodeValue === text) {
-      elements.push(node.parentNode)
-    }
-  }
-  return elements
-}
-
-const querySelectorByCss = (selector) => {
-  return Array.from(document.querySelectorAll(selector))
-}
-
-const querySelector = (selector) => {
-  if (typeof selector !== 'string') {
-    throw new Error('selector must be of type string')
-  }
-  if (selector.startsWith('text=')) {
-    return querySelectorByText(document.body, selector.slice('text='.length))
-  }
-  if (selector.includes('text=')) {
-    const index = selector.indexOf('text=')
-    const elements = querySelectorByCss(selector.slice(0, index))
-    const text = selector.slice(index + 'text='.length)
-    return elements.flatMap((element) => {
-      return querySelectorByText(element, text)
-    })
-    // for(const element of elements)
-  }
-  if (selector.startsWith('.')) {
-    return querySelectorByCss(selector)
-  }
-  if (selector.startsWith('#')) {
-    return querySelectorByCss(selector)
-  }
-  throw new Error(`unsupported selector: ${selector}`)
-}
-
-const querySelectorWithOptions = (
-  selector,
-  { nth = -1, hasText = '' } = {}
-) => {
-  let elements = querySelector(selector)
-  if (hasText) {
-    elements = elements.filter((element) => element.textContent === hasText)
-  }
-  if (elements.length === 0) {
-    return undefined
-  }
-  if (elements.length === 1) {
-    const element = elements[0]
-    return element
-  }
-  if (nth === -1) {
-    throw new Error(`too many matching elements for ${selector}`)
-  }
-  const element = elements[nth]
-  if (!element) {
-    throw new Error(`selector not found: ${selector}`)
-  }
-  return element
-}
-
-const getKeyOptions = (rawKey) => {
-  if (rawKey.includes('+')) {
-    const parts = rawKey.split('+')
-    let ctrlKey = false
-    let altKey = false
-    let spaceKey = false
-    let key = ''
-    for (const part of parts) {
-      switch (part) {
-        case 'Control':
-          ctrlKey = true
-          break
-        case 'Space':
-          key = ' '
-          break
-        case 'Alt':
-          altKey = true
-          break
-        default:
-          key = part
-          break
-      }
-    }
-    return {
-      key,
-      ctrlKey,
-      altKey,
-    }
-  }
-  return { key: rawKey }
-}
-
-const createKeyBoard = () => {
-  return {
-    async press(key) {
-      const element = document.activeElement
-      const keyOptions = getKeyOptions(key)
-      const options = {
-        cancelable: true,
-        bubbles: true,
-        ...keyOptions,
-      }
-      ElementActions.keyDown(element, options)
-      ElementActions.keyUp(element, options)
-    },
-  }
-}
-
-const waitForReady = async () => {
-  //   const startTime = Time.getTimeStamp()
-  //   const endTime = startTime + maxTimeout
-  //   let currentTime = startTime
-  //   while (currentTime < endTime) {
-  //     const element = querySelectorWithOptions(
-  //       '.ActivityBarItem[title="Explorer"]'
-  //     )
-  //     if (element) {
-  //       return
-  //     }
-  //     await Timeout.waitForMutation(100)
-  //     currentTime = Time.getTimeStamp()
-  //   }
-  // throw new Error(`Main element not found`)
-}
-
-export const test = async (name, fn) => {
-  let _error
-  let _start
-  let _end
-  let _duration
-  try {
-    await waitForReady()
-    _start = performance.now()
-    await fn()
-    _end = performance.now()
-    _duration = `${_end - _start}ms`
-    console.info(`[test passed] ${name} in ${_duration}`)
-  } catch (error) {
-    _error = error.message
-    error.message = `Test failed: ${name}: ${error.message}`
-    console.error(error)
-  }
-  let state
-  let background
-  let text
-  if (_error) {
-    state = 'fail'
-    background = 'red'
-    text = `test failed: ${_error}`
-  } else {
-    background = 'green'
-    text = `test passed in ${_duration}`
-    state = 'pass'
-  }
-  await RendererProcess.invoke(
-    'TestFrameWork.showOverlay',
-    state,
-    background,
-    text
-  )
-}
-
-test.skip = async (id, fn) => {
-  const state = 'skip'
-  const background = 'yellow'
-  const text = `test skipped ${id}`
-  await RendererProcess.invoke(
-    'TestFrameWork.showOverlay',
-    state,
-    background,
-    text
-  )
-}
-
-const Assert = {
-  string(value, message) {
-    if (typeof value !== 'string') {
-      throw new Error(message)
-    }
-  },
-  number(value, message) {
-    if (typeof value !== 'number' || isNaN(value)) {
-      throw new Error(message)
-    }
-  },
-}
-
-export const expect = (locator) => {
-  return {
-    async checkSingleElementCondition(fnName, options) {
-      Assert.string(fnName)
-      return RendererProcess.invoke(
-        'TestFrameWork.checkSingleElementCondition',
-        locator,
-        fnName,
-        options
-      )
-    },
-    async checkMultiElementCondition(fnName, options) {
-      return RendererProcess.invoke(
-        'TestFrameWork.checkMultiElementCondition',
-        locator,
-        fnName,
-        options
-      )
-    },
-    async toBeVisible() {
-      return this.checkSingleElementCondition('toBeVisible', {})
-    },
-    async toHaveText(text) {
-      Assert.string(text, 'text must be of type string')
-      return this.checkSingleElementCondition('toHaveText', { text })
-    },
-    async toBeFocused() {
-      return this.checkSingleElementCondition('toBeFocused')
-    },
-    async toHaveCSS(key, value) {
-      return this.checkSingleElementCondition('toHaveCss', {
-        key,
-        value,
-      })
-    },
-    async toHaveAttribute(key, value) {
-      Assert.string(key, 'key must be of type string')
-      // Assert.string(value, 'value must be of type string')
-      return this.checkSingleElementCondition('toHaveAttribute', {
-        key,
-        value,
-      })
-    },
-    async toHaveClass(className) {
-      Assert.string(className, 'className must be of type string')
-      return await this.checkSingleElementCondition('toHaveClass', {
-        className,
-      })
-    },
-    async toHaveCount(count) {
-      Assert.number(count, 'count must be of type string')
-      return this.checkMultiElementCondition('toHaveCount', { count })
-    },
-    async toBeHidden() {
-      return this.checkMultiElementCondition('toBeHidden', {})
-    },
-    get not() {
-      this.negated = true
-      return this
-    },
-  }
-}

package/static/f9b8874/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentEditor.js

@@ -1,21 +0,0 @@
-import * as Command from '../Command/Command.js'
-
-export const setCursor = async (rowIndex, columnIndex) => {
-  await Command.execute('Editor.cursorSet', { rowIndex, columnIndex })
-}
-
-export const openCompletion = async () => {
-  await Command.execute('Editor.openCompletion')
-}
-
-export const openEditorContextMenu = async () => {
-  await Command.execute('Editor.handleContextMenu', 0, 0)
-}
-
-export const executeTabCompletion = async () => {
-  await Command.execute('Editor.tabCompletion')
-}
-
-export const executeBraceCompletion = async (text) => {
-  await Command.execute('Editor.braceCompletion', text)
-}

package/static/f9b8874/packages/renderer-worker/src/parts/TextDocument/TextDocument.js

@@ -1,190 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Arrays from '../Arrays/Arrays.js'
-
-export const create = (text) => {
-  const lines = text.split('\n')
-  const state = {
-    lines,
-  }
-  // TODO send to shared process somehow
-  return state
-}
-
-// TODO have function for single edit (most common, avoid one array)
-export const applyEdits = (textDocument, changes) => {
-  Assert.object(textDocument)
-  Assert.array(changes)
-  // TODO don't copy all lines (can be expensive, e.g. 10000 lines = 10000 * 64bit = 64kB on every keystroke)
-  const newLines = [...textDocument.lines]
-  for (const change of changes) {
-    const startRowIndex = change.start.rowIndex
-    const endRowIndex = change.end.rowIndex
-    const startColumnIndex = change.start.columnIndex
-    const endColumnIndex = change.end.columnIndex
-    const inserted = change.inserted
-    const deleted = change.deleted
-    Assert.number(startRowIndex)
-    Assert.number(endRowIndex)
-    Assert.number(startColumnIndex)
-    Assert.number(endColumnIndex)
-    Assert.array(inserted)
-    Assert.array(deleted)
-    if (startRowIndex === endRowIndex) {
-      if (inserted.length === 0) {
-        const line = newLines[startRowIndex]
-        const before = line.slice(0, startColumnIndex)
-        const after = line.slice(endColumnIndex)
-        newLines[startRowIndex] = before + after
-      } else if (inserted.length === 1) {
-        const line = newLines[startRowIndex]
-        let before = line.slice(0, startColumnIndex)
-        if (startColumnIndex > line.length) {
-          before += ' '.repeat(startColumnIndex - line.length)
-        }
-        const after = line.slice(endColumnIndex)
-        const text = inserted[0]
-        newLines[startRowIndex] = before + text + after
-      } else {
-        const line = newLines[startRowIndex]
-        const before = line.slice(0, startColumnIndex) + inserted[0]
-        const after = inserted.at(-1) + line.slice(endColumnIndex)
-        Arrays.splice(newLines, startRowIndex, deleted.length, [
-          before,
-          ...inserted.slice(1, -1),
-          after,
-        ])
-        // TODO only do this once after all edits, not inside loop
-        textDocument.maxLineY = Math.min(
-          textDocument.numberOfVisibleLines,
-          newLines.length
-        )
-      }
-    } else {
-      if (inserted.length === 1) {
-        const before =
-          newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0]
-        const after =
-          endRowIndex >= newLines.length
-            ? ''
-            : newLines[endRowIndex].slice(endColumnIndex)
-        console.log({ before, after })
-        Arrays.splice(newLines, startRowIndex, deleted.length, [before + after])
-      } else {
-        const before =
-          newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0]
-        const middle = inserted.slice(1, -1)
-        const after =
-          inserted.at(-1) +
-          (endRowIndex >= newLines.length
-            ? ''
-            : newLines[endRowIndex].slice(endColumnIndex))
-        console.log({ before, after })
-        Arrays.splice(newLines, startRowIndex, deleted.length, [
-          before,
-          ...middle,
-          after,
-        ])
-      }
-      // TODO only do this once after all edits, not inside loop
-      textDocument.maxLineY = Math.min(
-        textDocument.numberOfVisibleLines,
-        textDocument.lines.length
-      )
-    }
-  }
-  return newLines
-}
-
-export const getLine = (textDocument, index) => {
-  return textDocument.lines[index]
-}
-
-export const getLineLength = (textDocument, index) => {
-  return textDocument.lines[index].length
-}
-
-export const getText = (state) => {
-  return state.lines.join('\n')
-}
-const RE_WHITESPACE = /^\s+/
-
-// TODO this doesn't belong here
-export const getIndent = (line) => {
-  const whitespaceMatch = line.match(RE_WHITESPACE)
-  if (!whitespaceMatch) {
-    return ''
-  }
-  return whitespaceMatch[0]
-}
-
-// TDOO this doesn;t belong here
-export const getSelectionText = (textDocument, range) => {
-  Assert.object(textDocument)
-  // console.log(range)
-  // console.log(textDocument)
-  const startRowIndex = range.start.rowIndex
-  const startColumnIndex = range.start.columnIndex
-  const endRowIndex = Math.min(
-    range.end.rowIndex,
-    textDocument.lines.length - 1
-  )
-  const endColumnIndex = range.end.columnIndex
-
-  if (startRowIndex === endRowIndex) {
-    // console.log(startRowIndex)
-    // console.log(textDocument.lines)
-    return [
-      textDocument.lines[startRowIndex].slice(startColumnIndex, endColumnIndex),
-    ]
-  }
-  const selectedLines = [
-    textDocument.lines[startRowIndex].slice(startColumnIndex),
-    ...textDocument.lines.slice(startRowIndex + 1, endRowIndex),
-    textDocument.lines[endRowIndex].slice(0, endColumnIndex),
-  ]
-  return selectedLines
-}
-
-export const offsetAt = (textDocument, position) => {
-  let offset = 0
-  let rowIndex = 0
-  const lines = textDocument.lines
-  const max = Math.min(position.rowIndex, textDocument.lines.length)
-  while (rowIndex < max) {
-    offset += lines[rowIndex].length + 1
-    rowIndex++
-  }
-  offset += position.columnIndex
-  return offset
-}
-
-export const positionAt = (textDocument, offset) => {
-  // console.log({ textDocument, offset })
-  let rowIndex = 0
-  let columnIndex = 0
-  let currentOffset = 0
-  while (rowIndex < textDocument.lines.length && currentOffset < offset) {
-    textDocument
-    currentOffset += textDocument.lines[rowIndex].length + 1
-    rowIndex++
-  }
-
-  if (currentOffset > offset) {
-    rowIndex
-    rowIndex--
-    currentOffset -= textDocument.lines[rowIndex].length + 1
-    columnIndex = offset - currentOffset
-  } else {
-    columnIndex = currentOffset - offset
-  }
-  currentOffset
-  offset
-  // for (let i = 0; i < textDocument.lines.length; i++) {
-  // if(currentOffset)
-  // }
-  // TODO
-  return {
-    rowIndex,
-    columnIndex,
-  }
-}

package/static/f9b8874/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.ipc.js

@@ -1,23 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as TitleBarMenuBar from './TitleBarMenuBar.js'
-
-// prettier-ignore
-export const __initialize__ = () => {
-  Command.register('TitleBarMenuBar.toggleIndex', TitleBarMenuBar.toggleIndex)
-  Command.register('TitleBarMenuBar.hydrate', TitleBarMenuBar.hydrate)
-  Command.register('TitleBarMenuBar.focus', TitleBarMenuBar.focus)
-  Command.register('TitleBarMenuBar.focusIndex', TitleBarMenuBar.focusIndex)
-  Command.register('TitleBarMenuBar.focusPrevious', TitleBarMenuBar.focusPrevious)
-  Command.register('TitleBarMenuBar.focusNext', TitleBarMenuBar.focusNext)
-  Command.register('TitleBarMenuBar.closeMenu', TitleBarMenuBar.closeMenu)
-  Command.register('TitleBarMenuBar.openMenu', TitleBarMenuBar.openMenu)
-  Command.register('TitleBarMenuBar.handleKeyArrowDown', TitleBarMenuBar.handleKeyArrowDown)
-  Command.register('TitleBarMenuBar.handleKeyArrowUp', TitleBarMenuBar.handleKeyArrowUp)
-  Command.register('TitleBarMenuBar.handleKeyArrowRight', TitleBarMenuBar.handleKeyArrowRight)
-  Command.register('TitleBarMenuBar.handleKeyHome', TitleBarMenuBar.handleKeyHome)
-  Command.register('TitleBarMenuBar.handleKeyEnd', TitleBarMenuBar.handleKeyEnd)
-  Command.register('TitleBarMenuBar.handleKeySpace', TitleBarMenuBar.handleKeySpace)
-  Command.register('TitleBarMenuBar.handleKeyEnter', TitleBarMenuBar.handleKeyEnter)
-  Command.register('TitleBarMenuBar.handleKeyEscape', TitleBarMenuBar.handleKeyEscape)
-  Command.register('TitleBarMenuBar.handleKeyArrowLeft', TitleBarMenuBar.handleKeyArrowLeft)
-}

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

@@ -1,7 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as Viewlet from './Viewlet.js'
-
-export const __initialize__ = () => {
-  Command.register(2133, Viewlet.send)
-  Command.register('Viewlet.getAllStates', Viewlet.getAllStates)
-}

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

@@ -1,203 +0,0 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as Command from '../Command/Command.js'
-import * as Assert from '../Assert/Assert.js'
-
-export const state = {
-  instances: Object.create(null),
-  modules: Object.create(null),
-}
-
-/**
- * @deprecated
- */
-export const focus = (id) => {
-  // if(state.instances[id]){
-  // }
-  // console.log('focus', { id })
-  // // TODO open if it is not already open
-  // RendererProcess.send([/* viewletFocus */ 3027, /* id */ id])
-}
-// export const createOrFocus = async id=>{
-//   const instance = state.instances[id] || await create(id)
-// }
-
-/**
- * @deprecated
- */
-export const refreshInstance = async (instance, id) => {
-  if (!instance) {
-    return
-  }
-  if (instance.status === 'refreshing' || instance.status === 'disposed') {
-    return
-  }
-  instance.status = 'refreshing'
-  try {
-    await instance.factory.refresh(instance.state)
-  } catch (error) {
-    if (instance.factory.handleError) {
-      try {
-        await instance.factory.handleError(error)
-      } catch (innerError) {
-        console.error(innerError)
-        console.error(error)
-        return
-      }
-    }
-    // TODO use ErrorHandling.handleError
-    // TODO show notification maybe
-    console.error(error)
-    instance.status = 'error'
-    return
-  }
-  instance.status = 'refreshed'
-}
-
-// TODO should refresh instance?
-/**
- * @deprecated
- */
-export const refresh = async (id) => {
-  const instance = state.instances[id]
-  if (!instance) {
-    return
-  }
-  await refreshInstance(instance, id)
-}
-
-/**
- * @deprecated
- */
-export const send = (id, method, ...args) => {
-  const instance = state.instances[id]
-  if (!instance) {
-    console.info('instance disposed', { id, method, args })
-    console.info(state.instances)
-    return
-  }
-  const fn = instance.factory[method]
-  Assert.fn(fn)
-  fn(instance.state, ...args)
-}
-
-/**
- * @deprecated
- */
-export const dispose = async (id) => {
-  if (!id) {
-    console.warn('no instance to dispose')
-    return
-  }
-  const instance = state.instances[id]
-  if (!instance) {
-    console.info('instance may already be disposed')
-    return
-  }
-  // TODO status should have enum
-  instance.status = 'disposing'
-  try {
-    if (!instance.factory) {
-      throw new Error(`${id} is missing a factory function`)
-    }
-    instance.factory.dispose(instance.state)
-    await RendererProcess.invoke(
-      /* Viewlet.dispose */ 'Viewlet.dispose',
-      /* id */ id
-    )
-  } catch (error) {
-    console.error(error)
-    // TODO use Error.cause once proper stack traces are supported by chrome
-    throw new Error(`Failed to dispose viewlet ${id}: ${error}`)
-  }
-  instance.status = 'disposed'
-  delete state.instances[id]
-  delete state.modules[id]
-  await GlobalEventBus.emitEvent(`Viewlet.dispose.${id}`)
-}
-
-/**
- * @deprecated
- */
-export const replace = () => {}
-
-// 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
-export const wrapViewletCommand = (id, fn) => {
-  const wrappedViewletCommand = async (...args) => {
-    // TODO get actual focused instance
-    const activeInstance = state.instances[id]
-    if (!activeInstance) {
-      console.log(state.instances)
-      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 = activeInstance.factory.render(oldState, newState)
-      state.instances[id].state = newState
-      await RendererProcess.invoke(
-        /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
-        /* commands */ commands
-      )
-    } else {
-      return fn(activeInstance.state, ...args)
-    }
-  }
-  return wrappedViewletCommand
-}
-
-export const resize = (id, dimensions) => {
-  const instance = state.instances[id]
-  if (!instance || !instance.factory || !instance.factory.resize) {
-    console.warn('cannot resize', id)
-    return []
-  }
-  const oldState = instance.state
-  const { newState, commands } = instance.factory.resize(oldState, dimensions)
-  Assert.object(newState)
-  Assert.array(commands)
-  state.instances[id].state = newState
-  if (instance.factory.hasFunctionalRender) {
-    return instance.factory.render(oldState, newState)
-  }
-  return commands
-}
-
-export const getState = (id) => {
-  const instance = state.instances[id]
-  return instance.state
-}
-
-export const setState = async (id, newState) => {
-  const instance = state.instances[id]
-  if (instance && instance.factory && instance.factory.hasFunctionalRender) {
-    const oldState = instance.state
-    const commands = instance.factory.render(oldState, newState)
-    instance.state = newState
-    await RendererProcess.invoke(
-      /* Viewlet.sendMultiple */ 'Viewlet.sendMultiple',
-      /* commands */ commands
-    )
-  }
-}
-
-export const getAllStates = () => {
-  const states = Object.create(null)
-  for (const [key, value] of Object.entries(state.instances)) {
-    states[key] = value.state
-  }
-  return states
-}