directix 1.0.0-beta.1 → 1.0.0

package/dist/index.d.ts

@@ -4,132 +4,132 @@ import { Plugin as Plugin_2 } from 'vue';
 import { VNode } from 'vue';
 
 /**
- * 添加清理函数到元素
+ * Add cleanup function to element
  */
 export declare function addCleanupVue2(el: Element, fn: () => void): void;
 
 /**
- * 添加清理函数到元素
+ * Add cleanup function to element
  */
 export declare function addCleanupVue3(el: Element, fn: () => void): void;
 
 /**
- * 指令绑定值类型
+ * Directive binding value type
  */
 export declare type ClickOutsideBinding = ClickOutsideHandler | ClickOutsideOptions;
 
 /**
- * 点击外部处理函数
+ * Click outside handler
  */
 export declare type ClickOutsideHandler = (event: MouseEvent | TouchEvent) => void;
 
 /**
- * 点击外部指令选项
+ * Click outside directive options
  */
 export declare interface ClickOutsideOptions {
     /**
-     * 点击外部时的回调函数
+     * Callback when clicking outside
      * @required
      */
     handler: ClickOutsideHandler;
     /**
-     * 排除的元素选择器或元素引用
+     * Excluded element selectors or element references
      */
     exclude?: (string | HTMLElement | (() => HTMLElement | null))[];
     /**
-     * 是否使用捕获模式
+     * Whether to use capture mode
      * @default true
      */
     capture?: boolean;
     /**
-     * 监听的事件类型
+     * Event types to listen for
      * @default ['click']
      */
     events?: ('click' | 'mousedown' | 'mouseup' | 'touchstart' | 'touchend')[];
     /**
-     * 是否禁用
+     * Whether to disable
      * @default false
      */
     disabled?: boolean;
     /**
-     * 停止传播
+     * Stop propagation
      * @default false
      */
     stop?: boolean;
     /**
-     * 阻止默认行为
+     * Prevent default behavior
      * @default false
      */
     prevent?: boolean;
 }
 
 /**
- * 指令绑定值类型
+ * Directive binding value type
  */
 export declare type CopyBinding = string | CopyOptions;
 
 /**
- * 复制失败回调
+ * Copy error callback
  */
 export declare type CopyErrorCallback = (error: Error) => void;
 
 /**
- * 复制指令选项
+ * Copy directive options
  */
 export declare interface CopyOptions {
     /**
-     * 要复制的文本
+     * Text to copy
      * @required
      */
     value: string;
     /**
-     * 复制成功回调
+     * Callback on copy success
      */
     onSuccess?: CopySuccessCallback;
     /**
-     * 复制失败回调
+     * Callback on copy error
      */
     onError?: CopyErrorCallback;
     /**
-     * 复制按钮的提示文本
+     * Tooltip text for the copy button
      */
     title?: string;
     /**
-     * 是否禁用
+     * Whether to disable
      * @default false
      */
     disabled?: boolean;
 }
 
 /**
- * 复制成功回调
+ * Copy success callback
  */
 export declare type CopySuccessCallback = (text: string) => void;
 
 /**
- * Vue 2 指令适配器
+ * Vue 2 directive adapter
  * @returns Vue 2 directive object with bind/inserted/update/unbind hooks
  */
 export declare function createVue2Directive<T, B extends Element>(hooks: DirectiveHooks<T, B>): Record<string, any>;
 
 /**
- * Vue 3 指令适配器
+ * Vue 3 directive adapter
  * @returns Vue 3 directive object with created/mounted/updated/unmounted hooks
  */
 export declare function createVue3Directive<T, B extends Element>(hooks: DirectiveHooks<T, B>): Record<string, any>;
 
 /**
- * 跨版本指令类型（兼容 Vue 2/3）
+ * Cross-version directive type (compatible with Vue 2/3)
  */
 export declare type CrossVersionDirective = Directive | Vue2DirectiveHooks | Vue3DirectiveHooks;
 
 /**
- * 指令绑定值类型
+ * Directive binding value type
  */
 export declare type DebounceBinding<T extends (...args: any[]) => any = any> = T | DebounceOptions<T>;
 
 /**
- * 防抖函数类型
+ * Debounced function type
  */
 export declare interface DebouncedFunction<T extends (...args: any[]) => any> {
     (...args: Parameters<T>): void;
@@ -138,7 +138,7 @@ export declare interface DebouncedFunction<T extends (...args: any[]) => any> {
 }
 
 /**
- * 防抖函数
+ * Debounce function
  */
 export declare function debounceFn<T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
     leading?: boolean;
@@ -149,49 +149,49 @@ export declare function debounceFn<T extends (...args: any[]) => any>(func: T, w
 };
 
 /**
- * 防抖指令选项
+ * Debounce directive options
  */
 export declare interface DebounceOptions<T extends (...args: any[]) => any = any> {
     /**
-     * 要防抖的函数
+     * Function to debounce
      */
     handler: T;
     /**
-     * 延迟时间（毫秒）
+     * Delay time in milliseconds
      * @default 300
      */
     wait?: number;
     /**
-     * 是否在延迟开始前立即调用
+     * Whether to invoke immediately before delay starts
      * @default false
      */
     leading?: boolean;
     /**
-     * 是否在延迟结束后调用
+     * Whether to invoke after delay ends
      * @default true
      */
     trailing?: boolean;
 }
 
 /**
- * 深拷贝
+ * Deep clone an object
  */
 export declare function deepClone<T>(obj: T): T;
 
 /**
- * 深合并
+ * Deep merge objects
  */
 export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
 
 /**
- * 定义一个跨版本兼容的指令
- * @param definition 指令定义
- * @returns Vue 指令对象
+ * Define a cross-version compatible directive
+ * @param definition The directive definition
+ * @returns Vue directive object
  */
 export declare function defineDirective<T = any, B extends Element = Element>(definition: DirectiveDefinition<T, B>): Directive;
 
 /**
- * 定义指令组
+ * Define a directive group
  */
 export declare function defineDirectiveGroup(name: string, directives: Record<string, any>): {
     name: string;
@@ -200,229 +200,229 @@ export declare function defineDirectiveGroup(name: string, directives: Record<st
 };
 
 /**
- * 统一的指令绑定对象
+ * Unified directive binding object
  */
 export declare interface DirectiveBinding<T = any> {
-    /** 指令绑定的值 */
+    /** The value passed to the directive */
     value: T;
-    /** 上一次绑定的值 */
+    /** The previous value */
     oldValue: T | null;
-    /** 指令参数 (v-xxx:arg) */
+    /** The directive argument (v-xxx:arg) */
     arg?: string;
-    /** 修饰符对象 (v-xxx.modifier) */
+    /** The modifiers object (v-xxx.modifier) */
     modifiers: Record<string, boolean>;
-    /** 组件实例 */
+    /** The component instance */
     instance: ComponentPublicInstance | null;
 }
 
 /**
- * 指令定义接口
+ * Directive definition interface
  */
 export declare interface DirectiveDefinition<T = any, B extends Element = Element> extends DirectiveHooks<T, B> {
-    /** 指令名称 */
+    /** The directive name */
     name: string;
-    /** 指令版本 */
+    /** The Vue version compatibility */
     version?: '2' | '3' | 'both';
-    /** 是否服务端渲染兼容 */
+    /** Whether SSR compatible */
     ssr?: boolean;
-    /** 默认值 */
+    /** Default values */
     defaults?: Partial<T>;
 }
 
 /**
- * 统一的指令钩子函数
+ * Unified directive hooks
  */
 export declare interface DirectiveHooks<T = any, B extends Element = Element> {
     /**
-     * 指令绑定到元素时调用
-     * @param el 绑定的 DOM 元素
-     * @param binding 绑定对象
-     * @param vnode Vue 虚拟节点
+     * Called when the directive is bound to an element
+     * @param el The bound DOM element
+     * @param binding The binding object
+     * @param vnode The Vue virtual node
      */
     mounted?: (el: B, binding: DirectiveBinding<T>, vnode: VNode) => void;
     /**
-     * 元素更新时调用
-     * @param el 绑定的 DOM 元素
-     * @param binding 新的绑定对象
-     * @param vnode 新的虚拟节点
-     * @param prevBinding 旧的绑定对象
-     * @param prevVnode 旧的虚拟节点
+     * Called when the element is updated
+     * @param el The bound DOM element
+     * @param binding The new binding object
+     * @param vnode The new virtual node
+     * @param prevBinding The previous binding object
+     * @param prevVnode The previous virtual node
      */
     updated?: (el: B, binding: DirectiveBinding<T>, vnode: VNode, prevBinding: DirectiveBinding<T>, prevVnode: VNode) => void;
     /**
-     * 指令卸载时调用
-     * @param el 绑定的 DOM 元素
-     * @param binding 绑定对象
-     * @param vnode 虚拟节点
+     * Called when the directive is unbound
+     * @param el The bound DOM element
+     * @param binding The binding object
+     * @param vnode The virtual node
      */
     unmounted?: (el: B, binding: DirectiveBinding<T>, vnode: VNode) => void;
 }
 
 /**
- * 指令安装选项
+ * Directive installation options
  */
 export declare interface DirectiveInstallOptions {
-    /** 注册的指令名称列表，不传则注册全部 */
+    /** List of directive names to register, registers all if not provided */
     directives?: string[];
-    /** 是否注册全部指令 */
+    /** Whether to register all directives */
     all?: boolean;
-    /** 全局配置 */
+    /** Global configuration */
     config?: Record<string, any>;
 }
 
 /**
- * Directix 插件
+ * Directix plugin
  */
 export declare const Directix: Plugin_2;
 
 /**
- * 指令绑定值类型
+ * Directive binding value type
  */
 export declare type FocusBinding = boolean | FocusOptions_2;
 
 /**
- * 焦点指令选项
+ * Focus directive options
  */
 declare interface FocusOptions_2 {
     /**
-     * 是否自动聚焦
+     * Whether to auto focus
      * @default true
      */
     focus?: boolean;
     /**
-     * 是否在每次更新时重新聚焦
+     * Whether to refocus when binding value changes
      * @default false
      */
     refocus?: boolean;
     /**
-     * 聚焦时的回调
+     * Callback when focused
      */
     onFocus?: (el: HTMLElement) => void;
     /**
-     * 失焦时的回调
+     * Callback when blurred
      */
     onBlur?: (el: HTMLElement) => void;
 }
 export { FocusOptions_2 as FocusOptions }
 
 /**
- * 生成唯一 ID
+ * Generate unique ID
  */
 export declare function generateId(prefix?: string): string;
 
 /**
- * 获取嵌套属性值
+ * Get nested property value by path
  */
 export declare function get<T = any>(obj: Record<string, any>, path: string, defaultValue?: T): T;
 
 /**
- * 获取当前 Vue 版本
+ * Get current Vue version
  */
 export declare function getVueVersion(): 2 | 3;
 
 /**
- * 检查是否为数组
+ * Check if value is an array
  */
 export declare function isArray(value: unknown): value is any[];
 
 /**
- * 检查是否为布尔值
+ * Check if value is a boolean
  */
 export declare function isBoolean(value: unknown): value is boolean;
 
 /**
- * 是否浏览器环境
+ * Check if browser environment
  */
 export declare const isBrowser: () => boolean;
 
 /**
- * 检查是否为空
+ * Check if value is empty
  */
 export declare function isEmpty(value: unknown): boolean;
 
 /**
- * 检查是否为函数
+ * Check if value is a function
  */
 export declare function isFunction(value: unknown): value is (...args: any[]) => any;
 
 /**
- * 检查是否为数字
+ * Check if value is a number
  */
 export declare function isNumber(value: unknown): value is number;
 
 /**
- * 检查是否为对象
+ * Check if value is an object
  */
 export declare function isObject(value: unknown): value is Record<string, any>;
 
 /**
- * 检查是否为 Promise
+ * Check if value is a Promise
  */
 export declare function isPromise<T = any>(value: unknown): value is Promise<T>;
 
 /**
- * 是否服务端渲染
+ * Check if server-side rendering
  */
 export declare const isSSR: () => boolean;
 
 /**
- * 检查是否为字符串
+ * Check if value is a string
  */
 export declare function isString(value: unknown): value is string;
 
 /**
- * 是否 Vue 2
+ * Check if Vue 2
  */
 export declare const isVue2: () => boolean;
 
 /**
- * 是否 Vue 3
+ * Check if Vue 3
  */
 export declare const isVue3: () => boolean;
 
 /**
- * 解析时间参数
- * 支持格式: "300" | "300ms" | "1s"
+ * Parse time argument
+ * Supports formats: "300" | "300ms" | "1s"
  */
 export declare function parseTime(arg?: string): number | null;
 
 /**
- * 设置嵌套属性值
+ * Set nested property value by path
  */
 export declare function set(obj: Record<string, any>, path: string, value: any): void;
 
 /**
- * 是否支持 Clipboard API
+ * Check if Clipboard API is supported
  */
 export declare const supportsClipboard: () => boolean;
 
 /**
- * 是否支持 IntersectionObserver
+ * Check if IntersectionObserver is supported
  */
 export declare const supportsIntersectionObserver: () => boolean;
 
 /**
- * 是否支持 MutationObserver
+ * Check if MutationObserver is supported
  */
 export declare const supportsMutationObserver: () => boolean;
 
 /**
- * 是否支持 Passive 事件监听
+ * Check if passive event listening is supported
  */
 export declare const supportsPassive: () => boolean;
 
 /**
- * 是否支持 ResizeObserver
+ * Check if ResizeObserver is supported
  */
 export declare const supportsResizeObserver: () => boolean;
 
 /**
- * 指令绑定值类型
+ * Directive binding value type
  */
 export declare type ThrottleBinding<T extends (...args: any[]) => any = any> = T | ThrottleOptions<T>;
 
 /**
- * 节流函数类型
+ * Throttled function type
  */
 export declare interface ThrottledFunction<T extends (...args: any[]) => any> {
     (...args: Parameters<T>): void;
@@ -430,7 +430,7 @@ export declare interface ThrottledFunction<T extends (...args: any[]) => any> {
 }
 
 /**
- * 节流函数
+ * Throttle function
  */
 export declare function throttleFn<T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
     leading?: boolean;
@@ -440,38 +440,38 @@ export declare function throttleFn<T extends (...args: any[]) => any>(func: T, w
 };
 
 /**
- * 节流指令选项
+ * Throttle directive options
  */
 export declare interface ThrottleOptions<T extends (...args: any[]) => any = any> {
     /**
-     * 要节流的函数
+     * Function to throttle
      */
     handler: T;
     /**
-     * 延迟时间（毫秒）
+     * Delay time in milliseconds
      * @default 300
      */
     wait?: number;
     /**
-     * 是否在延迟开始前立即调用
+     * Whether to invoke immediately before delay starts
      * @default true
      */
     leading?: boolean;
     /**
-     * 是否在延迟结束后调用
+     * Whether to invoke after delay ends
      * @default true
      */
     trailing?: boolean;
 }
 
 /**
- * v-click-outside 指令
+ * v-click-outside directive
  *
  * @example
  * ```vue
  * <template>
  *   <div v-click-outside="handleClickOutside">
- *     下拉菜单
+ *     Dropdown menu
  *   </div>
  * </template>
  * ```
@@ -481,12 +481,12 @@ export { vClickOutside as clickOutside }
 export { vClickOutside }
 
 /**
- * v-copy 指令
+ * v-copy directive
  *
  * @example
  * ```vue
  * <template>
- *   <button v-copy="textToCopy">复制文本</button>
+ *   <button v-copy="textToCopy">Copy Text</button>
  * </template>
  * ```
  */
@@ -495,7 +495,7 @@ export { vCopy as copy }
 export { vCopy }
 
 /**
- * v-debounce 指令
+ * v-debounce directive
  *
  * @example
  * ```vue
@@ -503,8 +503,8 @@ export { vCopy }
  *   <input v-debounce="handleInput" />
  *   <input v-debounce:500ms="handleInput" />
  *   <input v-debounce="{ handler: handleInput, wait: 500 }" />
- *   <div v-debounce.scroll="handleScroll">滚动防抖</div>
- *   <div v-debounce:100.scroll="handleScroll">100ms 滚动防抖</div>
+ *   <div v-debounce.scroll="handleScroll">Scroll Debounce</div>
+ *   <div v-debounce:100.scroll="handleScroll">100ms Scroll Debounce</div>
  * </template>
  * ```
  */
@@ -513,7 +513,7 @@ export { vDebounce as debounce }
 export { vDebounce }
 
 /**
- * v-focus 指令
+ * v-focus directive
  *
  * @example
  * ```vue
@@ -528,15 +528,15 @@ export { vFocus as focus }
 export { vFocus }
 
 /**
- * v-throttle 指令
+ * v-throttle directive
  *
  * @example
  * ```vue
  * <template>
- *   <button v-throttle="handleClick">节流按钮</button>
- *   <button v-throttle:1s="handleClick">1秒节流</button>
- *   <div v-throttle.scroll="handleScroll">滚动节流</div>
- *   <div v-throttle:100.scroll="handleScroll">100ms 滚动节流</div>
+ *   <button v-throttle="handleClick">Throttled Button</button>
+ *   <button v-throttle:1s="handleClick">1s Throttled</button>
+ *   <div v-throttle.scroll="handleScroll">Scroll Throttle</div>
+ *   <div v-throttle:100.scroll="handleScroll">100ms Scroll Throttle</div>
  * </template>
  * ```
  */
@@ -545,7 +545,7 @@ export { vThrottle as throttle }
 export { vThrottle }
 
 /**
- * Vue 2 指令钩子
+ * Vue 2 directive hooks
  */
 export declare interface Vue2DirectiveHooks {
     bind?: (el: any, binding: any, vnode: any, oldVnode: any) => void;
@@ -556,7 +556,7 @@ export declare interface Vue2DirectiveHooks {
 }
 
 /**
- * Vue 3 指令钩子
+ * Vue 3 directive hooks
  */
 export declare interface Vue3DirectiveHooks {
     created?: (el: any, binding: any, vnode: any, prevVnode: any) => void;