@lvce-editor/server 0.0.28 → 0.0.31

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

@@ -0,0 +1,43 @@
+export const name = 'Iframe'
+
+export const create = (id) => {
+  return {
+    disposed: false,
+    id,
+    src: '',
+  }
+}
+
+export const loadContent = async (state, src) => {
+  return {
+    ...state,
+    src,
+  }
+}
+
+export const contentLoaded = async (state) => {}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderSrc = {
+  isEqual(oldState, newState) {
+    return oldState.src === newState.src
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'Iframe',
+      /* method */ 'setSrc',
+      /* src */ newState.src,
+    ]
+  },
+}
+
+export const render = [renderSrc]

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

@@ -0,0 +1,3 @@
+export const Commands = {}
+
+export * from './ViewletImplementations.js'

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

@@ -0,0 +1,42 @@
+import * as ExtensionHostImplementation from '../ExtensionHost/ExtensionHostImplementation.js'
+import * as TextDocument from '../TextDocument/TextDocument.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletLocations from '../ViewletLocations/ViewletLocations.js'
+import * as ViewletStates from '../ViewletStates/ViewletStates.js'
+
+export const name = 'Implementations'
+
+// TODO speed up this function by 130% by not running activation event (onReferences) again and again
+// e.g. (21ms activation event, 11ms getReferences) => (11ms getReferences)
+const getImplementations = async () => {
+  const editor = ViewletStates.getState('EditorText')
+  const rowIndex = editor.selections[0]
+  const columnIndex = editor.selections[1]
+  const offset = TextDocument.offsetAt(editor, rowIndex, columnIndex)
+  const implementations =
+    await ExtensionHostImplementation.executeImplementationProvider(
+      editor,
+      offset
+    )
+  console.log({ implementations })
+  return implementations
+}
+
+export const create = ViewletLocations.create
+
+export const loadContent = async (state) => {
+  return ViewletLocations.loadContent(state, getImplementations)
+}
+
+export const contentLoaded = (state) => {
+  ViewletStates.set('Locations', {
+    factory: ViewletLocations,
+    state,
+  })
+}
+
+export const dispose = ViewletLocations.dispose
+
+export const hasFunctionalRender = ViewletLocations.hasFunctionalRender
+
+export const render = ViewletLocations.render

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

@@ -0,0 +1,298 @@
+import * as Assert from '../Assert/Assert.js'
+
+export const ITEM_HEIGHT = 62
+
+const MINIMUM_SLIDER_SIZE = 20
+
+export const name = 'List'
+
+export const create = (id, uri, left, top, width, height) => {
+  return {
+    items: [],
+    focusedIndex: -1,
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    width,
+    height,
+    negativeMargin: 0,
+    scrollBarHeight: 0,
+    handleOffset: 0,
+    top,
+    left,
+    finalDeltaY: 2728,
+  }
+}
+
+const getVisible = (state) => {
+  return state.items.slice(state.minLineY, state.maxLineY)
+}
+
+export const loadContent = (state) => {
+  return state
+}
+
+export const focusIndex = (state, index) => {
+  if (index === -1) {
+    return {
+      ...state,
+      focusedIndex: -1,
+    }
+  }
+  const listHeight = state.height
+  if (index < state.minLineY + 1) {
+    // scroll up
+    const minLineY = index
+    const maxLineY = minLineY + Math.ceil(listHeight / ITEM_HEIGHT)
+    const negativeMargin = -minLineY * ITEM_HEIGHT
+    return {
+      ...state,
+      focusedIndex: index,
+      minLineY,
+      maxLineY,
+      negativeMargin,
+    }
+  }
+  if (index >= state.maxLineY - 1) {
+    //  scroll down
+    const maxLineY = index + 1
+    const minLineY = maxLineY - Math.ceil(listHeight / ITEM_HEIGHT)
+    const negativeMargin =
+      -minLineY * ITEM_HEIGHT + (listHeight % ITEM_HEIGHT) - ITEM_HEIGHT
+    return {
+      ...state,
+      focusedIndex: index,
+      minLineY,
+      maxLineY,
+      negativeMargin,
+    }
+  }
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}
+
+// TODO lazyload this
+export const handleClick = (state, index) => {
+  return focusIndex(state, index)
+}
+
+export const focusNext = (state) => {
+  if (state.focusedIndex === state.items.length - 1) {
+    return state
+  }
+  return focusIndex(state, state.focusedIndex + 1)
+}
+
+export const focusNextPage = (state) => {
+  if (state.focusedIndex === state.items.length - 1) {
+    return state
+  }
+  const indexNextPage = Math.min(
+    state.maxLineY + (state.maxLineY - state.minLineY) - 2,
+    state.items.length - 1
+  )
+  return focusIndex(state, indexNextPage)
+}
+
+export const focusPrevious = (state) => {
+  if (state.focusedIndex === 0 || state.focusedIndex === -1) {
+    return state
+  }
+  return focusIndex(state, state.focusedIndex - 1)
+}
+
+export const focusPreviousPage = (state) => {
+  if (state.focusedIndex === 0 || state.focusedIndex === -1) {
+    return state
+  }
+
+  const indexPreviousPage = Math.max(
+    state.minLineY - (state.maxLineY - state.minLineY) + 1,
+    0
+  )
+  return focusIndex(state, indexPreviousPage)
+}
+
+export const focusFirst = (state) => {
+  if (state.items.length === 0) {
+    return state
+  }
+  return focusIndex(state, 0)
+}
+
+export const focusLast = (state) => {
+  if (state.items.length === 0) {
+    return state
+  }
+  return focusIndex(state, state.items.length - 1)
+}
+
+// TODO pass index instead
+export const handleContextMenu = async (state, x, y, extensionId) => {
+  // await Command.execute(
+  //   /* ContextMenu.show */ 'ContextMenu.show',
+  //   /* x */ x,
+  //   /* y */ y,
+  //   /* id */ 'manageExtension'
+  // )
+}
+
+export const hasFunctionalResize = true
+
+export const resize = (state, dimensions) => {
+  // TODO should just return new state, render function can take old state and new state and return render commands
+  const listHeight = dimensions.height
+  const maxLineY = state.minLineY + Math.ceil(listHeight / ITEM_HEIGHT)
+  return {
+    ...state,
+    ...dimensions,
+    maxLineY,
+  }
+}
+
+export const setDeltaY = (state, deltaY) => {
+  console.log({ deltaY })
+  Assert.object(state)
+  Assert.number(deltaY)
+  const listHeight = state.height
+  if (deltaY < 0) {
+    deltaY = 0
+  } else if (deltaY > state.items.length * ITEM_HEIGHT - listHeight) {
+    deltaY = Math.max(state.items.length * ITEM_HEIGHT - listHeight, 0)
+  }
+  if (state.deltaY === deltaY) {
+    return state
+  }
+  // TODO when it only moves by one px, extensions don't need to be rerendered, only negative margin
+  const minLineY = Math.floor(deltaY / ITEM_HEIGHT)
+  const maxLineY = minLineY + Math.round(listHeight / ITEM_HEIGHT)
+  const negativeMargin = -Math.round(deltaY)
+  return {
+    ...state,
+    deltaY,
+    minLineY,
+    maxLineY,
+    negativeMargin,
+  }
+  // await scheduleExtensions(state)
+}
+
+export const handleWheel = (state, deltaY) => {
+  return setDeltaY(state, state.deltaY + deltaY)
+}
+
+const getScrollBarHeight = (editorHeight, contentHeight) => {
+  if (editorHeight > contentHeight) {
+    return 0
+  }
+  return Math.max(
+    Math.round(editorHeight ** 2 / contentHeight),
+    MINIMUM_SLIDER_SIZE
+  )
+}
+
+const getNewPercent = (state, relativeY) => {
+  if (relativeY <= state.height - state.scrollBarHeight / 2) {
+    // clicked in middle
+    return relativeY / (state.height - state.scrollBarHeight)
+  }
+  // clicked at bottom
+  return 1
+}
+
+export const handleScrollBarMove = (state, y) => {
+  const relativeY = y - state.top - state.handleOffset
+  console.log('handle offset', state.handleOffset)
+  const newPercent = getNewPercent(state, relativeY)
+  const newDeltaY = newPercent * state.finalDeltaY
+  console.log({ relativeY, newPercent, newDeltaY })
+  return setDeltaY(state, newDeltaY)
+}
+
+const getNewDeltaPercent = (state, relativeY) => {
+  if (relativeY <= state.scrollBarHeight / 2) {
+    // clicked at top
+    return 0
+  }
+  if (relativeY <= state.height - state.scrollBarHeight / 2) {
+    // clicked in middle
+    return (
+      (relativeY - state.scrollBarHeight / 2) /
+      (state.height - state.scrollBarHeight)
+    )
+  }
+  // clicked at bottom
+  return 1
+}
+
+export const handleScrollBarClick = (state, y) => {
+  const relativeY = y - state.top
+  const newPercent = getNewDeltaPercent(state, relativeY)
+  const newDeltaY = newPercent * state.finalDeltaY
+  return {
+    ...setDeltaY(state, newDeltaY),
+    handleOffset: state.scrollBarHeight / 2,
+  }
+}
+
+export const hasFunctionalRender = true
+
+export const render = (oldState, newState) => {
+  const changes = []
+  if (
+    oldState.items !== newState.items ||
+    oldState.minLineY !== newState.minLineY ||
+    oldState.maxLineY !== newState.maxLineY
+  ) {
+    const visibleItems = getVisible(newState)
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'List',
+      /* method */ 'setItems',
+      /* visibleExtensions */ visibleItems,
+    ])
+  }
+  if (oldState.items.length !== newState.items.length) {
+    const contentHeight = newState.items.length * ITEM_HEIGHT
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'List',
+      /* method */ 'setContentHeight',
+      /* contentHeight */ contentHeight,
+    ])
+  }
+
+  if (oldState.negativeMargin !== newState.negativeMargin) {
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'List',
+      /* method */ 'setNegativeMargin',
+      /* negativeMargin */ newState.negativeMargin,
+    ])
+  }
+
+  if (oldState.focusedIndex !== newState.focusedIndex) {
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'List',
+      /* method */ 'setFocusedIndex',
+      /* oldFocusedIndex */ oldState.focusedIndex - oldState.minLineY,
+      /* newFocusedIndex */ newState.focusedIndex - newState.minLineY,
+    ])
+  }
+  if (oldState.deltaY !== newState.deltaY) {
+    const scrollBarY =
+      (newState.deltaY / newState.finalDeltaY) *
+      (newState.height - newState.scrollBarHeight)
+    changes.push([
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'List',
+      /* method */ 'setScrollBar',
+      /* scrollBarY */ scrollBarY,
+      /* scrollBarHeight */ newState.scrollBarHeight,
+    ])
+  }
+  return changes
+}

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

@@ -0,0 +1,13 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletLocations from './ViewletLocations.js'
+
+// prettier-ignore
+export const Commands = {
+  'Locations.selectIndex': Viewlet.wrapViewletCommand('Locations', ViewletLocations.selectIndex),
+  'Locations.focusFirst': Viewlet.wrapViewletCommand('Locations', ViewletLocations.focusFirst),
+  'Locations.focusLast': Viewlet.wrapViewletCommand('Locations', ViewletLocations.focusLast),
+  'Locations.focusNext': Viewlet.wrapViewletCommand('Locations', ViewletLocations.focusNext),
+  'Locations.focusPrevious': Viewlet.wrapViewletCommand('Locations', ViewletLocations.focusPrevious),
+  'Locations.selectCurrent': Viewlet.wrapViewletCommand('Locations', ViewletLocations.selectCurrent),
+  'Locations.focusIndex': Viewlet.wrapViewletCommand('Locations', ViewletLocations.focusIndex),
+}

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

@@ -0,0 +1,252 @@
+import * as Command from '../Command/Command.js'
+import * as IconTheme from '../IconTheme/IconTheme.js'
+
+export const name = 'Locations'
+
+export const create = (id, uri) => {
+  return {
+    references: [],
+    message: '',
+    displayReferences: [],
+    focusedIndex: -1,
+    id,
+  }
+}
+
+const getMessage = (resultCount, fileCount) => {
+  if (resultCount === 0) {
+    return 'No Results'
+  }
+  if (resultCount === 1 && fileCount === 1) {
+    return '1 result in 1 file'
+  }
+  if (fileCount === 1) {
+    return `${resultCount} results in 1 file`
+  }
+  return `${resultCount} results in ${fileCount} files`
+}
+
+const getName = (uri) => {
+  return uri.slice(uri.lastIndexOf('/') + 1)
+}
+
+const getDisplayReferences = (references) => {
+  const fileMap = Object.create(null)
+  const displayReferences = []
+  let current = {
+    uri: '',
+    startOffset: 0,
+    endOffset: 0,
+    lineText: '',
+  }
+  let outerPosInSet = 1
+  let innerPosInSet = 1
+  let fileCount = 0
+  let index = 0
+  for (const reference of references) {
+    if (reference.uri === current.uri) {
+      displayReferences.push({
+        depth: 2,
+        posInSet: innerPosInSet++,
+        setSize: 1,
+        type: 'leaf',
+        uri: '',
+        name: '',
+        lineText: reference.lineText,
+        index: index++,
+      })
+    } else {
+      fileCount++
+      current = reference
+      innerPosInSet = 1
+      const name = getName(reference.uri)
+      displayReferences.push({
+        depth: 1,
+        posInSet: outerPosInSet++,
+        setSize: 1,
+        type: 'expanded',
+        uri: reference.uri,
+        name,
+        lineText: '',
+        icon: IconTheme.getIcon({
+          type: 'file',
+          path: reference.uri,
+          name,
+        }),
+        index: index++,
+      })
+      displayReferences.push({
+        depth: 2,
+        posInSet: innerPosInSet++,
+        setSize: 1,
+        type: 'leaf',
+        uri: '',
+        name: '',
+        lineText: current.lineText,
+        index: index++,
+      })
+    }
+  }
+
+  return {
+    message: getMessage(references.length, fileCount),
+    displayReferences,
+  }
+}
+
+// TODO speed up this function by 130% by not running activation event (onReferences) again and again
+// e.g. (21ms activation event, 11ms getReferences) => (11ms getReferences)
+export const loadContent = async (state, getReferences) => {
+  const references = await getReferences()
+  const { message, displayReferences } = getDisplayReferences(references)
+  return {
+    ...state,
+    references,
+    displayReferences,
+    message,
+  }
+}
+
+export const contentLoaded = () => {}
+
+export const dispose = (state) => {
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+const getUri = (state, index) => {
+  for (let i = index; i >= 0; i--) {
+    if (state.displayReferences[i].depth === 1) {
+      return state.displayReferences[i].uri
+    }
+  }
+  return ''
+}
+
+const selectIndexLead = async (state, index) => {
+  const uri = getUri(state, index)
+  // TODO open file and jump to line
+  await Command.execute(/* Main.openUri */ 'Main.openUri', /* uri */ uri)
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}
+
+const selectIndexExpanded = (state, index) => {
+  // TODO expand
+
+  return { ...state, focusedIndex: index }
+}
+
+const selectIndexCollapsed = (state, index) => {
+  // TODO collapse
+
+  return { ...state, focusedIndex: index }
+}
+
+export const selectIndex = (state, index) => {
+  const displayReference = state.displayReferences[index]
+  switch (displayReference.type) {
+    case 'leaf':
+      return selectIndexLead(state, index)
+    case 'expanded':
+      return selectIndexExpanded(state, index)
+    case 'collapsed':
+      return selectIndexCollapsed(state, index)
+    default:
+      console.warn(displayReference)
+      return state
+  }
+}
+
+export const focusIndex = (state, index) => {
+  return {
+    ...state,
+    focusedIndex: index,
+  }
+}
+
+export const focusFirst = (state) => {
+  if (state.displayReferences.length === 0) {
+    return state
+  }
+  return focusIndex(state, 0)
+}
+
+export const focusPrevious = (state) => {
+  if (state.focusedIndex === 0 || state.focusedIndex === -1) {
+    return state
+  }
+  return focusIndex(state, state.focusedIndex - 1)
+}
+
+export const focusNext = (state) => {
+  if (state.focusedIndex === state.displayReferences.length - 1) {
+    return state
+  }
+  return focusIndex(state, state.focusedIndex + 1)
+}
+
+export const focusLast = (state) => {
+  if (state.focusedIndex === state.displayReferences.length - 1) {
+    return state
+  }
+  return focusIndex(state, state.displayReferences.length - 1)
+}
+
+export const selectCurrent = (state) => {
+  if (state.focusedIndex === -1) {
+    return state
+  }
+  return selectIndex(state, state.focusedIndex)
+}
+
+export const hasFunctionalRender = true
+
+const renderLocations = {
+  isEqual(oldState, newState) {
+    return oldState.displayReferences === newState.displayReferences
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ newState.id,
+      /* method */ 'setLocations',
+      /* references */ newState.displayReferences,
+    ]
+  },
+}
+
+const renderMessage = {
+  isEqual(oldState, newState) {
+    return oldState.message === newState.message
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ newState.id,
+      /* method */ 'setMessage',
+      /* message */ newState.message,
+    ]
+  },
+}
+
+const renderFocusedIndex = {
+  isEqual(oldState, newState) {
+    return oldState.focusedIndex === newState.focusedIndex
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ newState.id,
+      /* method */ 'setFocusedIndex',
+      /* oldFocusedIndex */ oldState.focusedIndex,
+      /* newFocusedIndex */ newState.focusedIndex,
+    ]
+  },
+}
+
+export const render = [renderFocusedIndex, renderLocations, renderMessage]

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

@@ -0,0 +1,25 @@
+import * as Viewlet from '../Viewlet/Viewlet.js'
+import * as ViewletMain from './ViewletMain.js'
+
+// prettier-ignore
+export const Commands = {
+  'Main.save': Viewlet.wrapViewletCommand('Main', ViewletMain.save),
+  'Main.handleDrop': Viewlet.wrapViewletCommand('Main', ViewletMain.handleDrop),
+  'Main.closeActiveEditor': Viewlet.wrapViewletCommand('Main', ViewletMain.closeActiveEditor),
+  'Main.closeAllEditors': Viewlet.wrapViewletCommand('Main', ViewletMain.closeAllEditors),
+  'Main.handleTabContextMenu': Viewlet.wrapViewletCommand('Main', ViewletMain.handleTabContextMenu),
+  'Main.hydrate': Viewlet.wrapViewletCommand('Main', ViewletMain.hydrate),
+  'Main.openUri': Viewlet.wrapViewletCommand('Main', ViewletMain.openUri),
+  'Main.closeEditor': Viewlet.wrapViewletCommand('Main', ViewletMain.closeEditor),
+  'Main.handleTabClick': Viewlet.wrapViewletCommand('Main', ViewletMain.handleTabClick),
+  'Main.focusFirst': Viewlet.wrapViewletCommand('Main', ViewletMain.focusFirst),
+  'Main.focusLast': Viewlet.wrapViewletCommand('Main', ViewletMain.focusLast),
+  'Main.focusPrevious': Viewlet.wrapViewletCommand('Main', ViewletMain.focusPrevious),
+  'Main.focusNext': Viewlet.wrapViewletCommand('Main', ViewletMain.focusNext),
+  'Main.closeFocusedTab': Viewlet.wrapViewletCommand('Main', ViewletMain.closeFocusedTab),
+  'Main.closeOthers': Viewlet.wrapViewletCommand('Main', ViewletMain.closeOthers),
+  'Main.closeTabsRight': Viewlet.wrapViewletCommand('Main', ViewletMain.closeTabsRight),
+  'Main.closeTabsLeft': Viewlet.wrapViewletCommand('Main', ViewletMain.closeTabsLeft),
+}
+
+export * from './ViewletMain.js'