@lvce-editor/server 0.0.27 → 0.0.28

package/static/eb65b4e/packages/renderer-worker/src/parts/QuickPick/QuickPick.js

@@ -1,463 +0,0 @@
-import * as RendererProcess from '../RendererProcess/RendererProcess.js'
-import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
-import * as QuickPickNoop from './QuickPickNoop.js'
-import * as Assert from '../Assert/Assert.js'
-import * as Command from '../Command/Command.js'
-// TODO send open signal to renderer process before items are ready
-// that way user can already type while items are still loading
-
-// TODO cache quick pick items -> don't send every time from renderer worker to renderer process
-// maybe cache by id opening commands -> has all commands cached
-// when filtering -> sends all indices (uint16Array) to renderer process instead of filtered/sorted command objects
-
-const RECENT_PICKS_MAX_SIZE = 3
-const ITEM_HEIGHT = 22
-
-// state:
-// 1. default
-// 2. creating (input is ready, but there are no items yet)
-// 3. finished
-
-const STATE_DEFAULT = 0
-const STATE_CREATING = 1
-const STATE_FINISHED = 2
-
-export const state = {
-  state: STATE_DEFAULT,
-  picks: [],
-  filteredPicks: [],
-  recentPicks: [],
-  recentPickIds: new Map(), // TODO use object.create(null) instead
-  versionId: 0,
-  provider: QuickPickNoop,
-  focusedIndex: 0,
-  warned: [],
-  visiblePicks: [],
-  minLineY: 0,
-  maxLineY: 0,
-  maxVisibleItems: 10,
-}
-
-// TODO naming for provider.getNoResults is a bit weird
-
-const filterPicks = (picks, exclude, value) => {
-  // TODO every pick should have label
-  const filterPick = (pick) => {
-    if (exclude.has(pick.id)) {
-      return false
-    }
-    if (!pick.label && !state.warned.includes(JSON.stringify(pick))) {
-      console.warn('[QuickPick] item has missing label', pick)
-      state.warned.push(JSON.stringify(pick))
-      return false
-    }
-    const labelMatch = FuzzySearch.fuzzySearch(value, pick.label || pick.id)
-    if (labelMatch) {
-      return labelMatch
-    }
-    // TODO also filtering for aliases might be expensive
-    // TODO maybe only filter for aliases if prefix is longer than 4-5 characters
-    // otherwise both will be found anyway
-    // e.g. "Relo" matches  "Window Reload"  and "Reload Window"
-    // But "Reload Win" only matches "Reload Window"
-    if (pick.aliases) {
-      for (const alias of pick.aliases) {
-        if (FuzzySearch.fuzzySearch(value, alias)) {
-          return true
-        }
-      }
-    }
-    return false
-  }
-  const filteredPicks = picks.filter(filterPick)
-  return filteredPicks
-}
-
-const slicePicks = (filteredPicks) => {
-  return filteredPicks.slice(0, 10)
-}
-
-const toDisplayPicks = (picks) => {
-  const toDisplayPick = (pick, index) => {
-    return {
-      label: pick.label,
-      posInSet: index + 1,
-      setSize: picks.length,
-    }
-  }
-  return picks.map(toDisplayPick)
-}
-
-const getVisiblePicks = (picks, filterValue) => {
-  const filteredPicks = filterPicks(picks, state.recentPickIds, filterValue)
-  state.filteredPicks = filteredPicks
-  state.state = STATE_FINISHED
-  const slicedPicks = slicePicks(filteredPicks)
-  return toDisplayPicks(slicedPicks)
-}
-
-// TODO have lazy loadable provider as argument
-export const show = async (value, provider) => {
-  state.provider = provider
-  if (state.state === STATE_FINISHED) {
-    const version = ++state.versionId
-    // TODO if provider is immutable, don't necessarily need to get new picks
-    const newPicks = await provider.getPicks(value)
-    Assert.array(newPicks)
-    if (version !== state.versionId) {
-      return
-    }
-    const filterValue = provider.getFilterValue(value)
-    const visiblePicks = getVisiblePicks(newPicks, filterValue)
-    const placeholder = provider.getPlaceholder()
-    const label = provider.getLabel()
-    RendererProcess.invoke(
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'QuickPick',
-      /* method */ 'updateValueAndPicksAndPlaceholder',
-      /* value */ value,
-      /* picks */ visiblePicks,
-      /* focusIndex */ 0,
-      /* unFocusIndex */ state.focusedIndex,
-      /* placeholder */ placeholder,
-      /* label */ label
-    )
-    state.picks = newPicks
-    state.visiblePicks = visiblePicks
-    state.focusedIndex = 0
-    state.state = STATE_FINISHED
-    state.minLineY = 0
-    state.maxLineY = Math.min(
-      state.minLineY + state.maxVisibleItems,
-      newPicks.length - 1
-    )
-    return
-  }
-  state.state = STATE_CREATING
-  const version = ++state.versionId
-  // TODO also pass initial value here
-  await RendererProcess.invoke(
-    /* Viewlet.load */ 'Viewlet.load',
-    /* id */ 'QuickPick'
-  )
-  const newPicks = await provider.getPicks(value)
-  Assert.array(newPicks)
-  if (version !== state.versionId) {
-    return
-  }
-  if (newPicks.length === 0) {
-    const noResults = await provider.getNoResults()
-    RendererProcess.invoke(
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'QuickPick',
-      /* method */ 'showNoResults',
-      /* noResults */ noResults,
-      /* unfocusIndex */ state.focusedIndex
-    )
-    return
-  }
-  const filterValue = provider.getFilterValue(value)
-  const visiblePicks = getVisiblePicks(newPicks, filterValue)
-  const placeholder = provider.getPlaceholder()
-  const label = provider.getLabel()
-  RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'QuickPick',
-    /* method */ 'updateValueAndPicksAndPlaceholder',
-    /* value */ value,
-    /* picks */ visiblePicks,
-    /* focusIndex */ 0,
-    /* unFocusIndex */ -1,
-    /* placeholder */ placeholder,
-    /* label */ label
-  )
-  state.picks = newPicks
-  state.visiblePicks = visiblePicks
-  state.focusedIndex = 0
-  state.state = STATE_FINISHED
-  state.minLineY = 0
-  state.maxLineY = Math.min(
-    state.minLineY + state.maxVisibleItems,
-    newPicks.length - 1
-  )
-}
-
-export const dispose = () => {
-  switch (state.state) {
-    case STATE_DEFAULT:
-    case STATE_CREATING:
-      break
-    case STATE_FINISHED:
-      state.state = STATE_DEFAULT
-      RendererProcess.invoke(
-        /* Viewlet.dispose */ 'Viewlet.dispose',
-        /* id */ 'QuickPick'
-      )
-      break
-    default:
-      break
-  }
-}
-
-export const handleBlur = async () => {
-  switch (state.state) {
-    case STATE_DEFAULT:
-    case STATE_CREATING:
-      break
-    case STATE_FINISHED:
-      await dispose()
-      break
-    default:
-      break
-  }
-}
-
-const getPick = (state, index) => {
-  // if (index < state.recentPicks.length) {
-  //   return state.recentPicks[index]
-  // }
-  // index -= state.recentPicks.length
-  if (index < state.filteredPicks.length) {
-    return state.filteredPicks[index]
-  }
-  console.warn('no pick matching index', index)
-}
-
-export const selectIndex = async (index, button = /* left */ 0) => {
-  const pick = getPick(state, index)
-  const versionBefore = state.versionId
-  const selectPickResult = await state.provider.selectPick(pick, index, button)
-  Assert.object(selectPickResult)
-  Assert.string(selectPickResult.command)
-  const { command } = selectPickResult
-  const versionAfter = state.versionId
-  if (versionBefore !== versionAfter) {
-    // selecting a pick might have opened another quick pick
-    // so there is no need to hide the quick pick
-    return
-  }
-  switch (command) {
-    case 'hide':
-      dispose()
-      break
-    default:
-      break
-  }
-
-  // TODO recent picks should be per provider
-  // if (!state.recentPickIds.has(pick.id)) {
-  //   state.recentPicks.unshift(pick)
-  //   state.recentPickIds.add(pick.id)
-  // }
-  // if (state.recentPicks.length > RECENT_PICKS_MAX_SIZE) {
-  //   const last = state.recentPicks.pop()
-  //   state.recentPickIds.delete(last.id)
-  // }
-}
-
-export const selectCurrentIndex = async () => {
-  await selectIndex(state.focusedIndex)
-}
-
-// TODO when user types letters -> no need to query provider again -> just filter existing results
-export const handleInput = async (value) => {
-  if (state.state === STATE_DEFAULT) {
-    return
-  }
-  state.state = STATE_CREATING
-  const version = ++state.versionId
-  // TODO if provider is immutable, don't necessarily need to get new picks
-  const newPicks = await state.provider.getPicks(value)
-  if (version !== state.versionId) {
-    return
-  }
-  const filterValue = state.provider.getFilterValue(value)
-  const visiblePicks = getVisiblePicks(newPicks, filterValue)
-
-  RendererProcess.invoke(
-    /* Viewlet.send */ 'Viewlet.send',
-    /* id */ 'QuickPick',
-    /* method */ 'updatePicks',
-    /* picks */ visiblePicks,
-    /* unFocusIndex */ state.focusedIndex
-  )
-  state.picks = newPicks
-  state.visiblePicks = visiblePicks
-  state.focusedIndex = 0
-  state.state = STATE_FINISHED
-}
-
-// TODO use reactive Programming
-// https://angular-2-training-book.rangle.io/http/search_with_switchmap
-
-// searchField.valuesChanges.debounceTime(400).switchMap(term => search(term)).subscribe(result => {
-//   sendRendererProcess(result)
-// })
-// merge(openStream, closeStream, updateStream).switchMap(state => {
-//   switch(state){
-//     case 'default':
-//
-// }
-//
-// })
-
-export const focusIndex = async (index) => {
-  console.log({ index, maxLineY: state.maxLineY })
-  if (index < state.minLineY) {
-    state.minLineY = index
-    state.maxLineY = Math.min(
-      index + state.maxVisibleItems,
-      state.filteredPicks.length - 1
-    )
-    const slicedPicks = state.filteredPicks.slice(
-      state.minLineY,
-      state.maxLineY
-    )
-    const displayPicks = toDisplayPicks(slicedPicks)
-    const relativeFocusIndex = index - state.minLineY
-    const relativeUnFocusIndex = state.focusedIndex - state.minLineY
-    RendererProcess.invoke(
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'QuickPick',
-      /* method */ 'updateValueAndPicks', // TODO don't need to update value, just picks and focus
-      /* value */ state.value,
-      /* visiblePicks */ displayPicks,
-      /* focusIndex */ relativeFocusIndex,
-      /* unFocusIndex */ relativeUnFocusIndex
-    )
-    // TODO need to scroll up
-  } else if (index > state.maxLineY) {
-    // TODO need to scroll down
-    state.minLineY = Math.max(0, index - state.maxVisibleItems)
-    state.maxLineY = Math.min(
-      index + state.maxVisibleItems - 1,
-      state.filteredPicks.length - 1
-    )
-    const slicedPicks = state.filteredPicks.slice(
-      state.minLineY,
-      state.maxLineY
-    )
-    console.log(
-      'scroll down',
-      index,
-      state.minLineY,
-      state.maxLineY,
-      slicedPicks
-    )
-    const displayPicks = toDisplayPicks(slicedPicks)
-    const relativeFocusIndex = index - state.minLineY
-    const relativeUnFocusIndex = state.focusedIndex - state.minLineY
-    console.log({
-      relativeFocusIndex,
-      relativeUnFocusIndex,
-    })
-    RendererProcess.invoke(
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'QuickPick',
-      /* method */ 'updateValueAndPicks', // TODO don't need to update value, just picks and focus
-      /* value */ state.value,
-      /* visiblePicks */ displayPicks,
-      /* focusIndex */ relativeFocusIndex,
-      /* unFocusIndex */ relativeUnFocusIndex
-    )
-  } else {
-    RendererProcess.invoke(
-      /* Viewlet.send */ 'Viewlet.send',
-      /* id */ 'QuickPick',
-      /* method */ 'focusIndex',
-      /* unFocusIndex */ state.focusedIndex,
-      /* index */ index
-    )
-  }
-
-  state.focusedIndex = index
-  // TODO get types working
-  // @ts-ignore
-  if (state.provider.focusPick) {
-    // @ts-ignore
-    await state.provider.focusPick(state.filteredPicks[index])
-  }
-}
-
-export const focusFirst = async () => {
-  await focusIndex(0)
-}
-
-export const focusLast = async () => {
-  await focusIndex(state.filteredPicks.length - 1)
-}
-
-export const focusPrevious = async () => {
-  const previousIndex =
-    state.focusedIndex === 0
-      ? state.filteredPicks.length - 1
-      : state.focusedIndex - 1
-  await focusIndex(previousIndex)
-}
-
-export const focusNext = async () => {
-  const nextIndex = (state.focusedIndex + 1) % state.filteredPicks.length
-  await focusIndex(nextIndex)
-}
-
-// TODO not sure these should be in this file
-export const openCommandPalette = async () => {
-  const QuickPickEverything = await import('./QuickPickEverything.js')
-  await show('>', QuickPickEverything)
-}
-
-export const openEverythingQuickPick = async () => {
-  const QuickPickEverything = await import('./QuickPickEverything.js')
-  await show('', QuickPickEverything)
-}
-
-export const openGoToLine = async () => {
-  const QuickPickEverything = await import('./QuickPickEverything.js')
-  await show(':', QuickPickEverything)
-}
-
-export const openView = async () => {
-  await show('view ')
-}
-
-export const openColorTheme = async () => {
-  const QuickPickColorTheme = await import('./QuickPickColorTheme.js')
-  await show('', QuickPickColorTheme)
-}
-
-export const fileOpenRecent = async () => {
-  const QuickPickOpenRecent = await import('./QuickPickOpenRecent.js')
-  await show('', QuickPickOpenRecent)
-}
-
-export const showExtensionsQuickPick = async (items) => {
-  Assert.array(items)
-  // TODO handle error, promise swallows error
-  const provider = {
-    getPicks() {
-      return items
-    },
-    async selectPick(item, index) {
-      const ExtensionHost = await import(
-        '../ExtensionHost/ExtensionHostCore.js'
-      )
-      await ExtensionHost.invoke(
-        /* ExtensionHostQuickPick.handleQuickPickResult */ 'ExtensionHostQuickPick.handleQuickPickResult',
-        /* index */ index
-      )
-      return {
-        command: 'hide',
-      }
-    },
-    getFilterValue(value) {
-      return value
-    },
-    getPlaceholder() {
-      return ''
-    },
-    getLabel() {
-      return 'extension pick'
-    },
-  }
-  await show('', provider)
-}

package/static/eb65b4e/packages/renderer-worker/src/parts/QuickPick/QuickPickCommand.js

@@ -1,105 +0,0 @@
-import * as Command from '../Command/Command.js'
-import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
-import * as ExtensionHostCommands from '../ExtensionHost/ExtensionHostCommands.js'
-import * as Platform from '../Platform/Platform.js'
-
-export const getPlaceholder = () => {
-  return 'Type the name of a command to run.'
-}
-
-export const helpEntries = () => {
-  return [
-    {
-      description: 'Show And Run Commands',
-      category: 'global commands',
-    },
-  ]
-}
-
-export const getLabel = () => {
-  return ''
-}
-
-export const getNoResults = () => {
-  return {
-    label: 'No matching results',
-  }
-}
-
-// TODO combine Ajax with cache (specify strategy: cacheFirst, networkFirst)
-const getBuiltinPicks = async () => {
-  const assetDir = Platform.getAssetDir()
-  const url = `${assetDir}/config/builtinCommands.json`
-  const builtinPicks = await Command.execute(
-    /* Ajax.getJson */ 'Ajax.getJson',
-    /* url */ url
-  )
-  return builtinPicks
-}
-
-const prefixIdWithExt = (item) => {
-  if (!item.label) {
-    ErrorHandling.warn('[QuickPick] item has missing label', item)
-  }
-  if (!item.id) {
-    ErrorHandling.warn('[QuickPick] item has missing id', item)
-  }
-  return {
-    ...item,
-    id: `ext.${item.id}`,
-    label: item.label || item.id,
-  }
-}
-
-const getExtensionPicks = async () => {
-  // TODO don't call this every time
-  const extensionPicks = await ExtensionHostCommands.getCommands()
-  const mappedPicks = extensionPicks.map(prefixIdWithExt)
-  return mappedPicks
-}
-
-// TODO send strings to renderer process only once for next occurrence send uint16array of ids of strings
-
-export const getPicks = async () => {
-  if (Platform.getPlatform() === 'web') {
-    const builtinPicks = await getBuiltinPicks()
-    return builtinPicks
-  }
-  const builtinPicks = await getBuiltinPicks()
-  const extensionPicks = await getExtensionPicks()
-  return [...builtinPicks, ...extensionPicks]
-}
-
-const selectPickBuiltin = async (item) => {
-  // TODO ids should be all numbers for efficiency -> also directly can call command
-  const id = await Command.execute(/* id */ item.id)
-  await Command.execute(id)
-  console.log('execute', id)
-}
-
-const selectPickExtension = async (item) => {
-  console.log('ext pick', item)
-  const id = item.id.slice(4) // TODO lots of string allocation with 'ext.' find a better way to separate builtin commands from extension commands
-  try {
-    await ExtensionHostCommands.executeCommand(id)
-  } catch (error) {
-    ErrorHandling.showErrorDialog(error)
-    // console.log({ error })
-    // console.error(error)
-  }
-}
-
-export const selectPick = async (item) => {
-  if (item.id.startsWith('ext.')) {
-    await selectPickExtension(item)
-  } else {
-    await selectPickBuiltin(item)
-  }
-  return {
-    command: 'hide',
-  }
-}
-
-export const getFilterValue = (value) => {
-  return value
-}

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

@@ -1,112 +0,0 @@
-/* istanbul ignore file */
-import * as Callback from '../Callback/Callback.js'
-import * as Command from '../Command/Command.js'
-
-export const state = {
-  pendingMessages: [],
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-}
-
-const handleMessageFromRendererProcess = async (event) => {
-  const message = event.data
-  if (message.id) {
-    if ('result' in message) {
-      Callback.resolve(message.id, message.result)
-    } else {
-      Callback.reject(message.id, message.error)
-    }
-  } else {
-    await Command.execute(...message)
-  }
-}
-
-const listenModuleWorker = () => {
-  onmessage = handleMessageFromRendererProcess
-  return {
-    send(message) {
-      postMessage(message)
-    },
-    sendAndTransfer(message, transferables) {
-      postMessage(message, transferables)
-    },
-  }
-}
-
-const listenMessagePort = () => {
-  const messageChannel = new MessageChannel()
-  messageChannel.port1.onmessage = handleMessageFromRendererProcess
-  globalThis.acceptPort(messageChannel.port2)
-  return {
-    send(message) {
-      messageChannel.port1.postMessage(message)
-    },
-    sendAndTransfer(message, transferables) {
-      messageChannel.port1.postMessage(message, transferables)
-    },
-  }
-}
-
-const listenReferencePort = () => {
-  const referencePort = {
-    onmessage(message, transferables) {},
-    postMessage: state.handleMessage,
-  }
-  // TODO get rid of extra data wrapper
-  globalThis.acceptReferencePort(referencePort)
-  return {
-    send(message) {
-      referencePort.onmessage({ data: message })
-    },
-    sendAndTransfer({ data: message }, transferables) {
-      referencePort.onmessage(message, transferables)
-    },
-  }
-}
-
-const getIpc = () => {
-  // TODO tree-shake out if/else in prod
-  if (globalThis.acceptPort) {
-    return listenMessagePort()
-  } else if (globalThis.acceptReferencePort) {
-    return listenReferencePort()
-  } else {
-    return listenModuleWorker()
-  }
-}
-
-export const listen = () => {
-  console.assert(state.pendingMessages.length === 0)
-  const ipc = getIpc()
-  state.ipc = ipc
-}
-
-/**
- * @deprecated use invoke instead
- * @param {*} message
- */
-export const send = (message) => {
-  state.ipc.send(message)
-}
-
-export const invoke = async (method, ...params) => {
-  const responseMessage = await new Promise((resolve, reject) => {
-    const callbackId = Callback.register(resolve, reject)
-    state.ipc.send({
-      jsonrpc: '2.0',
-      method,
-      params,
-      id: callbackId,
-    })
-  })
-  if (responseMessage instanceof Error) {
-    throw responseMessage
-  }
-  return responseMessage
-}
-
-export const sendAndTransfer = (message, transferables) => {
-  state.ipc.sendAndTransfer(message, transferables)
-}

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

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