@lvce-editor/server 0.4.4 → 0.6.0

package/static/fbac85f/packages/renderer-worker/src/parts/SessionReplay/SessionReplay.js

@@ -0,0 +1,201 @@
+import * as Command from '../Command/Command.js'
+import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
+import * as IndexedDb from '../IndexedDb/IndexedDb.js'
+import * as Location from '../Location/Location.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as Assert from '../Assert/Assert.js'
+import { VError } from '../VError/VError.js'
+import * as Json from '../Json/Json.js'
+import * as Timestamp from '../Timestamp/Timestamp.js'
+
+export const state = {
+  sessionId: '',
+}
+
+const getSessionId = () => {
+  if (!state.sessionId) {
+    state.sessionId = `session-${new Date().toISOString()}`
+  }
+  return state.sessionId
+}
+
+export const handleMessage = async (source, timestamp, message) => {
+  try {
+    const sessionId = getSessionId()
+    await IndexedDb.saveValue(sessionId, {
+      source,
+      timestamp,
+      sessionId,
+      ...message,
+    })
+  } catch (error) {
+    console.error(error)
+    // @ts-ignore
+    if (error.cause) {
+      // @ts-ignore
+      console.error(error.cause)
+    }
+    // await ErrorHandling.handleError(error)
+  }
+}
+
+const addSearchParam = (href, key, value) => {
+  const parsedUrl = new URL(href)
+  parsedUrl.searchParams.set('replayId', state.sessionId)
+  return parsedUrl.toString()
+}
+
+export const replayCurrentSession = async () => {
+  if (!state.sessionId) {
+    throw new VError(`session replay is disabled in settings`)
+  }
+  // TODO
+  // 1. read commands from indexeddb
+  // 2. open new window
+  // 3. replay ui with commands from indexeddb
+
+  const href = await Location.getHref()
+  const replayUrl = addSearchParam(href, 'replayId', state.sessionId)
+  await Command.execute('Open.openUrl', /* url */ replayUrl)
+}
+
+export const getSessionContent = async () => {
+  const sessionId = state.sessionId
+  const events = await getEvents(sessionId)
+  return Json.stringify(events)
+}
+
+const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile'])
+
+export const replaySession = async (sessionId) => {
+  const events = await getEvents(sessionId)
+  const originalIpc = RendererProcess.state.ipc
+  const originalSend = originalIpc.send
+  RendererProcess.state.ipc.send = () => {}
+  RendererProcess.state.ipc.onmessage = (event) => {
+    const data = event.data
+    if (typeof data === 'string') {
+      return
+    }
+    if ('result' in data) {
+      callbacks[data.id].resolve(data.result)
+    } else if ('error' in data) {
+      callbacks[data.id].reject(data.error)
+    } else if ('method' in data) {
+      // ignore
+    } else {
+      throw new Error('unexpected message from renderer worker')
+    }
+  }
+  const callbacks = Object.create(null)
+  const invoke = (event) => {
+    return new Promise((resolve, reject) => {
+      callbacks[event.id] = { resolve, reject }
+      originalSend(event)
+    })
+  }
+  let now = 0
+  for (const event of events) {
+    if (
+      event.source === 'to-renderer-process' &&
+      !DONT_REPLAY.has(event.method)
+    ) {
+      // console.log(event.timestamp)
+      const timeDifference = event.timestamp - now
+      await new Promise((resolve, reject) => {
+        setTimeout(resolve, timeDifference)
+      })
+      await invoke(event)
+      now = event.timestamp
+    }
+    // if (event.source === 'from-renderer-process') {
+    //   console.log(event)
+    // }
+  }
+  // console.log({ events })
+}
+
+export const getEvents = async (sessionId) => {
+  try {
+    const timestamp = Timestamp.now()
+    const events = await IndexedDb.getValuesByIndexName(
+      'session',
+      'sessionId',
+      sessionId
+    )
+    return events
+  } catch (error) {
+    throw new VError(error, `failed to get session replay events`)
+  }
+}
+
+export const downloadSession = async () => {
+  try {
+    const sessionId = getSessionId()
+    const events = await getEvents(sessionId)
+    const fileName = `${sessionId}.json`
+    await Command.execute(
+      /* Download.downloadJson */ 'Download.downloadJson',
+      /* json */ events,
+      /* fileName */ fileName
+    )
+  } catch (error) {
+    throw new VError(error, 'Failed to download session')
+  }
+}
+
+const wrapIpc = (ipc, name, getData) => {
+  if (!ipc) {
+    return
+  }
+  Assert.object(ipc)
+  Assert.string(name)
+  Assert.fn(getData)
+  const nameFrom = `from-${name}`
+  const nameTo = `to-${name}`
+  const wrappedIpc = {
+    async send(message) {
+      ipc.send(message)
+      const timestamp = Timestamp.now()
+      await handleMessage(nameTo, timestamp, message)
+    },
+    sendAndTransfer(message, transferables) {
+      ipc.sendAndTransfer(message, transferables)
+    },
+    get onmessage() {
+      return ipc.onmessage
+    },
+    set onmessage(listener) {
+      ipc.onmessage = listener
+    },
+  }
+  const originalOnMessage = wrappedIpc.onmessage
+  wrappedIpc.onmessage = async (event) => {
+    const message = getData(event)
+    const timestamp = Timestamp.now()
+    await originalOnMessage(event)
+    await handleMessage(nameFrom, timestamp, message)
+  }
+  return wrappedIpc
+}
+
+export const startRecording = () => {
+  RendererProcess.state.ipc = wrapIpc(
+    RendererProcess.state.ipc,
+    'renderer-process',
+    (event) => event.data
+  )
+  SharedProcess.state.ipc = wrapIpc(
+    SharedProcess.state.ipc,
+    'shared-process',
+    (event) => event
+  )
+}
+
+export const openSession = async () => {
+  await Command.execute(
+    /* Main.openUri */ 'Main.openUri',
+    /* uri */ 'app://session.json'
+  )
+}

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

@@ -0,0 +1,74 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+export const create = (selector, options) => {
+  return new Locator(selector, options)
+}
+
+const Locator = function (selector, { nth = -1, hasText = '' } = {}) {
+  this._selector = selector
+  this._nth = nth
+  this._hasText = hasText
+}
+
+const performAction = async (locator, fnName, options) => {
+  return RendererProcess.invoke(
+    'TestFrameWork.performAction',
+    locator,
+    fnName,
+    options
+  )
+}
+
+const toButtonNumber = (buttonType) => {
+  switch (buttonType) {
+    case 'left':
+      return 0
+    case 'middle':
+      return 1
+    case 'right':
+      return 2
+    default:
+      throw new Error(`unsupported button type: ${buttonType}`)
+  }
+}
+
+Locator.prototype.click = async function ({ button = 'left' } = {}) {
+  const options = {
+    cancable: true,
+    bubbles: true,
+    button: toButtonNumber(button),
+    detail: 1,
+  }
+  return performAction(this, 'click', options)
+}
+
+Locator.prototype.hover = async function () {
+  const options = {
+    cancable: true,
+    bubbles: true,
+  }
+  return performAction(this, 'hover', options)
+}
+
+Locator.prototype.first = function () {
+  return create(this._selector, {
+    nth: 0,
+  })
+}
+
+Locator.prototype.locator = function (subSelector) {
+  return create(`${this._selector} ${subSelector}`)
+}
+
+Locator.prototype.nth = function (nth) {
+  return create(this._selector, { nth })
+}
+
+Locator.prototype.type = async function (text) {
+  const options = { text }
+  return performAction(this, 'type', options)
+}
+
+Locator.prototype.dispatchEvent = async function (type, init) {
+  return performAction(this, 'dispatchEvent', { type, init })
+}

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

@@ -0,0 +1,174 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+export { create as Locator } from './Locator.js'
+import * as Timestamp from '../Timestamp/Timestamp.js'
+
+export const getTmpDir = async () => {
+  return `memfs://`
+}
+
+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`)
+}
+
+const printError = (error) => {
+  if (error && error.constructor.name === 'AssertionError') {
+    console.error(error.message)
+  } else {
+    console.error(error)
+  }
+}
+
+export const test = async (name, fn) => {
+  Object.defineProperty(fn, 'name', {
+    value: `test/${name}`,
+  })
+  let _error
+  let _start
+  let _end
+  let _duration
+  try {
+    await waitForReady()
+    _start = Timestamp.now()
+    await fn()
+    _end = Timestamp.now()
+    _duration = `${_end - _start}ms`
+    console.info(`[test passed] ${name} in ${_duration}`)
+  } catch (error) {
+    console.log({ error })
+    _error = error.message
+    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
+  )
+}
+
+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() {
+      if (this.negated) {
+        throw new Error(`use toBeHidden instead of not.toBeVisible`)
+      }
+      return this.checkSingleElementCondition('toBeVisible', {})
+    },
+    async toHaveText(text) {
+      Assert.string(text, 'text must be of type string')
+      return this.checkSingleElementCondition('toHaveText', { text })
+    },
+    async toHaveValue(value) {
+      Assert.string(value, 'value must be of type string')
+      return this.checkSingleElementCondition('toHaveValue', { value })
+    },
+    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 toHaveId(id) {
+      Assert.string(id, 'id must be of type string')
+      return await this.checkSingleElementCondition('toHaveId', {
+        id,
+      })
+    },
+    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/fbac85f/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponent.js

@@ -0,0 +1,16 @@
+export * as ContextMenu from './TestFrameWorkComponentContextMenu.js'
+export * as Editor from './TestFrameWorkComponentEditor.js'
+export * as Explorer from './TestFrameWorkComponentExplorer.js'
+export * as Extension from './TestFrameWorkComponentExtension.js'
+export * as FileSystem from './TestFrameWorkComponentFileSystem.js'
+export * as Main from './TestFrameWorkComponentMain.js'
+export * as Workspace from './TestFrameWorkComponentWorkspace.js'
+export * as KeyBoard from './TestFrameWorkComponentKeyBoard.js'
+export * as QuickPick from './TestFrameWorkComponentQuickPick.js'
+export * as Search from './TestFrameWorkComponentSearch.js'
+export * as SideBar from './TestFrameWorkComponentSideBar.js'
+export * as Command from './TestFrameWorkComponentCommand.js'
+export * as Platform from './TestFrameWorkComponentPlatform.js'
+export * as Settings from './TestFrameWorkComponentSettings.js'
+export * as Eval from './TestFrameWorkComponentEval.js'
+export * as EditorFindWidget from './TestFrameWorkComponentEditorFindWidget.js'

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

@@ -0,0 +1,73 @@
+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)
+}
+
+export const cursorCharacterRight = async () => {
+  await Command.execute('Editor.cursorCharacterRight')
+}
+
+export const cursorCharacterLeft = async () => {
+  await Command.execute('Editor.cursorCharacterLeft')
+}
+
+export const copyLineDown = async () => {
+  await Command.execute('Editor.copyLineDown')
+}
+
+export const cursorDown = async () => {
+  await Command.execute('Editor.cursorDown')
+}
+
+export const cursorUp = async () => {
+  await Command.execute('Editor.cursorUp')
+}
+
+export const cursorWordLeft = async () => {
+  await Command.execute('Editor.cursorWordLeft')
+}
+
+export const cursorWordRight = async () => {
+  await Command.execute('Editor.cursorWordRight')
+}
+
+export const goToDefinition = async () => {
+  await Command.execute('Editor.goToDefinition')
+}
+
+export const goToTypeDefinition = async () => {
+  await Command.execute('Editor.goToTypeDefinition')
+}
+
+export const type = async (text) => {
+  await Command.execute('Editor.type')
+}
+
+export const findAllReferences = async () => {
+  await Command.execute('SideBar.show', 'References', /* focus */ true)
+}
+
+export const setSelections = async (selections) => {
+  await Command.execute('Editor.setSelections', selections)
+}
+
+export const openFindWidget = async () => {
+  await Command.execute('Editor.openFind')
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentEditorFindWidget.js

@@ -0,0 +1,5 @@
+import * as Command from '../Command/Command.js'
+
+export const focusNext = async () => {
+  await Command.execute('EditorFindWidget.focusNext')
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentEval.js

@@ -0,0 +1,5 @@
+import * as Command from '../Command/Command.js'
+
+export const evalInRendererProcess = async (code) => {
+  await Command.execute('Eval.evalInRendererProcess', code)
+}

package/static/fbac85f/packages/renderer-worker/src/parts/TestFrameWorkComponent/TestFrameWorkComponentFileSystem.js

@@ -0,0 +1,44 @@
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+import * as PathSeparatorType from '../PathSeparatorType/PathSeparatorType.js'
+
+export const writeFile = async (path, content) => {
+  await Command.execute('FileSystem.writeFile', path, content)
+}
+
+export const mkdir = async (path) => {
+  await Command.execute('FileSystem.mkdir', path)
+}
+
+export const getTmpDir = async ({ scheme = 'memfs' } = {}) => {
+  switch (scheme) {
+    case 'memfs':
+      return 'memfs://'
+    default:
+      return Platform.getTmpDir()
+  }
+}
+
+export const chmod = async (uri, permissions) => {
+  await Command.execute('FileSystem.chmod', uri, permissions)
+}
+
+export const createExecutable = async (content) => {
+  const tmpDir = await getTmpDir({ scheme: 'file' })
+  const nodePath = await Platform.getNodePath()
+  const gitPath = `${tmpDir}/git`
+  await writeFile(
+    gitPath,
+    `#!${nodePath}
+  ${content}`
+  )
+  await chmod(gitPath, '755')
+  return gitPath
+}
+
+export const createExecutableFrom = async (path) => {
+  const testPath = await Platform.getTestPath()
+  const absolutePath = testPath + PathSeparatorType.Slash + path
+  const content = await Command.execute('Ajax.getText', absolutePath)
+  return createExecutable(content)
+}