@veltra/desktop 1.1.15 → 1.1.19

package/src/components/condition-editor/condition-editor.vue

@@ -27,13 +27,13 @@
 <script lang="ts" setup>
 import { useFormFallbackProps } from '@veltra/compositions'
 import { bem, injectFormContext } from '@veltra/utils'
-import { computed, nextTick, shallowRef, useTemplateRef, watch } from 'vue'
+import { computed, shallowRef, useTemplateRef, watch } from 'vue'
 
 import type { ConditionEditorProps, ConditionExpression } from '../../types'
 import VariablePicker from '../expression-editor/components/variable-picker.vue'
 import ConditionGroup from './components/condition-group.vue'
 import type { MentionPayload } from './components/condition-row.vue'
-import { createEmptyGroup, evaluate } from './core/evaluator'
+import { createEmptyGroup } from './core/evaluator'
 
 defineOptions({ name: 'ConditionEditor' })
 
@@ -43,7 +43,6 @@ const props = withDefaults(defineProps<ConditionEditorProps>(), {
 
 const emit = defineEmits<{
   (e: 'update:modelValue', value: ConditionExpression): void
-  (e: 'evaluate', results: ConditionExpression): void
 }>()
 
 const cls = bem('condition-editor')
@@ -58,34 +57,29 @@ const className = computed(() => [
 ])
 
 const rootGroup = shallowRef<ConditionExpression>(
-  props.modelValue ? JSON.parse(JSON.stringify(props.modelValue)) : createEmptyGroup()
+  props.modelValue ? clone(props.modelValue) : createEmptyGroup()
 )
 
-function serialize(): ConditionExpression {
-  function clean(group: ConditionExpression): ConditionExpression {
-    return {
-      logic: group.logic,
-      conditions: group.conditions.map((c) => {
-        const { _result, ...rest } = c
-        return rest
-      }),
-      groups: group.groups.map(clean).filter((g) => g.conditions.length > 0 || g.groups.length > 0)
-    }
-  }
-  return clean(JSON.parse(JSON.stringify(rootGroup.value)))
+function clone<T>(v: T): T {
+  return JSON.parse(JSON.stringify(v)) as T
 }
 
-function emitUpdate() {
-  emit('update:modelValue', serialize())
+function onGroupUpdate(group: ConditionExpression) {
+  rootGroup.value = group
+  emit('update:modelValue', clone(group))
 }
 
-function runEvaluate() {
-  if (!props.data) return
-  const cloned = JSON.parse(JSON.stringify(rootGroup.value)) as ConditionExpression
-  const result = evaluate(cloned, props.data)
-  rootGroup.value = result
-  emit('evaluate', serialize())
-}
+watch(
+  () => props.modelValue,
+  (v) => {
+    if (!v) {
+      rootGroup.value = createEmptyGroup()
+      return
+    }
+    if (JSON.stringify(v) === JSON.stringify(rootGroup.value)) return
+    rootGroup.value = clone(v)
+  }
+)
 
 // ── VariablePicker ──
 
@@ -121,35 +115,12 @@ function onPickerVisibleChange(v: boolean) {
   }
 }
 
-function onGroupUpdate(group: ConditionExpression) {
-  rootGroup.value = group
-  emitUpdate()
-  void nextTick(() => runEvaluate())
-}
-
-watch(
-  () => props.modelValue,
-  (v) => {
-    if (!v) return
-    const current = serialize()
-    if (JSON.stringify(v) === JSON.stringify(current)) return
-    rootGroup.value = JSON.parse(JSON.stringify(v))
-  }
-)
-
-watch(
-  () => props.data,
-  () => runEvaluate(),
-  { deep: true }
-)
-
 function onKeydown(e: KeyboardEvent) {
   if (disabled.value || readonly.value) return
   if (pickerVisible.value) {
     const handled = pickerRef.value?.handleKeydown(e)
     if (handled) {
       e.preventDefault()
-      return
     }
   }
 }

package/src/components/condition-editor/core/evaluator.ts

@@ -1,93 +1,179 @@
-import type { ConditionExpression, ConditionGroup, ConditionItem } from '../../../types'
+import { o } from '@cat-kit/core'
 
-function resolveValue(item: ConditionItem, data: Record<string, unknown>): string {
-  if (item.value.kind === 'constant') return item.value.value
-  return String(getByPath(data, item.value.name) ?? '')
+import type {
+  ConditionConnector,
+  ConditionExpression,
+  ConditionField,
+  ConditionGroup,
+  ConditionLeaf,
+  ConditionNode,
+  ConditionValue
+} from '../../../types'
+
+export interface EvaluateOptions {
+  /** 字段定义 —— 提供后按字段类型做类型感知比较 */
+  fields?: ConditionField[]
+  /** 上下文数据，用于解析 `kind: 'variable'` 引用 */
+  data?: Record<string, unknown>
+}
+
+/**
+ * 求值表达式
+ *
+ * - 纯函数，不修改入参
+ * - 空表达式（无任何叶子节点）返回 `true`（视作"无限制"）
+ * - 不完整的叶子（field/operator 缺失、或缺少所需值且 operator 需要值）按 `false` 计
+ * - 同组内 AND/OR 按 **从左到右、等优先级** 求值；需要更高优先级请用子分组
+ */
+export function evaluate(expression: ConditionExpression, options: EvaluateOptions = {}): boolean {
+  return evaluateGroup(expression, options)
 }
 
-function resolveCompareValue(item: ConditionItem, data: Record<string, unknown>): string {
-  if (item.value.kind === 'constant') return item.value.value
-  return String(getByPath(data, item.value.name) ?? '')
+function evaluateGroup(group: ConditionGroup, options: EvaluateOptions): boolean {
+  const { children, connectors } = group
+  if (children.length === 0) return true
+
+  let acc = evaluateNode(children[0]!, options)
+  for (let i = 1; i < children.length; i++) {
+    const connector: ConditionConnector = connectors[i - 1] ?? 'and'
+    const current = evaluateNode(children[i]!, options)
+    acc = connector === 'and' ? acc && current : acc || current
+  }
+  return acc
 }
 
-function getByPath(obj: Record<string, unknown>, path: string): unknown {
-  return path.split('.').reduce((acc: any, key) => (acc != null ? acc[key] : undefined), obj)
+function evaluateNode(node: ConditionNode, options: EvaluateOptions): boolean {
+  return node.type === 'group' ? evaluateGroup(node, options) : evaluateLeaf(node, options)
 }
 
-function evaluateItem(item: ConditionItem, data: Record<string, unknown>): boolean {
-  const resolved = resolveValue(item, data)
-  const compareValue = resolveCompareValue(item, data)
+function evaluateLeaf(leaf: ConditionLeaf, options: EvaluateOptions): boolean {
+  if (!leaf.field || !leaf.operator) return false
+  const field = options.fields?.find((f) => f.value === leaf.field)
+  const left = readField(leaf.field, options.data)
+  const op = leaf.operator
+
+  if (op === 'empty') return isEmpty(left)
+  if (op === 'not_empty') return !isEmpty(left)
+  if (op === 'is_true') return toBool(left) === true
+  if (op === 'is_false') return toBool(left) === false
 
-  switch (item.operator) {
-    case 'empty':
-      return resolved === '' || resolved === 'undefined' || resolved === 'null'
-    case 'not_empty':
-      return resolved !== '' && resolved !== 'undefined' && resolved !== 'null'
-    case 'is_true':
-      return resolved === 'true' || resolved === '1'
-    case 'is_false':
-      return resolved === 'false' || resolved === '0' || resolved === ''
+  // 其余 operator 需要一个右侧比较值
+  if (!isValueProvided(leaf.value)) return false
+  const right = resolveValue(leaf.value, options.data)
+
+  const fieldType = field?.type ?? 'string'
+
+  switch (op) {
     case 'eq':
-      return resolved === compareValue
+      return compareEq(left, right, fieldType)
     case 'ne':
-      return resolved !== compareValue
+      return !compareEq(left, right, fieldType)
     case 'contains':
-      return resolved.includes(compareValue)
+      return toStr(left).includes(toStr(right))
     case 'not_contains':
-      return !resolved.includes(compareValue)
+      return !toStr(left).includes(toStr(right))
     case 'gt':
-      return Number(resolved) > Number(compareValue)
+      return toNumber(left) > toNumber(right)
     case 'lt':
-      return Number(resolved) < Number(compareValue)
+      return toNumber(left) < toNumber(right)
     case 'gte':
-      return Number(resolved) >= Number(compareValue)
+      return toNumber(left) >= toNumber(right)
     case 'lte':
-      return Number(resolved) <= Number(compareValue)
+      return toNumber(left) <= toNumber(right)
     case 'before':
-      return new Date(resolved).getTime() < new Date(compareValue).getTime()
+      return toTime(left) < toTime(right)
     case 'after':
-      return new Date(resolved).getTime() > new Date(compareValue).getTime()
+      return toTime(left) > toTime(right)
     case 'in': {
-      const vals = compareValue.split(',').map((s) => s.trim())
-      return vals.includes(resolved)
+      // 右侧可能是数组、逗号分隔字符串或单值
+      const list = Array.isArray(right)
+        ? right.map(toStr)
+        : toStr(right)
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+      return list.includes(toStr(left))
     }
     default:
       return false
   }
 }
 
-function evaluateGroup(group: ConditionGroup, data: Record<string, unknown>): boolean {
-  const conditionsResult = group.conditions.map((item) => {
-    const result = evaluateItem(item, data)
-    item._result = result
-    return result
-  })
+function readField(path: string, data?: Record<string, unknown>): unknown {
+  if (!data) return undefined
+  return o(data).get(path)
+}
 
-  const groupsResult = group.groups.map((sub) => {
-    const result = evaluateGroup(sub, data)
-    sub._result = result
-    return result
-  })
+function resolveValue(value: ConditionValue, data?: Record<string, unknown>): unknown {
+  if (value.kind === 'constant') return value.value
+  return readField(value.name, data)
+}
 
-  const allResults = [...conditionsResult, ...groupsResult]
-  if (allResults.length === 0) return false
+function isValueProvided(value: ConditionValue): boolean {
+  if (value.kind === 'constant') return value.value !== ''
+  return value.name !== ''
+}
 
-  return group.logic === 'and' ? allResults.every(Boolean) : allResults.some(Boolean)
+function isEmpty(v: unknown): boolean {
+  if (v == null) return true
+  if (typeof v === 'string') return v.trim() === ''
+  if (Array.isArray(v)) return v.length === 0
+  return false
 }
 
-export function evaluate(
-  expression: ConditionExpression,
-  data: Record<string, unknown>
-): ConditionExpression {
-  const cloned = JSON.parse(JSON.stringify(expression)) as ConditionExpression
-  evaluateGroup(cloned, data)
-  return cloned
+function toBool(v: unknown): boolean {
+  if (typeof v === 'boolean') return v
+  if (typeof v === 'number') return v !== 0
+  if (typeof v === 'string') {
+    const s = v.trim().toLowerCase()
+    if (s === 'true' || s === '1') return true
+    if (s === 'false' || s === '0' || s === '') return false
+  }
+  return Boolean(v)
 }
 
+function toNumber(v: unknown): number {
+  if (typeof v === 'number') return v
+  if (typeof v === 'boolean') return v ? 1 : 0
+  if (typeof v === 'string') {
+    const n = Number(v)
+    return Number.isNaN(n) ? Number.NaN : n
+  }
+  return Number.NaN
+}
+
+function toTime(v: unknown): number {
+  if (v instanceof Date) return v.getTime()
+  if (typeof v === 'number') return v
+  if (typeof v === 'string' && v) return new Date(v).getTime()
+  return Number.NaN
+}
+
+function compareEq(left: unknown, right: unknown, type: ConditionField['type']): boolean {
+  if (type === 'number') return toNumber(left) === toNumber(right)
+  if (type === 'boolean') return toBool(left) === toBool(right)
+  if (type === 'date') return toTime(left) === toTime(right)
+  return toStr(left) === toStr(right)
+}
+
+function toStr(v: unknown): string {
+  if (v == null) return ''
+  if (typeof v === 'string') return v
+  if (typeof v === 'number' || typeof v === 'boolean' || typeof v === 'bigint') return String(v)
+  if (v instanceof Date) return v.toISOString()
+  try {
+    return JSON.stringify(v)
+  } catch {
+    return ''
+  }
+}
+
+// ── 工厂 ─────────────────────────────────────────
+
 export function createEmptyGroup(): ConditionGroup {
-  return { logic: 'and', conditions: [], groups: [] }
+  return { type: 'group', children: [], connectors: [] }
 }
 
-export function createEmptyItem(): ConditionItem {
-  return { field: '', operator: 'eq', value: { kind: 'constant', value: '' } }
+export function createEmptyLeaf(): ConditionLeaf {
+  return { type: 'condition', field: '', operator: 'eq', value: { kind: 'constant', value: '' } }
 }

package/src/components/condition-editor/index.ts

@@ -1 +1,7 @@
 export { default as UConditionEditor } from './condition-editor.vue'
+export {
+  createEmptyGroup,
+  createEmptyLeaf,
+  evaluate as evaluateConditionExpression
+} from './core/evaluator'
+export type { EvaluateOptions as ConditionEvaluateOptions } from './core/evaluator'