@zhin.js/core 1.0.57 → 1.1.2

package/tests/features-builtin.test.ts

@@ -1,191 +0,0 @@
-/**
- * 内置 Feature 测试
- * DatabaseFeature / PermissionFeature / ComponentFeature
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { PermissionFeature, Permissions } from '../src/built/permission.js';
-import { ComponentFeature } from '../src/built/component.js';
-import type { Message, MessageBase } from '../src/message.js';
-
-// ============================================================================
-// PermissionFeature 测试
-// ============================================================================
-
-describe('PermissionFeature', () => {
-  let feature: PermissionFeature;
-
-  beforeEach(() => {
-    feature = new PermissionFeature();
-  });
-
-  function makeMessage(overrides: Partial<MessageBase> = {}): Message<any> {
-    return {
-      $id: '1',
-      $adapter: 'test' as any,
-      $bot: 'bot1',
-      $content: [],
-      $raw: '',
-      $sender: { id: 'user1', name: 'User' },
-      $channel: { id: 'ch1', type: 'group' },
-      $timestamp: Date.now(),
-      $reply: vi.fn(),
-      $recall: vi.fn(),
-      ...overrides,
-    } as any;
-  }
-
-  it('应有正确的元数据', () => {
-    expect(feature.name).toBe('permission');
-    expect(feature.icon).toBe('Shield');
-    expect(feature.desc).toBe('权限');
-  });
-
-  it('构造时应注册内置权限检查器', () => {
-    // 构造时已注册 adapter(), group(), private(), channel(), user() 检查器
-    expect(feature.items.length).toBeGreaterThanOrEqual(5);
-  });
-
-  describe('check', () => {
-    it('adapter() 匹配应返回 true', async () => {
-      const msg = makeMessage({ $adapter: 'qq' as any });
-      expect(await feature.check('adapter(qq)', msg)).toBe(true);
-    });
-
-    it('adapter() 不匹配应返回 false', async () => {
-      const msg = makeMessage({ $adapter: 'qq' as any });
-      expect(await feature.check('adapter(discord)', msg)).toBe(false);
-    });
-
-    it('group() 匹配应返回 true', async () => {
-      const msg = makeMessage({ $channel: { id: 'g1', type: 'group' } });
-      expect(await feature.check('group(g1)', msg)).toBe(true);
-    });
-
-    it('group(*) 通配应返回 true', async () => {
-      const msg = makeMessage({ $channel: { id: 'g123', type: 'group' } });
-      expect(await feature.check('group(*)', msg)).toBe(true);
-    });
-
-    it('private() 匹配应返回 true', async () => {
-      const msg = makeMessage({ $channel: { id: 'p1', type: 'private' } });
-      expect(await feature.check('private(p1)', msg)).toBe(true);
-    });
-
-    it('user() 匹配应返回 true', async () => {
-      const msg = makeMessage({ $sender: { id: 'u1', name: 'U' } });
-      expect(await feature.check('user(u1)', msg)).toBe(true);
-    });
-
-    it('user() 不匹配应返回 false', async () => {
-      const msg = makeMessage({ $sender: { id: 'u1', name: 'U' } });
-      expect(await feature.check('user(u2)', msg)).toBe(false);
-    });
-
-    it('未注册的权限名应返回 false', async () => {
-      const msg = makeMessage();
-      expect(await feature.check('unknown_permission', msg)).toBe(false);
-    });
-  });
-
-  describe('自定义权限', () => {
-    it('应能添加自定义权限检查器', async () => {
-      const perm = Permissions.define('admin', (_name, msg) => {
-        return msg.$sender.id === 'admin_user';
-      });
-
-      feature.add(perm, 'test-plugin');
-
-      const adminMsg = makeMessage({ $sender: { id: 'admin_user', name: 'Admin' } });
-      const normalMsg = makeMessage({ $sender: { id: 'normal_user', name: 'Normal' } });
-
-      expect(await feature.check('admin', adminMsg)).toBe(true);
-      expect(await feature.check('admin', normalMsg)).toBe(false);
-    });
-  });
-
-  describe('toJSON', () => {
-    it('应序列化所有权限', () => {
-      const json = feature.toJSON();
-      expect(json.name).toBe('permission');
-      expect(json.count).toBeGreaterThan(0);
-    });
-
-    it('应按插件名过滤', () => {
-      feature.add(Permissions.define('custom', () => true), 'my-plugin');
-      const json = feature.toJSON('my-plugin');
-      expect(json.count).toBe(1);
-    });
-  });
-});
-
-// ============================================================================
-// ComponentFeature 测试
-// ============================================================================
-
-describe('ComponentFeature', () => {
-  let feature: ComponentFeature;
-
-  beforeEach(() => {
-    feature = new ComponentFeature();
-  });
-
-  const mockComponent = {
-    name: 'test-component',
-    render: () => ({ type: 'text', data: { text: 'test' } }),
-  } as any;
-
-  it('应有正确的元数据', () => {
-    expect(feature.name).toBe('component');
-    expect(feature.icon).toBe('Box');
-    expect(feature.desc).toBe('组件');
-  });
-
-  it('add 应添加组件', () => {
-    feature.add(mockComponent, 'test-plugin');
-    expect(feature.items).toHaveLength(1);
-    expect(feature.byName.get('test-component')).toBe(mockComponent);
-  });
-
-  it('remove 应移除组件', () => {
-    feature.add(mockComponent, 'test-plugin');
-    feature.remove(mockComponent);
-    expect(feature.items).toHaveLength(0);
-    expect(feature.byName.has('test-component')).toBe(false);
-  });
-
-  it('get 应按名称获取', () => {
-    feature.add(mockComponent, 'test-plugin');
-    expect(feature.get('test-component')).toBe(mockComponent);
-    expect(feature.get('nonexistent')).toBeUndefined();
-  });
-
-  it('getAllNames 应返回所有名称', () => {
-    feature.add(mockComponent, 'test-plugin');
-    feature.add({ name: 'another', render: () => null } as any, 'test-plugin');
-    expect(feature.getAllNames()).toEqual(['test-component', 'another']);
-  });
-
-  describe('toJSON', () => {
-    it('应返回正确结构', () => {
-      feature.add(mockComponent, 'test-plugin');
-      const json = feature.toJSON();
-      expect(json.name).toBe('component');
-      expect(json.count).toBe(1);
-      expect(json.items[0]).toEqual({ name: 'test-component', type: 'component' });
-    });
-
-    it('按插件名过滤', () => {
-      feature.add(mockComponent, 'plugin-a');
-      feature.add({ name: 'other', render: () => null } as any, 'plugin-b');
-      const json = feature.toJSON('plugin-a');
-      expect(json.count).toBe(1);
-    });
-  });
-});
-
-// ============================================================================
-// DatabaseFeature 说明
-// ============================================================================
-// DatabaseFeature 需要实际数据库连接（sqlite3 等），测试跳过。
-// 其核心逻辑（add/remove/toJSON）已由 Feature 基类测试覆盖。
-// 数据库相关测试见 basic/database/ 目录。

package/tests/jsx-runtime.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import * as jsxRuntime from '../src/jsx-runtime'
-import * as jsxDevRuntime from '../src/jsx-dev-runtime'
-
-describe('JSX Runtime', () => {
-  it('should export jsx function', () => {
-    expect(typeof jsxRuntime.jsx).toBe('function')
-  })
-
-  it('should export jsxs function', () => {
-    expect(typeof jsxRuntime.jsxs).toBe('function')
-  })
-
-  it('should export Fragment', () => {
-    expect(jsxRuntime.Fragment).toBeDefined()
-  })
-
-  it('should export renderJSX function', () => {
-    expect(typeof jsxRuntime.renderJSX).toBe('function')
-  })
-
-  it('should have default export', () => {
-    expect(jsxRuntime.default).toBeDefined()
-    expect(typeof jsxRuntime.default.jsx).toBe('function')
-    expect(typeof jsxRuntime.default.jsxs).toBe('function')
-  })
-})
-
-describe('JSX Dev Runtime', () => {
-  it('should export jsx function', () => {
-    expect(typeof jsxDevRuntime.jsx).toBe('function')
-  })
-
-  it('should export jsxDEV function', () => {
-    expect(typeof jsxDevRuntime.jsxDEV).toBe('function')
-  })
-
-  it('should export Fragment', () => {
-    expect(jsxDevRuntime.Fragment).toBeDefined()
-  })
-
-  it('should export renderJSX function', () => {
-    expect(typeof jsxDevRuntime.renderJSX).toBe('function')
-  })
-})

package/tests/jsx.test.ts

@@ -1,319 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { jsx, jsxs, Fragment, renderJSX } from '../src/jsx'
-import { Component, ComponentContext } from '../src/component'
-import { MessageComponent } from '../src/message'
-
-describe('JSX消息组件系统测试', () => {
-  let mockContext: ComponentContext
-
-  beforeEach(() => {
-    mockContext = {
-      event: {
-        $id: 'test-msg',
-        $adapter: 'test',
-        $bot: 'test-bot',
-        $content: [],
-        $sender: { id: 'user123', name: 'testuser' },
-        $reply: vi.fn().mockResolvedValue('reply123'),
-        $channel: { id: 'channel123', type: 'group' },
-        $timestamp: Date.now(),
-        $raw: 'test message'
-      }
-    } as any
-  })
-
-  describe('JSX元素创建', () => {
-    it('应该创建基础JSX元素', () => {
-      const element = jsx('text', { children: 'Hello World' })
-      
-      expect(element).toEqual({
-        type: 'text',
-        data: { children: 'Hello World' }
-      })
-    })
-
-    it('应该创建带属性的JSX元素', () => {
-      const element = jsx('image', { 
-        src: 'https://example.com/image.jpg',
-        alt: '测试图片',
-        children: null
-      })
-      
-      expect(element).toEqual({
-        type: 'image',
-        data: { 
-          src: 'https://example.com/image.jpg',
-          alt: '测试图片',
-          children: null
-        }
-      })
-    })
-
-    it('应该创建嵌套JSX元素', () => {
-      const child = jsx('text', { children: '内容' })
-      const parent = jsx('div', { children: [child] })
-      
-      expect(parent.data.children).toContain(child)
-    })
-
-    it('jsxs应该与jsx功能相同', () => {
-      const element1 = jsx('text', { children: 'Hello' })
-      const element2 = jsxs('text', { children: 'Hello' })
-      
-      expect(element1).toEqual(element2)
-    })
-  })
-
-  describe('Fragment组件', () => {
-    it('应该支持Fragment', () => {
-      const fragment = jsx(Fragment, { 
-        children: ['Hello', ' ', 'World'] 
-      })
-      
-      expect(fragment.type).toBe(Fragment)
-      expect(fragment.data.children).toEqual(['Hello', ' ', 'World'])
-    })
-
-    it('Fragment应该是函数类型', () => {
-      expect(typeof Fragment).toBe('function')
-      expect(Fragment.name).toBe('Fragment')
-    })
-  })
-
-  describe('JSX渲染', () => {
-    it('应该渲染纯文本元素', async () => {
-      const element = jsx('text', { children: 'Hello World' })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Hello World')
-    })
-
-    it('应该渲染Fragment', async () => {
-      const fragment = jsx('Fragment', { 
-        children: ['Hello', ' ', 'World'] 
-      })
-      const result = await renderJSX(fragment as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Hello World')
-    })
-
-    it('应该渲染嵌套元素', async () => {
-      const nested = jsx('div', {
-        children: [
-          jsx('text', { children: 'Hello' }),
-          ' ',
-          jsx('text', { children: 'World' })
-        ]
-      })
-      const result = await renderJSX(nested as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Hello World')
-    })
-
-    it('应该处理null和undefined子元素', async () => {
-      const element = jsx('div', { 
-        children: [null, undefined, 'Hello', null, 'World', undefined] 
-      })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('HelloWorld')
-    })
-
-    it('应该处理数字和布尔值', async () => {
-      const element = jsx('div', { 
-        children: [42, true, false, 'text'] 
-      })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('42truefalsetext')
-    })
-  })
-
-  describe('函数组件', () => {
-    it('应该渲染函数组件', async () => {
-      const TestComponent: Component<{ name: string }> = async (props, context) => {
-        return `Hello, ${props.name}!`
-      }
-
-      const element = jsx(TestComponent, { name: '用户' })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Hello, 用户!')
-    })
-
-    it('应该向函数组件传递context', async () => {
-      const ContextComponent: Component<{}> = async (props, context) => {
-        return `Root: ${context?.root || 'No Root'}`
-      }
-
-      const element = jsx(ContextComponent, {})
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toContain('Root:')
-    })
-
-    it('应该处理异步函数组件', async () => {
-      const AsyncComponent: Component<{ delay: number }> = async (props) => {
-        await new Promise(resolve => setTimeout(resolve, props.delay))
-        return 'Async content'
-      }
-
-      const element = jsx(AsyncComponent, { delay: 10 })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Async content')
-    })
-
-    it('应该支持组件返回JSX元素', async () => {
-      const WrapperComponent: Component<{ text: string }> = async (props) => {
-        return `Wrapped: ${props.text}`
-      }
-
-      const element = jsx(WrapperComponent, { text: 'content' })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      // 由于函数组件返回字符串
-      expect(result).toBe('Wrapped: content')
-    })
-  })
-
-  describe('复杂渲染场景', () => {
-    it('应该处理深度嵌套', async () => {
-      const DeepComponent: Component<{ level: number }> = async (props) => {
-        if (props.level <= 0) return `Level ${props.level}`
-        return `Nested Level ${props.level}`
-      }
-
-      const element = jsx(DeepComponent, { level: 3 })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Nested Level 3')
-    })
-
-    it('应该处理组件数组', async () => {
-      const Item: Component<{ text: string }> = async (props) => `[${props.text}]`
-
-      const items = ['A', 'B', 'C'].map(text => jsx(Item, { text }))
-      const container = jsx('div', { children: items })
-      
-      const result = await renderJSX(container as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('[A][B][C]')
-    })
-
-    it('应该处理条件渲染', async () => {
-      const ConditionalComponent: Component<{ show: boolean; text: string }> = async (props) => {
-        return props.show ? props.text : ''
-      }
-
-      const element1 = jsx(ConditionalComponent, { show: true, text: 'Visible' })
-      const element2 = jsx(ConditionalComponent, { show: false, text: 'Hidden' })
-      
-      const result1 = await renderJSX(element1 as MessageComponent<any>, mockContext)
-      const result2 = await renderJSX(element2 as MessageComponent<any>, mockContext)
-      
-      expect(result1).toBe('Visible')
-      expect(result2).toBe('')
-    })
-  })
-
-  describe('错误处理', () => {
-    it('应该捕获组件执行错误并返回错误消息', async () => {
-      const ErrorComponent: Component<{}> = async () => {
-        throw new Error('Component error')
-      }
-
-      const element = jsx(ErrorComponent, {})
-      
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      expect(result).toBe('❌ 组件渲染失败: Component error')
-    })
-
-    it('应该处理无效的元素类型', async () => {
-      const invalidElement = {
-        type: 123 as any, // 无效类型
-        data: { children: 'test' }
-      }
-      
-      const result = await renderJSX(invalidElement as MessageComponent<any>, mockContext)
-      expect(result).toMatch(/❌ 组件渲染失败/)
-    })
-    
-    it('应该处理异步组件返回 Promise 的情况', async () => {
-      const AsyncPromiseComponent: Component<{ text: string }> = async (props) => {
-        // 返回一个 Promise（会被自动 await）
-        return Promise.resolve(`Async: ${props.text}`)
-      }
-
-      const element = jsx(AsyncPromiseComponent, { text: 'test' })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('Async: test')
-    })
-    
-    it('应该处理子组件为 Promise 的情况', async () => {
-      const AsyncChild = Promise.resolve('Async Child Content')
-      const element = jsx('div', { children: [AsyncChild] })
-      
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      expect(result).toBe('Async Child Content')
-    })
-  })
-
-  describe('性能和内存', () => {
-    it('应该处理大量子元素', async () => {
-      const manyChildren = Array.from({ length: 100 }, (_, i) => `Item ${i}`)
-      const element = jsx('div', { children: manyChildren })
-      
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toContain('Item 0')
-      expect(result).toContain('Item 99')
-      expect(typeof result).toBe('string')
-    })
-
-    it('应该正确处理空子元素数组', async () => {
-      const element = jsx('div', { children: [] })
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('')
-    })
-  })
-
-  describe('类型安全', () => {
-    it('应该正确处理各种数据类型', async () => {
-      const element = jsx('div', {
-        children: [
-          'string',
-          42,
-          true,
-          false,
-          null,
-          undefined,
-          jsx('span', { children: 'nested' })
-        ]
-      })
-      
-      const result = await renderJSX(element as MessageComponent<any>, mockContext)
-      
-      expect(result).toBe('string42truefalsenested')
-    })
-
-    it('应该保持属性数据完整性', () => {
-      const props = {
-        id: 'test-id',
-        className: 'test-class',
-        onClick: () => {},
-        data: { key: 'value' },
-        children: 'content'
-      }
-      
-      const element = jsx('button', props)
-      
-      expect(element.data).toEqual(props)
-      expect(element.data.id).toBe('test-id')
-      expect(element.data.className).toBe('test-class')
-      expect(typeof element.data.onClick).toBe('function')
-    })
-  })
-})