@veltra/desktop 1.0.13 → 1.0.14

package/src/components/expression-editor/__test__/architecture-boundaries.test.ts

@@ -1,103 +0,0 @@
-/**
- * ARCH-01: Capability boundary and key wiring regression gate.
- * Verifies sync/insertion/drag-drop/rendering have independent entry points
- * and runtime -> command packs -> mutation services wiring is intact.
- * Failure maps to roadmap acceptance criteria.
- */
-import { describe, expect, it, vi } from 'vitest'
-
-vi.mock('../../tag', () => ({ UTag: () => null }))
-import { createEditor } from 'lexical'
-import { ref, shallowRef } from 'vue'
-
-import type { ExpressionEditorRuntime } from '../internal/contracts/editor-runtime'
-import { createExpressionEditorRuntime } from '../internal/editor-runtime'
-import { registerCommandPacks } from '../internal/features/commands/register-command-packs'
-import {
-  moveVariableByDirection,
-  reorderVariable
-} from '../internal/features/drag-drop/drag-drop-service'
-import { insertVariableAtTrigger } from '../internal/features/insertion/insertion-service'
-import { VariableNode } from '../nodes/variable-node'
-
-describe('ARCH-01: sync boundary', () => {
-  it('createExpressionEditorRuntime returns runtime with editor, mutations, syncFromModelValue', () => {
-    const container = shallowRef<HTMLElement | null>(null)
-    const props = { modelValue: '', variables: [] }
-    const emit = () => {}
-    const cls = { b: 'expression-editor', e: (s: string) => `expression-editor__${s}` } as const
-
-    const runtime = createExpressionEditorRuntime({
-      disabled: ref(false),
-      readonly: ref(false),
-      props,
-      cls,
-      emit,
-      container
-    })
-
-    expect(runtime).toHaveProperty('editor')
-    expect(runtime).toHaveProperty('mutations')
-    expect(runtime).toHaveProperty('syncFromModelValue')
-    expect(typeof runtime.syncFromModelValue).toBe('function')
-    expect(runtime.mutations).toHaveProperty('runUpdate')
-    expect(typeof runtime.mutations.runUpdate).toBe('function')
-  })
-
-  it('EditorMutationGateway.runUpdate executes updater inside editor.update', () => {
-    const container = shallowRef<HTMLElement | null>(null)
-    const props = { modelValue: '', variables: [] }
-    const emit = () => {}
-    const cls = { b: 'expression-editor', e: (s: string) => `expression-editor__${s}` } as const
-
-    const runtime = createExpressionEditorRuntime({
-      disabled: ref(false),
-      readonly: ref(false),
-      props,
-      cls,
-      emit,
-      container
-    }) as ExpressionEditorRuntime
-
-    let executed = false
-    runtime.mutations.runUpdate(() => {
-      executed = true
-    })
-    expect(executed).toBe(true)
-  })
-})
-
-describe('ARCH-01: insertion boundary', () => {
-  it('insertVariableAtTrigger is callable and returns boolean', () => {
-    const editor = createEditor({ namespace: 'Test', nodes: [VariableNode], onError: () => {} })
-    const result = insertVariableAtTrigger(editor, {
-      nodeKey: 'nonexistent',
-      charPosition: 0,
-      variable: { value: 'x', label: 'X' }
-    })
-    expect(typeof result).toBe('boolean')
-  })
-})
-
-describe('ARCH-01: drag-drop boundary', () => {
-  it('reorderVariable is callable and returns boolean', () => {
-    const editor = createEditor({ namespace: 'Test', nodes: [VariableNode], onError: () => {} })
-    const result = reorderVariable(editor, { payloadText: null, scopeId: 'test', targetSlot: 0 })
-    expect(typeof result).toBe('boolean')
-  })
-
-  it('moveVariableByDirection is callable and returns boolean', () => {
-    const editor = createEditor({ namespace: 'Test', nodes: [VariableNode], onError: () => {} })
-    const result = moveVariableByDirection(editor, 'nonexistent-key', -1, false)
-    expect(typeof result).toBe('boolean')
-  })
-})
-
-describe('ARCH-01: command packs boundary', () => {
-  it('registerCommandPacks returns cleanup function', () => {
-    const editor = createEditor({ namespace: 'Test', nodes: [VariableNode], onError: () => {} })
-    const cleanup = registerCommandPacks(editor)
-    expect(typeof cleanup).toBe('function')
-    cleanup()
-  })
-})

package/src/components/expression-editor/__test__/architecture-compatibility.test.ts

@@ -1,52 +0,0 @@
-/**
- * ARCH-02: Public API compatibility gate.
- * Locks export surface, props, and emits so future changes cannot break consumers.
- * Failure here maps directly to roadmap acceptance criteria.
- */
-import { describe, expect, it, vi } from 'vitest'
-
-import type { ExpressionEditorEmits, ExpressionEditorProps, VariableItem } from '../../../types'
-
-vi.mock('../expression-editor.vue', () => ({ default: { name: 'ExpressionEditor' } }))
-
-import { UExpressionEditor } from '../index'
-
-describe('ARCH-02: UExpressionEditor public API compatibility', () => {
-  it('UExpressionEditor is importable and is a Vue component', () => {
-    expect(UExpressionEditor).toBeDefined()
-    expect(typeof UExpressionEditor).toBe('object')
-    expect(UExpressionEditor).toHaveProperty('name', 'ExpressionEditor')
-  })
-
-  it('ExpressionEditorProps has required keys: modelValue, placeholder, variables', () => {
-    const requiredKeys: (keyof ExpressionEditorProps)[] = ['modelValue', 'placeholder', 'variables']
-    const props: ExpressionEditorProps = { modelValue: '', placeholder: 'test', variables: [] }
-    for (const key of requiredKeys) {
-      expect(key in props || typeof (props as Record<string, unknown>)[key] !== 'undefined').toBe(
-        true
-      )
-    }
-  })
-
-  it('ExpressionEditorProps modelValue accepts string', () => {
-    const props: ExpressionEditorProps = { modelValue: 'hello{foo}' }
-    expect(props.modelValue).toBe('hello{foo}')
-  })
-
-  it('ExpressionEditorProps variables accepts VariableItem[]', () => {
-    const items: VariableItem[] = [
-      { label: 'Foo', value: 'foo' },
-      { label: 'Bar', value: 'bar', type: 'string' }
-    ]
-    const props: ExpressionEditorProps = { variables: items }
-    expect(props.variables).toEqual(items)
-  })
-
-  it('update:modelValue emit signature: (e, value: string) => void', () => {
-    const emit: ExpressionEditorEmits = (e: 'update:modelValue', value: string) => {
-      expect(e).toBe('update:modelValue')
-      expect(typeof value).toBe('string')
-    }
-    emit('update:modelValue', 'new value')
-  })
-})

package/src/components/expression-editor/__test__/drag-drop.test.ts

@@ -1,171 +0,0 @@
-import { $createParagraphNode, $getRoot, createEditor, type LexicalEditor } from 'lexical'
-import { vi } from 'vitest'
-
-import { VariableNode } from '../nodes/variable-node'
-
-vi.mock('../../tag', () => ({ UTag: () => null }))
-
-import { parseContent } from '../parser'
-import {
-  applyDropReorder,
-  collectVariableNodeDescriptors,
-  createInternalDragPayload,
-  moveVariableByDirection,
-  reorderVariableNode
-} from '../use-expression-drag-drop'
-
-function createTestEditor(content: string): LexicalEditor {
-  const editor = createEditor({
-    namespace: 'ExpressionEditorDragDropTest',
-    nodes: [VariableNode],
-    onError: () => {}
-  })
-
-  editor.update(
-    () => {
-      const root = $getRoot()
-      root.clear()
-      const paragraph = $createParagraphNode()
-      paragraph.append(...parseContent(content))
-      root.append(paragraph)
-    },
-    { discrete: true }
-  )
-
-  return editor
-}
-
-function getEditorText(editor: LexicalEditor): string {
-  let text = ''
-  editor.getEditorState().read(() => {
-    text = $getRoot().getTextContent()
-  })
-  return text
-}
-
-function stripVariableTokens(content: string): string {
-  return content.replace(/\{[^}]+\}/g, '')
-}
-
-function getVariableOrder(editor: LexicalEditor): string[] {
-  return collectVariableNodeDescriptors(editor).map((item) => item.variable)
-}
-
-function getVariableKey(editor: LexicalEditor, variable: string): string {
-  const descriptor = collectVariableNodeDescriptors(editor).find(
-    (item) => item.variable === variable
-  )
-  if (!descriptor) {
-    throw new Error(`Cannot find variable: ${variable}`)
-  }
-  return descriptor.key
-}
-
-describe('expression drag drop (ARCH-01 drag-drop boundary)', () => {
-  it('reorders variable sequence correctly', () => {
-    const editor = createTestEditor('A {first} + {second} + {third}')
-    const secondKey = getVariableKey(editor, 'second')
-
-    let moved = false
-    editor.update(
-      () => {
-        moved = reorderVariableNode(secondKey, 0, false)
-      },
-      { discrete: true }
-    )
-
-    expect(moved).toBe(true)
-    expect(getVariableOrder(editor)).toEqual(['second', 'first', 'third'])
-  })
-
-  it('keeps plain text and whitespace unchanged while reordering variables', () => {
-    const editor = createTestEditor('left  {alpha}\t+\n{beta} right')
-    const before = getEditorText(editor)
-    const betaKey = getVariableKey(editor, 'beta')
-
-    editor.update(
-      () => {
-        reorderVariableNode(betaKey, 0, false)
-      },
-      { discrete: true }
-    )
-
-    const after = getEditorText(editor)
-    expect(stripVariableTokens(after)).toBe(stripVariableTokens(before))
-    expect(getVariableOrder(editor)).toEqual(['beta', 'alpha'])
-  })
-
-  it('ignores invalid or external payload without changing content', () => {
-    const editor = createTestEditor('x {foo} y {bar}')
-    const initial = getEditorText(editor)
-
-    let moved = true
-    editor.update(
-      () => {
-        moved = applyDropReorder({
-          payloadText: '{"action":"move-variable","scopeId":"scope-a"}',
-          scopeId: 'scope-a',
-          targetSlot: 0,
-          focusMovedNode: false
-        })
-      },
-      { discrete: true }
-    )
-
-    expect(moved).toBe(false)
-    expect(getEditorText(editor)).toBe(initial)
-  })
-
-  it('returns false when moveVariableByDirection is called with non-existent key (refactor behavior)', () => {
-    const editor = createTestEditor('{a} {b}')
-    let moved = false
-    editor.update(
-      () => {
-        moved = moveVariableByDirection('non-existent-key', -1, false)
-      },
-      { discrete: true }
-    )
-    expect(moved).toBe(false)
-    expect(getVariableOrder(editor)).toEqual(['a', 'b'])
-  })
-
-  it('uses the same reorder behavior for fallback move and drop payload', () => {
-    const input = 'start {a} middle {b} end {c}'
-    const fallbackEditor = createTestEditor(input)
-    const dropEditor = createTestEditor(input)
-
-    const fallbackKey = getVariableKey(fallbackEditor, 'b')
-    const dropKey = getVariableKey(dropEditor, 'b')
-
-    let fallbackMoved = false
-    fallbackEditor.update(
-      () => {
-        fallbackMoved = moveVariableByDirection(fallbackKey, -1, false)
-      },
-      { discrete: true }
-    )
-
-    let dropMoved = false
-    dropEditor.update(
-      () => {
-        const payload = createInternalDragPayload({
-          action: 'move-variable',
-          sourceKey: dropKey,
-          scopeId: 'scope-04-test'
-        })
-        dropMoved = applyDropReorder({
-          payloadText: payload,
-          scopeId: 'scope-04-test',
-          targetSlot: 0,
-          focusMovedNode: false
-        })
-      },
-      { discrete: true }
-    )
-
-    expect(fallbackMoved).toBe(true)
-    expect(dropMoved).toBe(true)
-    expect(getEditorText(dropEditor)).toBe(getEditorText(fallbackEditor))
-    expect(getVariableOrder(dropEditor)).toEqual(getVariableOrder(fallbackEditor))
-  })
-})

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

@@ -1,62 +0,0 @@
-import { createEditor } from 'lexical'
-import type { LexicalNode } from 'lexical'
-import { vi } from 'vitest'
-
-import { VariableNode } from '../nodes/variable-node'
-
-vi.mock('../../tag', () => ({ UTag: () => null }))
-
-import { parseContent } from '../parser'
-
-function serializeNodes(nodes: LexicalNode[]): string {
-  return nodes.map((n) => n.getTextContent()).join('')
-}
-
-function parseAndSerialize(content: string): string {
-  const editor = createEditor({ namespace: 'Test', nodes: [VariableNode], onError: () => {} })
-  let serialized = ''
-  editor.update(
-    () => {
-      const nodes = parseContent(content)
-      serialized = serializeNodes(nodes)
-    },
-    { discrete: true }
-  )
-  return serialized
-}
-
-describe('parseContent (ARCH-01 parse boundary)', () => {
-  it('round-trips hello{foo}world (trailing text preserved)', () => {
-    const input = 'hello{foo}world'
-    expect(parseAndSerialize(input)).toBe(input)
-  })
-
-  it('round-trips {a} (single variable)', () => {
-    const input = '{a}'
-    expect(parseAndSerialize(input)).toBe(input)
-  })
-
-  it('round-trips hello (no variables)', () => {
-    const input = 'hello'
-    expect(parseAndSerialize(input)).toBe(input)
-  })
-
-  it('round-trips {a}{b} (adjacent variables)', () => {
-    const input = '{a}{b}'
-    expect(parseAndSerialize(input)).toBe(input)
-  })
-
-  it('round-trips prefix{a}suffix', () => {
-    const input = 'prefix{a}suffix'
-    expect(parseAndSerialize(input)).toBe(input)
-  })
-
-  it('round-trips empty string (refactor behavior consistency)', () => {
-    expect(parseAndSerialize('')).toBe('')
-  })
-
-  it('preserves text with unclosed brace as plain text (no variable match)', () => {
-    const input = 'hello{unclosed'
-    expect(parseAndSerialize(input)).toBe(input)
-  })
-})

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

@@ -1,6 +0,0 @@
-export const CONTEXT_TRIGGER_CHAR = '@'
-
-export const EXPRESSION_VARIABLE_DRAG_TYPE = 'application/x-ultra-expression-variable'
-export const EXPRESSION_VARIABLE_DRAG_MARKER_ATTR = 'data-ultra-expression-variable-node'
-export const EXPRESSION_VARIABLE_DRAG_KEY_ATTR = 'data-ultra-expression-variable-key'
-export const EXPRESSION_DROP_SCOPE_ATTR = 'data-ultra-expression-drop-scope'

package/src/components/expression-editor/internal/contracts/editor-runtime.ts

@@ -1,11 +0,0 @@
-import type { LexicalEditor } from 'lexical'
-
-export interface EditorMutationGateway {
-  runUpdate(updater: () => void): void
-}
-
-export interface ExpressionEditorRuntime {
-  editor: LexicalEditor
-  mutations: EditorMutationGateway
-  syncFromModelValue(): void
-}

package/src/components/expression-editor/internal/editor-runtime/create-runtime.ts

@@ -1,64 +0,0 @@
-import type { BEM } from '@veltra/utils'
-import { createEditor } from 'lexical'
-import { watchEffect, computed, type Ref, type ShallowRef } from 'vue'
-
-import type { ExpressionEditorEmits, ExpressionEditorProps } from '../../../../types'
-import { createVariableMap } from '../../di'
-import { VariableNode } from '../../nodes/variable-node'
-import type { EditorMutationGateway, ExpressionEditorRuntime } from '../contracts/editor-runtime'
-import { createModelSync } from './model-sync'
-
-export interface CreateExpressionEditorRuntimeOptions {
-  disabled: Ref<boolean>
-  readonly: Ref<boolean>
-  props: ExpressionEditorProps
-  cls: BEM<'expression-editor'>
-  emit: ExpressionEditorEmits
-  container: ShallowRef<HTMLElement | null>
-}
-
-function createDefaultMutationGateway(
-  editor: ExpressionEditorRuntime['editor']
-): EditorMutationGateway {
-  return {
-    runUpdate(updater) {
-      editor.update(() => {
-        updater()
-      })
-    }
-  }
-}
-
-function resolveEditable(disabled: Ref<boolean>, readonly: Ref<boolean>) {
-  return !disabled.value && !readonly.value
-}
-
-export function createExpressionEditorRuntime(
-  options: CreateExpressionEditorRuntimeOptions
-): ExpressionEditorRuntime {
-  const { disabled, readonly, container, props, emit, cls } = options
-  const editor = createEditor({
-    namespace: 'ExpressionEditor',
-    nodes: [VariableNode],
-    onError: console.error,
-    editable: resolveEditable(disabled, readonly),
-    theme: { paragraph: cls.e('paragraph') }
-  })
-
-  watchEffect(() => {
-    editor.setEditable(resolveEditable(disabled, readonly))
-  })
-
-  watchEffect(() => {
-    container.value && editor.setRootElement(container.value)
-  })
-
-  const variableMap = computed(() => createVariableMap(props.variables))
-  const sync = createModelSync({ editor, props, emit, variableMap })
-
-  return {
-    editor,
-    mutations: createDefaultMutationGateway(editor),
-    syncFromModelValue: sync.syncFromModelValue
-  }
-}

package/src/components/expression-editor/internal/editor-runtime/index.ts

@@ -1 +0,0 @@
-export { createExpressionEditorRuntime } from './create-runtime'

package/src/components/expression-editor/internal/editor-runtime/model-sync.ts

@@ -1,68 +0,0 @@
-import { $createParagraphNode, $getRoot, SKIP_DOM_SELECTION_TAG, type LexicalEditor } from 'lexical'
-import { nextTick, watchEffect, type ComputedRef } from 'vue'
-
-import type { ExpressionEditorEmits, ExpressionEditorProps, VariableItem } from '../../../../types'
-import { parseContent } from '../../parser'
-
-interface CreateModelSyncOptions {
-  editor: LexicalEditor
-  props: ExpressionEditorProps
-  emit: ExpressionEditorEmits
-  variableMap: ComputedRef<Map<string, VariableItem>>
-}
-
-export function createModelSync(options: CreateModelSyncOptions) {
-  const { editor, props, emit, variableMap } = options
-
-  let changeByUser = false
-  let changeByModel = false
-  let lastEmittedValue: string | null = null
-
-  function syncFromModelValue() {
-    changeByModel = true
-    const { modelValue } = props
-    if (!modelValue) return
-
-    editor.update(
-      () => {
-        const root = $getRoot()
-        root.clear()
-        const paragraph = $createParagraphNode()
-        const nodes = parseContent(modelValue, variableMap.value)
-        paragraph.append(...nodes)
-        root.append(paragraph)
-      },
-      { tag: SKIP_DOM_SELECTION_TAG }
-    )
-
-    nextTick(() => {
-      changeByModel = false
-    })
-  }
-
-  editor.registerTextContentListener((text) => {
-    if (changeByModel) return
-
-    emit('update:modelValue', text)
-    lastEmittedValue = text
-    changeByUser = true
-    nextTick(() => {
-      if (lastEmittedValue === props.modelValue) {
-        changeByUser = false
-      } else {
-        setTimeout(() => {
-          changeByUser = false
-        }, 0)
-      }
-    })
-  })
-
-  watchEffect(() => {
-    if (changeByUser) return
-    const current = editor.getEditorState().read(() => $getRoot().getTextContent())
-    if (props.modelValue === current) return
-    syncFromModelValue()
-  })
-
-  return { syncFromModelValue }
-}