@pixelium/web-vue 0.0.3 → 0.0.5

package/es/scroll-bar/index.d.ts

@@ -0,0 +1,40 @@
+import type { ScrollBarExpose, ScrollBarProps } from './type';
+import type { OverlayScrollbars } from 'overlayscrollbars';
+declare var __VLS_9: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ScrollBarProps, ScrollBarExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    scroll: (event: Event) => any;
+    "update:scrollOffset": (value: {
+        left: number;
+        top: number;
+    }) => any;
+    initialize: (instance: OverlayScrollbars) => any;
+    update: (offset: {
+        left: number;
+        top: number;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<ScrollBarProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+    "onUpdate:scrollOffset"?: ((value: {
+        left: number;
+        top: number;
+    }) => any) | undefined;
+    onInitialize?: ((instance: OverlayScrollbars) => any) | undefined;
+    onUpdate?: ((offset: {
+        left: number;
+        top: number;
+    }) => any) | undefined;
+}>, {
+    variant: "pixel" | "simple";
+    showScrollPadding: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/scroll-bar/type.d.ts

@@ -0,0 +1,85 @@
+import type { OverlayScrollbars } from 'overlayscrollbars';
+export type ScrollBarProps = {
+    /**
+     * @property {{ left?: number; top?: number } | null} [scrollOffset]
+     * @version 0.1.0
+     */
+    scrollOffset?: {
+        left?: number;
+        top?: number;
+    } | null;
+    /**
+     * @property {{ left?: number; top?: number } | null} [defaultScrollOffset]
+     * @version 0.1.0
+     */
+    defaultScrollOffset?: {
+        left?: number;
+        top?: number;
+    } | null;
+    /**
+     * @property {'pixel' | 'simple'} [variant='pixel']
+     * @version 0.1.0
+     */
+    variant?: 'pixel' | 'simple';
+    /**
+     * @property {boolean} [showScrollPadding=true]
+     * @version 0.1.0
+     */
+    showScrollPadding?: boolean;
+};
+export type ScrollBarEvents = {
+    /**
+     * @event update:scrollOffset
+     * @param {{ left: number; top: number }} value
+     * @version 0.1.0
+     */
+    'update:scrollOffset': [value: {
+        left: number;
+        top: number;
+    }];
+    /**
+     * @event initialize
+     * @param {OverlayScrollbars} instance
+     * @version 0.1.0
+     */
+    initialize: [instance: OverlayScrollbars];
+    /**
+     * @event update
+     * @version 0.1.0
+     */
+    update: [offset: {
+        left: number;
+        top: number;
+    }];
+    /**
+     * @event scroll
+     * @param {Event} event
+     * @version 0.1.0
+     */
+    scroll: [event: Event];
+};
+export type ScrollBarSlots = {
+    /**
+     * @slot default
+     * @version 0.1.0
+     */
+    default: {};
+};
+export type ScrollBarExpose = {
+    /**
+     * @property {{ (options?: ScrollToOptions): void; (x: number, y: number): void }} scrollTo
+     * @version 0.1.0
+     */
+    scrollTo: {
+        (options?: ScrollToOptions): void;
+        (x: number, y: number): void;
+    };
+    /**
+     * @property {{ (options?: ScrollToOptions): void; (x: number, y: number): void }} scrollBy
+     * @version 0.1.0
+     */
+    scrollBy: {
+        (options?: ScrollToOptions): void;
+        (x: number, y: number): void;
+    };
+};

package/es/scroll-bar/use-scroll-bar.d.ts

@@ -0,0 +1 @@
+export declare const useScrollBar: (variant?: "pixel" | "simple") => readonly [import("overlayscrollbars-vue").UseOverlayScrollbarsInitialization, import("overlayscrollbars-vue").UseOverlayScrollbarsInstance, import("vue").Ref<boolean, boolean>];

package/es/select/index.css

@@ -134,8 +134,7 @@
   flex-shrink: 0;
 }
 .px-select-inner:focus-visible {
-  outline-color: var(--px-neutral-10);
-  outline-offset: var(--px-bit);
+  outline: none;
 }
 .px-select-label,
 .px-select-content,
@@ -173,7 +172,7 @@
   --select-size: var(--px-large-size);
 }
 .px-select__small {
-  --input-size: var(--px-small-size);
+  --select-size: var(--px-small-size);
 }
 .px-select__small .px-select-content .px-tag {
   margin-top: 0px;

package/es/select/index.d.ts

@@ -1,5 +1,5 @@
 import type { SelectExpose, SelectGroupOption, SelectOption, SelectProps } from './type';
-declare const _default: import("vue").DefineComponent<SelectProps, SelectExpose & {
+declare const __VLS_export: import("vue").DefineComponent<SelectProps, SelectExpose & {
     getElementRendered: () => HTMLDivElement | null;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     clear: (value: any) => any;
@@ -39,4 +39,5 @@ declare const _default: import("vue").DefineComponent<SelectProps, SelectExpose
     optionsDestroyOnHide: boolean;
     filterable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/es/share/hook/use-expand.d.ts

@@ -0,0 +1,2 @@
+import { type ComputedRef, type Ref, type ShallowRef } from 'vue';
+export declare const useExpand: (wrapperRef: ShallowRef<HTMLElement | null>, expandedRef: Ref<boolean | undefined> | ComputedRef<boolean | undefined>, foldDelay: number) => readonly [ComputedRef<boolean>, ComputedRef<string>];

package/es/share/hook/use-hidden-measure.d.ts

@@ -0,0 +1 @@
+export declare const useHiddenMeasure: (key: string) => () => HTMLDivElement | undefined;

package/es/share/hook/use-pixel-size.d.ts

@@ -0,0 +1 @@
+export declare const usePixelSize: () => Readonly<import("vue").Ref<number, number>>;

package/es/share/util/locale.d.ts

@@ -12,6 +12,14 @@ declare const _default: {
 		errorTitle: string;
 		confirmTitle: string;
 	};
+	popconfirm: {
+		confirm: string;
+		cancel: string;
+	};
+	table: {
+		filterReset: string;
+		filterConfirm: string;
+	};
 };
 export type DeepPartial<T> = {
 	[K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];

package/es/share/util/scroll.d.ts

@@ -0,0 +1,2 @@
+import 'overlayscrollbars/overlayscrollbars.css';
+export declare const initScroll: () => void;

package/es/slider/index.d.ts

@@ -2,35 +2,35 @@ import type { SliderProps } from './type';
 declare var __VLS_1: {
     value: number;
     label: string | undefined;
-}, __VLS_7: {}, __VLS_10: {
+}, __VLS_9: {}, __VLS_12: {
     value: number | null | undefined;
-}, __VLS_12: {}, __VLS_18: {}, __VLS_21: {
+}, __VLS_14: {}, __VLS_22: {}, __VLS_25: {
     value: number | null | undefined;
-}, __VLS_23: {}, __VLS_29: {}, __VLS_32: {
+}, __VLS_27: {}, __VLS_35: {}, __VLS_38: {
     value: number | null | undefined;
-}, __VLS_34: {};
+}, __VLS_40: {};
 type __VLS_Slots = {} & {
     mark?: (props: typeof __VLS_1) => any;
 } & {
-    thumb?: (props: typeof __VLS_7) => any;
+    thumb?: (props: typeof __VLS_9) => any;
 } & {
-    'tooltip-content'?: (props: typeof __VLS_10) => any;
+    'tooltip-content'?: (props: typeof __VLS_12) => any;
 } & {
-    thumb?: (props: typeof __VLS_12) => any;
+    thumb?: (props: typeof __VLS_14) => any;
 } & {
-    'thumb-start'?: (props: typeof __VLS_18) => any;
+    'thumb-start'?: (props: typeof __VLS_22) => any;
 } & {
-    'tooltip-content'?: (props: typeof __VLS_21) => any;
+    'tooltip-content'?: (props: typeof __VLS_25) => any;
 } & {
-    'thumb-start'?: (props: typeof __VLS_23) => any;
+    'thumb-start'?: (props: typeof __VLS_27) => any;
 } & {
-    'thumb-end'?: (props: typeof __VLS_29) => any;
+    'thumb-end'?: (props: typeof __VLS_35) => any;
 } & {
-    'tooltip-content'?: (props: typeof __VLS_32) => any;
+    'tooltip-content'?: (props: typeof __VLS_38) => any;
 } & {
-    'thumb-end'?: (props: typeof __VLS_34) => any;
+    'thumb-end'?: (props: typeof __VLS_40) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<SliderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<SliderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (value: number | [number, number]) => any;
     blur: (event: FocusEvent) => any;
     focus: (event: FocusEvent) => any;
@@ -57,7 +57,8 @@ declare const __VLS_component: import("vue").DefineComponent<SliderProps, {}, {}
     precision: number | null;
     tooltip: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/es/space/index.d.ts

@@ -1,5 +1,5 @@
 import type { SpaceProps } from './type';
-declare const _default: import("vue").DefineComponent<SpaceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaceProps> & Readonly<{}>, {
+declare const __VLS_export: import("vue").DefineComponent<SpaceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpaceProps> & Readonly<{}>, {
     justify: "start" | "center" | "end" | "space-around" | "space-between" | "space-evenly";
     wrap: boolean;
     direction: "horizontal" | "vertical";
@@ -9,4 +9,5 @@ declare const _default: import("vue").DefineComponent<SpaceProps, {}, {}, {}, {}
     };
     inline: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/es/spin/index.d.ts

@@ -1,13 +1,13 @@
 import type { SpinProps } from './type';
-declare var __VLS_1: {}, __VLS_7: {}, __VLS_14: {};
+declare var __VLS_1: {}, __VLS_8: {}, __VLS_15: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
 } & {
-    icon?: (props: typeof __VLS_7) => any;
+    icon?: (props: typeof __VLS_8) => any;
 } & {
-    description?: (props: typeof __VLS_14) => any;
+    description?: (props: typeof __VLS_15) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<SpinProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpinProps> & Readonly<{}>, {
+declare const __VLS_base: import("vue").DefineComponent<SpinProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SpinProps> & Readonly<{}>, {
     size: "medium" | "large" | "small" | number;
     loading: boolean;
     zIndex: number;
@@ -15,7 +15,8 @@ declare const __VLS_component: import("vue").DefineComponent<SpinProps, {}, {},
     maskLineWidth: number;
     maskGrid: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/es/submenu/index.d.ts

@@ -0,0 +1,28 @@
+import type { SubmenuProps } from './type';
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_10: {}, __VLS_18: {}, __VLS_20: {}, __VLS_28: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    label?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    icon?: (props: typeof __VLS_18) => any;
+} & {
+    label?: (props: typeof __VLS_20) => any;
+} & {
+    default?: (props: typeof __VLS_28) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SubmenuProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SubmenuProps> & Readonly<{}>, {
+    disabled: boolean;
+    mode: "inline" | "popover";
+    trigger: "hover" | "click";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/submenu/type.d.ts

@@ -0,0 +1,60 @@
+import type { ComputedRef } from 'vue';
+import type { PopoverProps, PopoverEvents } from '../popover/type';
+import type { EmitEvent } from '../share/type';
+export type SubmenuProps = {
+    /**
+     * @property {string} [label]
+     * @version 0.1.0
+     */
+    label?: string;
+    /**
+     * @property {number | string | symbol} index
+     * @version 0.1.0
+     */
+    index: number | string | symbol;
+    /**
+     * @property {boolean} [disabled=false]
+     * @version 0.1.0
+     */
+    disabled?: boolean;
+    /**
+     * @property {boolean} [mode]
+     * @version 0.1.0
+     */
+    mode?: 'inline' | 'popover';
+    /**
+     * @property {boolean} [trigger]
+     * @version 0.1.0
+     */
+    trigger?: 'hover' | 'click';
+    /**
+     * @property {Omit<PopoverProps, 'visible' | 'defaultVisible' | 'content'> & EmitEvent<PopoverEvents>} [popoverProps]
+     * @version 0.1.0
+     */
+    popoverProps?: Omit<PopoverProps, 'visible' | 'defaultVisible' | 'content'> & EmitEvent<PopoverEvents>;
+};
+export type SubmenuSlots = {
+    /**
+     * @slot default
+     * @version 0.1.0
+     */
+    default: {};
+    /**
+     * @slot label
+     * @version 0.1.0
+     */
+    label: {};
+    /**
+     * @slot icon
+     * @version 0.1.0
+     */
+    icon: {};
+};
+export type SubmenuProvide = {
+    mode: ComputedRef<SubmenuProps['mode']>;
+    trigger: ComputedRef<SubmenuProps['trigger']>;
+    disabled: ComputedRef<boolean | undefined>;
+    setActive: (status: boolean, id: string) => void;
+    removeActive: (id: string) => void;
+    triggerUpdate: () => void;
+};

package/es/switch/index.d.ts

@@ -13,7 +13,7 @@ type __VLS_Slots = {} & {
 } & {
     'active-label'?: (props: typeof __VLS_16) => any;
 };
-declare const __VLS_component: import("vue").DefineComponent<SwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<SwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (value: boolean, event: Event) => any;
     blur: (event: FocusEvent) => any;
     input: (value: boolean, event: InputEvent) => any;
@@ -33,7 +33,8 @@ declare const __VLS_component: import("vue").DefineComponent<SwitchProps, {}, {}
     modelValue: boolean | null;
     defaultValue: boolean | null;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/es/table/index.d.ts

@@ -0,0 +1,68 @@
+import type { TableData, TableExpose, TableProps } from './type';
+declare const __VLS_export: import("vue").DefineComponent<TableProps, TableExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (value: boolean, key: any, record: TableData, event: InputEvent) => any;
+    expand: (value: boolean, key: any, record: TableData, event: MouseEvent) => any;
+    selectAll: (value: boolean, event: InputEvent) => any;
+    "update:selectedKeys": (value: any[]) => any;
+    selectedChange: (value: any[]) => any;
+    expandedChange: (value: any[]) => any;
+    "update:expandedKeys": (value: any[]) => any;
+    "update:filterValue": (value: import("./type").FilterValue) => any;
+    filterSelect: (value: any[], key: string | number | symbol, option: string | import("./type").TableFilterOption<any>, column: import("./type").TableColumn, event: InputEvent) => any;
+    filterChange: (value: import("./type").FilterValue) => any;
+    filterReset: (key: string | number | symbol, event: MouseEvent) => any;
+    filterConfirm: (key: string | number | symbol, event: MouseEvent) => any;
+    "update:sortOrder": (value: import("./type").SortOrder) => any;
+    sortSelect: (value: "desc" | "none" | "asc", key: string | number | symbol, column: import("./type").TableColumn, event: MouseEvent) => any;
+    sortOrderChange: (value: import("./type").SortOrder) => any;
+    cellMouseenter: (column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any;
+    cellMouseleave: (column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any;
+    cellClick: (column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any;
+    rowClick: (record: TableData, rowIndex: number, event: MouseEvent) => any;
+    headCellClick: (column: import("./type").TableColumn, indexPath: number[], event: MouseEvent) => any;
+    cellDblclick: (column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any;
+    rowDblclick: (record: TableData, rowIndex: number, event: MouseEvent) => any;
+    headCellDblclick: (column: import("./type").TableColumn, indexPath: number[], event: MouseEvent) => any;
+    cellContextmenu: (column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any;
+    rowContextmenu: (record: TableData, rowIndex: number, event: MouseEvent) => any;
+    headCellContextmenu: (column: import("./type").TableColumn, indexPath: number[], event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<TableProps> & Readonly<{
+    onSelect?: ((value: boolean, key: any, record: TableData, event: InputEvent) => any) | undefined;
+    onExpand?: ((value: boolean, key: any, record: TableData, event: MouseEvent) => any) | undefined;
+    onSelectAll?: ((value: boolean, event: InputEvent) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((value: any[]) => any) | undefined;
+    onSelectedChange?: ((value: any[]) => any) | undefined;
+    onExpandedChange?: ((value: any[]) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((value: any[]) => any) | undefined;
+    "onUpdate:filterValue"?: ((value: import("./type").FilterValue) => any) | undefined;
+    onFilterSelect?: ((value: any[], key: string | number | symbol, option: string | import("./type").TableFilterOption<any>, column: import("./type").TableColumn, event: InputEvent) => any) | undefined;
+    onFilterChange?: ((value: import("./type").FilterValue) => any) | undefined;
+    onFilterReset?: ((key: string | number | symbol, event: MouseEvent) => any) | undefined;
+    onFilterConfirm?: ((key: string | number | symbol, event: MouseEvent) => any) | undefined;
+    "onUpdate:sortOrder"?: ((value: import("./type").SortOrder) => any) | undefined;
+    onSortSelect?: ((value: "desc" | "none" | "asc", key: string | number | symbol, column: import("./type").TableColumn, event: MouseEvent) => any) | undefined;
+    onSortOrderChange?: ((value: import("./type").SortOrder) => any) | undefined;
+    onCellMouseenter?: ((column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onCellMouseleave?: ((column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onCellClick?: ((column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onRowClick?: ((record: TableData, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onHeadCellClick?: ((column: import("./type").TableColumn, indexPath: number[], event: MouseEvent) => any) | undefined;
+    onCellDblclick?: ((column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onRowDblclick?: ((record: TableData, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onHeadCellDblclick?: ((column: import("./type").TableColumn, indexPath: number[], event: MouseEvent) => any) | undefined;
+    onCellContextmenu?: ((column: import("./type").TableColumn, record: TableData, colIndex: number, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onRowContextmenu?: ((record: TableData, rowIndex: number, event: MouseEvent) => any) | undefined;
+    onHeadCellContextmenu?: ((column: import("./type").TableColumn, indexPath: number[], event: MouseEvent) => any) | undefined;
+}>, {
+    variant: "normal" | "striped" | "checkered";
+    pollSizeChange: boolean;
+    data: TableData[];
+    bordered: boolean | import("./type").TableBordered;
+    columns: import("./type").TableColumn[];
+    fixedHead: boolean;
+    rowKey: string;
+    selection: boolean | import("./type").TableSelection;
+    expandable: boolean | import("./type").TableExpandable;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/es/table/module/cell-span.d.ts

@@ -0,0 +1,7 @@
+export declare class SpanCollector {
+    private spans;
+    private cellToSpanIndex;
+    constructor(totalRows: number, totalCols: number);
+    addSpan(startRow: number, startCol: number, colspan: number, rowspan: number): void;
+    isInSpan(row: number, col: number): boolean;
+}

package/es/table/module/column.d.ts

@@ -0,0 +1,46 @@
+import type { TableColumn, TableData, TableOptionsArg } from '../type';
+import type { SpanCollector } from './cell-span';
+export type HeaderCell = {
+    colspan: number;
+    rowspan: number;
+    depth: number;
+    isLeaf: boolean;
+    original: TableColumn;
+    fixed: 'none' | 'left' | 'right';
+    indexPath: number[];
+    presetWidth?: number;
+    presetMinWidth?: number;
+    left?: number;
+    right?: number;
+};
+export type BodyCell = {
+    original: TableColumn;
+    fixed: 'none' | 'left' | 'right';
+};
+export declare function buildHeaderRows(columns: TableColumn[]): {
+    columns: TableColumn[];
+    maxDepth: number;
+    headerRows: HeaderCell[][];
+    leafColumns: BodyCell[];
+};
+export declare const EMPTY_COL: {
+    key: symbol;
+};
+export type BodyCellWrapper = {
+    cell: BodyCell;
+    spanData: {
+        colspan?: number;
+        rowspan?: number;
+    };
+    originColIndex: number;
+    originRowIndex: number;
+    presetWidth?: number;
+    presetMinWidth?: number;
+    left?: number;
+    right?: number;
+};
+export declare const buildCommonRows: (cellDataArr: BodyCell[], data: TableData[], spanCollector: SpanCollector, spanMethod?: ({ rowIndex, colIndex, record, column }: TableOptionsArg) => void | {
+    colspan?: number;
+    rowspan?: number;
+} | null) => BodyCellWrapper[][];
+export declare const getMinWidthOfTable: (cellRow: BodyCell[]) => number;

package/es/table/module/draw.d.ts

@@ -0,0 +1,11 @@
+import { type ComputedRef, type Ref, type ShallowRef } from 'vue';
+import type { TableProps } from '../type';
+import type { LooseRequired } from '../../share/type';
+export declare const drawBorder: (ctx: CanvasRenderingContext2D, width: number, height: number, center: [number, number][], borderRadius: number[], rad: [number, number][], borderColor: string, pixelSize: number, hasBottom?: boolean) => void;
+export declare const useDrawPixel: (wrapperRef: ShallowRef<HTMLDivElement | null>, canvasRef: ShallowRef<HTMLCanvasElement | null>, pixelSize: Ref<number>, bordered: ComputedRef<{
+    table: boolean;
+    row: boolean;
+    col: boolean;
+    head: boolean;
+    side: boolean;
+}>, props: LooseRequired<TableProps>) => readonly [Ref<string, string>];

package/es/table/module/event.d.ts

@@ -0,0 +1,9 @@
+import type { ComputedRef, ShallowRef } from 'vue';
+import type { TableColumn, TableData } from '../type';
+import type { BodyCell, HeaderCell } from './column';
+export declare const useCellEvent: (tableRef: ShallowRef<HTMLTableElement | null>, columnsInfo: ComputedRef<{
+    columns: TableColumn[];
+    maxDepth: number;
+    headerRows: HeaderCell[][];
+    leafColumns: BodyCell[];
+}>, data: ComputedRef<TableData[]>, summary: ComputedRef<TableData[]>, emits: any) => readonly [(e: MouseEvent) => void, (e: MouseEvent) => void, (e: MouseEvent) => void, (e: MouseEvent) => void, (e: MouseEvent) => void];

package/es/table/module/expandable.d.ts

@@ -0,0 +1,20 @@
+import type { LooseRequired } from '../../share/type';
+import type { TableColumn, TableData, TableExpandable, TableProps } from '../type';
+export declare const useExpandable: (props: LooseRequired<TableProps>, emits: ((evt: "expand", value: boolean, key: any, record: TableData, event: MouseEvent) => void) & ((evt: "expandedChange", value: any[]) => void) & ((evt: "update:expandedKeys", value: any[]) => void), slots: Record<string, Function | undefined>) => readonly [import("vue").Ref<any[] | import("parsnip-kit").Nullish, any[] | import("parsnip-kit").Nullish>, (expandable: TableExpandable, columns: TableColumn[]) => {
+    key: symbol;
+    width: number;
+    minWidth: number | undefined;
+    fixed: "left" | "none";
+    contentProps: {
+        [x: string]: unknown;
+    };
+    labelContentProps: {
+        [x: string]: unknown;
+    };
+    cellProps: import("../..").RestAttrs | undefined;
+    labelCellProps: import("../..").RestAttrs | undefined;
+    render: ({ record }: {
+        record: TableData;
+    }) => import("vue/jsx-runtime").JSX.Element | null;
+    label: string;
+}, import("vue").ComputedRef<TableExpandable>];

package/es/table/module/filterable.d.ts

@@ -0,0 +1,9 @@
+import { type ComputedRef } from 'vue';
+import type { LooseRequired } from '../../share/type';
+import type { FilterValue, TableColumn, TableData, TableFilterable, TableFilterOption, TableProps } from '../type';
+import type { HeaderCell, BodyCell } from './column';
+export declare const useFilterable: (columnsInfo: ComputedRef<{
+    maxDepth: number;
+    headerRows: HeaderCell[][];
+    leafColumns: BodyCell[];
+}>, props: LooseRequired<TableProps>, emits: ((evt: "update:filterValue", value: FilterValue) => void) & ((evt: "filterSelect", value: any, key: string | number | symbol, option: TableFilterOption | string, column: TableColumn, event: InputEvent) => void) & ((evt: "filterChange", value: FilterValue) => void) & ((evt: "filterReset", key: string | number | symbol, event: MouseEvent) => void) & ((evt: "filterConfirm", key: string | number | symbol, event: MouseEvent) => void)) => readonly [import("vue").Ref<import("parsnip-kit").Nullish | FilterValue, import("parsnip-kit").Nullish | FilterValue>, (rows: TableData[]) => TableData[], (filterable: TableFilterable, column: TableColumn) => import("vue/jsx-runtime").JSX.Element | null];

package/es/table/module/selection.d.ts

@@ -0,0 +1,20 @@
+import type { LooseRequired } from '../../share/type';
+import type { TableColumn, TableData, TableProps, TableSelection } from '../type';
+export declare const useSelection: (props: LooseRequired<TableProps>, emits: ((evt: "select", value: boolean, key: any, record: TableData, event: InputEvent) => void) & ((evt: "selectAll", value: boolean, event: InputEvent) => void) & ((evt: "update:selectedKeys", value: any[]) => void) & ((evt: "selectedChange", value: any[]) => void)) => readonly [import("vue").Ref<any[] | import("parsnip-kit").Nullish, any[] | import("parsnip-kit").Nullish>, (selection: TableSelection, columns: TableColumn[]) => {
+    key: symbol;
+    width: number;
+    minWidth: number | undefined;
+    fixed: "left" | "none";
+    contentProps: {
+        [x: string]: unknown;
+    };
+    labelContentProps: {
+        [x: string]: unknown;
+    };
+    cellProps: import("../../index.ts").RestAttrs | undefined;
+    labelCellProps: import("../../index.ts").RestAttrs | undefined;
+    render: ({ record }: {
+        record: TableData;
+    }) => import("vue/jsx-runtime").JSX.Element;
+    labelRender: () => string | import("vue/jsx-runtime").JSX.Element;
+}, import("vue").ComputedRef<TableSelection>];

package/es/table/module/share.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_ADDITION_COL_WIDTH = 48;
+export declare const DEFAULT_ROW_KEY = "key";
+export declare const TABLE_SELECTION_COL_SYMBOL: unique symbol;
+export declare const TABLE_EXPANDABLE_COL_SYMBOL: unique symbol;
+export declare const TABLE_EMPTY_COL_SYMBOL: unique symbol;
+export declare const TABLE_SUMMARY_ROW_SYMBOL: unique symbol;
+export declare const DEFAULT_WIDTH = 80;
+export declare const DEFAULT_MIN_WIDTH = 0;

package/es/table/module/sortable.d.ts

@@ -0,0 +1,10 @@
+import { type ComputedRef } from 'vue';
+import type { LooseRequired } from '../../share/type';
+import type { SortOrder, TableColumn, TableData, TableProps, TableSortable } from '../type';
+import type { BodyCell, HeaderCell } from './column';
+export declare const useSortable: (columnsInfo: ComputedRef<{
+    maxDepth: number;
+    headerRows: HeaderCell[][];
+    leafColumns: BodyCell[];
+}>, props: LooseRequired<TableProps>, emits: ((evt: "update:sortOrder", value: SortOrder) => void) & ((evt: "sortSelect", value: "asc" | "desc" | "none", key: string | number | symbol, column: TableColumn, event: MouseEvent) => void) & ((evt: "sortOrderChange", value: SortOrder) => void)) => readonly [import("vue").Ref<import("parsnip-kit").Nullish | SortOrder, import("parsnip-kit").Nullish | SortOrder>, (rows: TableData[]) => TableData[], (sortable: TableSortable, column: TableColumn) => import("vue/jsx-runtime").JSX.Element | null];
+export declare const defaultComparator: (a: TableData, b: TableData, order: "asc" | "desc", field?: string) => number;

package/es/table/module/summary.d.ts

@@ -0,0 +1,2 @@
+import type { TableSummary } from '../type';
+export declare const useSummary: () => (summary: TableSummary) => import("../type").TableData[];