@lvce-editor/server 0.11.2 → 0.11.3

package/static/96d5271/packages/renderer-worker/src/parts/SharedProcess/SharedProcess.js

@@ -1,141 +0,0 @@
-/* istanbul ignore file */
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
-import * as PlatformType from '../PlatformType/PlatformType.js'
-import * as SharedProcessIpc from '../SharedProcessIpc/SharedProcessIpc.js'
-
-// TODO duplicate code with platform module
-/**
- * @returns {'electron'|'remote'|'web'|'test'}
- */
-const getPlatform = () => {
-  // @ts-ignore
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-ignore
-    return PLATFORM
-  }
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return 'test'
-  }
-  if (typeof location !== 'undefined' && location.search === '?web') {
-    return PlatformType.Web
-  }
-  if (
-    typeof location !== 'undefined' &&
-    location.search.includes('platform=electron')
-  ) {
-    return PlatformType.Electron
-  }
-  return PlatformType.Remote
-}
-
-const platform = getPlatform() // TODO tree-shake this out in production
-
-const constructError = (message) => {
-  if (message.startsWith('Error: ')) {
-    return new Error(message.slice('Error: '.length))
-  }
-  if (message.startsWith('TypeError: ')) {
-    return new TypeError(message.slice('TypeError: '.length))
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return new SyntaxError(message.slice('SyntaxError: '.length))
-  }
-  return new Error(message)
-}
-
-const preparePrettyError = (rawError) => {
-  const error = constructError(rawError.message)
-  if (rawError.data && rawError.data.stack) {
-    // @ts-ignore
-    error.originalStack = rawError.data.stack
-  }
-  if (rawError.data && rawError.data.codeFrame) {
-    // @ts-ignore
-    error.originalCodeFrame = rawError.data.codeFrame
-  }
-  if (rawError.data && rawError.data.category) {
-    // @ts-ignore
-    error.category = rawError.data.category
-  }
-  if (rawError.data && rawError.data.code) {
-    // @ts-ignore
-    error.code = rawError.data.code
-  }
-  if (rawError.data && rawError.data.stderr) {
-    // @ts-ignore
-    error.stderr = rawError.data.stderr
-  }
-  return error
-}
-
-export const state = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-}
-
-export const handleMessageFromSharedProcess = async (message) => {
-  if (message.method) {
-    const result = await Command.execute(message.method, ...message.params)
-    if (message.id) {
-      state.send({
-        jsonrpc: JsonRpcVersion.Two,
-        id: message.id,
-        result,
-      })
-    }
-  } else {
-    Callback.resolve(message.id, message)
-  }
-}
-
-const getIpcMethod = () => {
-  switch (platform) {
-    case 'web':
-    case 'remote':
-      return IpcParentType.WebSocket
-    case 'electron':
-      return IpcParentType.ElectronMessagePort
-    default:
-      throw new Error('unsupported platform')
-  }
-}
-
-export const listen = async () => {
-  const ipcMethod = await getIpcMethod()
-  const ipc = await SharedProcessIpc.listen(ipcMethod)
-  ipc.onmessage = handleMessageFromSharedProcess
-  state.ipc = ipc
-}
-
-export const send = (method, ...params) => {
-  if (platform === 'web') {
-    console.warn('SharedProcess is not available on web')
-    return
-  }
-  JsonRpc.send(state.ipc, method, ...params)
-}
-
-export const invoke = async (method, ...params) => {
-  if (platform === 'web') {
-    console.warn('SharedProcess is not available on web')
-    return
-  }
-  const responseMessage = await JsonRpc.invoke(state.ipc, method, ...params)
-  if (responseMessage.error) {
-    const prettyError = preparePrettyError(responseMessage.error)
-    throw prettyError
-  }
-  return responseMessage.result
-}
-
-export const dispose = () => {
-  state.dispose()
-}
-
-// TODO when shared process crashes / connection is lost: reconnect or show notification

package/static/96d5271/packages/renderer-worker/src/parts/SourceControl/SourceControl.ipc.js

@@ -1,7 +0,0 @@
-import * as SourceControl from './SourceControl.js'
-
-// prettier-ignore
-export const Commands = {
-
-  'SourceControl.updateDecorations': SourceControl.updateDecorations
-}

package/static/96d5271/packages/renderer-worker/src/parts/Test/Test.js

@@ -1,90 +0,0 @@
-import * as ImportScript from '../ImportScript/ImportScript.js'
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as TestFrameWork from '../TestFrameWork/TestFrameWork.js'
-import * as TestFrameWorkComponent from '../TestFrameWorkComponent/TestFrameWorkComponent.js'
-import * as TestState from '../TestState/TestState.js'
-import * as Timestamp from '../Timestamp/Timestamp.js'
-import * as Workspace from '../Workspace/Workspace.js'
-
-export const state = {
-  tests: [],
-}
-
-const exposeGlobals = (global, object) => {
-  for (const [key, value] of Object.entries(object)) {
-    global[key] = value
-  }
-}
-
-const printError = (error) => {
-  if (error && error.constructor.name === 'AssertionError') {
-    console.error(error.message)
-  } else {
-    console.error(error)
-  }
-}
-
-const executeTest = async (name, fn) => {
-  let _error
-  let _start
-  let _end
-  let _duration
-  try {
-    _start = Timestamp.now()
-    await fn()
-    _end = Timestamp.now()
-    _duration = `${_end - _start}ms`
-    console.info(`[test passed] ${name} in ${_duration}`)
-  } catch (error) {
-    console.log({ error })
-    // @ts-ignore
-    _error = error.message
-    // @ts-ignore
-    error.message = `Test failed: ${name}: ${error.message}`
-    printError(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
-  )
-}
-
-export const execute = async (href) => {
-  exposeGlobals(globalThis, TestFrameWorkComponent)
-  exposeGlobals(globalThis, TestFrameWork)
-  // TODO
-  // 0. wait for page to be ready
-  // 1. get script to import from renderer process (url or from html)
-  const scriptUrl = href
-  // 2. import that script
-  const module = await ImportScript.importScript(scriptUrl)
-  if (module.mockExec) {
-    // TODO this should not be in workspace but in another module
-    Workspace.state.mockExec = module.mockExec
-  }
-  console.log({ module })
-
-  const tests = TestState.getTests()
-  for (const test of tests) {
-    await executeTest(test.name, test.fn)
-  }
-  // 3. if import fails, display error message
-
-  // 4. run the test
-  // 5. if test fails, display error message
-  // 6. if test succeeds, display success message
-}

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

@@ -1,196 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Arrays from '../Arrays/Arrays.js'
-import * as SplitLines from '../SplitLines/SplitLines.js'
-
-export const create = (text) => {
-  const lines = SplitLines.splitLines(text)
-  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)
-        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))
-        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,
-  positionRowIndex,
-  positionColumnIndex
-) => {
-  Assert.object(textDocument)
-  Assert.number(positionRowIndex)
-  Assert.number(positionColumnIndex)
-  let offset = 0
-  let rowIndex = 0
-  const lines = textDocument.lines
-  const max = Math.min(positionRowIndex, textDocument.lines.length)
-  while (rowIndex < max) {
-    offset += lines[rowIndex].length + 1
-    rowIndex++
-  }
-  offset += positionColumnIndex
-  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/96d5271/packages/renderer-worker/src/parts/TextSearch/TextSearch.js

@@ -1,30 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-
-const getProvider = (scheme) => {
-  switch (scheme) {
-    case '':
-      return import('./TextSearchNode.js')
-    case 'web':
-      return import('./TextSearchWeb.js')
-    default:
-      return import('./TextSearchExtension.js')
-  }
-}
-
-export const textSearch = async (root, query) => {
-  Assert.string(root)
-  Assert.string(query)
-  const scheme = FileSystem.getProtocol(root)
-  const provider = await getProvider(scheme)
-  const results = await provider.textSearch(scheme, root, query)
-  return results
-}
-
-export const cancel = async (searchId) => {
-  // TODO
-  // await SharedProcess.invoke(
-  //   /* Search.cancel */ 'Search.cancel',
-  //   /* searchId */ state.searchId
-  // )
-}

package/static/96d5271/packages/renderer-worker/src/parts/VError/VError.js

@@ -1,28 +0,0 @@
-const getCombinedMessage = (error, message) => {
-  if (message) {
-    return `${message}: ${error}`
-  }
-  return `${error}`
-}
-
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent
-  }
-  const parentNewLineIndex = parent.indexOf('\n')
-  const childNewLineIndex = child.indexOf('\n')
-  const parentFirstLine = parent.slice(0, parentNewLineIndex)
-  const childRest = child.slice(childNewLineIndex)
-  return parentFirstLine + childRest
-}
-
-export class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message)
-    super(combinedMessage)
-    this.name = 'VError'
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack)
-    }
-  }
-}

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

@@ -1,10 +0,0 @@
-import * as Viewlet from './Viewlet.js'
-
-export const Commands = {
-  'Viewlet.closeWidget': Viewlet.closeWidget,
-  'Viewlet.executeViewletCommand': Viewlet.executeViewletCommand,
-  'Viewlet.focus': Viewlet.focus,
-  'Viewlet.getAllStates': Viewlet.getAllStates,
-  'Viewlet.openWidget': Viewlet.openWidget,
-  2133: Viewlet.send,
-}

package/static/96d5271/packages/renderer-worker/src/parts/ViewletEditorImage/ViewletEditorImage.ipc.js

@@ -1,22 +0,0 @@
-import * as ViewletEditorImage from './ViewletEditorImage.js'
-
-export const name = 'EditorImage'
-
-// prettier-ignore
-export const Commands = {
-  handlePointerDown: ViewletEditorImage.handlePointerDown,
-  handlePointerMove: ViewletEditorImage.handlePointerMove,
-  handlePointerUp: ViewletEditorImage.handlePointerUp,
-  handleWheel: ViewletEditorImage.handleWheel,
-}
-
-// prettier-ignore
-export const LazyCommands = {
-  copyImage: () => import('./ViewletEditorImageCopyImage.js'),
-  copyPath: () => import('./ViewletEditorImageCopyPath.js'),
-  handleContextMenu: () => import('./ViewletEditorImageHandleContextMenu.js')
-}
-
-export const Css = '/css/parts/ViewletEditorImage.css'
-
-export * from './ViewletEditorImage.js'