@lvce-editor/server 0.11.7 → 0.11.8

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

@@ -1,455 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Command from '../Command/Command.js'
-import * as Compare from '../Compare/Compare.js'
-import * as ErrorHandling from '../ErrorHandling/ErrorHandling.js'
-import * as Height from '../Height/Height.js'
-import * as I18nString from '../I18NString/I18NString.js'
-import * as IconTheme from '../IconTheme/IconTheme.js'
-import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
-import * as ScrollBarFunctions from '../ScrollBarFunctions/ScrollBarFunctions.js'
-import * as TextSearch from '../TextSearch/TextSearch.js'
-import * as TextSearchResultType from '../TextSearchResultType/TextSearchResultType.js'
-import * as VirtualList from '../VirtualList/VirtualList.js'
-import * as Workspace from '../Workspace/Workspace.js'
-
-/**
- * @enum {string}
- */
-export const UiStrings = {
-  NoResults: 'No results found',
-  Oneresult: 'Found 1 result in 1 file',
-  ManyResultsInOneFile: `Found {PH1} results in 1 file`,
-  ManyResultsInManyFiles: `Found {PH1} results in {PH2} files`,
-}
-
-export const create = (id, uri, left, top, width, height) => {
-  return {
-    searchResults: [],
-    stats: {},
-    searchId: -1,
-    value: '',
-    disposed: false,
-    fileCount: 0,
-    left,
-    top,
-    width,
-    height,
-    ...VirtualList.create({
-      itemHeight: Height.ListItem,
-      minimumSliderSize: Height.MinimumSliderSize,
-      headerHeight: 61, // TODO
-    }),
-  }
-}
-
-const getSavedValue = (savedState) => {
-  if (savedState && savedState.value) {
-    return savedState.value
-  }
-  return ''
-}
-
-export const saveState = (state) => {
-  const { value } = state
-  return {
-    value,
-  }
-}
-
-export const loadContent = async (state, savedState) => {
-  const savedValue = getSavedValue(savedState)
-  if (savedValue) {
-    return setValue(state, savedValue)
-  }
-  return state
-}
-
-const getStatusMessage = (resultCount, fileResultCount) => {
-  if (resultCount === 0) {
-    return I18nString.i18nString(UiStrings.NoResults)
-  }
-  if (resultCount === 1) {
-    return I18nString.i18nString(UiStrings.Oneresult)
-  }
-  if (fileResultCount === 1) {
-    return I18nString.i18nString(UiStrings.ManyResultsInOneFile, {
-      PH1: resultCount,
-    })
-  }
-  return I18nString.i18nString(UiStrings.ManyResultsInManyFiles, {
-    PH1: resultCount,
-    PH2: fileResultCount,
-  })
-}
-
-const getResultCounts = (results) => {
-  let resultCount = 0
-  let fileCount = 0
-  for (const result of results) {
-    switch (result.type) {
-      case TextSearchResultType.File:
-        fileCount++
-        break
-      case TextSearchResultType.Match:
-        resultCount++
-        break
-      default:
-        break
-    }
-  }
-  return { fileCount, resultCount }
-}
-
-export const setValue = async (state, value) => {
-  try {
-    if (value === '') {
-      return {
-        ...state,
-        value,
-        minLineY: 0,
-        maxLineY: 0,
-        deltaY: 0,
-        items: [],
-        matchIndex: 0,
-        matchCount: 0,
-        message: '',
-      }
-    }
-    const { height, itemHeight, minimumSliderSize, headerHeight } = state
-    const root = Workspace.state.workspacePath
-    const results = await TextSearch.textSearch(root, value)
-    if (!Array.isArray(results)) {
-      throw new Error(`results must be of type array`)
-    }
-    const { fileCount, resultCount } = getResultCounts(results)
-    const displayResults = toDisplayResults(
-      results,
-      itemHeight,
-      resultCount,
-      value
-    )
-    const message = getStatusMessage(resultCount, fileCount)
-    const total = displayResults.length
-    const contentHeight = total * itemHeight
-    const listHeight = height - headerHeight
-    const scrollBarHeight = ScrollBarFunctions.getScrollBarHeight(
-      height,
-      contentHeight,
-      minimumSliderSize
-    )
-    const numberOfVisible = Math.ceil(listHeight / itemHeight)
-    const maxLineY = Math.min(numberOfVisible, total)
-    const finalDeltaY = Math.max(contentHeight - listHeight, 0)
-    return {
-      ...state,
-      value,
-      items: displayResults,
-      message,
-      maxLineY: maxLineY,
-      scrollBarHeight,
-      finalDeltaY,
-    }
-  } catch (error) {
-    ErrorHandling.logError(error)
-    return {
-      ...state,
-      message: `${error}`,
-      value,
-    }
-  }
-}
-
-const updateIcon = (item) => {
-  switch (item.type) {
-    case TextSearchResultType.File:
-      return {
-        ...item,
-        icon: IconTheme.getFileIcon({ name: item.text }),
-      }
-    default:
-      return item
-  }
-}
-
-export const handleIconThemeChange = (state) => {
-  const { items } = state
-  const newItems = items.map(updateIcon)
-  return {
-    ...state,
-    items: newItems,
-  }
-}
-
-export const dispose = async (state) => {
-  // TODO cancel pending search
-  if (state.state === 'searching') {
-    await TextSearch.cancel(state.searchId)
-  }
-  return {
-    ...state,
-    disposed: true,
-  }
-}
-
-const compareResults = (resultA, resultB) => {
-  const pathA = resultA.text
-  const pathB = resultB.text
-  return Compare.compareString(pathA, pathB)
-}
-
-const getMatchStart = (preview, searchTerm) => {
-  const index = preview.preview.indexOf(searchTerm)
-  if (index === -1) {
-    return preview.preview.toLowerCase().indexOf(searchTerm)
-  }
-  return index
-}
-
-const toDisplayResults = (results, itemHeight, resultCount, searchTerm) => {
-  // results.sort(compareResults)
-  const displayResults = []
-  let i = -1
-  const setSize = resultCount
-  let path = ''
-  for (const result of results) {
-    i++
-    switch (result.type) {
-      case TextSearchResultType.File:
-        path = result.text
-        const absolutePath = Workspace.getAbsolutePath(path)
-        const baseName = Workspace.pathBaseName(path)
-        displayResults.push({
-          title: absolutePath,
-          type: TextSearchResultType.File,
-          text: baseName,
-          icon: IconTheme.getFileIcon({ name: baseName }),
-          posInSet: i + 1,
-          setSize,
-          top: i * itemHeight,
-          lineNumber: result.lineNumber,
-          matchStart: 0,
-          matchLength: 0,
-        })
-        break
-      case TextSearchResultType.Match:
-        displayResults.push({
-          title: result.text,
-          type: TextSearchResultType.Match,
-          text: result.text,
-          icon: '',
-          posInSet: i + 1,
-          setSize,
-          top: i * itemHeight,
-          lineNumber: result.lineNumber,
-          matchStart: result.start,
-          matchLength: searchTerm.length,
-        })
-        break
-      default:
-        break
-    }
-  }
-  return displayResults
-}
-// TODO implement virtual list, only send visible items to renderer process
-
-// TODO maybe rename to result.items and result.stats
-// TODO support streaming results
-// TODO support cancellation
-// TODO handle error
-// TODO use command.execute or use module directly?
-// TODO send results to renderer process
-// TODO use virtual list because there might be many results
-
-export const handleInput = (state, value) => {
-  return setValue(state, value)
-}
-
-const getFileIndex = (items, index) => {
-  console.log({ items })
-  for (let i = index; i >= 0; i--) {
-    const item = items[i]
-    if (item.type === TextSearchResultType.File) {
-      return i
-    }
-  }
-  return -1
-}
-
-const selectIndexFile = async (state, searchResult, index) => {
-  const path = searchResult.title
-  Assert.string(path)
-  await Command.execute(/* Main.openUri */ 'Main.openUri', /* uri */ path)
-  return state
-}
-
-const selectIndexPreview = async (state, searchResult, index) => {
-  const { items } = state
-  const fileIndex = getFileIndex(items, index)
-  if (fileIndex === -1) {
-    throw new Error('Search result is missing file')
-  }
-  const { lineNumber } = searchResult
-  // console.log({ searchResult })
-  const fileResult = items[fileIndex]
-  const path = fileResult.title
-  Assert.string(path)
-  await Command.execute(
-    /* Main.openUri */ 'Main.openUri',
-    /* uri */ path,
-    /* focus */ true,
-    {
-      selections: new Uint32Array([lineNumber, 0, lineNumber, 0]),
-    }
-  )
-  return state
-}
-
-export const selectIndex = async (state, index) => {
-  if (index === -1) {
-    return state
-  }
-  const { items } = state
-  const searchResult = items[index]
-  switch (searchResult.type) {
-    case TextSearchResultType.File:
-      return selectIndexFile(state, searchResult, index)
-    case TextSearchResultType.Match:
-      return selectIndexPreview(state, searchResult, index)
-    default:
-      throw new Error(`unexpected search result type ${searchResult.type}`)
-  }
-}
-
-export const handleContextMenuMouseAt = async (state, x, y) => {
-  const index = 1
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ MenuEntryId.Search
-  )
-  return state
-}
-
-export const handleContextMenuKeyboard = async (state) => {
-  const index = 1
-  const x = state.left // TODO
-  const y = state.top // TODO
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ MenuEntryId.Search
-  )
-  return state
-}
-
-export const handleClick = async (state, index) => {
-  const { minLineY } = state
-  const actualIndex = index + minLineY
-  return selectIndex(state, actualIndex)
-}
-
-export const hasFunctionalResize = true
-
-export const resize = (state, dimensions) => {
-  return {
-    ...state,
-    ...dimensions,
-  }
-}
-
-export const hasFunctionalRender = true
-
-const getVisible = (state) => {
-  const { minLineY, maxLineY, items } = state
-  return items.slice(minLineY, maxLineY)
-}
-
-const renderItems = {
-  isEqual(oldState, newState) {
-    return (
-      oldState.items === newState.items &&
-      oldState.minLineY === newState.minLineY &&
-      oldState.maxLineY === newState.maxLineY
-    )
-  },
-  apply(oldState, newState) {
-    const visible = getVisible(newState)
-    return [/* method */ 'setResults', /* results */ visible]
-  },
-}
-
-const renderScrollBar = {
-  isEqual(oldState, newState) {
-    return (
-      oldState.deltaY === newState.deltaY &&
-      oldState.height === newState.height &&
-      oldState.finalDeltaY === newState.finalDeltaY
-    )
-  },
-  apply(oldState, newState) {
-    const scrollBarY = ScrollBarFunctions.getScrollBarY(
-      newState.deltaY,
-      newState.finalDeltaY,
-      newState.height - newState.headerHeight,
-      newState.scrollBarHeight
-    )
-    return [
-      /* method */ 'setScrollBar',
-      /* scrollBarY */ scrollBarY,
-      /* scrollBarHeight */ newState.scrollBarHeight,
-    ]
-  },
-}
-
-const renderHeight = {
-  isEqual(oldState, newState) {
-    return oldState.items.length === newState.items.length
-  },
-  apply(oldState, newState) {
-    const { itemHeight } = newState
-    const contentHeight = newState.items.length * itemHeight
-    return [/* method */ 'setContentHeight', /* contentHeight */ contentHeight]
-  },
-}
-
-const renderMessage = {
-  isEqual(oldState, newState) {
-    return oldState.message === newState.message
-  },
-  apply(oldState, newState) {
-    return [/* method */ 'setMessage', /* message */ newState.message]
-  },
-}
-
-const renderValue = {
-  isEqual(oldState, newState) {
-    return oldState.value === newState.value
-  },
-  apply(oldState, newState) {
-    return [/* method */ 'setValue', /* value */ newState.value]
-  },
-}
-
-const renderNegativeMargin = {
-  isEqual(oldState, newState) {
-    return oldState.deltaY === newState.deltaY
-  },
-  apply(oldState, newState) {
-    return [
-      /* method */ 'setNegativeMargin',
-      /* negativeMargin */ -newState.deltaY,
-    ]
-  },
-}
-
-export const render = [
-  renderItems,
-  renderMessage,
-  renderValue,
-  renderScrollBar,
-  renderHeight,
-  renderNegativeMargin,
-]

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

@@ -1,26 +0,0 @@
-import * as ViewletSourceControl from './ViewletSourceControl.js'
-
-export const name = 'Source Control'
-
-// prettier-ignore
-export const Commands = {
-  acceptInput: ViewletSourceControl.acceptInput,
-  handleMouseOver: ViewletSourceControl.handleMouseOver,
-  handleContextMenu: ViewletSourceControl.handleContextMenu,
-  handleClick: ViewletSourceControl.handleClick,
-  handleClickAdd: ViewletSourceControl.handleClickAdd,
-  handleClickDiscard: ViewletSourceControl.handleClickDiscard,
-  handleClickRestore: ViewletSourceControl.handleClickRestore,
-  handleInput: ViewletSourceControl.handleInput,
-}
-
-export const Css = [
-  '/css/parts/InputBox.css',
-  '/css/parts/TreeItem.css',
-  '/css/parts/Label.css',
-  '/css/parts/IconButton.css',
-  '/css/parts/MaskIcon.css',
-  '/css/parts/ViewletSourceControl.css',
-]
-
-export * from './ViewletSourceControl.js'

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

@@ -1,225 +0,0 @@
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as SourceControl from '../SourceControl/SourceControl.js'
-import * as IconTheme from '../IconTheme/IconTheme.js'
-import * as Icon from '../Icon/Icon.js'
-import * as Command from '../Command/Command.js'
-import * as MenuEntryId from '../MenuEntryId/MenuEntryId.js'
-// TODO when accept input is invoked multiple times, it should not lead to errors
-
-/**
- * @enum {string}
- */
-const UiStrings = {
-  Add: 'Add',
-  Restore: 'Restore',
-  OpenFile: 'Open File',
-}
-
-export const create = () => {
-  return {
-    merge: [],
-    index: [],
-    untracked: [],
-    workingTree: [],
-    disposed: false,
-    inputValue: '',
-    displayItems: [],
-    buttonIndex: -1,
-  }
-}
-
-export const dispose = (state) => {
-  return {
-    ...state,
-    disposed: true,
-  }
-}
-
-export const handleInput = (state, text) => {
-  console.log({ text })
-  return {
-    ...state,
-    inputValue: text,
-  }
-}
-
-export const acceptInput = async (state) => {
-  const { inputValue } = state
-  await SourceControl.acceptInput(inputValue)
-  return {
-    ...state,
-    inputValue: '',
-  }
-}
-
-const getChangedFiles = async () => {
-  const changedFiles = await SourceControl.getChangedFiles()
-  return {
-    index: [],
-    merge: [],
-    untracked: [],
-    workingTree: changedFiles,
-    gitRoot: '',
-  }
-}
-
-const getDisplayItems = (workingTree) => {
-  const displayItems = []
-  const setSize = workingTree.length
-  for (let i = 0; i < workingTree.length; i++) {
-    const item = workingTree[i]
-    displayItems.push({
-      file: item.file,
-      label: item.file,
-      posInSet: i + 1,
-      setSize,
-      icon: IconTheme.getFileIcon({ name: item.file }),
-    })
-  }
-  return displayItems
-}
-
-export const loadContent = async (state) => {
-  const changedFiles = await getChangedFiles()
-  const displayItems = getDisplayItems(changedFiles.workingTree)
-  return {
-    ...state,
-    index: changedFiles.index,
-    merge: changedFiles.merge,
-    untracked: changedFiles.untracked,
-    workingTree: changedFiles.workingTree,
-    gitRoot: changedFiles.gitRoot,
-    displayItems,
-  }
-}
-
-const updateIcon = (displayItem) => {
-  return {
-    ...displayItem,
-    icon: IconTheme.getFileIcon({ name: displayItem.file }),
-  }
-}
-
-export const updateIcons = (state) => {
-  const { displayItems } = state
-  const newDisplayItems = displayItems.map(updateIcon)
-  return {
-    ...state,
-    displayItems: newDisplayItems,
-  }
-}
-
-export const handleIconThemeChange = (state) => {
-  return updateIcons(state)
-}
-
-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([
-    SourceControl.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 handleMouseOver = (state, index) => {
-  return {
-    ...state,
-    buttonIndex: index,
-    buttons: [
-      {
-        label: UiStrings.OpenFile,
-        icon: Icon.GoToFile,
-      },
-      {
-        label: UiStrings.Restore,
-        icon: Icon.Discard,
-      },
-      {
-        label: UiStrings.Add,
-        icon: Icon.Add,
-      },
-    ],
-  }
-}
-
-export const handleContextMenu = async (state, x, y) => {
-  await Command.execute(
-    /* ContextMenu.show */ 'ContextMenu.show',
-    /* x */ x,
-    /* y */ y,
-    /* id */ MenuEntryId.SourceControl
-  )
-  return state
-}
-
-export const handleClickAdd = async (state, index) => {
-  const { displayItems } = state
-  const item = displayItems[index]
-  const { file } = item
-  await SourceControl.add(file)
-  return state
-}
-
-export const handleClickRestore = (state, index) => {
-  return state
-}
-
-export const handleClickDiscard = (state, index) => {
-  return state
-}
-
-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 [/* method */ 'setInputValue', /* value */ newState.inputValue]
-  },
-}
-
-const renderChangedFiles = {
-  isEqual(oldState, newState) {
-    return oldState.displayItems === newState.displayItems
-  },
-  apply(oldState, newState) {
-    return [
-      /* method */ 'setChangedFiles',
-      /* changedFiles */ newState.displayItems,
-    ]
-  },
-}
-
-const renderButtons = {
-  isEqual(oldState, newState) {
-    return (
-      oldState.buttonIndex === newState.buttonIndex &&
-      oldState.buttons === newState.buttons
-    )
-  },
-  apply(oldState, newState) {
-    return [
-      /* method */ 'setItemButtons',
-      /* index */ newState.buttonIndex,
-      /* buttons */ newState.buttons,
-    ]
-  },
-}
-
-export const render = [renderValue, renderChangedFiles, renderButtons]

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

@@ -1,11 +0,0 @@
-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
-export const Input = 11