@lvce-editor/server 0.0.26 → 0.0.29

package/static/0895dce/packages/renderer-worker/src/parts/SaveState/SaveState.js

@@ -1,39 +0,0 @@
-import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
-import * as Viewlet from '../Viewlet/Viewlet.js'
-// import * as Main from '../Main/Main.js'
-import * as Workspace from '../Workspace/Workspace.js'
-import * as Json from '../Json/Json.js'
-import * as Preferences from '../Preferences/Preferences.js'
-
-const getStateToSave = () => {
-  const instances = Viewlet.state.instances
-  // const mainEditors = Main.state.editors
-  return {
-    instances,
-    mainEditors: [],
-    workspace: {
-      path: Workspace.state.workspacePath,
-      homeDir: Workspace.state.homeDir,
-      pathSeparator: Workspace.state.pathSeparator,
-      uri: Workspace.state.workspaceUri,
-    },
-  }
-}
-
-export const hydrate = () => {
-  // TODO should set up listener in renderer process
-  if (!Preferences.get('workbench.saveStateOnVisibilityChange')) {
-    // console.info(
-    // '[info] not saving state on visibility change - disabled by settings'
-    // )
-    return
-  }
-  document.addEventListener('visibilitychange', () => {
-    console.log('visibility changed')
-    if (document.visibilityState === 'hidden') {
-      const stateToSave = getStateToSave()
-      localStorage.setItem('stateToSave', Json.stringify(stateToSave))
-      sessionStorage.setItem('workspace', Json.stringify(stateToSave.workspace))
-    }
-  })
-}

package/static/0895dce/packages/renderer-worker/src/parts/ServiceWorker/ServiceWorker.ipc.js

@@ -1,7 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ServiceWorker from './ServiceWorker.js'
-
-export const __initialize__ = () => {
-  Command.register('ServiceWorker.hydrate', ServiceWorker.hydrate)
-  Command.register('ServiceWorker.uninstall', ServiceWorker.uninstall)
-}

package/static/0895dce/packages/renderer-worker/src/parts/SessionStorage/SessionStorage.ipc.js

@@ -1,9 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as SessionStorage from './SessionStorage.js'
-
-// TODO only use SessionStorage module via ipc -> that way is is always lazyloaded
-
-export const __initialize__ = () => {
-  Command.register('SessionStorage.clear', SessionStorage.clear)
-  Command.register('SessionStorage.getJson', SessionStorage.getJson)
-}

package/static/0895dce/packages/renderer-worker/src/parts/SessionStorage/SessionStorage.js

@@ -1,32 +0,0 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as Json from '../Json/Json.js'
-
-export const clear = async () => {
-  await RendererProcess.invoke(
-    /* SessionStorage.clear */ 'SessionStorage.clear'
-  )
-}
-
-export const getJson = async (key) => {
-  const item = await RendererProcess.invoke(
-    /* SessionStorage.getItem */ 'SessionStorage.getItem',
-    /* key */ key
-  )
-  if (!item) {
-    return undefined
-  }
-  try {
-    return Json.parse(item)
-  } catch {
-    return undefined
-  }
-}
-
-export const setJson = async (key, value) => {
-  const stringifiedValue = Json.stringify(value)
-  await RendererProcess.invoke(
-    /* SessionStorage.setItem */ 'SessionStorage.setItem',
-    /* key */ key,
-    /* value */ stringifiedValue
-  )
-}

package/static/0895dce/packages/renderer-worker/src/parts/SharedProcess/SharedProcess.js

@@ -1,167 +0,0 @@
-/* istanbul ignore file */
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-import * as WebSocket from '../WebSocket/WebSocket.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
-
-// TODO duplicate code with platform module
-/**
- * @returns {'electron'|'remote'|'web'|'test'}
- */
-const getPlatform = () => {
-  // TODO maybe use import.meta.env.PLATFORM
-  // @ts-ignore
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-ignore
-    return PLATFORM
-  }
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return 'test'
-  }
-
-  // TODO don't use window here -> want to run renderer-worker as webworker
-  if (
-    // @ts-ignore
-    typeof window !== 'undefined' &&
-    // @ts-ignore
-    window.myApi &&
-    // @ts-ignore
-    window.myApi.ipcConnect &&
-    // @ts-ignore
-    typeof window.myApi.ipcConnect === 'function'
-  ) {
-    return 'electron'
-  }
-  return 'remote'
-}
-
-export const platform = 'remote'// 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.stderr) {
-    // @ts-ignore
-    error.stderr = rawError.data.stderr
-  }
-  return error
-}
-
-// TODO state is actually not needed here, only for testing because jest doesn't support mocking esm
-export const state = {
-  pendingMessages: [],
-  send(message) {
-    state.pendingMessages.push(message)
-  },
-  async receive(message) {
-    if (message.method) {
-      const result = await Command.execute(message.method, ...message.params)
-      if (message.id) {
-        state.send({
-          jsonrpc: '2.0',
-          id: message.id,
-          result,
-        })
-      }
-    } else {
-      Callback.resolve(message.id, message)
-    }
-  },
-  dispose() {},
-  totalSent: 0,
-  totalReceived: 0,
-  retryCount: 0,
-}
-
-export const listen = () => {
-  console.assert(state.pendingMessages.length === 0)
-  if (platform === 'web' || platform === 'remote') {
-    // TODO replace this during build
-    const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:'
-    const wsUrl = `${wsProtocol}//${location.host}`
-    const webSocket = WebSocket.create(wsUrl, state)
-  } else if (platform === 'electron') {
-    const handleMessage = (event) => {
-      const port = event.ports[0]
-      state.send = (message) => {
-        port.postMessage(message)
-      }
-      port.onmessage = (event) => {
-        const message = event.data
-        state.receive(message)
-      }
-      for (const pendingMessage of state.pendingMessages) {
-        state.send(pendingMessage)
-      }
-      // port.start()
-    }
-    if (
-      // @ts-ignore
-      typeof window !== 'undefined' &&
-      // @ts-ignore
-      window.myApi &&
-      // @ts-ignore
-      window.myApi.ipcConnect &&
-      // @ts-ignore
-      typeof window.myApi.ipcConnect === 'function'
-    ) {
-      // @ts-ignore
-      window.addEventListener('message', handleMessage, { once: true })
-      // @ts-ignore
-      window.myApi.ipcConnect()
-    } else {
-      console.warn('api is not available')
-    }
-  }
-}
-
-export const send = (method, ...params) => {
-  if (platform === 'web') {
-    console.warn('SharedProcess is not available on web')
-    return
-  }
-  JsonRpc.send(state, 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, 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/0895dce/packages/renderer-worker/src/parts/SourceControl/SourceControl.ipc.js

@@ -1,7 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as SourceControl from './SourceControl.js'
-
-// prettier-ignore
-export const __initialize__ = () => {
-  Command.register('SourceControl.updateDecorations', SourceControl.updateDecorations)
-}

package/static/0895dce/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/0895dce/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)
-}