@lvce-editor/server 0.0.28 → 0.0.31

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletSearch/ViewletSearch.js

@@ -0,0 +1,167 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+import * as Command from '../Command/Command.js'
+import * as Workspace from '../Workspace/Workspace.js'
+import * as FindInWorkspace from '../FindInWorkspace/FindInWorkspace.js'
+
+// TODO maybe create should have a container as param like vscode?
+// maybe not?
+
+// const toList = ([fileName, previews]) => [
+//   {
+//     type: 'fileName',
+//     text: `file: ${fileName}`,
+//   },
+//   ...previews.map(({ preview }) => ({
+//     type: 'preview',
+//     text: preview,
+//   })),
+// ]
+
+const SEARCH_ORDER_FILE_NAMES = 1
+
+export const name = 'Search'
+
+export const create = () => {
+  return {
+    searchResults: [],
+    stats: {},
+    searchId: -1,
+    value: '',
+    disposed: false,
+    fileCount: 0,
+  }
+}
+
+export const loadContent = async (state) => {
+  return state
+}
+
+export const contentLoaded = async () => {}
+
+export const setValue = (state, value) => {
+  state.value = value
+  // TODO use Id module
+  state.searchId = Math.random()
+  SharedProcess.send(
+    /* Search.search */ 907771,
+    /* id */ state.id,
+    /* searchId */ state.searchId
+  )
+}
+
+export const handleResult = async (state, result) => {
+  if (result.version !== state.version) {
+    return
+  }
+  await RendererProcess.invoke(
+    /* viewletInvoke */ 'Viewlet.send',
+    /* id */ state.id,
+    /* method */ 'handleSearchResult',
+    /* result */ result
+  )
+}
+
+export const dispose = async (state) => {
+  // TODO cancel pending search
+  if (state.state === 'searching') {
+    // TODO this should be invoke
+    await SharedProcess.invoke(
+      /* Search.cancel */ 'Search.cancel',
+      /* searchId */ state.searchId
+    )
+  }
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+const getPath = (result) => {
+  return result[0]
+}
+
+const compareResults = (resultA, resultB) => {
+  const pathA = getPath(resultA)
+  const pathB = getPath(resultB)
+  return pathA.localeCompare(pathB)
+}
+
+const toDisplayResults = (results) => {
+  results.sort(compareResults)
+  const displayResults = []
+  for (const result of results) {
+    const path = getPath(result)
+    const absolutePath = Workspace.getAbsolutePath(path)
+    displayResults.push({
+      path: absolutePath,
+      name: path,
+    })
+  }
+  return displayResults
+}
+
+export const handleInput = async (state, value) => {
+  // TODO support streaming results
+  // TODO support cancellation
+  // TODO handle error
+  // TODO use command.execute or use module directly?
+  const results = await FindInWorkspace.findInWorkspace(value)
+  // TODO send results to renderer process
+  // TODO use virtual list because there might be many results
+  console.log({
+    value,
+    results,
+  })
+
+  // TODO implement virtual list, only send visible items to renderer process
+
+  // TODO maybe rename to result.items and result.stats
+  const displayResults = toDisplayResults(results.results)
+  return {
+    ...state,
+    items: displayResults,
+    fileCount: results.results.length, // TODO this is weird
+    value,
+  }
+}
+
+export const handleClick = async (state, index) => {
+  const searchResult = state.items[index]
+  console.log({ searchResult })
+  await Command.execute(
+    /* Main.openUri */ 'Main.openUri',
+    /* uri */ searchResult.path
+  )
+  return state
+}
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  return {
+    ...state,
+    ...dimensions,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items
+  },
+  apply(oldState, newState) {
+    console.log(newState.items)
+    return [
+      /* viewletSend */ 'Viewlet.send',
+      /* id */ 'Search',
+      /* method */ 'setResults',
+      /* results */ newState.items,
+      /* resultCount */ newState.items.length,
+      /* fileCount */ newState.fileCount,
+    ]
+  },
+}
+
+export const render = [renderItems]

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletSideBar/ViewletSideBar.ipc.js

@@ -0,0 +1,12 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletSideBar from './ViewletSideBar.js'
+
+// prettier-ignore
+export const Commands =  {
+  'SideBar.showOrHideViewlet': Viewlet.wrapViewletCommand('SideBar', ViewletSideBar.showOrHideViewlet),
+  'SideBar.openViewlet': Viewlet.wrapViewletCommand('SideBar', ViewletSideBar.openViewlet),
+  'SideBar.show': Viewlet.wrapViewletCommand('SideBar', ViewletSideBar.openViewlet),
+  'SideBar.focus': Viewlet.wrapViewletCommand('SideBar', ViewletSideBar.focus),
+}
+
+export * from './ViewletSideBar.js'

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletSideBar/ViewletSideBar.js

@@ -0,0 +1,182 @@
+import * as Command from '../Command/Command.js'
+import * as GlobalEventBus from '../GlobalEventBus/GlobalEventBus.js'
+import * as Layout from '../Layout/Layout.js'
+import * as LifeCycle from '../LifeCycle/LifeCycle.js'
+import * as ViewletManager from '../ViewletManager/ViewletManager.js'
+import * as Assert from '../Assert/Assert.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+export const create = (id, uri, left, top, width, height) => {
+  return {
+    currentViewletId: '',
+    left,
+    top,
+    width,
+    height,
+  }
+}
+
+export const loadContent = async (state) => {
+  const currentViewletId = await getSideBarViewlet()
+  return {
+    ...state,
+    currentViewletId,
+  }
+}
+
+export const loadContentEffects = () => {
+  LifeCycle.once(LifeCycle.PHASE_TWELVE, hydrateLazy)
+  GlobalEventBus.addListener('Layout.hideSideBar', handleSideBarClose)
+}
+
+export const contentLoaded = async (state) => {
+  if (state.currentViewletId) {
+    await openViewlet(state, state.currentViewletId)
+  }
+}
+
+const getSideBarViewlet = async () => {
+  const cachedViewlet = await Command.execute(
+    /* LocalStorage.getJson */ 'LocalStorage.getJson',
+    /* key */ 'sideBarPanel'
+  )
+  if (cachedViewlet) {
+    return cachedViewlet
+  }
+
+  // TODO what if explorer has been deactivated
+  // probably need to check activity bar items
+  // but activity bar already has a dependency on sidebar
+  return 'Explorer'
+}
+
+const hydrateLazy = () => () => {
+  // TODO update file icons in explorer
+}
+
+const SIDE_BAR_TITLE_AREA_HEIGHT = 35
+
+// TODO add test for this
+export const showOrHideViewlet = async (state, viewletId) => {
+  Assert.object(state)
+  Assert.string(viewletId)
+  if (Layout.isSideBarVisible()) {
+    // TODO don't depend on sidebar directly
+    if (state.currentViewletId === viewletId) {
+      await Layout.hideSideBar()
+    } else {
+      state.currentViewletId = viewletId
+      await openViewlet(state, viewletId)
+    }
+  } else {
+    console.log('show side bar')
+    state.currentViewletId = viewletId
+    // TODO race condition: what if sidebar should be hidden again
+    // while sidebar is opening?
+    await Layout.showSideBar()
+  }
+}
+
+const getContentDimensions = (dimensions) => {
+  return {
+    left: dimensions.left,
+    top: dimensions.top + SIDE_BAR_TITLE_AREA_HEIGHT,
+    width: dimensions.width,
+    height: dimensions.height - SIDE_BAR_TITLE_AREA_HEIGHT,
+  }
+}
+
+// TODO no default parameter -> monomorphism
+export const openViewlet = async (state, id, focus = false) => {
+  console.assert(typeof id === 'string')
+  // if (state.currentViewletId) {
+  //   console.log('dispose current viewlet', state.currentViewletId)
+  //   Viewlet.dispose(state.currentViewletId)
+  // }
+  // state.currentViewletId = id
+  const childDimensions = getContentDimensions(state)
+  // TODO race condition (check if disposed after created)
+  const viewlet = ViewletManager.create(
+    ViewletManager.getModule,
+    id,
+    'SideBar',
+    'builtin://',
+    childDimensions.left,
+    childDimensions.top,
+    childDimensions.width,
+    childDimensions.height
+  )
+
+  // if (state.currentViewletId !== id) {
+  //   console.log('return')
+
+  //   return
+  // }
+  // // TODO activity and sidebar changes should ideally be rendered at the same time
+  // // but this works for now
+  // RendererProcess.send([
+  //   /* Viewlet.appendViewlet */ 3029,
+  //   /* parentId */ 'SideBar',
+  //   /* childId */ id,
+  //   /* focus */ focus,
+  // ])
+  GlobalEventBus.emitEvent('SideBar.viewletChange', id)
+  // await Viewlet.refresh(id)
+  // TODO add keybinding to title
+  // @ts-ignore
+  await ViewletManager.load(viewlet, focus)
+}
+
+const handleSideBarClose = (state) => {
+  state.currentViewletId = ''
+}
+
+export const dispose = (state) => {
+  // state.currentViewletId = undefined
+}
+
+export const openDefaultViewlet = async (state) => {
+  await openViewlet(state, 'Explorer')
+}
+
+export const close = (state) => {
+  if (state.currentViewletId) {
+    Viewlet.dispose(state.currentViewletId)
+  }
+  state.currentViewletId = undefined
+  // RendererProcess.send([/* sideBarHide */ 5552, /* id */ id])
+}
+
+export const resize = (state, dimensions) => {
+  const childDimensions = getContentDimensions(dimensions)
+  const commands = Viewlet.resize(state.currentViewletId, childDimensions)
+  return {
+    newState: {
+      ...state,
+      ...dimensions,
+    },
+    commands,
+  }
+}
+
+export const focus = async (state) => {
+  const { currentViewletId } = state
+  const currentViewlet = ViewletStates.getInstance(currentViewletId)
+  if (!currentViewlet) {
+    return state
+  }
+  await Command.execute(`${currentViewletId}.focus`)
+  // if (!currentViewlet.factory.focus) {
+  //   throw new Error(`missing focus function for ${currentViewletId}`)
+  // }
+  // const newState = currentViewlet.factory.focus(currentViewlet.state)
+  // const commands = ViewletManager.render(
+  //   currentViewlet.factory,
+  //   currentViewlet.state,
+  //   newState
+  // )
+  // currentViewlet.state = newState
+  // console.log({ commands })
+  return state
+  // console.log({ currentViewletId })
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletSourceControl/ViewletSourceControl.ipc.js

@@ -0,0 +1,9 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletSourceControl from './ViewletSourceControl.js'
+
+// prettier-ignore
+export const Commands = {
+  '6532': Viewlet.wrapViewletCommand('Source Control',ViewletSourceControl.acceptInput)
+}
+
+export * from './ViewletSourceControl.js'

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletSourceControl/ViewletSourceControl.js

@@ -0,0 +1,111 @@
+import * as ExtensionHostSourceControl from '../ExtensionHost/ExtensionHostSourceControl.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+
+// TODO when accept input is invoked multiple times, it should not lead to errors
+
+export const name = 'Source Control'
+
+export const create = () => {
+  return {
+    merge: [],
+    index: [],
+    untracked: [],
+    workingTree: [],
+    disposed: false,
+    inputValue: '',
+  }
+}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const acceptInput = async (state, text) => {
+  state.inputValue = text // TODO avoid side effect here
+  await ExtensionHostSourceControl.acceptInput(text)
+  return {
+    ...state,
+    inputValue: '',
+  }
+}
+
+const getChangedFiles = async () => {
+  console.info('get changed files')
+  const changedFiles = await ExtensionHostSourceControl.getChangedFiles()
+
+  console.log({ changedFiles })
+
+  return {
+    index: [],
+    merge: [],
+    untracked: [],
+    workingTree: changedFiles,
+    gitRoot: '',
+  }
+}
+
+export const loadContent = async (state) => {
+  const changedFiles = await getChangedFiles()
+  return {
+    ...state,
+    index: changedFiles.index,
+    merge: changedFiles.merge,
+    untracked: changedFiles.untracked,
+    workingTree: changedFiles.workingTree,
+    gitRoot: changedFiles.gitRoot,
+  }
+}
+
+export const contentLoaded = async (state) => {
+  // TODO
+  // await RendererProcess.invoke(
+  //   /* Viewlet.send */ 'Viewlet.send',
+  //   /* id */ 'Source Control',
+  //   /* method */ 'setChangedFiles',
+  //   /* changedFiles */ state.changedFiles
+  // )
+}
+
+export const handleClick = async (state, index) => {
+  const item = state.workingTree[index]
+  const absolutePath = `${state.gitRoot}/${item.file}`
+  // TODO handle error
+  const [fileBefore, fileNow] = await Promise.all([
+    ExtensionHostSourceControl.getFileBefore(item.file),
+    FileSystem.readFile(absolutePath),
+  ])
+  const content = `before:\n${fileBefore}\n\n\nnow:\n${fileNow}`
+  // const content
+  // await Main.openRawText(`diff://${absolutePath}`, content, 'plaintext')
+  // await Main.openAbsolutePath(absolutePath)
+}
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  return {
+    ...state,
+    ...dimensions,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderValue = {
+  isEqual(oldState, newState) {
+    return oldState.inputValue === newState.inputValue
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'Source Control',
+      /* method */ 'setInputValue',
+      /* value */ newState.inputValue,
+    ]
+  },
+}
+
+export const render = [renderValue]

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletStates/ViewletStates.js

@@ -0,0 +1,38 @@
+import * as Assert from '../Assert/Assert.js'
+
+export const state = {
+  instances: Object.create(null),
+}
+
+export const set = (key, value) => {
+  Assert.object(value)
+  Assert.object(value.factory)
+  Assert.object(value.state)
+  state.instances[key] = value
+}
+
+export const getInstance = (key) => {
+  return state.instances[key]
+}
+
+export const remove = (key) => {
+  delete state.instances[key]
+}
+
+export const getAllInstances = () => {
+  return state.instances
+}
+
+export const getState = (key) => {
+  const instance = getInstance(key)
+  return instance.state
+}
+
+export const setState = (key, newState) => {
+  const instance = getInstance(key)
+  instance.state = newState
+}
+
+export const reset = () => {
+  state.instances = Object.create(null)
+}

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletStatusBar/ViewletStatusBar.ipc.js

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

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletStatusBar/ViewletStatusBar.js

@@ -0,0 +1,152 @@
+import * as ExtensionHostStatusBarItems from '../ExtensionHost/ExtensionHostStatusBarItems.js'
+
+export const name = 'Status Bar'
+
+export const create = () => {
+  return {
+    statusBarItemsLeft: [],
+    statusBarItemsRight: [],
+  }
+}
+
+const toUiStatusBarItem = (extensionHostStatusBarItem) => {
+  return {
+    name: extensionHostStatusBarItem.id,
+    text: extensionHostStatusBarItem.id,
+    tooltip: '',
+    command: -1,
+    icon: extensionHostStatusBarItem.icon || '',
+  }
+}
+
+const toUiStatusBarItems = (statusBarItems) => {
+  if (!statusBarItems) {
+    return []
+  }
+  return statusBarItems.map(toUiStatusBarItems)
+}
+
+export const loadContent = async (state) => {
+  const extensionStatusBarItems =
+    await ExtensionHostStatusBarItems.getStatusBarItems()
+
+  const uiStatusBarItems = toUiStatusBarItems(extensionStatusBarItems)
+  return {
+    ...state,
+    statusBarItemsLeft: [
+      // {
+      //   name: 'RunTests',
+      //   text: 'Run Tests',
+      //   tooltip: '',
+      //   command: 909021,
+      // },
+      ...uiStatusBarItems,
+    ],
+  }
+}
+
+export const contentLoaded = async (state) => {}
+
+export const updateStatusBarItems = async (state) => {
+  const newState = await loadContent(state)
+  return newState
+}
+
+export const contentLoadedEffects = (state) => {
+  // TODO dispose listener
+  const handleChange = async () => {
+    if (state.disposed) {
+      return
+    }
+    await updateStatusBarItems(state)
+    console.log('status bar items changed')
+  }
+  // maybe return cleanup function from here like react hooks
+  ExtensionHostStatusBarItems.onChange(handleChange)
+}
+
+const updateArray = (items, newItem) => {
+  const index = getIndex(items, newItem)
+  const before = items.slice(0, index)
+  const after = items.slice(index + 1)
+  return [...before, newItem, ...after]
+}
+
+export const itemLeftCreate = (state, name, text, tooltip) => {
+  const newItem = {
+    name,
+    text,
+    tooltip,
+  }
+  const statusBarItemsLeft = [...state.statusBarItemsLeft, newItem]
+  return {
+    ...state,
+    statusBarItemsLeft,
+  }
+}
+
+const getIndex = (items, item) => {
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].name === item.name) {
+      return i
+    }
+  }
+  return -1
+}
+
+export const itemLeftUpdate = (state, newItem) => {
+  return {
+    ...state,
+    statusBarItemsLeft: updateArray(state.statusBarItemsLeft, newItem),
+  }
+}
+
+export const itemRightCreate = (state, newItem) => {
+  const statusBarItemsRight = [...state.statusBarItemsRight, newItem]
+  return {
+    ...state,
+    statusBarItemsRight,
+  }
+}
+
+export const itemRightUpdate = (state, newItem) => {
+  return {
+    ...state,
+    statusBarItemsRight: updateArray(state.statusBarItemsRight, newItem),
+  }
+}
+
+export const handleClick = (name) => {
+  // sendExtensionWorker([/* statusBarItemHandleClick */ 7657, /* name */ name])
+}
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  return {
+    ...state,
+    ...dimensions,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return (
+      oldState.statusBarItemsLeft === newState.statusBarItemsLeft &&
+      oldState.statusBarItemsRight === newState.statusBarItemsRight
+    )
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'StatusBar',
+      /* method */ 'setItems',
+      /* statusBarItemsLeft */ newState.statusBarItemsLeft,
+      /* statusBarItemsRight */ newState.statusBarItemsRight,
+    ]
+  },
+}
+
+export const render = [renderItems]

package/static/0e4d46a/packages/renderer-worker/src/parts/ViewletTerminal/ViewletTerminal.ipc.js

@@ -0,0 +1,10 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletTerminal from './ViewletTerminal.js'
+
+// prettier-ignore
+export const Commands = {
+  'Terminal.write': Viewlet.wrapViewletCommand('Terminal', ViewletTerminal.write),
+  'Terminal.clear': Viewlet.wrapViewletCommand('Terminal', ViewletTerminal.clear),
+}
+
+export * from './ViewletTerminal.js'