@lvce-editor/server 0.0.21 → 0.0.22

package/static/{e236e21 → 09bf9c7}/packages/renderer-worker/src/parts/Platform/Platform.js

@@ -31,9 +31,9 @@ export const state = {
   },
   getAssetDir() {
     // @ts-ignore
-    if (typeof '/e236e21' !== 'undefined') {
+    if (typeof '/09bf9c7' !== 'undefined') {
       // @ts-ignore
-      return '/e236e21'
+      return '/09bf9c7'
     }
     if (this.getPlatform() === 'electron') {
       return '../../../../..'

package/static/{e236e21 → 09bf9c7}/packages/renderer-worker/src/parts/QuickPick/QuickPick.js

@@ -111,7 +111,7 @@ export const show = async (value, provider) => {
     const visiblePicks = getVisiblePicks(newPicks, filterValue)
     const placeholder = provider.getPlaceholder()
     const label = provider.getLabel()
-    RendererProcess.send([
+    RendererProcess.invoke(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'updateValueAndPicksAndPlaceholder',
@@ -120,8 +120,8 @@ export const show = async (value, provider) => {
       /* focusIndex */ 0,
       /* unFocusIndex */ state.focusedIndex,
       /* placeholder */ placeholder,
-      /* label */ label,
-    ])
+      /* label */ label
+    )
     state.picks = newPicks
     state.visiblePicks = visiblePicks
     state.focusedIndex = 0
@@ -144,20 +144,20 @@ export const show = async (value, provider) => {
   }
   if (newPicks.length === 0) {
     const noResults = await provider.getNoResults()
-    RendererProcess.send([
+    RendererProcess.invoke(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'showNoResults',
       /* noResults */ noResults,
-      /* unfocusIndex */ state.focusedIndex,
-    ])
+      /* unfocusIndex */ state.focusedIndex
+    )
     return
   }
   const filterValue = provider.getFilterValue(value)
   const visiblePicks = getVisiblePicks(newPicks, filterValue)
   const placeholder = provider.getPlaceholder()
   const label = provider.getLabel()
-  RendererProcess.send([
+  RendererProcess.invoke(
     /* Viewlet.send */ 3024,
     /* id */ 'QuickPick',
     /* method */ 'updateValueAndPicksAndPlaceholder',
@@ -166,8 +166,8 @@ export const show = async (value, provider) => {
     /* focusIndex */ 0,
     /* unFocusIndex */ -1,
     /* placeholder */ placeholder,
-    /* label */ label,
-  ])
+    /* label */ label
+  )
   state.picks = newPicks
   state.visiblePicks = visiblePicks
   state.focusedIndex = 0
@@ -186,7 +186,7 @@ export const dispose = () => {
       break
     case STATE_FINISHED:
       state.state = STATE_DEFAULT
-      RendererProcess.send([/* Viewlet.dispose */ 3026, /* id */ 'QuickPick'])
+      RendererProcess.invoke(/* Viewlet.dispose */ 3026, /* id */ 'QuickPick')
       break
     default:
       break
@@ -310,15 +310,15 @@ export const focusIndex = async (index) => {
     const displayPicks = toDisplayPicks(slicedPicks)
     const relativeFocusIndex = index - state.minLineY
     const relativeUnFocusIndex = state.focusedIndex - state.minLineY
-    RendererProcess.send([
+    RendererProcess.invoke(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'updateValueAndPicks', // TODO don't need to update value, just picks and focus
       /* value */ state.value,
       /* visiblePicks */ displayPicks,
       /* focusIndex */ relativeFocusIndex,
-      /* unFocusIndex */ relativeUnFocusIndex,
-    ])
+      /* unFocusIndex */ relativeUnFocusIndex
+    )
     // TODO need to scroll up
   } else if (index > state.maxLineY) {
     // TODO need to scroll down
@@ -345,23 +345,23 @@ export const focusIndex = async (index) => {
       relativeFocusIndex,
       relativeUnFocusIndex,
     })
-    RendererProcess.send([
+    RendererProcess.invoke(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'updateValueAndPicks', // TODO don't need to update value, just picks and focus
       /* value */ state.value,
       /* visiblePicks */ displayPicks,
       /* focusIndex */ relativeFocusIndex,
-      /* unFocusIndex */ relativeUnFocusIndex,
-    ])
+      /* unFocusIndex */ relativeUnFocusIndex
+    )
   } else {
-    RendererProcess.send([
+    RendererProcess.invoke(
       /* Viewlet.send */ 3024,
       /* id */ 'QuickPick',
       /* method */ 'focusIndex',
       /* unFocusIndex */ state.focusedIndex,
-      /* index */ index,
-    ])
+      /* index */ index
+    )
   }
 
   state.focusedIndex = index

package/static/{e236e21 → 09bf9c7}/packages/renderer-worker/src/parts/RendererProcess/RendererProcess.js

@@ -5,51 +5,48 @@ import * as Command from '../Command/Command.js'
 export const state = {
   pendingMessages: [],
   /**
-   *
-   * @param {any} message
-   * @returns {void}
+   * @type {any}
    */
-  send(message) {
-    throw new Error('not implemented')
-  },
-  // TODO renderer process should only be able send events
-  // should not be able to invoke callbacks
-  handleMessage(message) {
-    switch (message[0]) {
-      case 67330:
-      case 67331:
-        Callback.resolve(message[1], message[2])
-        break
-      default:
-        Command.execute(...message)
-        break
-    }
-  },
-  sendAndTransfer(message, transferables) {},
+  ipc: undefined,
 }
 
 const handleMessageFromRendererProcess = (event) => {
-  state.handleMessage(event.data)
+  const message = event.data
+  switch (message[0]) {
+    case 67330:
+    case 67331:
+      Callback.resolve(message[1], message[2])
+      break
+    default:
+      Command.execute(...message)
+      break
+  }
 }
 
 const listenModuleWorker = () => {
   onmessage = handleMessageFromRendererProcess
-  state.send = (message) => postMessage(message)
-  state.sendAndTransfer = (message, transferables) => {
-    postMessage(message, transferables)
+  return {
+    send(message) {
+      postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      postMessage(message, transferables)
+    },
   }
 }
 
 const listenMessagePort = () => {
   const messageChannel = new MessageChannel()
   messageChannel.port1.onmessage = handleMessageFromRendererProcess
-  state.send = (message) => {
-    messageChannel.port1.postMessage(message)
-  }
-  state.sendAndTransfer = (message, transferables) => {
-    messageChannel.port1.postMessage(message, transferables)
-  }
   globalThis.acceptPort(messageChannel.port2)
+  return {
+    send(message) {
+      messageChannel.port1.postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      messageChannel.port1.postMessage(message, transferables)
+    },
+  }
 }
 
 const listenReferencePort = () => {
@@ -58,39 +55,46 @@ const listenReferencePort = () => {
     postMessage: state.handleMessage,
   }
   // TODO get rid of extra data wrapper
-  state.send = (message) => {
-    referencePort.onmessage({ data: message })
-  }
-  state.sendAndTransfer = ({ data: message }, transferables) => {
-    referencePort.onmessage(message, transferables)
-  }
   globalThis.acceptReferencePort(referencePort)
+  return {
+    send(message) {
+      referencePort.onmessage({ data: message })
+    },
+    sendAndTransfer({ data: message }, transferables) {
+      referencePort.onmessage(message, transferables)
+    },
+  }
 }
 
-export const listen = () => {
-  console.assert(state.pendingMessages.length === 0)
+const getIpc = () => {
   // TODO tree-shake out if/else in prod
   if (globalThis.acceptPort) {
-    listenMessagePort()
+    return listenMessagePort()
   } else if (globalThis.acceptReferencePort) {
-    listenReferencePort()
+    return listenReferencePort()
   } else {
-    listenModuleWorker()
+    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.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.send([
+    state.ipc.send([
       /* RendererWorker.invoke */ 909090,
       /* callbackId */ callbackId,
       /* method */ method,
@@ -104,5 +108,5 @@ export const invoke = async (method, ...params) => {
 }
 
 export const sendAndTransfer = (message, transferables) => {
-  state.sendAndTransfer(message, transferables)
+  state.ipc.sendAndTransfer(message, transferables)
 }

package/static/{e236e21 → 09bf9c7}/packages/renderer-worker/src/parts/TitleBarMenuBar/TitleBarMenuBar.js

@@ -4,6 +4,9 @@ import * as MenuEntries from '../MenuEntries/MenuEntries.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 
 export const state = {
+  /**
+   * @type{any[]}
+   */
   titleBarEntries: [],
   focusedIndex: 0,
   isMenuOpen: false,
@@ -78,20 +81,20 @@ export const openMenu = async (focus) => {
   await openMenuAtIndex(state.focusedIndex, focus)
 }
 
-export const closeMenu = (keepFocus) => {
+export const closeMenu = async (keepFocus) => {
   // TODO send to renderer process
   // 1. close menu
   // 2. focus top level entry
   const focusIndex = keepFocus ? state.focusedIndex : -1
   // TODO use Viewlet.dispose instead
-  RendererProcess.send([
+  state.isMenuOpen = false
+  await RendererProcess.invoke(
     /* Viewlet.send */ 3024,
     /* id */ 'TitleBar',
     /* method */ 'menuClose',
     /* unFocusIndex */ state.focusedIndex,
-    /* focusIndex */ focusIndex,
-  ])
-  state.isMenuOpen = false
+    /* focusIndex */ focusIndex
+  )
 }
 
 export const toggleMenu = async () => {
@@ -106,11 +109,11 @@ export const focusIndex = async (index) => {
   if (state.isMenuOpen) {
     await openMenuAtIndex(index, /* focus */ false)
   } else {
-    RendererProcess.send([
+    await RendererProcess.invoke(
       /* TitleBarMenuBar.focusIndex */ 1371,
       /* unFocusIndex */ state.focusedIndex,
-      /* index */ index,
-    ])
+      /* index */ index
+    )
   }
   state.focusedIndex = index
 }
@@ -145,7 +148,6 @@ const getIndexToFocusNextStartingAt = (items, index) => {
 }
 
 export const focusNext = async () => {
-  console.log('ff next')
   const indexToFocus = getIndexToFocusNextStartingAt(
     state.titleBarEntries,
     state.focusedIndex + 1

package/static/{e236e21 → 09bf9c7}/packages/renderer-worker/src/parts/Viewlet/ViewletContextMenu.js

@@ -58,13 +58,13 @@ export const contentLoaded = async (state) => {
   if (y + contextMenuHeight > windowHeight) {
     y -= contextMenuHeight
   }
-  await RendererProcess.invoke([
+  await RendererProcess.invoke(
     /* Viewlet.load */ 3030,
     /* id */ 'ContextMenu',
     /* top */ y,
     /* left */ x,
     /* width */ contextMenuWidth,
     /* height */ contextMenuHeight,
-    /* items */ state.items,
-  ])
+    /* items */ state.items
+  )
 }

package/static/{e236e21 → 09bf9c7}/packages/renderer-worker/src/parts/Viewlet/ViewletExplorer.js

@@ -101,7 +101,7 @@ export const create = (id, uri, left, top, width, height) => {
   return {
     root: '',
     dirents: [],
-    focusedIndex: -1,
+    focusedIndex: -2,
     hoverIndex: -1,
     top,
     left,
@@ -506,7 +506,7 @@ const newDirent = async (state) => {
   // TODO do it like vscode, select position between folders and files
   const focusedIndex = state.focusedIndex
   const index = state.focusedIndex + 1
-  if (focusedIndex !== -1) {
+  if (focusedIndex >= 0) {
     const dirent = state.dirents[state.focusedIndex]
     console.log({ dirent, dirents: state.dirents, fi: state.focusedIndex })
     if (dirent.type === 'directory') {
@@ -699,7 +699,7 @@ const handleClickDirectoryExpanded = async (state, dirent, index) => {
 
 export const handleClick = async (state, index) => {
   if (index === -1) {
-    state.focusedIndex = -1
+    await focusIndex(state, -1)
     return
   }
   const actualIndex = index + state.minLineY
@@ -731,12 +731,14 @@ export const handleClickCurrent = async (state) => {
 }
 
 export const focusIndex = async (state, index) => {
+  const oldFocusedIndex = state.focusedIndex
   state.focusedIndex = index
   await RendererProcess.invoke(
     /* viewSend */ 3024,
     /* id */ 'Explorer',
-    /* method */ 'focusIndex',
-    /* focusedIndex */ state.focusedIndex
+    /* method */ 'setFocusedIndex',
+    /* oldIndex */ oldFocusedIndex,
+    /* newIndex */ state.focusedIndex
   )
 }