@lvce-editor/server 0.0.2

package/static/1914fad/packages/renderer-worker/src/parts/SaveState/SaveState.js

@@ -0,0 +1,39 @@
+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/1914fad/packages/renderer-worker/src/parts/ServiceWorker/ServiceWorker.ipc.js

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

package/static/1914fad/packages/renderer-worker/src/parts/ServiceWorker/ServiceWorker.js

@@ -0,0 +1,37 @@
+import * as Platform from '../Platform/Platform.js'
+import * as Preferences from '../Preferences/Preferences.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+const SERVICE_WORKER_URL = '/serviceWorker.js'
+
+export const hydrate = async () => {
+  if (Platform.getPlatform() === 'electron') {
+    return
+  }
+  if (!Preferences.get('serviceWorker.enabled')) {
+    return
+  }
+  try {
+    await RendererProcess.invoke(
+      /* ServiceWorker.register */ 43725,
+      /* url */ SERVICE_WORKER_URL
+    )
+  } catch (error) {
+    if (error.message === 'A Service Worker has been blocked for this domain') {
+      // ignore
+    } else {
+      console.info(`service worker could not be registered: ${error}`)
+    }
+  }
+}
+
+export const uninstall = async () => {
+  if (Platform.getPlatform() === 'electron') {
+    return
+  }
+  try {
+    await RendererProcess.invoke(/* ServiceWorker.uninstall */ 42726)
+  } catch (error) {
+    console.info(`service worker could not be unregistered: ${error}`)
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/SessionStorage/SessionStorage.ipc.js

@@ -0,0 +1,9 @@
+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(6755, SessionStorage.clear)
+  Command.register(6756, SessionStorage.getJson)
+}

package/static/1914fad/packages/renderer-worker/src/parts/SessionStorage/SessionStorage.js

@@ -0,0 +1,30 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as Json from '../Json/Json.js'
+
+export const clear = async () => {
+  await RendererProcess.invoke(/* SessionStorage.clear */ 8976)
+}
+
+export const getJson = async (key) => {
+  const item = await RendererProcess.invoke(
+    /* SessionStorage.getItem */ 8977,
+    /* 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 */ 8978,
+    /* key */ key,
+    /* value */ stringifiedValue
+  )
+}

package/static/1914fad/packages/renderer-worker/src/parts/SharedProcess/SharedProcess.js

@@ -0,0 +1,167 @@
+/* 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/1914fad/packages/renderer-worker/src/parts/SourceControl/SourceControl.ipc.js

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

package/static/1914fad/packages/renderer-worker/src/parts/SourceControl/SourceControl.js

@@ -0,0 +1,38 @@
+import * as Platform from '../Platform/Platform.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as Workspace from '../Workspace/Workspace.js'
+
+export const state = {
+  count: 0,
+  decorations: [],
+  listeners: [],
+}
+
+export const onDidChangeCount = (listener) => {
+  state.listeners.push(listener)
+}
+
+export const setCount = (count) => {
+  state.count = count
+  for (const listener of state.listeners) {
+    listener()
+  }
+}
+
+export const updateDecorations = () => {
+  for (const listener of state.listeners) {
+    listener()
+  }
+}
+
+export const getBadgeCount = async () => {
+  if (Platform.getPlatform() === 'web') {
+    return 0
+  }
+  const workspacePath = Workspace.getWorkspacePath()
+  const count = await SharedProcess.invoke(
+    /* ExtensionHost.getSourceControlBadgeCount */ 'ExtensionHostSourceControl.getSourceControlBadgeCount',
+    /* cwd */ workspacePath
+  )
+  return count
+}

package/static/1914fad/packages/renderer-worker/src/parts/Storage/Storage.js

@@ -0,0 +1,27 @@
+export const save = (key, value) => {
+  let db
+  const request = indexedDB.open('vscode-db', 4)
+
+  request.onsuccess = (event) => {
+    // @ts-ignore
+    const db = event.target.result
+    const tx = db.transaction('vscode', 'readwrite')
+    // var store = tx.objectStore('vscode')
+
+    // Add some data
+  }
+
+  // This event is only implemented in recent browsers
+  request.onupgradeneeded = (event) => {
+    // Save the IDBDatabase interface
+    // @ts-ignore
+    const db = event.target.result
+
+    // Create an objectStore for this database
+    const store = db.createObjectStore('vscode')
+
+    store.put(value, key)
+    // store.put({ name: { first: 'Bob', last: 'Smith' }, age: 35 }, 'user-2')
+    // objectStore.
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/SyntaxHighlightingWorker/SyntaxHighlightingWorker.js

@@ -0,0 +1,33 @@
+import * as Worker from '../Worker/Worker.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as Languages from '../Languages/Languages.js'
+
+export const state = {
+  pendingMessages: [],
+  send(message) {
+    state.pendingMessages.push(message)
+  },
+}
+
+export const hydrate = async () => {
+  // const syntaxHighlightingWorker = await Worker.create(
+  //   '/packages/syntax-highlighting-worker/src/syntaxHighlightingWorkerMain.js'
+  // )
+  // const messageChannel = new MessageChannel()
+  // RendererProcess.sendAndTransfer(
+  //   [/* SyntaxHighlighting.setPort */ 9997],
+  //   [/* port */ messageChannel.port1]
+  // )
+  // syntaxHighlightingWorker.postMessage(
+  //   [/* SyntaxHighlighting.setPort */ 9997],
+  //   [/* port */ messageChannel.port2]
+  // )
+  // state.send = (message) => syntaxHighlightingWorker.postMessage(message)
+  // while (state.pendingMessages.length > 0) {
+  //   send(state.pendingMessages.shift())
+  // }
+}
+
+export const send = (message) => {
+  state.send(message)
+}

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

@@ -0,0 +1,190 @@
+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/1914fad/packages/renderer-worker/src/parts/TextSegmenter/TextSegmenter.js

@@ -0,0 +1,37 @@
+export const supported = () => {
+  return 'Segmenter' in Intl
+}
+
+export const create = () => {
+  // @ts-ignore
+  const segmenter = new Intl.Segmenter()
+  return {
+    at(line, index) {
+      const segments = segmenter.segment(line)
+      return segments.containing(index)
+    },
+    visualIndex(line, index) {
+      const segments = segmenter.segment(line)
+      let currentVisualIndex = 0
+      for (const segment of segments) {
+        if (segment.index >= index) {
+          return currentVisualIndex
+        }
+        currentVisualIndex++
+      }
+      return currentVisualIndex
+    },
+    modelIndex(line, visualIndex) {
+      const segments = segmenter.segment(line)
+      let currentVisualIndex = 0
+      for (const segment of segments) {
+        if (currentVisualIndex >= visualIndex) {
+          return segment.index
+        }
+        console.log({ segment })
+        currentVisualIndex++
+      }
+      return line.length
+    },
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/Timers/Timers.js

@@ -0,0 +1,25 @@
+import * as Command from '../Command/Command.js'
+
+export const state = {
+  /**
+   * @type {any[]}
+   */
+  timeouts: [],
+}
+
+// TODO race condition
+const handleTimeouts = async () => {
+  for (const command of state.timeouts) {
+    await Command.execute(command)
+  }
+  state.timeouts = []
+}
+
+export const setTimeout = (command, timeout) => {
+  state.timeouts.push(command)
+  globalThis.setTimeout(handleTimeouts, timeout)
+}
+
+export const clearTimeout = (timeout) => {
+  globalThis.clearTimeout(timeout)
+}

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

@@ -0,0 +1,22 @@
+import * as Command from '../Command/Command.js'
+import * as TitleBarMenuBar from './TitleBarMenuBar.js'
+
+export const __initialize__ = () => {
+  Command.register(4610, TitleBarMenuBar.toggleIndex)
+  Command.register(4611, TitleBarMenuBar.hydrate)
+  Command.register(4612, TitleBarMenuBar.focus)
+  Command.register(4613, TitleBarMenuBar.focusIndex)
+  Command.register(4614, TitleBarMenuBar.focusPrevious)
+  Command.register(4615, TitleBarMenuBar.focusNext)
+  Command.register(4616, TitleBarMenuBar.closeMenu)
+  Command.register(4617, TitleBarMenuBar.openMenu)
+  Command.register(4618, TitleBarMenuBar.handleKeyArrowDown)
+  Command.register(4619, TitleBarMenuBar.handleKeyArrowUp)
+  Command.register(4620, TitleBarMenuBar.handleKeyArrowRight)
+  Command.register(4621, TitleBarMenuBar.handleKeyHome)
+  Command.register(4622, TitleBarMenuBar.handleKeyEnd)
+  Command.register(4623, TitleBarMenuBar.handleKeySpace)
+  Command.register(4624, TitleBarMenuBar.handleKeyEnter)
+  Command.register(4625, TitleBarMenuBar.handleKeyEscape)
+  Command.register(4626, TitleBarMenuBar.handleKeyArrowLeft)
+}