@lvce-editor/server 0.4.3 → 0.5.0

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

@@ -68,3 +68,7 @@ Locator.prototype.type = async function (text) {
   const options = { text }
   return performAction(this, 'type', options)
 }
+
+Locator.prototype.dispatchEvent = async function (type, init) {
+  return performAction(this, 'dispatchEvent', { type, init })
+}

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

@@ -12,3 +12,4 @@ export * as SideBar from './TestFrameWorkComponentSideBar.js'
 export * as Command from './TestFrameWorkComponentCommand.js'
 export * as Platform from './TestFrameWorkComponentPlatform.js'
 export * as Settings from './TestFrameWorkComponentSettings.js'
+export * as Eval from './TestFrameWorkComponentEval.js'

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

@@ -0,0 +1,5 @@
+import * as Command from '../Command/Command.js'
+
+export const evalInRendererProcess = async (code) => {
+  await Command.execute('Eval.evalInRendererProcess', code)
+}

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

@@ -1,5 +1,6 @@
 import * as Command from '../Command/Command.js'
 import * as Platform from '../Platform/Platform.js'
+import * as PathSeparatorType from '../PathSeparatorType/PathSeparatorType.js'
 
 export const writeFile = async (path, content) => {
   await Command.execute('FileSystem.writeFile', path, content)
@@ -37,7 +38,7 @@ export const createExecutable = async (content) => {
 
 export const createExecutableFrom = async (path) => {
   const testPath = await Platform.getTestPath()
-  const absolutePath = testPath + '/' + path
+  const absolutePath = testPath + PathSeparatorType.Slash + path
   const content = await Command.execute('Ajax.getText', absolutePath)
   return createExecutable(content)
 }

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

@@ -67,7 +67,6 @@ export const applyEdits = (textDocument, changes) => {
           endRowIndex >= newLines.length
             ? ''
             : newLines[endRowIndex].slice(endColumnIndex)
-        console.log({ before, after })
         Arrays.splice(newLines, startRowIndex, deleted.length, [before + after])
       } else {
         const before =
@@ -78,7 +77,6 @@ export const applyEdits = (textDocument, changes) => {
           (endRowIndex >= newLines.length
             ? ''
             : newLines[endRowIndex].slice(endColumnIndex))
-        console.log({ before, after })
         Arrays.splice(newLines, startRowIndex, deleted.length, [
           before,
           ...middle,

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

@@ -3,8 +3,6 @@ import * as MenuIpc from '../Menu/Menu.ipc.js'
 
 // prettier-ignore
 export const Commands = {
-
-
   'TitleBarMenuBar.closeMenu': TitleBarMenuBar.closeMenu,
   'TitleBarMenuBar.focus': TitleBarMenuBar.focus,
   'TitleBarMenuBar.focusIndex': TitleBarMenuBar.focusIndex,

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

@@ -112,7 +112,9 @@ export const focusIndex = async (index) => {
     await openMenuAtIndex(index, /* focus */ false)
   } else {
     await RendererProcess.invoke(
-      /* TitleBarMenuBar.focusIndex */ 1371,
+      /* Viewlet.send */ 'Viewlet.send',
+      /* id */ 'TitleBar',
+      /* menuFocusIndex */ 'menuFocusIndex',
       /* unFocusIndex */ state.focusedIndex,
       /* index */ index
     )

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

@@ -0,0 +1,6 @@
+import * as Url from './Url.js'
+
+export const Commands = {
+  'Url.createObjectUrl': Url.createObjectUrl,
+  'Url.revokeObjectUrl': Url.revokeObjectUrl,
+}

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

@@ -0,0 +1,7 @@
+export const createObjectUrl = (blob) => {
+  return URL.createObjectURL(blob)
+}
+
+export const revokeObjectUrl = (url) => {
+  return URL.revokeObjectURL(url)
+}

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

@@ -0,0 +1,28 @@
+const getCombinedMessage = (error, message) => {
+  if (message) {
+    return `${message}: ${error}`
+  }
+  return `${error}`
+}
+
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent
+  }
+  const parentNewLineIndex = parent.indexOf('\n')
+  const childNewLineIndex = child.indexOf('\n')
+  const parentFirstLine = parent.slice(0, parentNewLineIndex)
+  const childRest = child.slice(childNewLineIndex)
+  return parentFirstLine + childRest
+}
+
+export class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message)
+    super(combinedMessage)
+    this.name = 'VError'
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack)
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+import { focusIndex } from './ViewletActivityBarFocusIndex.js'
+import * as Arrays from '../Arrays/Arrays.js'
+
+export const focusLast = (state) => {
+  return focusIndex(state, Arrays.lastIndex(state.activityBarItems))
+}

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

@@ -2,7 +2,6 @@ import * as Command from '../Command/Command.js'
 import * as Layout from '../Layout/Layout.js'
 
 const handleClickSettings = async (state, x, y, viewletId) => {
-  console.log('is settings')
   await Command.execute(
     /* ContextMenu.show */ 'ContextMenu.show',
     /* x */ x,

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

@@ -16,10 +16,10 @@ const getPosition = (state, index) => {
   }
 }
 
-export const selectCurrent = async (state) => {
+export const selectCurrent = (state) => {
   if (state.focusedIndex === -1) {
     return
   }
   const position = getPosition(state, state.focusedIndex)
-  await handleClick(state, state.focusedIndex, position.x, position.y)
+  return handleClick(state, state.focusedIndex, position.x, position.y)
 }

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

@@ -1,11 +1,10 @@
 import * as Command from '../Command/Command.js'
 import * as EditorPosition from '../EditorCommand/EditorCommandPosition.js'
+import * as EditorShowMessage from '../EditorCommand/EditorCommandShowMessage.js'
+import * as EditorCompletionMap from '../EditorCompletionMap/EditorCompletionMap.js'
 import * as ExtensionHostCompletion from '../ExtensionHost/ExtensionHostCompletion.js'
 import * as TextDocument from '../TextDocument/TextDocument.js'
 import * as Viewlet from '../Viewlet/Viewlet.js'
-import * as IconTheme from '../IconTheme/IconTheme.js'
-import * as EditorShowMessage from '../EditorCommand/EditorCommandShowMessage.js'
-import * as EditorCompletionType from '../EditorCompletionType/EditorCompletionType.js'
 
 export const create = (id, uri, top, left, width, height) => {
   console.log({ id, uri, top, left, width, height })
@@ -56,26 +55,12 @@ const getLabel = (item) => {
   return item.label
 }
 
-const EditorCompletionClassNames = {
-  [EditorCompletionType.Property]: 'IconProperty',
-  [EditorCompletionType.Value]: 'IconValue',
-  [EditorCompletionType.Function]: 'IconFunction',
-  [EditorCompletionType.Variable]: 'IconVariable',
-  [EditorCompletionType.Keyword]: 'IconKeyword',
-}
-
-const defaultClassName = 'IconDefault'
-
-const getIconClassName = (item) => {
-  return EditorCompletionClassNames[item.kind] || defaultClassName
-}
-
 const getVisibleItems = (filteredItems) => {
   const visibleItems = []
   for (const filteredItem of filteredItems) {
     visibleItems.push({
       label: getLabel(filteredItem),
-      icon: getIconClassName(filteredItem),
+      icon: EditorCompletionMap.getIconClassName(filteredItem),
     })
   }
   return visibleItems

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

@@ -0,0 +1,12 @@
+import * as ViewletEditorImage from './ViewletEditorImage.js'
+import * as Viewlet from '../Viewlet/Viewlet.js'
+
+// prettier-ignore
+export const Commands = {
+  'EditorImage.handlePointerDown': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handlePointerDown),
+  'EditorImage.handlePointerMove': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handlePointerMove),
+  'EditorImage.handlePointerUp': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handlePointerUp),
+  'EditorImage.handleWheel': Viewlet.wrapViewletCommand('EditorImage', ViewletEditorImage.handleWheel),
+}
+
+export * from './ViewletEditorImage.js'

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

@@ -0,0 +1,280 @@
+import * as Assert from '../Assert/Assert.js'
+import * as Clamp from '../Clamp/Clamp.js'
+import * as Command from '../Command/Command.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+
+export const name = 'EditorImage'
+
+export const create = (id, uri, left, top, width, height) => {
+  return {
+    src: '',
+    disposed: false,
+    top,
+    left,
+    width,
+    height,
+    uri,
+    domMatrix: new DOMMatrix(),
+    pointerOffsetX: 0,
+    pointerOffsetY: 0,
+    minZoom: 0.1,
+    maxZoom: 2 ** 15, // max value that doesn't result in degradation
+    zoomFactor: 200,
+    touchZoomFactor: 1.015,
+    eventCache: [],
+    previousDiff: 0,
+    pointerDownCount: 0,
+  }
+}
+
+const loadContentRemote = (state, uri) => {
+  const src = `/remote${uri}`
+  return {
+    ...state,
+    src,
+  }
+}
+
+const loadContentWithBlobUrl = async (state, uri) => {
+  const content = await FileSystem.readFile(uri)
+  const mimeType = await Command.execute('Mime.getMediaMimeType', uri)
+  const blob = await Command.execute(
+    'Blob.binaryStringToBlob',
+    content,
+    mimeType
+  )
+  const dataUrl = await Command.execute('Url.createObjectUrl', blob)
+  return {
+    ...state,
+    src: dataUrl,
+  }
+}
+
+const canUseRemoteLoading = (uri) => {
+  const protocol = FileSystem.getProtocol(uri)
+  return protocol === ''
+}
+
+// TODO revoke object url when disposed
+export const loadContent = async (state, ...args) => {
+  const { uri } = state
+  if (canUseRemoteLoading(uri)) {
+    return loadContentRemote(state, uri)
+  }
+  return loadContentWithBlobUrl(state, uri)
+}
+
+export const contentLoaded = async (state) => {}
+
+export const dispose = async (state) => {
+  const { src } = state
+  if (src.startsWith('blob:')) {
+    await Command.execute('Url.revokeObjectUrl', src)
+  }
+  return {
+    ...state,
+    disposed: true,
+  }
+}
+
+export const handlePointerDown = (state, pointerId, x, y) => {
+  Assert.object(state)
+  Assert.number(x)
+  Assert.number(y)
+  const { eventCache, pointerDownCount } = state
+  const newEventCache = [...eventCache, { pointerId, x, y }]
+  const newPointerDownCount = pointerDownCount + 1
+  return {
+    ...state,
+    pointerOffsetX: x,
+    pointerOffsetY: y,
+    eventCache: newEventCache,
+    pointerDownCount: newPointerDownCount,
+  }
+}
+
+const distance = (point1, point2) => {
+  var dx = point1.x - point2.x
+  var dy = point1.y - point2.y
+  return Math.sqrt(dx * dx + dy * dy)
+}
+
+export const handlePointerMove = (state, pointerId, x, y) => {
+  Assert.object(state)
+  Assert.number(x)
+  Assert.number(y)
+  const {
+    pointerOffsetX,
+    pointerOffsetY,
+    domMatrix,
+    eventCache,
+    previousDiff,
+    touchZoomFactor,
+    pointerDownCount,
+  } = state
+  if (pointerDownCount === 0) {
+    return state
+  }
+  const index = eventCache.findIndex((event) => event.pointerId === pointerId)
+  // TODO avoid mutation
+  eventCache[index] = { pointerId, x, y }
+
+  if (eventCache.length === 2) {
+    const currentDiff = distance(eventCache[0], eventCache[1])
+    if (previousDiff > 0) {
+      if (currentDiff > previousDiff) {
+        const newDomMatrix = new DOMMatrix([
+          (domMatrix.a *= touchZoomFactor),
+          domMatrix.b,
+          domMatrix.c,
+          (domMatrix.d *= touchZoomFactor),
+          domMatrix.e,
+          domMatrix.f,
+        ])
+        return {
+          ...state,
+          previousDiff: currentDiff,
+          domMatrix: newDomMatrix,
+        }
+      }
+      if (currentDiff < previousDiff) {
+        const newDomMatrix = new DOMMatrix([
+          (domMatrix.a /= touchZoomFactor),
+          domMatrix.b,
+          domMatrix.c,
+          (domMatrix.d /= touchZoomFactor),
+          domMatrix.e,
+          domMatrix.f,
+        ])
+        return {
+          ...state,
+          previousDiff: currentDiff,
+          domMatrix: newDomMatrix,
+        }
+      }
+    }
+    return {
+      ...state,
+      previousDiff: currentDiff,
+    }
+  }
+  const deltaX = x - pointerOffsetX
+  const deltaY = y - pointerOffsetY
+  const newDomMatrix = new DOMMatrix([
+    domMatrix.a,
+    domMatrix.b,
+    domMatrix.c,
+    domMatrix.d,
+    domMatrix.e + deltaX,
+    domMatrix.f + deltaY,
+  ])
+  return {
+    ...state,
+    pointerOffsetX: x,
+    pointerOffsetY: y,
+    domMatrix: newDomMatrix,
+  }
+}
+
+export const handlePointerUp = (state, pointerId, x, y) => {
+  const { eventCache, pointerDownCount } = state
+  const index = eventCache.findIndex((event) => event.pointerId === pointerId)
+  const newEventCache = [
+    ...eventCache.slice(0, index),
+    ...eventCache.slice(index + 1),
+  ]
+  const newPointerDownCount = pointerDownCount - 1
+  return {
+    ...state,
+    eventCache: newEventCache,
+    pointerDownCount: newPointerDownCount,
+  }
+}
+
+const getNewZoom = (zoom, currentZoomFactor, minZoom, maxZoom) => {
+  const newZoom = zoom * currentZoomFactor
+  return Clamp.clamp(newZoom, minZoom, maxZoom)
+}
+
+const getCurrentZoomFactor = (zoomFactor, deltaY) => {
+  // TODO use enum for direction
+  const direction = deltaY < 0 ? 'up' : 'down'
+  const normalizedDeltaY = 1 + Math.abs(deltaY) / zoomFactor
+  const currentZoomFactor =
+    direction === 'up' ? normalizedDeltaY : 1 / normalizedDeltaY
+  return currentZoomFactor
+}
+
+export const handleWheel = (state, x, y, deltaX, deltaY) => {
+  if (deltaY === 0) {
+    return state
+  }
+  const { top, left } = state
+  const relativeX = x - left
+  const relativeY = y - top
+  const { domMatrix, zoomFactor, minZoom, maxZoom } = state
+  const currentZoomFactor = getCurrentZoomFactor(zoomFactor, deltaY)
+  const newDomMatrix = new DOMMatrix()
+    .translateSelf(relativeX, relativeY)
+    .scaleSelf(currentZoomFactor)
+    .translateSelf(-relativeX, -relativeY)
+    .multiplySelf(domMatrix)
+  return {
+    ...state,
+    domMatrix: newDomMatrix,
+  }
+}
+
+export const hasFunctionalRender = true
+
+const renderSrc = {
+  isEqual(oldState, newState) {
+    return oldState.src === newState.src
+  },
+  apply(oldState, newState) {
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorImage',
+      /* method */ 'setSrc',
+      /* src */ newState.src,
+    ]
+  },
+}
+
+// workaround for browser bug
+const stringifyDomMatrix = (domMatrix) => {
+  const { a, b, c, d, e, f } = domMatrix
+  return `matrix(${a}, ${b}, ${c}, ${d}, ${e}, ${f})`
+}
+
+const renderTransform = {
+  isEqual(oldState, newState) {
+    return oldState.domMatrix === newState.domMatrix
+  },
+  apply(oldState, newState) {
+    const transform = stringifyDomMatrix(newState.domMatrix)
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorImage',
+      /* method */ 'setTransform',
+      /* transform */ transform,
+    ]
+  },
+}
+
+const renderCursor = {
+  isEqual(oldState, newState) {
+    return oldState.eventCache.length === newState.eventCache.length
+  },
+  apply(oldState, newState) {
+    const isDragging = newState.eventCache.length > 0
+    return [
+      /* Viewlet.invoke */ 'Viewlet.send',
+      /* id */ 'EditorImage',
+      /* method */ 'setDragging',
+      /* isDragging */ isDragging,
+    ]
+  },
+}
+
+export const render = [renderSrc, renderTransform, renderCursor]