@lvce-editor/server 0.4.3 → 0.5.0

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletMain/ViewletMain.js

@@ -5,10 +5,14 @@ import * as LifeCycle from '../LifeCycle/LifeCycle.js'
 import * as RendererProcess from '../RendererProcess/RendererProcess.js'
 import * as SharedProcess from '../SharedProcess/SharedProcess.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as ViewletStates from '../ViewletStates/ViewletStates.js'
 import * as ViewletManager from '../ViewletManager/ViewletManager.js'
-import * as Workspace from '../Workspace/Workspace.js'
+import * as ViewletMap from '../ViewletMap/ViewletMap.js'
 import * as ViewletModule from '../ViewletModule/ViewletModule.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+import * as Workspace from '../Workspace/Workspace.js'
+import * as Arrays from '../Arrays/Arrays.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+
 const COLUMN_WIDTH = 9 // TODO compute this automatically once
 
 // interface Editor {
@@ -40,17 +44,22 @@ const COLUMN_WIDTH = 9 // TODO compute this automatically once
 //   readonly type: 'video'
 // }
 
-const getMainEditor = (state) => {
+const canBeRestored = (editor) => {
+  return FileSystem.canBeRestored(editor.uri)
+}
+
+const getMainEditors = (state) => {
   if (
     !state ||
     !state.instances ||
-    !state.instances.EditorText ||
-    !state.instances.EditorText.state
+    !state.instances.Main ||
+    !state.instances.Main.state ||
+    !state.instances.Main.state.editors
   ) {
-    return undefined
+    return []
   }
   // TODO check that type is string (else runtime error occurs and page is blank)
-  return state.instances.EditorText.state
+  return state.instances.Main.state.editors.filter(canBeRestored).slice(-1)
 }
 
 const restoreEditors = async (state) => {
@@ -155,7 +164,6 @@ const findEditorWithUri = (editors, uri) => {
 }
 
 const TAB_HEIGHT = 35
-const id = 'EditorText'
 
 const getRestoredEditors = async () => {
   if (Workspace.isTest()) {
@@ -165,15 +173,13 @@ const getRestoredEditors = async () => {
     /* LocalStorage.getJson */ 'LocalStorage.getJson',
     /* key */ 'stateToSave'
   )
-  const restoredEditor = getMainEditor(savedState)
-  if (!restoredEditor) {
-    return []
-  }
-  return [restoredEditor]
+  const restoredEditors = getMainEditors(savedState)
+  return restoredEditors
 }
 
 export const loadContent = async (state) => {
   const editors = await getRestoredEditors()
+  console.log({ editors })
   // @ts-ignore
 
   LifeCycle.once(LifeCycle.PHASE_TWELVE, hydrateLazy)
@@ -187,11 +193,12 @@ export const contentLoaded = async (state) => {
   if (state.editors.length === 0) {
     return
   }
-  const editor = state.editors[0]
+  const editor = Arrays.last(state.editors)
   const top = state.top + TAB_HEIGHT
   const left = state.left
   const width = state.width
   const height = state.height - TAB_HEIGHT
+  const id = ViewletMap.getId(editor.uri)
   const instance = ViewletManager.create(
     ViewletModule.load,
     id,
@@ -208,7 +215,6 @@ export const contentLoaded = async (state) => {
     /* Viewlet.send */ 'Viewlet.send',
     /* id */ 'Main',
     /* method */ 'openViewlet',
-    /* id */ id,
     /* tabLabel */ tabLabel,
     /* tabTitle */ tabTitle
   )
@@ -225,9 +231,11 @@ export const openUri = async (state, uri, focus = true) => {
   const left = state.left
   const width = state.width
   const height = state.height - TAB_HEIGHT
+  const id = ViewletMap.getId(uri)
 
   for (const editor of state.editors) {
     if (editor.uri === uri) {
+      // TODO if the editor is already open, nothing needs to be done
       const instance = ViewletManager.create(
         ViewletModule.load,
         id,
@@ -263,7 +271,6 @@ export const openUri = async (state, uri, focus = true) => {
     /* Viewlet.send */ 'Viewlet.send',
     /* id */ 'Main',
     /* method */ 'openViewlet',
-    /* id */ id,
     /* tabLabel */ tabLabel,
     /* tabTitle */ tabTitle,
     /* oldActiveIndex */ oldActiveIndex
@@ -316,23 +323,32 @@ export const closeActiveEditor = (state) => {
   }
 }
 
-export const closeAllEditors = (state) => {
+const getId = (editor) => {
+  return ViewletMap.getId(editor.uri)
+}
+
+export const closeAllEditors = async (state) => {
   RendererProcess.invoke(
     /* Viewlet.send */ 'Viewlet.send',
     /* id */ 'Main',
     /* method */ 'dispose'
   )
+  const ids = state.editors.map(getId)
   state.editors = []
   state.focusedIndex = -1
   state.selectedIndex = -1
   // TODO should call dispose method, but only in renderer-worker
-  ViewletStates.remove('EditorText')
+  for (const id of ids) {
+    await ViewletStates.dispose(id)
+  }
 }
 
 export const dispose = () => {}
 
 export const closeEditor = async (state, index) => {
+  console.log('close', index, 'of', state.editors)
   if (state.editors.length === 1) {
+    console.log('close all')
     closeAllEditors(state)
     return
   }
@@ -342,9 +358,11 @@ export const closeEditor = async (state, index) => {
   const height = state.height
   if (index === state.activeIndex) {
     const oldActiveIndex = state.activeIndex
+    const oldEditor = state.editors[index]
     state.editors.splice(index, 1)
     const newActiveIndex = index === 0 ? index : index - 1
-    Viewlet.dispose('EditorText')
+    const id = ViewletMap.getId(oldEditor.uri)
+    Viewlet.dispose(id)
     state.activeIndex = newActiveIndex
     state.focusedIndex = newActiveIndex
     // const instance = Viewlet.create(id, 'uri', left, top, width, height)
@@ -360,7 +378,7 @@ export const closeEditor = async (state, index) => {
     //   columnWidth: COLUMN_WIDTH,
     // })
     await RendererProcess.invoke(
-      /* Main.closeOneTab */ 2164,
+      /* Main.closeOneTab */ 'Main.closeOneTab',
       /* closeIndex */ oldActiveIndex,
       /* focusIndex */ newActiveIndex
     )
@@ -408,6 +426,7 @@ export const focusIndex = (state, index) => {
   const left = state.left
   const width = state.width
   const height = state.height - TAB_HEIGHT
+  const id = ViewletMap.getId(editor.uri)
 
   const viewlet = ViewletManager.create(
     ViewletModule.load,

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletManager/ViewletManager.js

@@ -144,7 +144,7 @@ export const load = async (viewlet, focus = false) => {
       })
     }
 
-    if (viewletState !== newState) {
+    if (viewletState !== newState && module.contentLoaded) {
       await module.contentLoaded(newState)
     }
 

package/static/4d80653/packages/renderer-worker/src/parts/ViewletMap/ViewletMap.js

@@ -0,0 +1,24 @@
+import * as Path from '../Path/Path.js'
+
+const mapExtToEditorType = {
+  '.png': 'EditorImage',
+  '.svg': 'EditorImage',
+  '.avif': 'EditorImage',
+  '.gif': 'EditorImage',
+  '.ico': 'EditorImage',
+  '.webp': 'EditorImage',
+  '.jpg': 'EditorImage',
+  '.jpeg': 'EditorImage',
+}
+
+export const getId = (uri) => {
+  const fileExtension = Path.fileExtension(uri)
+  const type = mapExtToEditorType[fileExtension]
+  if (type) {
+    return type
+  }
+  if (uri === 'app://keybindings') {
+    return 'KeyBindings'
+  }
+  return 'EditorText'
+}

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletModule/ViewletModule.js

@@ -50,6 +50,8 @@ export const load = (moduleId) => {
       return import('../ViewletImplementations/ViewletImplementations.ipc.js')
     case ViewletModuleId.QuickPick:
       return import('../ViewletQuickPick/ViewletQuickPick.ipc.js')
+    case ViewletModuleId.KeyBindings:
+      return import('../ViewletKeyBindings/ViewletKeyBindings.ipc.js')
     default:
       throw new Error(`unknown module "${moduleId}"`)
   }

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletModuleId/ViewletModuleId.js

@@ -18,6 +18,8 @@ export const Extensions = 'Extensions'
 
 export const Implementations = 'Implementations'
 
+export const KeyBindings = 'KeyBindings'
+
 export const Main = 'Main'
 
 export const Noop = 'Noop'

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletPanel/ViewletPanel.js

@@ -75,7 +75,6 @@ export const openViewlet = async (state, id) => {
 }
 
 export const selectIndex = async (state, index) => {
-  console.log({ index })
   await openViewlet(state, state.views[index])
   return {
     ...state,

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletProblems/ViewletProblems.js

@@ -34,7 +34,6 @@ export const loadContent = async (state) => {
 export const contentLoaded = async (state) => {}
 
 export const focusIndex = (state, index) => {
-  console.log({ index })
   return {
     ...state,
     focusedIndex: index,

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletQuickPick/ViewletQuickPick.js

@@ -3,6 +3,8 @@ import * as FuzzySearch from '../FuzzySearch/FuzzySearch.js'
 import * as QuickPickEveryThing from '../QuickPick/QuickPickEverything.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
 import * as InputEventType from '../InputEventType/InputEventType.js'
+import * as QuickPickModule from '../QuickPickModule/QuickPickModule.js'
+
 // TODO send open signal to renderer process before items are ready
 // that way user can already type while items are still loading
 
@@ -10,9 +12,6 @@ import * as InputEventType from '../InputEventType/InputEventType.js'
 // 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)
@@ -112,33 +111,6 @@ const getFilteredItems = (state, picks, filterValue) => {
   // return toDisplayPicks(slicedPicks)
 }
 
-const getProvider = (uri) => {
-  switch (uri) {
-    case 'quickPick://commandPalette':
-      return import('../QuickPick/QuickPickCommand.js')
-    case 'quickPick://file':
-      return import('../QuickPick/QuickPickFile.js')
-    case 'quickPick://everything':
-      return import('../QuickPick/QuickPickEverything.js')
-    case 'quickPick://noop':
-      return import('../QuickPick/QuickPickNoop.js')
-    case 'quickPick://number':
-      return import('../QuickPick/QuickPickNumber.js')
-    case 'quickPick://recent':
-      return import('../QuickPick/QuickPickOpenRecent.js')
-    case 'quickPick://color-theme':
-      return import('../QuickPick/QuickPickColorTheme.js')
-    case 'quickPick://symbol':
-      return import('../QuickPick/QuickPickSymbol.js')
-    case 'quickPick://view':
-      return import('../QuickPick/QuickPickView.js')
-    case 'quickPick://workspace-symbol':
-      return import('../QuickPick/QuickPickWorkspaceSymbol.js')
-    default:
-      throw new Error(`unsupported quick pick type: ${uri}`)
-  }
-}
-
 const getDefaultValue = (uri) => {
   switch (uri) {
     case 'quickPick://everything':
@@ -151,7 +123,7 @@ const getDefaultValue = (uri) => {
 export const loadContent = async (state) => {
   const uri = state.uri
   const value = getDefaultValue(uri)
-  const provider = await getProvider(uri)
+  const provider = await QuickPickModule.load(uri)
   const newPicks = await provider.getPicks(value)
   Assert.array(newPicks)
   const filterValue = provider.getFilterValue(value)
@@ -213,7 +185,6 @@ const findLabelIndex = (items, label) => {
 export const selectItem = (state, label) => {
   Assert.string(label)
   const index = findLabelIndex(state.items, label)
-  console.log({ index })
   if (index === -1) {
     return state
   }
@@ -404,6 +375,8 @@ const getNewValue = (value, inputType, data, selectionStart, selectionEnd) => {
       return getNewValueDeleteWordForward(value, selectionStart, selectionEnd)
     case InputEventType.DeleteWordBackward:
       return getNewValueDeleteWordBackward(value, selectionStart, selectionEnd)
+    case InputEventType.InsertLineBreak:
+      return value
     default:
       throw new Error(`unsupported input type ${inputType}`)
   }
@@ -540,14 +513,11 @@ const renderItems = {
         /* method */ 'showNoResults',
       ]
     }
-    console.log('minLineY', newState.minLineY)
-    console.log('maxLineY', newState.maxLineY)
     const visibleItems = getVisible(
       newState.items,
       newState.minLineY,
       newState.maxLineY
     )
-    console.log({ visibleItems, items: newState.items })
     return [
       /* Viewlet.send */ 'Viewlet.send',
       /* id */ 'QuickPick',

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/ViewletStates/ViewletStates.js

@@ -23,6 +23,14 @@ export const remove = (key) => {
   delete state.instances[key]
 }
 
+export const dispose = async (key) => {
+  const instance = state.instances[key]
+  delete state.instances[key]
+  if (instance.factory.dispose) {
+    await instance.factory.dispose(instance.state)
+  }
+}
+
 export const getAllInstances = () => {
   return state.instances
 }

package/static/4d80653/packages/renderer-worker/src/parts/ViewletTitleBar/ViewletTitleBar.ipc.js

@@ -0,0 +1,9 @@
+import * as ViewletTitleBar from './ViewletTitleBar.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+// prettier-ignore
+export const Commands = {
+  'TitleBar.handleTitleBarButtonsClick': Viewlet.wrapViewletCommand('TitleBar', ViewletTitleBar.handleTitleBarButtonsClick),
+}
+
+export * from './ViewletTitleBar.js'

package/static/4d80653/packages/renderer-worker/src/parts/ViewletTitleBar/ViewletTitleBar.js

@@ -0,0 +1,143 @@
+import * as TitleBarMenuBar from '../TitleBarMenuBar/TitleBarMenuBar.js'
+import * as Command from '../Command/Command.js'
+import * as Platform from '../Platform/Platform.js'
+import * as PlatformType from '../PlatformType/PlatformType.js'
+import * as Preferences from '../Preferences/Preferences.js'
+
+export const name = 'TitleBar'
+
+const TITLE_BAR_BUTTON_WIDTH = 46
+
+export const create = (id, uri, top, left, width, height) => {
+  return {
+    disposed: false,
+    titleBarEntries: [],
+    titleBarButtons: [],
+    top,
+    left,
+    width,
+    height,
+  }
+}
+
+const getTitleBarButtonsWeb = () => {
+  return []
+}
+
+const getTitleBarButtonsRemote = () => {
+  return []
+}
+
+const getTitleBarButtonsElectron = () => {
+  if (Preferences.get('window.titleBarStyle') === 'custom') {
+    return [
+      { label: 'Minimize', icon: 'Minimize', id: 'Minimize' },
+      { label: 'Maximize', icon: 'Maximize', id: 'Maximize' },
+      { label: 'Close', icon: 'Close', id: 'Close' },
+    ]
+  }
+  return []
+}
+
+const getTitleBarButtons = () => {
+  switch (Platform.platform) {
+    case PlatformType.Electron:
+      return getTitleBarButtonsElectron()
+    case PlatformType.Web:
+      return getTitleBarButtonsWeb()
+    case PlatformType.Remote:
+      return getTitleBarButtonsRemote()
+  }
+}
+
+export const loadContent = async (state) => {
+  const titleBarEntries = await TitleBarMenuBar.getEntries()
+  const titleBarButtons = getTitleBarButtons()
+  return {
+    ...state,
+    titleBarEntries,
+    titleBarButtons,
+  }
+}
+
+export const contentLoaded = (state) => {}
+
+export const focus = async () => {
+  await TitleBarMenuBar.focus()
+}
+
+const handleTitleBarClickMinimize = async (state) => {
+  await Command.execute('ElectronWindow.minimize')
+  return state
+}
+
+const handleTitleBarClickClose = async (state) => {
+  await Command.execute('ElectronWindow.close')
+  return state
+}
+
+const handleTitleBarClickToggleMaximize = async (state) => {
+  // TODO need command for toggleMaximize
+  await Command.execute('ElectronWindow.maximize')
+  return state
+}
+
+export const handleTitleBarButtonsClick = (state, x, y) => {
+  const { width, left } = state
+  const offsetRight = width + left - x
+  if (offsetRight >= TITLE_BAR_BUTTON_WIDTH * 2) {
+    return handleTitleBarClickMinimize(state)
+  }
+  if (offsetRight > TITLE_BAR_BUTTON_WIDTH * 1) {
+    return handleTitleBarClickToggleMaximize(state)
+  }
+  return handleTitleBarClickClose(state)
+}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  return {
+    ...state,
+    ...dimensions,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderTitleBarEntries = {
+  isEqual(oldState, newState) {
+    return oldState.titleBarEntries === newState.titleBarEntries
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'TitleBar',
+      /* method */ 'menuSetEntries',
+      /* titleBarEntries */ newState.titleBarEntries,
+    ]
+  },
+}
+
+const renderTitleBarButtons = {
+  isEqual(oldState, newState) {
+    return oldState.titleBarButtons === newState.titleBarButtons
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'TitleBar',
+      /* method */ 'setButtons',
+      /* titleBarEntries */ newState.titleBarButtons,
+    ]
+  },
+}
+
+export const render = [renderTitleBarEntries, renderTitleBarButtons]

package/static/4d80653/packages/renderer-worker/src/parts/VirtualDomElements/VirtualDomElements.js

@@ -0,0 +1,10 @@
+export const Div = 1
+export const H1 = 2
+export const Kbd = 3
+export const Table = 4
+export const TBody = 5
+export const Td = 6
+export const Text = 7
+export const Th = 8
+export const THead = 9
+export const Tr = 10

package/static/4d80653/packages/renderer-worker/src/parts/VirtualDomHelpers/VirtualDomHelpers.js

@@ -0,0 +1,19 @@
+import * as VirtualDomElements from '../VirtualDomElements/VirtualDomElements.js'
+
+export const h = (type, props, childCount) => {
+  return {
+    type,
+    props,
+    childCount,
+  }
+}
+
+export const text = (data) => {
+  return h(
+    VirtualDomElements.Text,
+    {
+      text: data,
+    },
+    0
+  )
+}

package/static/{2394f34 → 4d80653}/packages/renderer-worker/src/parts/Workbench/Workbench.js

@@ -18,24 +18,10 @@ import * as InitData from '../InitData/InitData.js'
 import * as Command from '../Command/Command.js'
 import * as Platform from '../Platform/Platform.js'
 
-const handleUnhandledRejection = async (event) => {
-  console.info(`[renderer-worker] Unhandled Rejection: ${event.reason}`)
-  try {
-    await ErrorHandling.handleError(event.reason)
-  } catch {}
-}
-
-const handleError = async (event) => {
-  console.info(`[renderer-worker] Unhandled Error: ${event}`)
-  try {
-    await ErrorHandling.handleError(event.reason)
-  } catch {}
-}
-
 // TODO lazyload parts one by one (Main, SideBar, ActivityBar, TitleBar, StatusBar)
 export const startup = async (config) => {
-  onunhandledrejection = handleUnhandledRejection
-  onerror = handleError
+  onunhandledrejection = ErrorHandling.handleUnhandledRejection
+  onerror = ErrorHandling.handleUnhandledError
   LifeCycle.mark(LifeCycle.Phase.Zero)
 
   Performance.mark('willStartupWorkbench')