intable 0.0.1

package/dist/plugins/HistoryPlugin.d.ts

@@ -0,0 +1,10 @@
+import { useHistory } from '@/hooks';
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+    }
+    interface TableStore {
+        history: ReturnType<typeof useHistory>;
+    }
+}
+export declare const HistoryPlugin: Plugin;

package/dist/plugins/HistoryPlugin.js

@@ -0,0 +1,35 @@
+import { useHistory, useTinykeys } from "../hooks/index.js";
+import { createComponent } from "solid-js/web";
+import { createMemo } from "solid-js";
+import { unwrap } from "solid-js/store";
+import { combineProps } from "@solid-primitives/props";
+import { captureStoreUpdates } from "@solid-primitives/deep";
+const HistoryPlugin = {
+	store: (store) => {
+		const getDelta = createMemo(() => captureStoreUpdates(store.rawProps.data || []));
+		let clonedState;
+		return { history: useHistory([() => {
+			const delta = getDelta()();
+			if (!delta.length) return;
+			for (const { path, value } of delta) if (path.length == 0) clonedState = structuredClone(unwrap(value));
+			else {
+				const target = [...clonedState];
+				path.reduce((o, k, i) => o[k] = i < path.length - 1 ? Array.isArray(o[k]) ? [...o[k]] : { ...o[k] } : structuredClone(unwrap(value)), target);
+				clonedState = target;
+			}
+			return clonedState;
+		}, (v) => store.props.onDataChange?.(v)]) };
+	},
+	rewriteProps: {
+		Table: ({ Table }, { store }) => (o) => {
+			useTinykeys(() => store.table, {
+				"Control+Z": () => store.history.undo(),
+				"Control+Y": () => store.history.redo()
+			});
+			o = combineProps({ tabindex: -1 }, o);
+			return createComponent(Table, o);
+		},
+		tdProps: ({ tdProps }, { store }) => (o) => combineProps(tdProps?.(o) || {}, {})
+	}
+};
+export { HistoryPlugin };

package/dist/plugins/MenuPlugin.d.ts

@@ -0,0 +1,18 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+    }
+    interface TableStore {
+    }
+    interface Plugin {
+        menus?: (store: TableStore) => any[];
+    }
+    interface Commands {
+        rowEquals: (a: any, b: any) => boolean;
+        rowIndexOf: (data: any[], row: any) => number;
+        rowChange: (row: any, i?: any) => void;
+        addRows: (i: number, rows: any[], before?: boolean) => void;
+        deleteRows: (i: number[]) => void;
+    }
+}
+export declare const MenuPlugin: Plugin;

package/dist/plugins/MenuPlugin.js

@@ -0,0 +1,131 @@
+import { log } from "../utils.js";
+import { useMemoAsync } from "../hooks/index.js";
+import { Menu } from "../components/Menu.js";
+import { createComponent, memo, mergeProps } from "solid-js/web";
+import { batch, createMemo, createSignal, mapArray } from "solid-js";
+import { range, remove } from "es-toolkit";
+import { combineProps } from "@solid-primitives/props";
+import { createEventListener } from "@solid-primitives/event-listener";
+import { autoPlacement, computePosition } from "@floating-ui/dom";
+const MenuPlugin = {
+	store: (store) => ({}),
+	rewriteProps: { Table: ({ Table }, { store }) => (o) => {
+		const [menuEl, setMenuEl] = createSignal();
+		const _menus = mapArray(() => store.plugins || [], (plugin) => createMemo(() => plugin.menus?.(store)));
+		const menus = createMemo(() => _menus().flatMap((e) => e() || []));
+		const [pos, setPos] = createSignal();
+		function onContextMenu(e) {
+			e.preventDefault();
+			setPos({
+				x: e.x,
+				y: e.y
+			});
+		}
+		createEventListener(document, "pointerdown", (e) => {
+			menuEl()?.contains(e.target) || setPos();
+		});
+		const style$1 = useMemoAsync(() => {
+			const mel = menuEl();
+			if (!mel) return;
+			return computePosition({ getBoundingClientRect: () => DOMRect.fromRect(pos()) }, mel, {
+				strategy: "fixed",
+				placement: "top-start",
+				middleware: [autoPlacement({
+					boundary: document.body,
+					alignment: "start"
+				})]
+			}).then(({ x, y }) => ({
+				position: "fixed",
+				transform: `translate(${x}px, ${y}px)`,
+				top: 0,
+				left: 0,
+				"z-index": 10
+			}));
+		});
+		o = combineProps({
+			tabindex: -1,
+			onContextMenu
+		}, o);
+		return createComponent(Table, mergeProps(o, { get children() {
+			return [memo(() => memo(() => !!pos())() && createComponent(Menu, {
+				ref: setMenuEl,
+				get style() {
+					return style$1() || "position: absolute";
+				},
+				get items() {
+					return menus();
+				},
+				onAction: () => setPos()
+			})), memo(() => o.children)];
+		} }));
+	} },
+	menus: (store) => [
+		{
+			label: "新增行 ↑",
+			disabled: () => true,
+			cb: () => store.commands.addRows(store.selected.end[1], [store.props.newRow(store.selected.end[1])])
+		},
+		{
+			label: "新增行 ↓",
+			cb: () => store.commands.addRows(store.selected.end[1], [store.props.newRow(store.selected.end[1])], false)
+		},
+		{
+			label: "删除行",
+			cb: () => store.commands.deleteRows(range(...((e) => [e[0], e[1] + 1])([store.selected.start[1], store.selected.end[1]].sort((a, b) => a - b))))
+		}
+	],
+	commands: (store) => ({
+		rowEquals(a, b) {
+			return a == b;
+		},
+		rowIndexOf(data, row) {
+			return data.findIndex((e) => store.commands.rowEquals(e, row));
+		},
+		rowChange(row, i) {
+			const data = [...store.rawProps.data || []];
+			i = i != null ? data.findIndex((ee) => ee == store.props.data[i]) : store.commands.rowIndexOf(data, row);
+			if (i > -1) {
+				data[i] = row;
+				store.props.onDataChange?.(data);
+			}
+		},
+		addRows(i, rows, before = true) {
+			addRows(store, i, rows, before);
+		},
+		deleteRows(ii) {
+			const { rowKey, data } = store.props;
+			const val = [...store.rawProps.data || []];
+			const ids = new Set(ii.map((i) => data[i]));
+			log([...ids]);
+			remove(val, (e) => ids.has(e));
+			store.props?.onDataChange?.(val);
+		}
+	})
+};
+function addRows(store, i, rows, before) {
+	const { data } = store.props;
+	const prev = (i$1) => {
+		before = false;
+		while (--i$1 >= 0 && data[i$1]?.[store.internal]);
+		return i$1 >= 0 ? data[i$1] : null;
+	};
+	const next = (i$1) => {
+		before = true;
+		while (++i$1 < data.length && data[i$1]?.[store.internal]);
+		return i$1 < data.length ? data[i$1] : null;
+	};
+	const anchor = !data[i]?.[store.internal] ? data[i] : before ? prev(i) || next(i) : next(i) || prev(i);
+	if (anchor) batch(() => {
+		i = store.commands.rowIndexOf(data, anchor);
+		if (!store.selected) return;
+		store.selected.start = [0, i + (before ? 0 : 1)];
+		store.selected.end = [Infinity, i + rows.length - 1 + (before ? 0 : 1)];
+	});
+	(() => {
+		const data$1 = [...store.rawProps.data || []];
+		const i$1 = anchor ? store.commands.rowIndexOf(data$1, anchor) + (before ? 0 : 1) : data$1.length;
+		data$1.splice(i$1, 0, ...rows);
+		store.props?.onDataChange?.(data$1);
+	})();
+}
+export { MenuPlugin };

package/dist/plugins/RenderPlugin/components.d.ts

@@ -0,0 +1,5 @@
+export declare const Checkbox: import("solid-js").Component<Record<string, any>>;
+export declare const Files: import("solid-js").Component<Record<string, any>>;
+export declare const Tags: import("solid-js").Component<Record<string, any>>;
+export declare const Tag: import("solid-js").Component<Record<string, any>>;
+export declare const evaluateFormula: (formula: string, data: any) => any;

package/dist/plugins/RenderPlugin/components.js

@@ -0,0 +1,105 @@
+import plus_default from "../../plus.js";
+import x_default from "../../x.js";
+import { createComponent, insert, memo, mergeProps, spread, template } from "solid-js/web";
+import { For, splitProps } from "solid-js";
+import { combineProps } from "@solid-primitives/props";
+var _tmpl$ = /* @__PURE__ */ template(`<input type=checkbox>`), _tmpl$2 = /* @__PURE__ */ template(`<div>`);
+const Checkbox = (_props) => {
+	let props;
+	[_props, props] = splitProps(_props, ["value", "onChange"]);
+	props = combineProps({ get class() {
+		return `you-checkbox ${_props.value && "checked"}`;
+	} }, props);
+	return (() => {
+		var _el$ = _tmpl$();
+		_el$.addEventListener("change", (e) => _props.onChange?.(e.currentTarget.checked));
+		spread(_el$, mergeProps({ get checked() {
+			return _props.value || false;
+		} }, props), false, false);
+		return _el$;
+	})();
+};
+const Files = (_props2) => {
+	let props;
+	[_props2, props] = splitProps(_props2, []);
+	return createComponent(Tags, props);
+};
+const Tags = (_props3) => {
+	let props;
+	[_props3, props] = splitProps(_props3, [
+		"value",
+		"children",
+		"disabled",
+		"onChange",
+		"onAdd"
+	]);
+	props = combineProps({ class: "flex flex-wrap items-center gap-2 h-full" }, props);
+	const toarr = (v) => Array.isArray(v) ? v : v != null ? [v] : [];
+	return (() => {
+		var _el$2 = _tmpl$2();
+		spread(_el$2, props, false, true);
+		insert(_el$2, createComponent(For, {
+			get each() {
+				return toarr(_props3.value);
+			},
+			children: (e) => createComponent(Tag, {
+				get style() {
+					return `background: ${e.color}`;
+				},
+				get disabled() {
+					return _props3.disabled;
+				},
+				onDel: () => _props3.onChange(toarr(_props3.value).filter((e2) => e2 != e)),
+				get children() {
+					return memo(() => !!_props3.children)() ? _props3.children(e) : e?.text ?? e?.label ?? e?.name ?? e;
+				}
+			})
+		}), null);
+		insert(_el$2, (() => {
+			var _c$ = memo(() => !!!_props3.disabled);
+			return () => _c$() && createComponent(Tag, {
+				disabled: true,
+				get onClick() {
+					return _props3.onAdd;
+				},
+				get children() {
+					return createComponent(plus_default, {});
+				}
+			});
+		})(), null);
+		return _el$2;
+	})();
+};
+const Tag = (_props4) => {
+	let props;
+	[_props4, props] = splitProps(_props4, [
+		"disabled",
+		"children",
+		"onDel"
+	]);
+	props = combineProps({ class: "flex items-center px-2 py-1 rd-sm bg-gray/20 text-3.5 lh-[1]" }, props);
+	return (() => {
+		var _el$3 = _tmpl$2();
+		spread(_el$3, props, false, true);
+		insert(_el$3, () => _props4.children, null);
+		insert(_el$3, (() => {
+			var _c$2 = memo(() => !!!_props4.disabled);
+			return () => _c$2() && createComponent(x_default, {
+				"class": "icon-clickable flex-shrink-0 size-4! ml-1 mr--1 op-75",
+				get onClick() {
+					return _props4.onDel;
+				}
+			});
+		})(), null);
+		return _el$3;
+	})();
+};
+const evaluateFormula = (formula, data) => {
+	try {
+		const ctx = { data };
+		return new Function(...Object.keys(ctx), `return ` + formula)(...Object.values(ctx));
+	} catch (error) {
+		return "公式错误";
+	}
+};
+export { Checkbox, Files, Tag, Tags, evaluateFormula };

package/dist/plugins/RenderPlugin/index.d.ts

@@ -0,0 +1,30 @@
+import { type JSX } from 'solid-js';
+import { type Plugin, type TD } from '../..';
+declare module '../../index' {
+    interface TableProps {
+    }
+    interface TableColumn {
+        render?: Render;
+        enum?: Record<string, any> | {
+            label?: string;
+            value: any;
+        }[];
+    }
+    interface TableStore {
+        renders: {
+            [key: string]: Render;
+        };
+    }
+}
+export type RenderProps = Parameters<TD>[0] & {
+    onChange: (v: any) => void;
+};
+export type Render = (props: RenderProps) => JSX.Element | any;
+export declare const RenderPlugin: Plugin;
+export declare const renders: {
+    text: Render;
+    number: Render;
+    date: Render;
+    checkbox: Render;
+    file: Render;
+};

package/dist/plugins/RenderPlugin/index.js

@@ -0,0 +1,61 @@
+import { resolveOptions } from "../../utils.js";
+import { Checkbox, Files } from "./components.js";
+import { renderComponent, solidComponent } from "../../components/utils.js";
+import { createComponent, insert, memo, mergeProps, template } from "solid-js/web";
+import { mergeProps as mergeProps$1 } from "solid-js";
+var _tmpl$ = /* @__PURE__ */ template(`<div class="flex items-center h-full">`);
+const RenderPlugin = {
+	priority: -Infinity,
+	store: () => ({ renders: { ...renders } }),
+	rewriteProps: { Td: ({ Td }, { store }) => (o) => {
+		return createComponent(Td, mergeProps(o, { get children() {
+			return (() => {
+				let Comp = ((e) => typeof e == "string" ? store.renders[e] : e)(o.col.render) || text;
+				return renderComponent(Comp, mergeProps$1(o, { onChange: (v) => store.commands.rowChange({
+					...o.data,
+					[o.col.id]: v
+				}, o.y) }), store.props.renderer);
+			})();
+		} }));
+	} }
+};
+var text = (_props) => {
+	return memo(() => ((v) => _props.col.enum ? resolveOptions(_props.col.enum).find((e) => e.value == v)?.label ?? v : v)(_props.data[_props.col.id]));
+};
+var number = text;
+var date = text;
+var checkbox = (_props2) => {
+	return (() => {
+		var _el$ = _tmpl$();
+		insert(_el$, createComponent(Checkbox, {
+			"class": "",
+			get value() {
+				return _props2.data[_props2.col.id];
+			},
+			get onChange() {
+				return _props2.onChange;
+			}
+		}));
+		return _el$;
+	})();
+};
+var file = (_props3) => {
+	return createComponent(Files, {
+		get value() {
+			return _props3.data[_props3.col.id];
+		},
+		get onChange() {
+			return _props3.onChange;
+		},
+		disabled: true
+	});
+};
+const renders = {
+	text,
+	number,
+	date,
+	checkbox,
+	file
+};
+for (const k in renders) renders[k] = solidComponent(renders[k]);
+export { RenderPlugin, renders };

package/dist/plugins/ResizePlugin.d.ts

@@ -0,0 +1,27 @@
+import { type Plugin } from "@/index";
+declare module '../index' {
+    interface TableProps {
+        resizable?: {
+            col: Partial<{
+                enable: boolean;
+                min: number;
+                max: number;
+            }>;
+            row: Partial<{
+                enable: boolean;
+                min: number;
+                max: number;
+            }>;
+        };
+        onColumnsChange?: (columns: TableColumn[]) => void;
+    }
+    interface TableColumn {
+        resizable?: boolean;
+        onWidthChange?: (width: number) => void;
+    }
+    interface TableStore {
+    }
+    interface Commands {
+    }
+}
+export declare const ResizePlugin: Plugin;

package/dist/plugins/ResizePlugin.js

@@ -0,0 +1,103 @@
+import { usePointerDrag } from "../hooks/index.js";
+import { Ctx } from "../index.js";
+import { useSplit } from "../components/Split.js";
+import { createComponent, template, use } from "solid-js/web";
+import { createMemo, onMount, useContext } from "solid-js";
+import { clamp } from "es-toolkit";
+import { combineProps } from "@solid-primitives/props";
+import { defaultsDeep } from "es-toolkit/compat";
+var _tmpl$ = /* @__PURE__ */ template(`<div class="in-cell__resize-handle flex justify-center after:w-1 cursor-w-resize">`), _tmpl$2 = /* @__PURE__ */ template(`<div class="in-cell__resize-handle flex flex-row items-center after:h-1 cursor-s-resize">`);
+const ResizePlugin = { rewriteProps: {
+	resizable: ({ resizable }) => defaultsDeep(resizable, {
+		col: {
+			enable: true,
+			min: 45,
+			max: 800
+		},
+		row: {
+			enable: false,
+			min: 20,
+			max: 400
+		}
+	}),
+	columns: ({ columns }, { store }) => columns.map((e) => defaultsDeep(e, { resizable: store.props?.resizable?.col.enable })),
+	Thead: ({ Thead }, { store }) => (o) => {
+		let theadEl;
+		const { props } = useContext(Ctx);
+		const ths = createMemo(() => store.ths.filter((e) => e != null));
+		onMount(() => {
+			useSplit({
+				container: theadEl,
+				cells: ths,
+				size: 10,
+				trailing: true,
+				dir: "x",
+				handle: (i) => createComponent(Handle, { i })
+			});
+		});
+		const Handle = (_props) => {
+			let el;
+			usePointerDrag(() => el, { start(e, move, end) {
+				const { min, max } = props.resizable.col;
+				const th = ths()[_props.i];
+				const sw = th.offsetWidth;
+				move((e$1, o$1) => th.style.width = `${clamp(sw + o$1.ox, min, max)}px`);
+				end(() => {
+					const col = props.columns[_props.i];
+					const cols = [...store.rawProps.columns || []];
+					const index = cols?.findIndex((e$1) => e$1.id == col.id);
+					if (index > -1) {
+						cols[index] = {
+							...cols[index],
+							width: th.offsetWidth
+						};
+						props.onColumnsChange?.(cols);
+					}
+					col.onWidthChange?.(th.offsetWidth);
+				});
+			} });
+			return (() => {
+				var _el$ = _tmpl$();
+				var _ref$ = el;
+				typeof _ref$ === "function" ? use(_ref$, _el$) : el = _el$;
+				return _el$;
+			})();
+		};
+		o = combineProps({ ref: (e) => theadEl = e }, o);
+		return createComponent(Thead, o);
+	},
+	Tbody: ({ Tbody }, { store }) => (o) => {
+		let el;
+		const { props } = useContext(Ctx);
+		const tds = createMemo(() => store.trs.filter((e) => e != null).map((e) => e.firstElementChild));
+		onMount(() => {
+			useSplit({
+				container: el,
+				cells: tds,
+				size: 8,
+				trailing: true,
+				dir: "y",
+				handle: (i) => createComponent(Handle, { i })
+			});
+		});
+		const Handle = (_props2) => {
+			let el$1;
+			usePointerDrag(() => el$1, { start(e, move, end) {
+				const { min, max } = props.resizable.row;
+				const tr = tds()[_props2.i];
+				const sw = tr.offsetHeight;
+				move((e$1, o$1) => tr.style.height = `${clamp(sw + o$1.oy, min, max)}px`);
+				end(() => {});
+			} });
+			return (() => {
+				var _el$2 = _tmpl$2();
+				var _ref$2 = el$1;
+				typeof _ref$2 === "function" ? use(_ref$2, _el$2) : el$1 = _el$2;
+				return _el$2;
+			})();
+		};
+		o = combineProps({ ref: (e) => el = e }, o);
+		return createComponent(Tbody, o);
+	}
+} };
+export { ResizePlugin };

package/dist/plugins/RowGroupPlugin.d.ts

@@ -0,0 +1,17 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+        rowGroup?: {
+            fields?: string[];
+        };
+    }
+    interface TableStore {
+        rowGroup: {
+            expands: string[][];
+            isExpand: (data: any) => boolean;
+            expand: (data: any, r?: any) => void;
+            toggleExpand: (data: any) => void;
+        };
+    }
+}
+export declare const RowGroupPlugin: Plugin;

package/dist/plugins/RowGroupPlugin.js

@@ -0,0 +1,99 @@
+import { Ctx } from "../index.js";
+import chevron_right_default from "../chevron-right.js";
+import { createComponent, delegateEvents, effect, insert, memo, mergeProps, style, template } from "solid-js/web";
+import { batch, createMemo, useContext } from "solid-js";
+import { groupBy, isEqual, remove, zipObject } from "es-toolkit";
+import { findLast } from "es-toolkit/compat";
+var _tmpl$ = /* @__PURE__ */ template(`<div class="flex items-center">`);
+const RowGroupPlugin = {
+	priority: -Infinity,
+	store: (store) => ({ rowGroup: {
+		expands: [],
+		isExpand: (data) => store.rowGroup.expands.some((e) => isEqual(e, data[GROUP].path)),
+		expand: (data, r) => batch(() => r ? data[GROUP].path2.forEach((e) => store.rowGroup.isExpand(e) || store.rowGroup.expands.push(e[GROUP].path)) : store.rowGroup.isExpand(data) || store.rowGroup.expands.push(data[GROUP].path)),
+		toggleExpand: (data) => store.rowGroup.isExpand(data) ? remove(store.rowGroup.expands, (e) => isEqual(e, data[GROUP].path)) : store.rowGroup.expand(data)
+	} }),
+	commands: (store, { addRows }) => ({ addRows(i, rows, before) {
+		const { data, rowGroup, rowKey } = store.props;
+		if (rowGroup?.fields?.length) {
+			const group = findLast(data, (e) => e[GROUP], i);
+			if (group) {
+				if (data[i][GROUP]) {
+					const leaf = function r(group$1) {
+						return group$1[GROUP]?.children[0]?.[GROUP] ? r(group$1[GROUP].children[0]) : group$1;
+					}(group);
+					store.rowGroup.expand(leaf, true);
+					const anchor = leaf[GROUP].children[0];
+					i = store.props.data.indexOf(anchor);
+					before = true;
+				}
+			}
+			addRows?.(i, rows, before);
+		} else addRows?.(...arguments);
+	} }),
+	rewriteProps: {
+		data: ({ data }, { store }) => store.props?.rowGroup?.fields?.length ? expandData(data, store) : data,
+		newRow: ({ newRow }, { store }) => function(i) {
+			const row = newRow(...arguments);
+			const { data, rowGroup } = store.props;
+			if (rowGroup?.fields?.length) {
+				const group = findLast(data, (e) => e[GROUP], i);
+				if (group) {
+					const leaf = function r(group$1) {
+						return group$1[GROUP]?.children[0]?.[GROUP] ? r(group$1[GROUP].children[0]) : group$1;
+					}(group);
+					const extra = zipObject(rowGroup.fields, leaf[GROUP].path);
+					Object.assign(row, extra);
+				}
+			}
+			return row;
+		},
+		Td: ({ Td }, { store }) => (o) => {
+			if (!o.data?.[GROUP]) return createComponent(Td, o);
+			const { props } = useContext(Ctx);
+			const show = createMemo(() => store.rowGroup.isExpand(o.data));
+			return createComponent(Td, mergeProps(o, { get children() {
+				return memo(() => props.columns?.findIndex((e) => !e[store.internal]) == o.x)() ? (() => {
+					var _el$ = _tmpl$();
+					_el$.$$dblclick = () => store.rowGroup.toggleExpand(o.data);
+					insert(_el$, createComponent(chevron_right_default, {
+						"class": "icon-clickable mr-2",
+						get style() {
+							return `transform: rotate(${show() ? 90 : 0}deg); opacity: .6`;
+						},
+						onClick: () => store.rowGroup.toggleExpand(o.data)
+					}), null);
+					insert(_el$, () => o.data[GROUP].value, null);
+					effect((_$p) => style(_el$, `padding-left: ${(o.data[GROUP].path.length - 1) * 16}px`, _$p));
+					return _el$;
+				})() : o.children;
+			} }));
+		}
+	}
+};
+var GROUP = Symbol("row-group");
+var expandData = (data, store, path2 = []) => {
+	const fields = store.props.rowGroup.fields;
+	const col = store.props.columns.find((e) => !e[store.internal]);
+	if (!col) return data;
+	if (fields.length == path2.length) return data;
+	const path = path2[path2.length - 1]?.[GROUP].path || [];
+	const obj = groupBy(data, (e) => e[fields[path.length]]);
+	return Object.keys(obj).flatMap((k) => {
+		const group = {
+			[col.id]: k,
+			[store.internal]: 1
+		};
+		const ps = [...path2, group];
+		group[GROUP] = {
+			path: [...path, k],
+			value: k,
+			path2: ps
+		};
+		group[GROUP].children = expandData(obj[k], store, ps);
+		const arr = store.rowGroup.isExpand(group) ? group[GROUP].children : [];
+		return [group, ...arr];
+	});
+};
+delegateEvents(["dblclick"]);
+export { RowGroupPlugin };

package/dist/plugins/RowSelectionPlugin.d.ts

@@ -0,0 +1,32 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+        rowSelection?: {
+            enable?: boolean;
+            multiple?: boolean;
+            value?: any[];
+            selectable?: (row: any) => boolean;
+            onChange?: (selected: any[]) => void;
+        };
+    }
+    interface TableStore {
+        rowSelectionCol: TableColumn;
+    }
+    interface Commands {
+        rowSelector: ReturnType<typeof useSelector>;
+    }
+}
+export declare const RowSelectionPlugin: Plugin;
+declare function useSelector(opt: Partial<{
+    value: any;
+    rowKey: any;
+    multiple: any;
+    selectable: any;
+    onChange: any;
+}>): {
+    isSelected: (data: any) => boolean;
+    select: (data: any, bool?: boolean) => void;
+    clear: () => any;
+    set: (rows?: never[]) => any;
+};
+export {};