@lvce-editor/server 0.0.28 → 0.0.31

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

@@ -1,47 +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'
-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/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/f9b8874/packages/renderer-worker/src/parts/SessionReplay/SessionReplay.ipc.js

@@ -1,10 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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/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/f9b8874/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/f9b8874/packages/renderer-worker/src/parts/SharedProcess/SharedProcess.js

@@ -1,129 +0,0 @@
-/* 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/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/f9b8874/packages/renderer-worker/src/parts/Test/Test.ipc.js

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