@lvce-editor/server 0.0.26 → 0.0.29

package/static/bf7d47a/packages/renderer-process/src/parts/Renderer/RendererQuickPick.js

@@ -0,0 +1,30 @@
+export const renderTemplate = () => {
+  const label = document.createElement('div')
+  label.className = 'QuickPickItemLabel'
+  const description = document.createElement('div')
+  description.className = 'QuickPickItemDescription'
+  const root = document.createElement('li')
+  root.className = 'ListItem QuickPickItem'
+  // @ts-ignore
+  root.role= 'option'
+  root.append(label, description)
+  return {
+    root,
+    label,
+    description,
+  }
+}
+
+export const renderElement = (template, data, index) => {
+  template.label.textContent = data.label
+  template.description.textContent = data.description || '~/sample-folder'
+  template.root.id = `item-${index}`
+  for (const key of Object.keys(template.root.dataset)) {
+    delete template.root.dataset[key]
+  }
+  template.root.dataset.index = index
+  for (const [key, value] of Object.entries(data.dataset || {})) {
+    template.root.dataset[key] = value
+  }
+  // template.root.dataset = data.dataset
+}

package/static/bf7d47a/packages/renderer-process/src/parts/Renderer/RendererSearchResult.js

@@ -0,0 +1,19 @@
+export const renderTemplate = () => {
+  const label = document.createElement('div')
+  label.className = 'SearchResultLabel'
+  const root = document.createElement('div')
+  root.className = 'ListItem SearchResults'
+  // @ts-ignore
+  root.role = 'option'
+  root.append(label)
+  return {
+    root,
+    label,
+  }
+}
+
+export const renderElement = (template, data, index) => {
+  template.label.textContent = data.text
+  template.root.id = `item-${index}`
+  template.root.dataset.index = index
+}

package/static/bf7d47a/packages/renderer-process/src/parts/Renderer/RendererTree.js

@@ -0,0 +1,41 @@
+export const renderTemplate = () => {
+  const label = document.createElement('div')
+  label.className = 'TreeItemLabel'
+  const root = document.createElement('div')
+  root.className = 'ListItem TreeItem'
+  // @ts-ignore
+  root.role = 'treeitem'
+  root.append(label)
+  return {
+    root,
+    label,
+  }
+}
+
+export const renderElement = (template, data, index) => {
+  template.label.textContent = data.name
+  template.root.setAttribute('aria-level', data.level)
+  // TODO renderer should do the index and id thing
+  // template.root.id = `treeitem-${index}`
+  template.root.dataset.index = index
+  template.root.title = data.absolutePath
+  switch (data.type) {
+    case /* file */ 'file':
+      template.root.removeAttribute('aria-expanded')
+      break
+    case /* expandedFolder */ 'directory-expanded':
+      template.root.setAttribute('aria-expanded', 'true')
+      break
+    case /* collapsedFolder */ 'directory':
+      template.root.setAttribute('aria-expanded', 'false')
+      break
+    default:
+      break
+  }
+}
+
+export const renderWrapper = (wrapper) => {
+  wrapper.role = 'tree'
+  wrapper.ariaLabel = 'Files Explorer'
+  wrapper.setAttribute('aria-multiselectable', 'true')
+}

package/static/bf7d47a/packages/renderer-process/src/parts/RendererWorker/RendererWorker.js

@@ -0,0 +1,187 @@
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import { JsonRpcError } from '../Errors/JsonRpcError.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as Platform from '../Platform/Platform.js'
+
+// const URL_RENDERER_WORKER =
+// '/packages/renderer-worker/distmin/rendererWorkerMain-0ead0bed.js'
+
+export const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
+class NonError extends Error {
+  name = 'NonError'
+
+  constructor(message) {
+    super(message)
+  }
+}
+
+// ensureError based on https://github.com/sindresorhus/ensure-error/blob/main/index.js (License MIT)
+const ensureError = (input) => {
+  if (!(input instanceof Error)) {
+    return new NonError(input)
+  }
+  return input
+}
+
+const serializeError = (error) => {
+  error = ensureError(error)
+  return {
+    stack: error.stack,
+    message: error.message,
+  }
+}
+
+const handleMessageFromRendererWorker = async (event) => {
+  const message = event.data
+  if ('id' in message) {
+    if ('method' in message) {
+      try {
+        const result = await Command.execute(message.method, ...message.params)
+        state.ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          result,
+        })
+        return
+      } catch (error) {
+        const serializedError = serializeError(error)
+        state.ipc.send({
+          jsonrpc: '2.0',
+          id: message.id,
+          error: {
+            message: serializedError.message,
+            stack: serializedError.stack,
+          },
+        })
+      }
+      return
+    }
+    Callback.resolve(message.id, message)
+    return
+  }
+  throw new JsonRpcError('unexpected message from renderer process')
+}
+
+const getIpc = async () => {
+  const rendererWorker = await IpcParent.create({
+    method: IpcParent.Methods.ModuleWorker,
+    url: Platform.getRendererWorkerUrl(),
+    name: 'Renderer Worker',
+  })
+  return {
+    send(message) {
+      rendererWorker.postMessage(message)
+    },
+    sendAndTransfer(message, transferables) {
+      rendererWorker.postMessage(message, transferables)
+    },
+    get onmessage() {
+      return rendererWorker.onmessage
+    },
+    set onmessage(listener) {
+      rendererWorker.onmessage = listener
+    },
+  }
+}
+
+export const hydrate = async (config) => {
+  const ipc = await getIpc()
+
+  // setup electron message port
+  if (Platform.isElectron()) {
+    await new Promise((resolve, reject) => {
+      const handleIpcMessage = (event) => {
+        if (event.data !== 'get-port') {
+          reject(new Error('unexpected message from renderer worker'))
+          return
+        }
+        const handleMessageFromWindow = (event) => {
+          const port = event.ports[0]
+          ipc.sendAndTransfer('port', [port])
+          resolve()
+        }
+
+        // @ts-ignore
+        window.addEventListener('message', handleMessageFromWindow, {
+          once: true,
+        })
+        // @ts-ignore
+        window.myApi.ipcConnect()
+      }
+      ipc.onmessage = handleIpcMessage
+    })
+  }
+  ipc.onmessage = handleMessageFromRendererWorker
+  state.ipc = ipc
+}
+
+// TODO needed?
+export const dispose = () => {
+  if (state.rendererWorker) {
+    state.rendererWorker.terminate()
+  }
+}
+
+export const send = (method, ...params) => {
+  state.ipc.send({
+    jsonrpc: '2.0',
+    method,
+    params,
+  })
+}
+
+const deserializeError = (serializedError) => {
+  const error = new Error()
+  if (serializedError && serializedError.message) {
+    error.message = serializedError.message
+  }
+  if (serializedError && serializedError.stack) {
+    error.stack = serializedError.stack
+  }
+  return error
+}
+
+const combineStacks = (upperStack, lowerStack) => {
+  const indexNewLine = lowerStack.indexOf('\n')
+  return upperStack + lowerStack.slice(indexNewLine)
+}
+
+class RendererWorkerError extends Error {
+  constructor(serializedError) {
+    const deserializedError = deserializeError(serializedError)
+    super(deserializedError.message)
+    if (this.stack) {
+      this.stack = combineStacks(deserializedError.stack, this.stack)
+    }
+  }
+}
+
+export const invoke = async (method, ...params) => {
+  const responseMessage = await new Promise((resolve, reject) => {
+    const callbackId = Callback.register(resolve, reject)
+    state.ipc.send({
+      jsonrpc: '2.0',
+      method,
+      params,
+      id: callbackId,
+    })
+  })
+  if ('error' in responseMessage) {
+    throw new RendererWorkerError(responseMessage.error)
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+  throw new JsonRpcError('unexpected message from renderer process')
+}
+
+export const sendAndTransfer = (message, transfer) => {
+  state.ipc.sendAndTransfer(message, transfer)
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/ConditionErrors.js

@@ -0,0 +1,52 @@
+import * as QuerySelector from './QuerySelector.js'
+
+export const toBeVisible = (locator) => {
+  return `expected selector to be visible ${locator._selector}`
+}
+
+export const toHaveText = (locator, { text }) => {
+  const [element] = QuerySelector.querySelector(locator._selector)
+  if (!element) {
+    return `expected selector ${locator._selector} to have text "${text}" element was not found`
+  }
+  return `expected selector ${locator._selector} to have text "${text}" but was "${element.textContent}"`
+}
+
+export const toHaveAttribute = (locator, { key, value }) => {
+  const [element] = QuerySelector.querySelector(locator._selector)
+  if (!element) {
+    return `expected ${locator._selector} to have attribute ${key} ${value} but element was not found`
+  }
+  const actual = element.getAttribute(key)
+  return `expected ${locator._selector} to have attribute ${key} ${value} but was ${actual}`
+}
+
+export const toHaveCount = (locator, { count }) => {
+  return `expected ${locator._selector} to have count ${count}`
+}
+
+export const toBeFocused = (locator) => {
+  return `expected ${locator._selector} to be focused`
+}
+
+export const toHaveClass = (locator, { className }) => {
+  const [element] = QuerySelector.querySelector(locator._selector)
+  if (!element) {
+    return `expected ${locator._selector} to have class ${className} but element was not found`
+  }
+  return `expected ${locator._selector} to have class ${className}`
+}
+
+export const toBeHidden = (locator) => {
+  return `expected ${locator._selector} to be hidden`
+}
+
+export const toHaveCss = (locator, { key, value }) => {
+  const [element] = QuerySelector.querySelector(locator._selector)
+  if (!element) {
+    return `expected ${locator._selector} to have css ${key} ${value}`
+  }
+  const style = getComputedStyle(element)
+  const actual = style[key]
+  return `expected ${locator._selector} to have css ${key} ${value} but was ${actual}`
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/ElementActions.js

@@ -0,0 +1,46 @@
+export const mouseEvent = (element, eventType, options) => {
+  const event = new MouseEvent(eventType, options)
+  element.dispatchEvent(event)
+}
+
+export const mouseDown = (element, options) => {
+  mouseEvent(element, 'mousedown', options)
+}
+
+export const mouseUp = (element, options) => {
+  mouseEvent(element, 'mouseup', options)
+}
+
+export const contextMenu = (element, options) => {
+  mouseEvent(element, 'contextmenu', options)
+}
+
+export const click = (element, options) => {
+  mouseDown(element, options)
+  mouseEvent(element, 'click', options)
+  mouseUp(element, options)
+  if (options.button === 2 /* right */) {
+    contextMenu(element, options)
+  }
+}
+
+export const hover = (element, options) => {
+  mouseEvent(element, 'mouseenter', options)
+}
+
+export const type = (element, options) => {
+  element.value = options.text
+}
+
+export const keyboardEvent = (element, eventType, options) => {
+  const event = new KeyboardEvent(eventType, options)
+  element.dispatchEvent(event)
+}
+
+export const keyDown = (element, options) => {
+  keyboardEvent(element, 'keydown', options)
+}
+
+export const keyUp = (element, options) => {
+  keyboardEvent(element, 'keyup', options)
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/HtmlElements.js

@@ -0,0 +1,104 @@
+export const htmlElements = [
+  'a',
+  'abbr',
+  'address',
+  'area',
+  'article',
+  'aside',
+  'audio',
+  'b',
+  'base',
+  'bdo',
+  'body',
+  'br',
+  'button',
+  'canvas',
+  'caption',
+  'center',
+  'cite',
+  'code',
+  'col',
+  'colgroup',
+  'command',
+  'datalist',
+  'dd',
+  'del',
+  'details',
+  'dfn',
+  'dialog',
+  'div',
+  'dl',
+  'dt',
+  'em',
+  'embed',
+  'fieldset',
+  'figcaption',
+  'figure',
+  'footer',
+  'form',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'head',
+  'hr',
+  'html',
+  'i',
+  'iframe',
+  'img',
+  'input',
+  'ins',
+  'kbd',
+  'label',
+  'legend',
+  'li',
+  'link',
+  'map',
+  'mark',
+  'menu',
+  'meta',
+  'meter',
+  'nav',
+  'noscript',
+  'object',
+  'ol',
+  'optgroup',
+  'option',
+  'output',
+  'p',
+  'param',
+  'pre',
+  'progress',
+  'q',
+  'rp',
+  'rt',
+  's',
+  'samp',
+  'script',
+  'section',
+  'select',
+  'small',
+  'source',
+  'span',
+  'strong',
+  'sub',
+  'sup',
+  'table',
+  'tbody',
+  'td',
+  'textarea',
+  'tfoot',
+  'th',
+  'thead',
+  'time',
+  'title',
+  'tr',
+  'track',
+  'u',
+  'ul',
+  'var',
+  'video',
+  'wbr',
+]

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/KeyBoardActions.js

@@ -0,0 +1,8 @@
+import * as ElementActions from './ElementActions.js'
+
+export const press = (options) => {
+  const element = document.activeElement
+
+  ElementActions.keyDown(element, options)
+  ElementActions.keyUp(element, options)
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/MultiElementConditions.js

@@ -0,0 +1,7 @@
+export const toHaveCount = (elements, { count }) => {
+  return elements.length === count
+}
+
+export const toBeHidden = (elements) => {
+  return elements.length === 0
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/QuerySelector.js

@@ -0,0 +1,88 @@
+import { htmlElements } from './HtmlElements.js'
+
+const querySelectorByText = (root, text) => {
+  let node
+  const elements = []
+  const walk = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null)
+  while ((node = walk.nextNode())) {
+    // @ts-ignore
+    if (node.nodeValue === text) {
+      elements.push(node.parentNode)
+    }
+  }
+  return elements
+}
+
+const querySelectorByCss = (selector) => {
+  return Array.from(document.querySelectorAll(selector))
+}
+
+const isElement = (selector) => {
+  return htmlElements.includes(selector)
+}
+
+export const querySelector = (selector) => {
+  if (typeof selector !== 'string') {
+    throw new Error('selector must be of type string')
+  }
+  if (selector.startsWith('text=')) {
+    return querySelectorByText(document.body, selector.slice('text='.length))
+  }
+  if (selector.includes('text=')) {
+    const index = selector.indexOf('text=')
+    const elements = querySelectorByCss(selector.slice(0, index))
+    const text = selector.slice(index + 'text='.length)
+    return elements.flatMap((element) => {
+      return querySelectorByText(element, text)
+    })
+    // for(const element of elements)
+  }
+  if (selector.startsWith('.')) {
+    return querySelectorByCss(selector)
+  }
+  if (selector.startsWith('#')) {
+    return querySelectorByCss(selector)
+  }
+  if (isElement(selector)) {
+    return querySelectorByCss(selector)
+  }
+  throw new Error(`unsupported selector: ${selector}`)
+}
+
+const toButtonNumber = (buttonType) => {
+  switch (buttonType) {
+    case 'left':
+      return 0
+    case 'middle':
+      return 1
+    case 'right':
+      return 2
+    default:
+      throw new Error(`unsupported button type: ${buttonType}`)
+  }
+}
+
+export const querySelectorWithOptions = (
+  selector,
+  { nth = -1, hasText = '' } = {}
+) => {
+  let elements = querySelector(selector)
+  if (hasText) {
+    elements = elements.filter((element) => element.textContent === hasText)
+  }
+  if (elements.length === 0) {
+    return undefined
+  }
+  if (elements.length === 1) {
+    const element = elements[0]
+    return element
+  }
+  if (nth === -1) {
+    throw new Error(`too many matching elements for ${selector}`)
+  }
+  const element = elements[nth]
+  if (!element) {
+    throw new Error(`selector not found: ${selector}`)
+  }
+  return element
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/SingleElementConditions.js

@@ -0,0 +1,28 @@
+export const toBeVisible = (element) => {
+  if (typeof element.isVisible === 'function') {
+    return element.isVisible()
+  }
+  return element.isConnected
+}
+
+export const toHaveText = (element, { text }) => {
+  return element.textContent === text
+}
+
+export const toHaveAttribute = (element, { key, value }) => {
+  const attribute = element.getAttribute(key)
+  return attribute === value
+}
+
+export const toBeFocused = (element) => {
+  return element === document.activeElement
+}
+
+export const toHaveClass = (element, { className }) => {
+  return element.classList.contains(className)
+}
+
+export const toHaveCss = (element, { key, value }) => {
+  const style = getComputedStyle(element)
+  return style[key] === value
+}

package/static/bf7d47a/packages/renderer-process/src/parts/TestFrameWork/TestFrameWork.ipc.js

@@ -0,0 +1,11 @@
+import * as Command from '../Command/Command.js'
+import * as TestFrameWork from './TestFrameWork.js'
+
+// prettier-ignore
+export const __initialize__ = () => {
+  Command.register('TestFrameWork.showOverlay', TestFrameWork.showOverlay)
+  Command.register('TestFrameWork.performAction', TestFrameWork.performAction)
+  Command.register('TestFrameWork.checkSingleElementCondition', TestFrameWork.checkSingleElementCondition)
+  Command.register('TestFrameWork.checkMultiElementCondition', TestFrameWork.checkMultiElementCondition)
+  Command.register('TestFrameWork.performKeyBoardAction', TestFrameWork.performKeyBoardAction)
+}