@veltra/desktop 1.0.13 → 1.0.14

package/src/components/expression-editor/nodes/variable-node.tsx

@@ -1,118 +0,0 @@
-import { DecoratorNode, type LexicalNode, type SerializedLexicalNode, type NodeKey } from 'lexical'
-import type { VNode } from 'vue'
-
-import { UTag } from '../../tag'
-import {
-  EXPRESSION_VARIABLE_DRAG_KEY_ATTR,
-  EXPRESSION_VARIABLE_DRAG_MARKER_ATTR
-} from '../constants'
-
-interface SerializedVariableNode extends SerializedLexicalNode {
-  type: 'variable'
-  variable: string
-  label?: string
-  variableType?: string
-}
-
-export class VariableNode extends DecoratorNode<VNode> {
-  __variable: string
-  __label: string
-  __variableType: string
-  __text: string
-  __domNode: HTMLElement | null = null
-
-  static override getType(): string {
-    return 'variable'
-  }
-
-  static override clone(node: VariableNode): VariableNode {
-    return new VariableNode(node.__variable, node.__label, node.__variableType, node.__key)
-  }
-
-  static override importJSON(serializedNode: SerializedLexicalNode): VariableNode {
-    const variableNode = serializedNode as SerializedVariableNode
-    return new VariableNode(
-      variableNode.variable,
-      variableNode.label || variableNode.variable,
-      variableNode.variableType
-    )
-  }
-
-  constructor(variable: string, label?: string, type?: string, key?: NodeKey) {
-    super(key)
-
-    this.__variable = variable
-    this.__label = label || variable
-    this.__variableType = type || ''
-    this.__text = `{${variable}}`
-  }
-
-  override createDOM(): HTMLElement {
-    const span = document.createElement('span')
-    span.style.display = 'inline-block'
-    span.classList.add('ultra-expression-variable-source')
-    span.setAttribute(EXPRESSION_VARIABLE_DRAG_MARKER_ATTR, 'true')
-    span.setAttribute(EXPRESSION_VARIABLE_DRAG_KEY_ATTR, this.getKey())
-    span.draggable = true
-    return span
-  }
-
-  override getTextContent(): string {
-    return this.__text
-  }
-
-  override updateDOM(): false {
-    return false
-  }
-
-  override decorate(): VNode {
-    const displayText = this.__variableType
-      ? `${this.__label} (${this.__variableType})`
-      : this.__label
-    return (
-      <UTag size='small' style='margin: 0 2px' type='primary' round title={this.__label}>
-        {displayText}
-      </UTag>
-    )
-  }
-
-  updateVariable(newVariable: string, newLabel?: string, newType?: string): void {
-    const writable = this.getWritable()
-    writable.__variable = newVariable
-    writable.__label = newLabel || newVariable
-    writable.__variableType = newType ?? writable.__variableType
-    writable.__text = `{${newVariable}}`
-  }
-
-  getVariable(): string {
-    return this.__variable
-  }
-
-  getLabel(): string {
-    return this.__label
-  }
-
-  getVariableType(): string {
-    return this.__variableType
-  }
-
-  override exportJSON(): SerializedVariableNode {
-    return {
-      ...super.exportJSON(),
-      type: 'variable',
-      variable: this.__variable,
-      label: this.__label,
-      variableType: this.__variableType
-    }
-  }
-}
-
-/** 判断是否为变量节点 */
-export function $isVariableNode(node: LexicalNode | null | undefined): boolean {
-  return node instanceof VariableNode
-}
-
-/** 创建变量节点 */
-export function $createVariableNode(variable: string, label?: string, type?: string): VariableNode {
-  return new VariableNode(variable, label, type)
-}

package/src/components/expression-editor/parser.ts

@@ -1,46 +0,0 @@
-import { $createTextNode, type LexicalNode } from 'lexical'
-
-import type { VariableItem } from '../../types'
-import { $createVariableNode } from './nodes/variable-node'
-
-/**
- * 解析表达式内容
- * @param content 表达式内容
- * @param variableMap 变量映射表（可选，用于查找 label）
- * @returns 节点列表
- */
-export function parseContent(
-  content: string,
-  variableMap?: Map<string, VariableItem>
-): LexicalNode[] {
-  const nodes: LexicalNode[] = []
-
-  let prevItem: null | RegExpExecArray = null
-  for (const item of content.matchAll(/\{([^}]+)\}/g)) {
-    const variable = item[1]!
-
-    const startIndex = prevItem ? prevItem.index! + prevItem[0].length : 0
-    const endIndex = item.index
-
-    const text = content.slice(startIndex, endIndex)
-
-    if (text) {
-      nodes.push($createTextNode(text))
-    }
-
-    prevItem = item
-
-    // 从映射表中查找对应的 label
-    const label = variableMap?.get(variable)?.label
-    nodes.push($createVariableNode(variable, label))
-  }
-
-  if (prevItem) {
-    const tail = content.slice(prevItem.index! + prevItem[0].length)
-    if (tail) nodes.push($createTextNode(tail))
-  } else if (content) {
-    nodes.push($createTextNode(content))
-  }
-
-  return nodes
-}

package/src/components/expression-editor/plain-text.ts

@@ -1,25 +0,0 @@
-import type { LexicalEditor } from 'lexical'
-import { onBeforeUnmount } from 'vue'
-
-import { registerCommandPacks } from './internal/features/commands/register-command-packs'
-import { clearDragVisualState } from './use-expression-drag-drop'
-
-export interface RegisterPlainTextOptions {
-  /** Optional context-key commands registration (e.g. from use-context). Merged when provided. */
-  getContextCommands?: () => () => void
-}
-
-/**
- * Registers plain-text editing commands for the expression editor.
- * Delegates to capability command packs (text-editing, clipboard, drag-drop, optional context-keys).
- */
-export function registerPlainText(editor: LexicalEditor, options?: RegisterPlainTextOptions): void {
-  const removeListener = registerCommandPacks(editor, {
-    getContextCommands: options?.getContextCommands
-  })
-
-  onBeforeUnmount(() => {
-    clearDragVisualState(editor)
-    removeListener()
-  })
-}

package/src/components/expression-editor/plan.md

@@ -1,22 +0,0 @@
-当前组件是基于 `lexical` 的表达式编辑器
-
-接收以下变量格式:
-
-```js
-[
-  {
-    type: 'item',
-    props: [
-      {
-        name: 'name',
-        desc: '名称',
-        type: 'string'
-      }
-    ]
-  }
-  {
-    type: 'group'
-    items: []
-  }
-]
-```

package/src/components/expression-editor/use-context.ts

@@ -1,134 +0,0 @@
-import { mergeRegister } from '@lexical/utils'
-import {
-  $getSelection,
-  $isRangeSelection,
-  COMMAND_PRIORITY_LOW,
-  COMMAND_PRIORITY_EDITOR,
-  KEY_ARROW_DOWN_COMMAND,
-  KEY_ARROW_UP_COMMAND,
-  type LexicalEditor,
-  SELECTION_CHANGE_COMMAND,
-  KEY_ENTER_COMMAND,
-  KEY_ESCAPE_COMMAND,
-  TextNode
-} from 'lexical'
-import { shallowRef, type ShallowRef } from 'vue'
-
-import { CONTEXT_TRIGGER_CHAR } from './constants'
-
-export function useContext(editor: LexicalEditor): {
-  contextVisible: ShallowRef<boolean>
-  contextTriggerDom: ShallowRef<HTMLElement | undefined>
-  textNode: ShallowRef<TextNode | undefined>
-  charPosition: ShallowRef<number>
-  registerPickerKeyHandler: (handler: ((e: KeyboardEvent) => void) | null) => void
-  /** Returns cleanup for context-key commands. Injected into registerCommandPacks. */
-  registerContextCommands: () => () => void
-} {
-  const contextVisible = shallowRef(false)
-  const contextTriggerDom = shallowRef<HTMLElement>()
-  const textNode = shallowRef<TextNode>()
-  const charPosition = shallowRef(0)
-  const pickerKeyHandlerRef = shallowRef<((e: KeyboardEvent) => void) | null>(null)
-
-  function registerPickerKeyHandler(handler: ((e: KeyboardEvent) => void) | null) {
-    pickerKeyHandlerRef.value = handler
-  }
-
-  function openContextMenu(triggerElement: HTMLElement) {
-    contextVisible.value = true
-
-    contextTriggerDom.value = triggerElement
-  }
-
-  function closeContextMenu() {
-    contextVisible.value = false
-    contextTriggerDom.value = undefined
-  }
-
-  function PreventDefaultListener(event: KeyboardEvent) {
-    if (event.isComposing) return false
-    if (contextVisible.value) {
-      event.preventDefault()
-      pickerKeyHandlerRef.value?.(event)
-      return true
-    }
-    return false
-  }
-
-  function registerContextCommands(): () => void {
-    return mergeRegister(
-      // 选取变更命令，实现呼出上下文菜单的核心
-      editor.registerCommand(
-        SELECTION_CHANGE_COMMAND,
-        () => {
-          const selection = $getSelection()
-
-          // 如果菜单已经打开，不要因为失焦而关闭（用户可能在输入搜索框）
-          if (contextVisible.value) {
-            return true
-          }
-
-          // 选区类型必须为rangeSelection且选取的anchor和focus的offset值必须一致
-          // 否则关闭上下文菜单
-          if (!$isRangeSelection(selection) || selection.anchor.offset !== selection.focus.offset) {
-            closeContextMenu()
-
-            return false
-          }
-
-          const cursorPosition = selection.focus.offset
-          const node = selection.focus.getNode()
-          const textContent = node.getTextContent()
-
-          // 检测光标是否在 '@' 左右
-          const isAtTriggerLeft = textContent[cursorPosition - 1] === CONTEXT_TRIGGER_CHAR
-          const isAtTriggerRight = textContent[cursorPosition] === CONTEXT_TRIGGER_CHAR
-
-          // 光标左右的字符都不是'@'时，关闭上下文菜单
-          if (!isAtTriggerLeft && !isAtTriggerRight) {
-            closeContextMenu()
-            return false
-          }
-
-          // 更新文本节点和光标位置
-          // charPosition: index of first char after '@' (for slice in handleVariableSelect)
-          // isAtTriggerLeft: '@' is left of cursor (cursor already after '@') → charPosition = cursorPosition
-          // isAtTriggerRight: '@' is right of cursor (cursor before '@') → charPosition = cursorPosition + 1
-          textNode.value = node as TextNode
-          charPosition.value = isAtTriggerLeft ? cursorPosition : cursorPosition + 1
-
-          const triggerDom = editor.getElementByKey(node.getKey())
-
-          // 如果弹框已经打开，更新位置；否则打开弹框
-          if (contextVisible.value) {
-            // 更新触发元素位置（如果变化了）
-            if (triggerDom && triggerDom !== contextTriggerDom.value) {
-              contextTriggerDom.value = triggerDom
-            }
-          } else {
-            triggerDom && openContextMenu(triggerDom)
-          }
-
-          return true
-        },
-        COMMAND_PRIORITY_EDITOR
-      ),
-
-      // 当上下文菜单显示时，阻止下面的命令的默认行为
-      editor.registerCommand(KEY_ENTER_COMMAND, PreventDefaultListener, COMMAND_PRIORITY_LOW),
-      editor.registerCommand(KEY_ESCAPE_COMMAND, PreventDefaultListener, COMMAND_PRIORITY_LOW),
-      editor.registerCommand(KEY_ARROW_UP_COMMAND, PreventDefaultListener, COMMAND_PRIORITY_LOW),
-      editor.registerCommand(KEY_ARROW_DOWN_COMMAND, PreventDefaultListener, COMMAND_PRIORITY_LOW)
-    )
-  }
-
-  return {
-    contextVisible,
-    contextTriggerDom,
-    textNode,
-    charPosition,
-    registerPickerKeyHandler,
-    registerContextCommands
-  }
-}

package/src/components/expression-editor/use-decorators.tsx

@@ -1,29 +0,0 @@
-import type { LexicalEditor } from 'lexical'
-import type { DefineComponent, VNode } from 'vue'
-import { Teleport, computed, onBeforeUnmount, shallowRef, type ComputedRef } from 'vue'
-
-export function useDecorators(editor: LexicalEditor): ComputedRef<VNode[]> {
-  const decorators = shallowRef(editor.getDecorators<DefineComponent>())
-
-  const removeListener = editor.registerDecoratorListener<DefineComponent>((nextDecorators) => {
-    decorators.value = nextDecorators
-  })
-
-  onBeforeUnmount(() => {
-    removeListener()
-  })
-
-  return computed(() => {
-    const decoratedTeleports: VNode[] = []
-    const decoratorKeys = Object.keys(decorators.value)
-    decoratorKeys.forEach((nodeKey) => {
-      const node = decorators.value[nodeKey]!
-      const element = editor.getElementByKey(nodeKey)
-      if (element !== null) {
-        decoratedTeleports.push(<Teleport to={element}>{node}</Teleport>)
-      }
-    })
-
-    return decoratedTeleports
-  })
-}

package/src/components/expression-editor/use-editor.ts

@@ -1,12 +0,0 @@
-import type { LexicalEditor } from 'lexical'
-
-import {
-  createExpressionEditorRuntime,
-  type CreateExpressionEditorRuntimeOptions
-} from './internal/editor-runtime/create-runtime'
-
-export type EditorOptions = CreateExpressionEditorRuntimeOptions
-
-export function useEditor(options: EditorOptions): LexicalEditor {
-  return createExpressionEditorRuntime(options).editor
-}