@composy/store-core 0.0.1 → 0.0.2

package/lib/middleware/time-travel.d.ts

@@ -1,30 +0,0 @@
-import type { Middleware, // 状态快照接口
-StateTree, // 状态树类型
-StoreId, // Store 标识类型
-TimeTravelController, // 时间旅行控制器接口
-TimeTravelMiddlewareOptions } from '../types';
-/**
- * 创建时间旅行中间件
- *
- * 返回一个中间件函数和一个控制器对象：
- * - 中间件负责拦截 state: 类型的操作，在操作前后记录状态快照
- * - 控制器提供 undo/redo/goto/clear 等方法，用于在历史快照之间跳转
- *
- * @param options - 中间件配置选项（可选，与默认值合并）
- * @returns 包含 middleware（中间件）和 controller（控制器）的对象
- */
-export declare function createTimeTravelMiddleware(options?: TimeTravelMiddlewareOptions): {
-    middleware: Middleware;
-    controller: TimeTravelController;
-};
-/**
- * 外部设置恢复回调的辅助函数
- * 将外部提供的状态恢复函数注入到时间旅行控制器中
- *
- * 使用场景：Store 运行时初始化时调用此函数，将控制器与 Store 的状态恢复逻辑连接
- *
- * @param controller - 时间旅行控制器实例
- * @param callback - 恢复回调函数，接收 storeId 和已深拷贝的状态树
- */
-export declare function setRestoreCallback(controller: TimeTravelController, callback: (storeId: StoreId, state: StateTree) => void): void;
-//# sourceMappingURL=time-travel.d.ts.map

package/lib/middleware/validation.d.ts

@@ -1,100 +0,0 @@
-/**
- * 验证中间件
- *
- * 对状态变化进行规则校验，支持同步/异步校验器
- * @module middleware/validation
- */
-import type { Middleware, StateTree, StoreId } from '../types';
-/**
- * 单个字段校验规则
- */
-export interface ValidationRule<T = unknown> {
-    /** 校验函数，返回 true 表示通过 */
-    validate: (value: T, state: StateTree) => boolean | Promise<boolean>;
-    /** 校验失败时的错误信息 */
-    message: string;
-}
-/**
- * Store 校验规则集
- */
-export type StoreValidationRules = Record<string, ValidationRule | ValidationRule[]>;
-/**
- * 校验错误
- */
-export interface ValidationError {
-    /** Store ID */
-    storeId: StoreId;
-    /** 字段路径 */
-    field: string;
-    /** 错误信息 */
-    message: string;
-    /** 字段值 */
-    value: unknown;
-}
-/**
- * 校验结果
- */
-export interface ValidationResult {
-    /** 是否全部通过 */
-    valid: boolean;
-    /** 错误列表 */
-    errors: ValidationError[];
-}
-/**
- * 验证中间件选项
- */
-export interface ValidationMiddlewareOptions {
-    /** 按 Store ID 配置的校验规则 */
-    rules: Record<StoreId, StoreValidationRules>;
-    /** 校验失败时的回调 */
-    onValidationError?: (result: ValidationResult) => void;
-    /** 校验失败是否阻止状态变化 (默认 false，仅报告) */
-    blocking?: boolean;
-    /** 是否只在 state:patch 时校验 (默认 false，所有 state: 前缀均校验) */
-    patchOnly?: boolean;
-}
-/**
- * 创建验证中间件
- *
- * 对状态变化进行规则校验，可选择阻止无效变化或仅报告错误
- *
- * @param options - 验证配置
- * @returns 中间件实例和校验辅助 API
- *
- * @example
- * ```typescript
- * const { middleware, validate, getErrors, clearErrors } = createValidationMiddleware({
- *   rules: {
- *     'user-form': {
- *       name: {
- *         validate: (v) => typeof v === 'string' && v.length >= 2,
- *         message: 'Name must be at least 2 characters',
- *       },
- *       age: [
- *         { validate: (v) => typeof v === 'number', message: 'Age must be a number' },
- *         { validate: (v) => (v as number) >= 0 && (v as number) <= 150, message: 'Age must be 0-150' },
- *       ],
- *       email: {
- *         validate: (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(v)),
- *         message: 'Invalid email format',
- *       },
- *     },
- *   },
- *   onValidationError: (result) => {
- *     console.warn('Validation failed:', result.errors)
- *   },
- * })
- *
- * manager.use(middleware)
- * ```
- */
-export declare function createValidationMiddleware(options: ValidationMiddlewareOptions): {
-    middleware: Middleware;
-    /** 手动校验某个 store 的当前状态 */
-    validate: (storeId: StoreId, state: StateTree) => Promise<ValidationResult>;
-    /** 获取最近一次的校验错误 */
-    getErrors: () => ValidationError[];
-    /** 清空错误 */
-    clearErrors: () => void;
-};
-//# sourceMappingURL=validation.d.ts.map

package/lib/plugins/define-plugin.d.ts

@@ -1,74 +0,0 @@
-/**
- * 插件定义辅助函数
- *
- * @module plugins/define-plugin
- */
-import type { DefinePluginOptions, PluginFactory, StorePlugin } from '../types';
-/**
- * 定义 Store 插件
- *
- * 提供类型安全的插件定义方式
- *
- * @template Options - 插件选项类型
- * @param options - 插件定义选项
- * @returns 插件实例
- *
- * @example
- * ```typescript
- * // 定义一个简单的日志插件
- * const loggerPlugin = defineStorePlugin({
- *   name: 'logger',
- *   version: '1.0.0',
- *   install(context) {
- *     console.log('Logger plugin installed')
- *   },
- *   onStateChange(storeId, state, oldState) {
- *     console.log(`[${storeId}] State changed:`, state)
- *   },
- * })
- * ```
- */
-export declare function defineStorePlugin<Options = Record<string, unknown>>(options: DefinePluginOptions<Options>): StorePlugin<Options>;
-/**
- * 创建插件工厂函数
- *
- * 用于创建可配置的插件
- *
- * @template Options - 插件选项类型
- * @param factory - 插件工厂函数
- * @returns 插件工厂
- *
- * @example
- * ```typescript
- * // 创建可配置的持久化插件
- * const createPersistPlugin = createPluginFactory<{ key: string }>(
- *   (options) => ({
- *     name: 'persist',
- *     install(context) {
- *       console.log('Persist key:', options?.key)
- *     },
- *   })
- * )
- *
- * // 使用
- * const plugin = createPersistPlugin({ key: 'my-store' })
- * ```
- */
-export declare function createPluginFactory<Options = Record<string, unknown>>(factory: (options?: Options) => DefinePluginOptions<Options>): PluginFactory<Options>;
-/**
- * 组合多个插件
- *
- * @param plugins - 插件列表
- * @returns 组合后的插件
- *
- * @example
- * ```typescript
- * const combinedPlugin = composePlugins([
- *   loggerPlugin,
- *   persistPlugin,
- *   devtoolsPlugin,
- * ])
- * ```
- */
-export declare function composePlugins(plugins: StorePlugin[]): StorePlugin;
-//# sourceMappingURL=define-plugin.d.ts.map

package/lib/plugins/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * 插件模块导出
- *
- * @module plugins
- */
-export { composePlugins, createPluginFactory, defineStorePlugin, } from './define-plugin';
-export { createPluginManager, getGlobalPluginManager, setGlobalPluginManager, } from './plugin-manager';
-//# sourceMappingURL=index.d.ts.map

package/lib/plugins/plugin-manager.d.ts

@@ -1,35 +0,0 @@
-/**
- * 插件管理器
- *
- * @module plugins/plugin-manager
- */
-import type { PluginManager } from '../types';
-/**
- * 创建插件管理器
- *
- * @returns 插件管理器实例
- *
- * @example
- * ```typescript
- * const manager = createPluginManager()
- *
- * // 注册插件
- * manager.use(myPlugin, { option: 'value' })
- *
- * // 获取插件
- * const plugin = manager.get('my-plugin')
- *
- * // 移除插件
- * manager.remove('my-plugin')
- * ```
- */
-export declare function createPluginManager(): PluginManager;
-/**
- * 获取全局插件管理器
- */
-export declare function getGlobalPluginManager(): PluginManager;
-/**
- * 设置全局插件管理器
- */
-export declare function setGlobalPluginManager(manager: PluginManager): void;
-//# sourceMappingURL=plugin-manager.d.ts.map

package/lib/types/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * @lkit/store-core 类型定义
- *
- * 提供状态管理的核心类型定义
- * @module types
- */
-export * from './store';
-export * from './plugin';
-export * from './middleware';
-export * from './subscription';
-export * from './utility';
-//# sourceMappingURL=index.d.ts.map

package/lib/utils/debounce-throttle.d.ts

@@ -1,86 +0,0 @@
-/**
- * 防抖和节流工具函数
- *
- * 提供性能优化的防抖、节流功能
- * @module utils/debounce-throttle
- */
-/**
- * 防抖函数返回类型
- */
-export interface DebouncedFunction<T extends (...args: never[]) => void> {
-    (...args: Parameters<T>): void;
-    /** 取消待执行的调用 */
-    cancel: () => void;
-    /** 立即执行待处理的调用 */
-    flush: () => void;
-    /** 是否有待处理的调用 */
-    pending: () => boolean;
-}
-/**
- * 节流函数返回类型
- */
-export interface ThrottledFunction<T extends (...args: never[]) => void> {
-    (...args: Parameters<T>): void;
-    /** 取消待执行的调用 */
-    cancel: () => void;
-}
-/**
- * 创建防抖函数
- *
- * 在连续调用停止后，延迟指定时间执行函数
- *
- * @template T - 函数类型
- * @param fn - 需要防抖的函数
- * @param delay - 延迟时间（毫秒）
- * @param immediate - 是否在首次调用时立即执行
- * @returns 防抖后的函数
- *
- * @example
- * ```typescript
- * const debouncedSearch = debounce((query: string) => {
- *   fetchResults(query)
- * }, 300)
- *
- * // 连续调用只会在最后一次调用后 300ms 执行
- * debouncedSearch('a')
- * debouncedSearch('ab')
- * debouncedSearch('abc') // 只有这次会触发
- *
- * // 取消待执行的调用
- * debouncedSearch.cancel()
- * ```
- */
-export declare function debounce<T extends (...args: never[]) => void>(fn: T, delay: number, immediate?: boolean): DebouncedFunction<T>;
-/**
- * 创建节流函数
- *
- * 在指定时间间隔内最多执行一次函数
- *
- * @template T - 函数类型
- * @param fn - 需要节流的函数
- * @param interval - 间隔时间（毫秒）
- * @param options - 节流选项
- * @param options.leading - 是否在时间窗开始时立即执行
- * @param options.trailing - 是否在时间窗结束时补执行最后一次调用
- * @returns 节流后的函数
- *
- * @example
- * ```typescript
- * const throttledUpdate = throttle((x: number, y: number) => {
- *   updatePosition(x, y)
- * }, 100)
- *
- * // 在 100ms 内多次调用，只会执行一次
- * window.addEventListener('mousemove', (e) => {
- *   throttledUpdate(e.clientX, e.clientY)
- * })
- *
- * // 取消
- * throttledUpdate.cancel()
- * ```
- */
-export declare function throttle<T extends (...args: never[]) => void>(fn: T, interval: number, options?: {
-    leading?: boolean;
-    trailing?: boolean;
-}): ThrottledFunction<T>;
-//# sourceMappingURL=debounce-throttle.d.ts.map