@expcat/tigercat-vue 1.4.0 → 2.0.0-preview.1

package/dist/components/TreeSelect.d.mts

@@ -1,6 +1,6 @@
 import * as vue from 'vue';
 import { PropType } from 'vue';
-import { TreeSelectValue, TreeNode, TreeSelectSize, TigerLocale } from '@expcat/tigercat-core';
+import { TreeSelectValue, TreeNode, ComponentSize, TigerLocale } from '@expcat/tigercat-core';
 
 type VueTreeSelectProps = InstanceType<typeof TreeSelect>['$props'];
 declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
@@ -17,7 +17,7 @@ declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
         default: string;
     };
     size: {
-        type: PropType<TreeSelectSize>;
+        type: PropType<ComponentSize>;
         default: string;
     };
     disabled: {
@@ -32,11 +32,19 @@ declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
         type: BooleanConstructor;
         default: boolean;
     };
-    showSearch: {
+    searchable: {
         type: BooleanConstructor;
         default: boolean;
     };
-    notFoundText: {
+    searchValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultSearchValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    emptyText: {
         type: StringConstructor;
         default: undefined;
     };
@@ -53,7 +61,7 @@ declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:modelValue" | "update:searchValue" | "search-change")[], "change" | "update:modelValue" | "update:searchValue" | "search-change", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     modelValue: {
         type: PropType<TreeSelectValue>;
         default: undefined;
@@ -67,7 +75,7 @@ declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
         default: string;
     };
     size: {
-        type: PropType<TreeSelectSize>;
+        type: PropType<ComponentSize>;
         default: string;
     };
     disabled: {
@@ -82,11 +90,19 @@ declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
         type: BooleanConstructor;
         default: boolean;
     };
-    showSearch: {
+    searchable: {
         type: BooleanConstructor;
         default: boolean;
     };
-    notFoundText: {
+    searchValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultSearchValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    emptyText: {
         type: StringConstructor;
         default: undefined;
     };
@@ -104,16 +120,20 @@ declare const TreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
 }>> & Readonly<{
     onChange?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:searchValue"?: ((...args: any[]) => any) | undefined;
+    "onSearch-change"?: ((...args: any[]) => any) | undefined;
 }>, {
     locale: Partial<TigerLocale>;
-    size: TreeSelectSize;
+    emptyText: string;
+    size: ComponentSize;
     disabled: boolean;
-    multiple: boolean;
     modelValue: TreeSelectValue;
+    searchable: boolean;
+    multiple: boolean;
     placeholder: string;
+    searchValue: string;
+    defaultSearchValue: string;
     clearable: boolean;
-    showSearch: boolean;
-    notFoundText: string;
     treeData: TreeNode[];
     defaultExpandAll: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

package/dist/components/TreeSelect.mjs

@@ -1,7 +1,7 @@
 import {
   TreeSelect,
   TreeSelect_default
-} from "../chunk-XJ5VGC5V.mjs";
+} from "../chunk-YJSWHGAR.mjs";
 import "../chunk-R6WFL6NI.mjs";
 export {
   TreeSelect,

package/dist/components/Upload.d.mts

@@ -324,9 +324,9 @@ declare const Upload: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{
+    onError?: ((error: Error, _file: UploadFile) => any) | undefined;
     onProgress?: ((progress: number, _file: UploadFile) => any) | undefined;
     onChange?: ((_file: UploadFile, _fileList: UploadFile[]) => any) | undefined;
-    onError?: ((error: Error, _file: UploadFile) => any) | undefined;
     onSuccess?: ((_response: unknown, _file: UploadFile) => any) | undefined;
     "onUpdate:file-list"?: ((files: UploadFile[]) => any) | undefined;
     onRemove?: ((_file: UploadFile, _fileList: UploadFile[]) => any) | undefined;

package/dist/components/Upload.mjs

@@ -1,7 +1,7 @@
 import {
   Upload,
   Upload_default
-} from "../chunk-QKP5C26H.mjs";
+} from "../chunk-CW5TEG7N.mjs";
 import "../chunk-R6WFL6NI.mjs";
 export {
   Upload,

package/dist/components/VirtualList.d.mts

@@ -32,6 +32,11 @@ declare const VirtualList: vue.DefineComponent<vue.ExtractPropTypes<{
         type: NumberConstructor;
         default: number;
     };
+    /** Custom class name (merged with the `class` attribute) */
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
 }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "scroll"[], "scroll", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
@@ -63,9 +68,15 @@ declare const VirtualList: vue.DefineComponent<vue.ExtractPropTypes<{
         type: NumberConstructor;
         default: number;
     };
+    /** Custom class name (merged with the `class` attribute) */
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
 }>> & Readonly<{
     onScroll?: ((...args: any[]) => any) | undefined;
 }>, {
+    className: string;
     height: number;
     itemCount: number;
     itemHeight: number;

package/dist/components/VirtualList.mjs

@@ -1,7 +1,7 @@
 import {
   VirtualList,
   VirtualList_default
-} from "../chunk-PENI3H3I.mjs";
+} from "../chunk-HS4YQGZQ.mjs";
 export {
   VirtualList,
   VirtualList_default as default

package/dist/components/VirtualTable.d.mts

@@ -1,25 +1,27 @@
 import * as vue from 'vue';
 import { PropType } from 'vue';
-import { TableColumn, TigerLocale } from '@expcat/tigercat-core';
+import { TableColumn, RowSelectionConfig, TigerLocale } from '@expcat/tigercat-core';
 
 interface VueVirtualTableProps {
-    data?: unknown[];
+    dataSource?: Record<string, unknown>[];
     columns?: TableColumn[];
-    rowHeight?: number;
-    height?: number;
+    virtualItemHeight?: number;
+    virtualHeight?: number;
+    width?: number | 'auto';
     overscan?: number;
     stickyHeader?: boolean;
+    virtualizeColumns?: boolean;
     rowKey?: string | ((row: unknown, index: number) => string | number);
+    rowClassName?: string | ((row: unknown, index: number) => string);
     loading?: boolean;
     emptyText?: string;
-    selectable?: boolean;
-    selectedKeys?: (string | number)[];
+    rowSelection?: RowSelectionConfig;
     striped?: boolean;
     bordered?: boolean;
     className?: string;
 }
 declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
-    data: {
+    dataSource: {
         type: PropType<Record<string, unknown>[]>;
         default: () => never[];
     };
@@ -27,14 +29,18 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TableColumn[]>;
         default: () => never[];
     };
-    rowHeight: {
+    virtualItemHeight: {
         type: NumberConstructor;
         default: number;
     };
-    height: {
+    virtualHeight: {
         type: NumberConstructor;
         default: number;
     };
+    width: {
+        type: PropType<number | "auto">;
+        default: string;
+    };
     overscan: {
         type: NumberConstructor;
         default: number;
@@ -43,10 +49,18 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         type: BooleanConstructor;
         default: boolean;
     };
+    virtualizeColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     rowKey: {
         type: PropType<string | ((row: unknown, index: number) => string | number)>;
         default: undefined;
     };
+    rowClassName: {
+        type: PropType<string | ((row: unknown, index: number) => string)>;
+        default: undefined;
+    };
     loading: {
         type: BooleanConstructor;
         default: boolean;
@@ -55,13 +69,9 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
-    selectable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    selectedKeys: {
-        type: PropType<(string | number)[]>;
-        default: () => never[];
+    rowSelection: {
+        type: PropType<RowSelectionConfig>;
+        default: undefined;
     };
     striped: {
         type: BooleanConstructor;
@@ -81,8 +91,8 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
     };
 }>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("select" | "row-click")[], "select" | "row-click", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    data: {
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("row-click" | "selection-change" | "update:rowSelection")[], "row-click" | "selection-change" | "update:rowSelection", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    dataSource: {
         type: PropType<Record<string, unknown>[]>;
         default: () => never[];
     };
@@ -90,14 +100,18 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         type: PropType<TableColumn[]>;
         default: () => never[];
     };
-    rowHeight: {
+    virtualItemHeight: {
         type: NumberConstructor;
         default: number;
     };
-    height: {
+    virtualHeight: {
         type: NumberConstructor;
         default: number;
     };
+    width: {
+        type: PropType<number | "auto">;
+        default: string;
+    };
     overscan: {
         type: NumberConstructor;
         default: number;
@@ -106,10 +120,18 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         type: BooleanConstructor;
         default: boolean;
     };
+    virtualizeColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     rowKey: {
         type: PropType<string | ((row: unknown, index: number) => string | number)>;
         default: undefined;
     };
+    rowClassName: {
+        type: PropType<string | ((row: unknown, index: number) => string)>;
+        default: undefined;
+    };
     loading: {
         type: BooleanConstructor;
         default: boolean;
@@ -118,13 +140,9 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         type: StringConstructor;
         default: undefined;
     };
-    selectable: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    selectedKeys: {
-        type: PropType<(string | number)[]>;
-        default: () => never[];
+    rowSelection: {
+        type: PropType<RowSelectionConfig>;
+        default: undefined;
     };
     striped: {
         type: BooleanConstructor;
@@ -143,24 +161,27 @@ declare const VirtualTable: vue.DefineComponent<vue.ExtractPropTypes<{
         default: undefined;
     };
 }>> & Readonly<{
-    onSelect?: ((...args: any[]) => any) | undefined;
+    "onSelection-change"?: ((...args: any[]) => any) | undefined;
     "onRow-click"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:rowSelection"?: ((...args: any[]) => any) | undefined;
 }>, {
     locale: Partial<TigerLocale>;
     emptyText: string;
     className: string;
-    data: Record<string, unknown>[];
     loading: boolean;
-    height: number;
+    width: number | "auto";
+    dataSource: Record<string, unknown>[];
     columns: TableColumn<Record<string, unknown>>[];
     bordered: boolean;
     striped: boolean;
+    rowSelection: RowSelectionConfig<Record<string, unknown>>;
     rowKey: string | ((row: unknown, index: number) => string | number);
+    rowClassName: string | ((row: unknown, index: number) => string);
     stickyHeader: boolean;
+    virtualHeight: number;
+    virtualItemHeight: number;
     overscan: number;
-    selectedKeys: (string | number)[];
-    selectable: boolean;
-    rowHeight: number;
+    virtualizeColumns: boolean;
 }, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 export { VirtualTable, type VueVirtualTableProps, VirtualTable as default };

package/dist/components/VirtualTable.mjs

@@ -1,7 +1,7 @@
 import {
   VirtualTable,
   VirtualTable_default
-} from "../chunk-3UQECWNL.mjs";
+} from "../chunk-4ZKSTL5P.mjs";
 import "../chunk-R6WFL6NI.mjs";
 export {
   VirtualTable,

package/dist/composables/useChartInteraction.d.mts

@@ -0,0 +1,84 @@
+import { Ref, ComputedRef } from 'vue';
+import { ChartLegendPosition, ChartLegendItem } from '@expcat/tigercat-core';
+
+/**
+ * Options for useChartInteraction composable
+ */
+interface UseChartInteractionOptions<T = unknown> {
+    /** Enable hover highlight */
+    hoverable: boolean | Ref<boolean>;
+    /** Getter for controlled hovered index from props (e.g. () => props.hoveredIndex) */
+    hoveredIndexProp?: () => number | null | undefined;
+    /** Enable click selection */
+    selectable: boolean | Ref<boolean>;
+    /** Getter for controlled selected index from props (e.g. () => props.selectedIndex) */
+    selectedIndexProp?: () => number | null | undefined;
+    /** Opacity for active element */
+    activeOpacity: number | Ref<number>;
+    /** Opacity for inactive elements */
+    inactiveOpacity: number | Ref<number>;
+    /** Legend position for wrapper classes */
+    legendPosition?: ChartLegendPosition | Ref<ChartLegendPosition | undefined>;
+    /** Emit function from setup context */
+    emit: (event: string, ...args: unknown[]) => void;
+    /** Get data item by index */
+    getData?: (index: number) => T | undefined;
+    /** Custom event names */
+    eventNames?: {
+        hover?: string;
+        click?: string;
+    };
+}
+/**
+ * Return type for useChartInteraction
+ */
+interface UseChartInteractionReturn {
+    /** Local hovered index state */
+    localHoveredIndex: Ref<number | null>;
+    /** Local selected index state */
+    localSelectedIndex: Ref<number | null>;
+    /** Tooltip position state */
+    tooltipPosition: Ref<{
+        x: number;
+        y: number;
+    }>;
+    /** Resolved hovered index (controlled or uncontrolled) */
+    resolvedHoveredIndex: ComputedRef<number | null>;
+    /** Resolved selected index (controlled or uncontrolled) */
+    resolvedSelectedIndex: ComputedRef<number | null>;
+    /** Current active index for highlighting */
+    activeIndex: ComputedRef<number | null>;
+    /** Get element opacity based on active state */
+    getElementOpacity: (index: number) => number | undefined;
+    /** Handle mouse enter on chart element */
+    handleMouseEnter: (index: number, event: MouseEvent) => void;
+    /** Handle mouse move for tooltip */
+    handleMouseMove: (event: MouseEvent) => void;
+    /** Handle mouse leave */
+    handleMouseLeave: () => void;
+    /** Handle click on chart element */
+    handleClick: (index: number) => void;
+    /** Handle keydown for accessibility */
+    handleKeyDown: (event: KeyboardEvent, index: number) => void;
+    /** Handle legend item click */
+    handleLegendClick: (index: number) => void;
+    /** Handle legend item hover */
+    handleLegendHover: (index: number) => void;
+    /** Handle legend item leave */
+    handleLegendLeave: () => void;
+    /** Wrapper classes for legend layout */
+    wrapperClasses: ComputedRef<string>;
+    /** Create legend items from data */
+    createLegendItems: (items: Array<{
+        label?: string;
+        color?: string;
+        x?: unknown;
+    }>, palette: string[], labelFormatter?: (item: unknown, index: number) => string) => ChartLegendItem[];
+}
+/**
+ * Composable for chart interaction state and handlers
+ * Extracts common interaction logic from high-level chart components
+ */
+declare function useChartInteraction<T = unknown>(options: UseChartInteractionOptions<T>): UseChartInteractionReturn;
+
+export { type UseChartInteractionOptions, type UseChartInteractionReturn, useChartInteraction };

package/dist/composables/useChartInteraction.mjs

@@ -0,0 +1,6 @@
+import {
+  useChartInteraction
+} from "../chunk-PE5OA4YG.mjs";
+export {
+  useChartInteraction
+};

package/dist/composables/useDrag.d.mts

@@ -0,0 +1,40 @@
+import { ComputedRef } from 'vue';
+import { DragCallbacks, DragConfig, DragState, DragItem, DragDropEvent, DragReorderResult, DragMoveResult } from '@expcat/tigercat-core';
+
+interface UseDragOptions extends DragCallbacks {
+    /** Drag configuration */
+    config?: DragConfig;
+    /** Container id (for cross-container scenarios) */
+    containerId?: string;
+}
+interface UseDragReturn {
+    /** Reactive drag state */
+    state: DragState;
+    /** Whether a drag is currently active */
+    isDragging: ComputedRef<boolean>;
+    /** The item currently being dragged */
+    draggedItem: ComputedRef<DragItem | null>;
+    /** Start a drag operation */
+    startDrag: (item: DragItem, event?: DragEvent) => void;
+    /** Handle drag over an item */
+    dragOver: (item: DragItem | null, event?: DragEvent) => void;
+    /** Handle drop */
+    drop: (event?: DragEvent) => DragDropEvent | null;
+    /** Cancel or end drag */
+    endDrag: (cancelled?: boolean) => void;
+    /** Reorder items in the current list */
+    reorder: <T extends DragItem>(items: readonly T[]) => DragReorderResult<T> | null;
+    /** Move item between two containers */
+    moveBetween: <T extends DragItem>(sourceItems: readonly T[], targetItems: readonly T[]) => DragMoveResult<T> | null;
+    /** Check if current drag is within same container */
+    isSameContainer: ComputedRef<boolean>;
+    /** Check if current drag crosses containers */
+    isCrossContainer: ComputedRef<boolean>;
+    /** HTML attribute bindings for a draggable item */
+    getDragItemAttrs: (item: DragItem) => Record<string, unknown>;
+    /** HTML attribute bindings for a drop zone */
+    getDropZoneAttrs: () => Record<string, unknown>;
+}
+declare function useDrag(options?: UseDragOptions): UseDragReturn;
+
+export { type UseDragOptions, type UseDragReturn, useDrag };

package/dist/composables/useDrag.mjs

@@ -0,0 +1,6 @@
+import {
+  useDrag
+} from "../chunk-KIPTVKU2.mjs";
+export {
+  useDrag
+};

package/dist/composables/useFormController.d.mts

@@ -0,0 +1,23 @@
+import { FormControllerOptions, FormController } from '@expcat/tigercat-core';
+
+/**
+ * Headless form controller composable.
+ *
+ * Returns a `FormController` with reactive `values` and `errors` that can
+ * be used independently of `<Form>`.
+ *
+ * @example
+ * ```ts
+ * const form = useFormController({
+ *   initialValues: { name: '', email: '' },
+ *   rules: { name: { required: true, message: '必填' } }
+ * })
+ *
+ * // In template: v-model bound to form.values.name
+ * // form.errorsByField.name for error display
+ * // form.validate() on submit
+ * ```
+ */
+declare function useFormController(options?: FormControllerOptions): FormController;
+
+export { useFormController };

package/dist/composables/useFormController.mjs

@@ -0,0 +1,6 @@
+import {
+  useFormController
+} from "../chunk-Y2HO4IBQ.mjs";
+export {
+  useFormController
+};