@lvce-editor/server 0.0.27 → 0.0.28

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

@@ -0,0 +1,99 @@
+/* istanbul ignore file */
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import { JsonRpcError } from '../Errors/Errors.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+
+export const state = {
+  pendingMessages: [],
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
+const handleMessageFromRendererProcess = async (event) => {
+  const message = event.data
+  if (typeof message === 'string') {
+    console.warn(`unexpected message from renderer process: ${message}`)
+    return
+  }
+  if (message.id) {
+    if ('result' in message) {
+      Callback.resolve(message.id, message.result)
+      return
+    }
+    if ('error' in message) {
+      Callback.reject(message.id, message.error)
+      return
+    }
+    if ('method' in message) {
+      try {
+        const result = await Command.execute(message.method, ...message.params)
+        state.ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          result,
+        })
+        return
+      } catch (error) {
+        state.ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          error,
+        })
+        return
+      }
+    }
+
+    Callback.reject(
+      message.id,
+      new JsonRpcError('unexpected message from renderer process')
+    )
+    return
+  }
+  await Command.execute(message.method, ...message.params)
+}
+
+const getIpc = () => {
+  return IpcChild.listen({ method: IpcChild.Methods.Auto })
+}
+
+export const listen = async () => {
+  console.assert(state.pendingMessages.length === 0)
+  const ipc = await getIpc()
+  ipc.onmessage = handleMessageFromRendererProcess
+  state.ipc = ipc
+}
+
+/**
+ * @deprecated use invoke instead
+ * @param {*} message
+ */
+export const send = (message) => {
+  state.ipc.send(message)
+}
+
+export const invoke = async (method, ...parameters) => {
+  const responseMessage = await new Promise((resolve, reject) => {
+    const callbackId = Callback.register(resolve, reject)
+    if (!state.ipc) {
+      reject(new Error('ipc not active'))
+      return
+    }
+    state.ipc.send({
+      jsonrpc: '2.0',
+      method,
+      params: parameters,
+      id: callbackId,
+    })
+  })
+  if (responseMessage instanceof Error) {
+    throw responseMessage
+  }
+  return responseMessage
+}
+
+export const sendAndTransfer = (message, transferables) => {
+  state.ipc.sendAndTransfer(message, transferables)
+}

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

@@ -0,0 +1,8 @@
+import * as Command from '../Command/Command.js'
+import * as SaveState from './SaveState.js'
+
+// prettier-ignore
+export const __initialize__ = () => {
+  Command.register('SaveState.hydrate', SaveState.hydrate)
+  Command.register('SaveState.handleVisibilityChange', SaveState.handleVisibilityChange)
+}

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

@@ -0,0 +1,47 @@
+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'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as LocalStorage from '../LocalStorage/LocalStorage.js'
+import * as SessionStorage from '../SessionStorage/SessionStorage.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 handleVisibilityChange = async (visibilityState) => {
+  console.log('[renderer worker] visibility changed to', visibilityState)
+  if (visibilityState === 'hidden') {
+    const stateToSave = getStateToSave()
+    await Promise.all([
+      LocalStorage.setJson('stateToSave', stateToSave),
+      SessionStorage.setJson('workspace', stateToSave.workspace),
+    ])
+    console.log('[renderer worker] state was saved')
+  }
+}
+
+export const hydrate = async () => {
+  // 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
+  }
+  await RendererProcess.invoke('Window.onVisibilityChange')
+}

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

@@ -0,0 +1,10 @@
+import * as Command from '../Command/Command.js'
+import * as SessionReplay from './SessionReplay.js'
+
+// prettier-ignore
+export const __initialize__ = () => {
+  Command.register('SessionReplay.downloadSession', SessionReplay.downloadSession)
+  Command.register('SessionReplay.replayCurrentSession', SessionReplay.replayCurrentSession)
+  Command.register('SessionReplay.replaySession', SessionReplay.replaySession)
+  Command.register('SessionReplay.openSession', SessionReplay.openSession)
+}

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

@@ -0,0 +1,192 @@
+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'
+
+export const state = {
+  sessionId: '',
+}
+
+const getSessionId = () => {
+  if (!state.sessionId) {
+    state.sessionId = `session-${new Date().toISOString()}`
+  }
+  return state.sessionId
+}
+
+export const handleMessage = async (source, message) => {
+  try {
+    const sessionId = getSessionId()
+    const timestamp = performance.now()
+    // console.log({ message, timestamp })
+    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)
+  }
+}
+
+export const replayCurrentSession = async () => {
+  // TODO
+  // 1. read commands from indexeddb
+  // 2. open new window
+  // 3. replay ui with commands from indexeddb
+
+  const href = await Location.getHref()
+  const replayUrl = `${href}?replayId=${state.sessionId}`
+  await Command.execute('Open.openUrl', /* url */ replayUrl)
+}
+
+export const getSessionContent = async () => {
+  const sessionId = state.sessionId
+  const events = await getEvents(sessionId)
+  // TODO use JSON module for this
+  return JSON.stringify(events, null, 2) + '\n'
+}
+
+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 ('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 = performance.now()
+    // console.log({ message, timestamp })
+    const events = await IndexedDb.getValuesByIndexName(
+      'session',
+      'sessionId',
+      sessionId
+    )
+    return events
+  } catch (error) {
+    ErrorHandling.handleError(error)
+    // console.info(`failed to get events from indexeddb: ${error}`)
+    // ignore
+    return []
+  }
+}
+
+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)
+      await handleMessage(nameTo, 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)
+    await originalOnMessage(event)
+    await handleMessage(nameFrom, 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/f9b8874/packages/renderer-worker/src/parts/SharedProcess/SharedProcess.js

@@ -0,0 +1,129 @@
+/* istanbul ignore file */
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as IpcParent from '../IpcParent/IpcParent.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'
+  }
+  if (navigator.appVersion.includes('Electron')) {
+    return 'electron'
+  }
+  return '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.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: '2.0',
+        id: message.id,
+        result,
+      })
+    }
+  } else {
+    Callback.resolve(message.id, message)
+  }
+}
+
+const getIpc = () => {
+  if (platform === 'web' || platform === 'remote') {
+    return IpcParent.create({
+      method: IpcParent.Methods.WebSocket,
+      protocol: 'lvce.shared-process',
+    })
+  }
+  if (platform === 'electron') {
+    return IpcParent.create({ method: IpcParent.Methods.Electron })
+  }
+  throw new Error('unsupported platform')
+}
+
+export const listen = async () => {
+  const ipc = await getIpc()
+  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/f9b8874/packages/renderer-worker/src/parts/Test/Test.ipc.js

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

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

@@ -0,0 +1,27 @@
+import { VError } from '../VError/VError.js'
+
+export const state = {
+  tests: [],
+}
+
+const importScript = async (url) => {
+  try {
+    return await import(url)
+  } catch (error) {
+    throw new VError(error, `Failed to import script ${url}`)
+  }
+}
+
+export const execute = async (href) => {
+  // 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(scriptUrl)
+  // 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/f9b8874/packages/renderer-worker/src/parts/TestFrameWork/Locator.js

@@ -0,0 +1,70 @@
+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)
+}