@kine-design/core 0.0.1-beta.6 → 0.0.1-beta.8

package/components/base/datePicker/__tests__/useDatePicker.test.ts

@@ -27,6 +27,11 @@ describe('toDayjs', () => {
     const d = toDayjs(undefined);
     expect(d.isValid()).toBe(true);
   });
+
+  it('无效日期字符串返回 invalid dayjs 对象', () => {
+    const d = toDayjs('not-a-date');
+    expect(d.isValid()).toBe(false);
+  });
 });
 
 describe('generateTimeColumn', () => {

package/components/base/image/__tests__/useImage.test.ts

@@ -33,6 +33,8 @@ describe('useImage', () => {
   it('handleLoad 设置状态为 loaded 并触发 emit', () => {
     const emit = createEmit();
     const { status, handleLoad } = useImage(defaultProps, emit);
+    // Vitest node 环境下由 happy-dom/jsdom 提供 Event 构造函数，
+    // handleLoad 仅需接收 Event 实例作为参数传给 emit，不依赖 DOM 行为
     const event = new Event('load');
 
     handleLoad(event);

package/components/base/inputNumber/__tests__/useInputNumber.test.ts

@@ -150,4 +150,40 @@ describe('useInputNumber 输入流程', () => {
     const call = lastUpdate(emit);
     expect(call[1]).toBe(3);
   });
+
+  it('disabled 时 increment 和 decrement 为 no-op', () => {
+    const { increment, decrement, emit } = setup({ modelValue: 5, disabled: true });
+    emit.mockClear();
+    increment();
+    decrement();
+    // disabled 状态下不触发任何 emit
+    expect(emit).not.toHaveBeenCalled();
+  });
+
+  it('readonly 时 increment 和 decrement 为 no-op', () => {
+    const { increment, decrement, emit } = setup({ modelValue: 5, readonly: true });
+    emit.mockClear();
+    increment();
+    decrement();
+    // readonly 状态下不触发任何 emit
+    expect(emit).not.toHaveBeenCalled();
+  });
+});
+
+describe('useInputNumber 中间态处理', () => {
+  it('validate(".") 为中间态 → emit null', () => {
+    const { validate, emit } = setup({ modelValue: null });
+    validate('.' as unknown as number);
+    // "." 经 handleInputChange 会被转为 "0."，但直接 validate('.') 是非法输入
+    // validate 里 isNaN(+'.') 为 true 且不是 '' 也不是 '-'，所以不触发 emit
+    expect(emit.mock.calls.filter((c: unknown[]) => c[0] === 'update:modelValue')).toHaveLength(0);
+  });
+
+  it('validate("-.") 为非法输入 → 不触发 emit', () => {
+    const { validate, emit } = setup({ modelValue: null });
+    emit.mockClear();
+    validate('-.' as unknown as number);
+    // '-.' → isNaN(+'-.')=true, 不是 '' 不是 '-'，走非法输入分支
+    expect(emit).not.toHaveBeenCalled();
+  });
 });

package/components/base/timePicker/__tests__/useTimePicker.test.ts

@@ -17,6 +17,12 @@ describe('generateColumn', () => {
   it('生成 60 分钟列，步进 5', () => {
     expect(generateColumn(60, 5)).toEqual([0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55]);
   });
+
+  // step=0 会导致 for 循环条件 i += 0 永远不推进，造成死循环。
+  // 源码无守卫，此处跳过并记录风险，避免测试挂起。
+  it.skip('step=0 会导致死循环（源码未做守卫）', () => {
+    // generateColumn(24, 0) — 无限循环，不可执行
+  });
 });
 
 describe('useTimePicker', () => {

package/components/base/tree/__tests__/tree.test.ts

@@ -211,4 +211,13 @@ describe('Tree', () => {
     const childKeys = tree.getChildrenKeys(roots[0]);
     expect(childKeys).toEqual(['b']);
   });
+
+  it('getTreeData 不存在的 key 返回 undefined 元素', () => {
+    // cacheMap.get(key) 对不存在的 key 返回 undefined，
+    // getNodesByKeys 不做过滤，数组中会包含 undefined
+    const tree = new Tree({ data: SAMPLE_DATA });
+    const nodes = tree.getTreeData(['nonexistent']);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]).toBeUndefined();
+  });
 });

package/components/template/table/__tests__/useTable.test.ts

@@ -6,10 +6,13 @@
  *
  * 江湖的业务千篇一律，复杂的代码好几百行。
  */
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { useTable } from '../useTable';
 
 describe('useTable', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
   const createRenders = () => ({
     empty: 'EMPTY',
     tbodyTr: (opt: any) => `TD:${opt.param}:${opt.data}`,
@@ -58,8 +61,6 @@ describe('useTable', () => {
     const result = initTable(createRenders(), columns, data);
     expect(result.thead).toBe('THEAD:[TH:name:姓名]');
     expect(errorSpy).toHaveBeenCalled();
-
-    errorSpy.mockRestore();
   });
 
   it('列宽 number 转换为 px', () => {
@@ -133,7 +134,5 @@ describe('useTable', () => {
 
     error('test error');
     expect(spy).toHaveBeenCalledWith('[水墨UI表格组件] test error');
-
-    spy.mockRestore();
   });
 });

package/compositions/common/__tests__/useEventListener.test.ts

@@ -15,6 +15,7 @@ describe('useEventListener', () => {
     const target = {
       addEventListener: vi.fn(),
       removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
     };
 
     const { add, remove } = useEventListener({
@@ -35,6 +36,7 @@ describe('useEventListener', () => {
     const target = {
       addEventListener: vi.fn(),
       removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
     };
 
     const { onMounted, onBeforeUnmount } = useEventListener({
@@ -55,6 +57,7 @@ describe('useEventListener', () => {
     const realTarget = {
       addEventListener: vi.fn(),
       removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
     };
     const targetFn = vi.fn(() => realTarget);
 
@@ -68,4 +71,28 @@ describe('useEventListener', () => {
     expect(targetFn).toHaveBeenCalled();
     expect(realTarget.addEventListener).toHaveBeenCalledWith('click', handler);
   });
+
+  it('target 为 null 时 add 抛出异常（无防御性检查）', () => {
+    // useEventListener 不对 null/undefined target 做守卫，
+    // 调用 add() 时会对 null 调用 addEventListener，导致 TypeError
+    const handler = vi.fn();
+    const { add } = useEventListener({
+      target: null as unknown as EventTarget,
+      event: 'click',
+      handler,
+    });
+
+    expect(() => add()).toThrow();
+  });
+
+  it('target 为返回 undefined 的函数时 add 抛出异常', () => {
+    const handler = vi.fn();
+    const { add } = useEventListener({
+      target: (() => undefined) as unknown as () => EventTarget,
+      event: 'click',
+      handler,
+    });
+
+    expect(() => add()).toThrow();
+  });
 });

package/compositions/common/__tests__/usePopover.test.ts

@@ -27,7 +27,12 @@ describe('usePopover', () => {
 
   it('自定义 offset', () => {
     const { popoverOptions } = usePopover(undefined, { offset: 10 });
-    expect(popoverOptions.popper?.middleware).toHaveLength(3);
+    const middleware = popoverOptions.popper?.middleware;
+    expect(middleware).toHaveLength(3);
+    // middleware[0] 是 offset(10)，验证自定义 offset 值确实被应用
+    const offsetMiddleware = middleware![0] as { name: string; options: unknown };
+    expect(offsetMiddleware.name).toBe('offset');
+    expect(offsetMiddleware.options).toBe(10);
   });
 
   it('扩展 middleware', () => {

package/compositions/common/__tests__/useTeleport.test.ts

@@ -22,4 +22,11 @@ describe('initTeleportOptions', () => {
     const custom = { to: '#app', disabled: false };
     expect(initTeleportOptions(custom as any)).toBe(custom);
   });
+
+  it('false 不命中 true/undefined 分支，原样返回', () => {
+    // initTeleportOptions 只对 true 和 undefined 返回 { to: 'body' }，
+    // false 走 else 分支直接返回原值
+    const result = initTeleportOptions(false as unknown as import('vue').TeleportProps);
+    expect(result).toBe(false);
+  });
 });

package/compositions/common/testAnchor.ts

@@ -0,0 +1,211 @@
+/**
+ * @description Test anchor system: provide/inject keys, types, and kDefineComponent wrapper
+ * @author kine-design
+ * @date 2026/4/28
+ * @version v1.0.0
+ *
+ * Renders business-semantic `data-k` attributes on DOM elements when testAnchor is enabled,
+ * allowing E2E tests to target components by stable identifiers.
+ */
+import {
+  cloneVNode,
+  defineComponent,
+  inject,
+  type ComponentPropsOptions,
+  type EmitsOptions,
+  type InjectionKey,
+  type Ref,
+  type SetupContext,
+  type VNode,
+} from 'vue';
+
+// ---------------------------------------------------------------------------
+// Injection keys
+// ---------------------------------------------------------------------------
+
+/** Global switch provided by KConfigProvider to enable data-k rendering */
+export const K_TEST_ANCHOR_KEY: InjectionKey<Ref<boolean>> = Symbol('k-test-anchor');
+
+/** Field identity provided by KFormItem so child inputs inherit field name */
+export const K_FIELD_KEY: InjectionKey<Ref<string | undefined>> = Symbol('k-field');
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface KAnchorConfig {
+  /** Semantic type: 'field' | 'action' | 'table' | 'col' | 'dialog' | 'drawer' | 'tab' */
+  type: string;
+  /** Which prop to derive the identity from (e.g., 'prop' for KFormItem, 'title' for KDialog) */
+  prop?: string;
+  /** Derive identity from default slot text content (for KButton) */
+  slotText?: boolean;
+}
+
+interface KDefineComponentOptions {
+  name: string;
+  props?: ComponentPropsOptions;
+  emits?: EmitsOptions;
+  kAnchor?: KAnchorConfig;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract text content from a VNode tree (for slotText mode).
+ * Walks children recursively, concatenating string segments.
+ */
+function extractSlotText(nodes: VNode[] | undefined): string {
+  if (!nodes) return '';
+  let text = '';
+  for (const node of nodes) {
+    if (typeof node.children === 'string') {
+      text += node.children;
+    } else if (Array.isArray(node.children)) {
+      text += extractSlotText(node.children as VNode[]);
+    }
+  }
+  return text.trim();
+}
+
+/**
+ * Resolve the data-k value for a component instance.
+ * Returns undefined when testAnchor is off or no identity can be derived.
+ */
+function resolveDataK(
+  config: KAnchorConfig,
+  props: Record<string, unknown>,
+  attrs: Record<string, unknown>,
+  fieldFromParent: string | undefined,
+  slotNodes?: VNode[],
+): string | undefined {
+  // Developer override via k-{type} attr (e.g., k-action="approve")
+  const overrideKey = `k-${config.type}`;
+  const override = attrs[overrideKey];
+  if (typeof override === 'string' && override) {
+    return `${config.type}:${override}`;
+  }
+
+  // Derive from prop
+  if (config.prop) {
+    const val = props[config.prop];
+    if (typeof val === 'string' && val) {
+      return `${config.type}:${val}`;
+    }
+  }
+
+  // Derive from slot text (e.g., KButton default slot)
+  if (config.slotText && slotNodes) {
+    const text = extractSlotText(slotNodes);
+    if (text) {
+      return `${config.type}:${text}`;
+    }
+  }
+
+  // Fallback: check props.text (for KButton text prop)
+  if (config.slotText && typeof props.text === 'string' && props.text) {
+    return `${config.type}:${props.text}`;
+  }
+
+  // Inherit from parent KFormItem for input-type components
+  if (config.type === 'field' && !config.prop && fieldFromParent) {
+    return `${config.type}:${fieldFromParent}`;
+  }
+
+  return undefined;
+}
+
+/**
+ * Inject data-k attribute into a VNode.
+ * Uses cloneVNode to avoid mutating the original.
+ */
+function injectDataK(vnode: VNode, dataK: string): VNode {
+  return cloneVNode(vnode, { 'data-k': dataK });
+}
+
+// ---------------------------------------------------------------------------
+// kDefineComponent
+// ---------------------------------------------------------------------------
+
+/**
+ * Wrapper around Vue's defineComponent that automatically injects `data-k`
+ * test anchor attributes when testAnchor is enabled via KConfigProvider.
+ *
+ * Usage:
+ * ```tsx
+ * export default kDefineComponent((_props, ctx) => {
+ *   return () => <div class="k-form-item">...</div>;
+ * }, {
+ *   name: 'KFormItem',
+ *   props: FormCore.formItemProps,
+ *   kAnchor: { type: 'field', prop: 'prop' },
+ * });
+ * ```
+ */
+export function kDefineComponent<P extends Record<string, unknown>>(
+  setup: (props: P, ctx: SetupContext) => () => VNode | VNode[] | null | undefined,
+  options: KDefineComponentOptions,
+) {
+  const { kAnchor, ...defineOptions } = options;
+
+  return defineComponent((rawProps: P, ctx: SetupContext) => {
+    // Call the original setup to get the render function
+    const render = setup(rawProps, ctx);
+
+    // If no kAnchor config, skip entirely
+    if (!kAnchor) {
+      return render;
+    }
+
+    // Read the global testAnchor switch
+    const testAnchor = inject(K_TEST_ANCHOR_KEY, undefined);
+
+    // For field-type components without own prop, inject parent field identity
+    const parentField = (kAnchor.type === 'field' && !kAnchor.prop)
+      ? inject(K_FIELD_KEY, undefined)
+      : undefined;
+
+    return () => {
+      const vnode = render();
+
+      // When testAnchor is off (default), render as-is
+      if (!testAnchor?.value) {
+        return vnode;
+      }
+
+      // Resolve the data-k value
+      const props = rawProps as Record<string, unknown>;
+      const slotNodes = kAnchor.slotText ? (ctx.slots.default?.() ?? undefined) : undefined;
+      const dataK = resolveDataK(
+        kAnchor,
+        props,
+        ctx.attrs,
+        parentField?.value,
+        slotNodes,
+      );
+
+      if (!dataK) {
+        return vnode;
+      }
+
+      // Inject into root vnode
+      if (vnode === null || vnode === undefined) {
+        return vnode;
+      }
+
+      // Handle array of vnodes (Fragment) — inject into first element
+      if (Array.isArray(vnode)) {
+        if (vnode.length === 0) return vnode;
+        const first = vnode[0];
+        if (first && typeof first === 'object') {
+          return [injectDataK(first, dataK), ...vnode.slice(1)];
+        }
+        return vnode;
+      }
+
+      return injectDataK(vnode, dataK);
+    };
+  }, defineOptions as Parameters<typeof defineComponent>[1]);
+}

package/compositions/modal/__tests__/useModal.test.ts

@@ -7,6 +7,7 @@
  * 江湖的业务千篇一律，复杂的代码好几百行。
  */
 import { describe, expect, it, vi } from 'vitest';
+import { nextTick, reactive } from 'vue';
 import { useModal } from '../useModal';
 
 describe('useModal', () => {
@@ -89,4 +90,21 @@ describe('useModal', () => {
     onContentClick(event);
     expect(event.stopPropagation).toHaveBeenCalled();
   });
+
+  it('外部 props.visible 变化时 watcher 同步内部 visible', async () => {
+    const emit = vi.fn();
+    const props = reactive({ visible: false });
+    const { visible } = useModal(props, emit);
+
+    expect(visible.value).toBe(false);
+
+    // 外部修改 props.visible → watcher 同步 visible.value
+    props.visible = true;
+    await nextTick();
+    expect(visible.value).toBe(true);
+
+    props.visible = false;
+    await nextTick();
+    expect(visible.value).toBe(false);
+  });
 });

package/dist/compositions/common/testAnchor.d.ts

@@ -0,0 +1,40 @@
+import { ComponentPropsOptions, EmitsOptions, InjectionKey, Ref, SetupContext, VNode } from 'vue';
+/** Global switch provided by KConfigProvider to enable data-k rendering */
+export declare const K_TEST_ANCHOR_KEY: InjectionKey<Ref<boolean>>;
+/** Field identity provided by KFormItem so child inputs inherit field name */
+export declare const K_FIELD_KEY: InjectionKey<Ref<string | undefined>>;
+export interface KAnchorConfig {
+    /** Semantic type: 'field' | 'action' | 'table' | 'col' | 'dialog' | 'drawer' | 'tab' */
+    type: string;
+    /** Which prop to derive the identity from (e.g., 'prop' for KFormItem, 'title' for KDialog) */
+    prop?: string;
+    /** Derive identity from default slot text content (for KButton) */
+    slotText?: boolean;
+}
+interface KDefineComponentOptions {
+    name: string;
+    props?: ComponentPropsOptions;
+    emits?: EmitsOptions;
+    kAnchor?: KAnchorConfig;
+}
+/**
+ * Wrapper around Vue's defineComponent that automatically injects `data-k`
+ * test anchor attributes when testAnchor is enabled via KConfigProvider.
+ *
+ * Usage:
+ * ```tsx
+ * export default kDefineComponent((_props, ctx) => {
+ *   return () => <div class="k-form-item">...</div>;
+ * }, {
+ *   name: 'KFormItem',
+ *   props: FormCore.formItemProps,
+ *   kAnchor: { type: 'field', prop: 'prop' },
+ * });
+ * ```
+ */
+export declare function kDefineComponent<P extends Record<string, unknown>>(setup: (props: P, ctx: SetupContext) => () => VNode | VNode[] | null | undefined, options: KDefineComponentOptions): import('vue').DefineSetupFnComponent<P, EmitsOptions, {}, P & ({
+    [x: `on${Capitalize<string>}`]: ((...args: never) => any) | undefined;
+} | {
+    [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}), import('vue').PublicProps>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kine-design/core",
-  "version": "0.0.1-beta.6",
+  "version": "0.0.1-beta.8",
   "description": "",
   "type": "module",
   "main": "./dist/core.js",

package/tools/__tests__/empty.test.ts

@@ -6,7 +6,7 @@
  *
  * 江湖的业务千篇一律，复杂的代码好几百行。
  */
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { notEmpty, isEmpty } from '../empty';
 
 describe('notEmpty', () => {
@@ -57,8 +57,27 @@ describe('notEmpty', () => {
   it('非空正则非空', () => expect(notEmpty(/abc/)).toBe(true));
 
   // TypedArray
+  // notEmpty 对 TypedArray 返回 value.length（number），0 为 falsy，>0 为 truthy
   it('空 Uint8Array 为空', () => expect(notEmpty(new Uint8Array(0))).toBe(0));
   it('非空 Float64Array 非空', () => expect(notEmpty(new Float64Array([1.5]))).toBe(1));
+
+  // WeakMap / WeakSet — 无法判断是否为空，始终返回 false 并 console.error
+  it('WeakMap 无法判断，返回 false', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    expect(notEmpty(new WeakMap())).toBe(false);
+    expect(spy).toHaveBeenCalledWith('WeakMap和WeakSet无法以通用的方式判断是否为空。');
+    spy.mockRestore();
+  });
+  it('WeakSet 无法判断，返回 false', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    expect(notEmpty(new WeakSet())).toBe(false);
+    expect(spy).toHaveBeenCalledWith('WeakMap和WeakSet无法以通用的方式判断是否为空。');
+    spy.mockRestore();
+  });
+
+  // BigInt — typeof bigint 分支，始终返回 true
+  it('BigInt(0) 非空', () => expect(notEmpty(BigInt(0))).toBe(true));
+  it('BigInt(42) 非空', () => expect(notEmpty(BigInt(42))).toBe(true));
 });
 
 describe('isEmpty', () => {