intable 0.0.8 → 0.0.10

package/dist/hooks/index.js

@@ -0,0 +1,174 @@
+import { unFn } from "../utils.js";
+import { $PROXY, batch, createComputed, createEffect, createMemo, createRenderEffect, createRoot, createSignal, getOwner, mergeProps, on, onCleanup, runWithOwner, untrack } from "solid-js";
+import { $RAW, createMutable } from "solid-js/store";
+import { isFunction, isPromise, mapValues } from "es-toolkit";
+import { createEventListener, createEventListenerMap } from "@solid-primitives/event-listener";
+import { createPointerListeners } from "@solid-primitives/pointer";
+import { access } from "@solid-primitives/utils";
+import { makePersisted, storageSync } from "@solid-primitives/storage";
+import { createMutationObserver } from "@solid-primitives/mutation-observer";
+import { castArray } from "es-toolkit/compat";
+import { createKeybindingsHandler } from "tinykeys";
+function usePointerDrag(h, B) {
+	B = mergeProps({ preventDefault: !0 }, B), createPointerListeners({
+		target: h,
+		passive: !1,
+		onDown(h) {
+			B.preventDefault && h.preventDefault();
+			let [V, H] = [h.x, h.y], U, W;
+			B.start?.(h, (h) => U = h, (h) => W = h), createRoot((B) => {
+				createPointerListeners({
+					target: document,
+					onMove(h) {
+						let [B, W] = [h.x - V, h.y - H];
+						U?.(h, {
+							sx: V,
+							sy: H,
+							ox: B,
+							oy: W
+						});
+					},
+					onUp() {
+						W?.(h), B(), U = void 0, W = void 0;
+					}
+				}), createEventListenerMap(document, { drop: B });
+			});
+		}
+	});
+}
+function model(h, B) {
+	let [V, H] = B();
+	createRenderEffect(() => h.value = V()), h.addEventListener("input", (h) => H(h.target.value));
+}
+function toSignle(h, B) {
+	return [() => h[B], (V) => h[B] = V];
+}
+function useDark() {
+	let h = (h) => h == "dark" || V() && !h, B = (h) => h ? "dark" : "light", V = () => window.matchMedia("(prefers-color-scheme: dark)").matches, H = makePersisted(createSignal(V()), {
+		name: "color-schema",
+		storage: localStorage,
+		sync: storageSync,
+		serialize: B,
+		deserialize: h
+	});
+	return createEffect(() => document.documentElement.classList[H[0]() ? "add" : "remove"]("dark")), createEffect(() => window.dispatchEvent(new StorageEvent("storage", {
+		key: "color-schema",
+		newValue: B(H[0]())
+	}))), H;
+}
+function useMemoAsync(h, B) {
+	let V = Symbol(), [U, W] = createSignal(B);
+	return createComputed(async () => {
+		let B = h(untrack(U)), H = B instanceof Promise ? await new Promise((h) => {
+			B.then(h), onCleanup(() => h(V));
+		}) : B;
+		H == V || W(() => H);
+	}), U;
+}
+function useSignle2(h, B) {
+	let V = createSignal(isFunction(h) ? void 0 : h), U = (h) => {
+		let V = B?.before?.(h);
+		return isPromise(V) ? V.then((B) => B === void 0 ? h : B) : V ?? h;
+	}, W = useMemoAsync(() => U(V[0]()));
+	if (isFunction(h)) {
+		let B = useMemoAsync(() => U(h()));
+		createComputed(() => V[1](B()));
+	}
+	return [W, V[1]];
+}
+var $MEMO = Symbol();
+function toReactive(V) {
+	let H = () => unFn(V), U = () => !0, W = (h) => ((h) => typeof h == "function" && $MEMO in h ? h() : h)(H()[h]);
+	return new Proxy(Object.create(null), {
+		get: (h, V, U) => V == $PROXY || V == $RAW ? U : ((h) => typeof h == "function" && $MEMO in h ? h() : h)(H()[V]),
+		set: U,
+		defineProperty: (h, B, V) => Object.defineProperty(H(), B, V),
+		deleteProperty: U,
+		getPrototypeOf: () => Object.getPrototypeOf(H()),
+		has: (h, V) => V == $PROXY || V in H(),
+		ownKeys: (h) => Object.keys(H()),
+		getOwnPropertyDescriptor: (h, B) => ({
+			enumerable: !0,
+			configurable: !0,
+			get() {
+				return W(B);
+			},
+			set: U
+		})
+	});
+}
+function useMemo(h) {
+	let B = createMemo(h);
+	return B[$MEMO] = 1, B;
+}
+function useHover(h) {
+	let [B, V] = createSignal(!1);
+	return createEventListener(h, "pointerenter", () => V(!0)), createEventListener(h, "pointerleave", () => V(!1)), B;
+}
+function useMouseDown(h) {
+	let [B, V] = createSignal(!1);
+	return createEventListener(h, "pointerdown", () => V(!0)), createEventListener(document.body, "pointerup", () => V(!1)), B;
+}
+function useClicked(h) {
+	let [B, V] = createSignal(!1), H = () => castArray(access(h));
+	return createEventListener(() => H().map((h) => h?.getRootNode()), "click", (h) => V(H().some((B) => B?.contains(h.target)))), B;
+}
+function useMutation(h, B, V) {
+	let H = createSignal(V());
+	return createMutationObserver(h, B, (h) => H[1](V())), H[0];
+}
+function useTinykeys(h, B) {
+	createEventListener(h, "keydown", createKeybindingsHandler({ ...mapValues(B, (h) => (B) => {
+		B.preventDefault(), h(B);
+	}) }));
+}
+function useHistory([h, B]) {
+	let V = 1, H = createMutable({
+		index: -1,
+		history: []
+	}), U = () => (H.index = 0, H.history = [h()]), W = () => H.index > 0, G = () => H.index < H.history.length - 1;
+	return createRenderEffect(on(h, (h) => {
+		if (h != null) {
+			if (!V) return V = 1;
+			G() && (H.history = H.history.slice(0, H.index + 1)), H.history[++H.index] = h;
+		}
+	})), {
+		undo: () => W() && ((V = 0) || B(H.history[--H.index])),
+		redo: () => G() && ((V = 0) || B(H.history[++H.index])),
+		clear: U,
+		get index() {
+			return H.index;
+		},
+		get history() {
+			return H.history;
+		}
+	};
+}
+function createShallowState(h) {
+	let V = getOwner(), H = {}, U = (h, B) => H[h] ??= runWithOwner(V, () => createSignal(B));
+	for (let B in h) U(B, h[B]);
+	return new Proxy(h, {
+		get(h, V, H) {
+			return V == $PROXY ? H : U(V)[0]();
+		},
+		set(h, B, V) {
+			return h[B] = V, U(B, V)[1](() => V), !0;
+		},
+		deleteProperty(h, B) {
+			return U(B)[1](void 0), delete h[B], delete H[B], !0;
+		},
+		has: (h, V) => V == $PROXY || V in H,
+		ownKeys: (h) => Reflect.ownKeys(H)
+	});
+}
+function useMemoState(h) {
+	let B = createShallowState({});
+	return createComputed(() => {
+		let H = { ...h() };
+		untrack(() => batch(() => {
+			for (let h in B) h in H || delete B[h];
+			Object.assign(B, H);
+		}));
+	}), B;
+}
+export { createShallowState, model, toReactive, toSignle, useClicked, useDark, useHistory, useHover, useMemo, useMemoAsync, useMemoState, useMouseDown, useMutation, usePointerDrag, useSignle2, useTinykeys };

package/dist/hooks/useDir.d.ts

@@ -0,0 +1,11 @@
+import { type MaybeAccessor } from '@solid-primitives/utils';
+interface UseDirOptions {
+    ref: MaybeAccessor<HTMLElement | undefined>;
+    list?: MaybeAccessor<HTMLElement | undefined>;
+    loop?: boolean;
+    options?: EventListenerOptions;
+    defaultFirst?: boolean;
+}
+export declare function useDir(options: UseDirOptions): void;
+export declare function VDir(el: HTMLElement, options: any): void;
+export {};

package/dist/hooks/useDir.js

@@ -0,0 +1,42 @@
+import { createEffect, mergeProps } from "solid-js";
+import { createEventListener } from "@solid-primitives/event-listener";
+import { access } from "@solid-primitives/utils";
+import { createMutationObserver } from "@solid-primitives/mutation-observer";
+function useDir(a) {
+	a = mergeProps({ loop: !0 }, a);
+	let o = () => access(a.list) ?? access(a.ref), s = () => access(a.ref) ?? access(a.list);
+	createEffect(() => {
+		s().tabIndex > -1 || (s().tabIndex = 0);
+	}), createEventListener(s, "keydown", (e) => {
+		if (![
+			"ArrowDown",
+			"ArrowUp",
+			"Enter"
+		].includes(e.key)) return;
+		e.stopPropagation(), e.preventDefault();
+		let n = o()?.querySelector(".hover");
+		if (e.key == "Enter") {
+			n?.click();
+			return;
+		}
+		let r = e.key == "ArrowDown" ? n ? +n?.getAttribute("data-index") + 1 : 0 : e.key == "ArrowUp" ? n ? n?.getAttribute("data-index") - 1 : -1 : 0, i = o()?.querySelector(`[data-index='${r}']`);
+		i ? (n?.classList.remove("hover"), i.classList.add("hover")) : a.loop && (n?.classList.remove("hover"), r >= 0 ? o()?.querySelector("[data-index='0']")?.classList.add("hover") : [...o()?.querySelectorAll("[data-index]")].at(-1)?.classList.add("hover"));
+	}, a.options), createEffect(() => {
+		if (!a.defaultFirst) return;
+		let e = o();
+		if (!e) return;
+		let n = () => {
+			e.querySelector(".hover") || e.querySelector("[data-index]")?.classList.add("hover");
+		};
+		createMutationObserver(e, { childList: !0 }, n), n();
+	}), createEventListener(o, "mouseover", () => {
+		o()?.querySelector(".hover")?.classList.remove("hover");
+	});
+}
+function VDir(e, n) {
+	useDir({
+		...n(),
+		list: e
+	});
+}
+export { VDir, useDir };

package/dist/hooks/useSelector.d.ts

@@ -0,0 +1,16 @@
+interface UseSelectorOpt<T> {
+    value?: T;
+    onChange?: (v: T) => void;
+    multiple?: boolean;
+    selectable?: (v: any) => boolean;
+}
+export declare function useSelector<T = any>(opt: UseSelectorOpt<T>): {
+    clear: () => void;
+    set: (v: T) => void;
+    has: (key: any) => boolean;
+    add: (v: T) => void;
+    del: (v: T) => void;
+    toggle: (v: T) => void;
+    readonly value: T;
+};
+export {};

package/dist/hooks/useSelector.js

@@ -0,0 +1,69 @@
+import { toArr } from "../utils.js";
+import { createMemo, createSelector, createSignal } from "solid-js";
+var _Symbol$toStringTag, SingleSet = class {
+	static {
+		_Symbol$toStringTag = Symbol.toStringTag;
+	}
+	#value;
+	constructor(e) {
+		this[_Symbol$toStringTag] = "SingleSet", this.#value = Array.from(e || [])[0];
+	}
+	add(e) {
+		return this.#value = e, this;
+	}
+	clear() {
+		this.#value = void 0;
+	}
+	delete(e) {
+		return this.#value === e ? (this.#value = void 0, !0) : !1;
+	}
+	forEach(e) {
+		this.#value !== void 0 && e.call(this, this.#value, this.#value, this);
+	}
+	has(e) {
+		return this.#value === e;
+	}
+	get size() {
+		return this.#value === void 0 ? 0 : 1;
+	}
+	entries() {
+		return this.values();
+	}
+	keys() {
+		return this.values();
+	}
+	values() {
+		return this.#value === void 0 ? [].entries() : [[this.#value, this.#value]].entries();
+	}
+	[Symbol.iterator]() {
+		return this.values()[Symbol.iterator]();
+	}
+};
+function useSelector(a) {
+	let { value: o, onChange: s, multiple: c = !1, selectable: l } = a, u = c ? Set : SingleSet, [d, f] = createSignal(new u(toArr(o))), p = createSelector(d, (e, i) => i.has(e)), m = (e) => l ? l(e) : !0, h = () => {
+		f(new u()), s?.(b());
+	}, g = (i) => {
+		m(i) && (f(new u(toArr(i))), s?.(b()));
+	}, _ = (e) => {
+		if (!m(e)) return;
+		let i = new u(d());
+		i.add(e), f(i), s?.(b());
+	}, v = (e) => {
+		let i = new u(d());
+		i.delete(e), f(i), s?.(b());
+	}, y = (e) => {
+		p(e) ? v(e) : _(e);
+	}, b = createMemo(() => c ? Array.from(d()) : Array.from(d())[0]);
+	return {
+		clear: h,
+		set: g,
+		has: p,
+		add: _,
+		del: v,
+		toggle: y,
+		get value() {
+			return b();
+		}
+	};
+}
+export { useSelector };

package/dist/hooks/useSort.d.ts

@@ -0,0 +1,18 @@
+import { type MaybeAccessor } from '@solid-primitives/utils';
+type Awaitable<T> = T | Promise<T>;
+interface UseSortOption {
+    enable?: boolean;
+    guideLine: any;
+    draggable: (el: HTMLElement) => Awaitable<boolean>;
+    dragover: (el: HTMLElement) => boolean;
+    children: (el: HTMLElement) => HTMLElement[];
+    dragend: () => void;
+}
+export declare const useSort: (el: MaybeAccessor<HTMLElement | undefined>, opt: UseSortOption) => {
+    style: any;
+    drag: any;
+    over: any;
+    rel: any;
+    type: string;
+};
+export {};

package/dist/hooks/useSort.js

@@ -0,0 +1,83 @@
+import { findAsync } from "../utils.js";
+import { Portal, createComponent, memo, mergeProps, spread, template } from "solid-js/web";
+import { createMutable, reconcile } from "solid-js/store";
+import { createEventListenerMap } from "@solid-primitives/event-listener";
+import { access } from "@solid-primitives/utils";
+var _tmpl$ = /* @__PURE__ */ template("<div>");
+const useSort = (l, f) => {
+	f = mergeProps({ enable: !0 }, f);
+	let p = 0;
+	createEventListenerMap(() => f.enable ? access(l) : void 0, {
+		async pointerdown(i) {
+			let a = p, o = await findAsync(i.composedPath(), (e) => e instanceof HTMLElement && f.draggable(e));
+			a == p && o && (i.stopPropagation(), h.drag = o, h.drag?.setAttribute("draggable", "true"));
+		},
+		pointerup() {
+			p++, m();
+		},
+		pointermove() {
+			p++;
+		},
+		dragstart(e) {
+			e.dataTransfer.setDragImage(document.createElement("img"), 0, 0);
+		},
+		dragover(e) {
+			if (!h.drag) return;
+			let i = h.over = e.composedPath().filter((e) => e instanceof HTMLElement).find((e) => f.dragover(e)) ?? h.over;
+			if (!i) return;
+			e.preventDefault(), e.stopPropagation();
+			let a = f.children(i);
+			if (a) {
+				let i = 0, o = Infinity, s = "";
+				a.forEach((a, c) => {
+					let l = getComputedStyle(a).display, u = ["table-cell", "inline"].some((e) => l.includes(e)), d = a.getBoundingClientRect();
+					if (u) {
+						let a = Math.sqrt((e.clientX - d.x) ** 2 + (e.clientY - d.y + d.height / 2) ** 2);
+						a < o && (i = c, o = a, s = "l"), a = Math.sqrt((e.clientX - d.right) ** 2 + (e.clientY - d.y + d.height / 2) ** 2), a < o && (i = c, o = a, s = "r");
+					} else {
+						let a = Math.sqrt((e.clientY - d.y) ** 2 + (e.clientX - d.x + d.width / 2) ** 2);
+						a < o && (i = c, o = a, s = "t"), a = Math.sqrt((e.clientY - d.bottom) ** 2 + (e.clientX - d.x + d.width / 2) ** 2), a < o && (i = c, o = a, s = "b");
+					}
+				});
+				let c = a[i].getBoundingClientRect(), l = s == "l" || s == "r", u = s == "t" || s == "b";
+				h.style = {
+					width: `${u ? c.width : 3}px`,
+					height: `${u ? 3 : c.height}px`,
+					translate: `${u ? c.x : (s == "l" ? c.x : c.right) - 3 / 2}px ${l ? c.y : (s == "t" ? c.y : c.bottom) - 3 / 2}px`
+				}, h.rel = a[i], h.type = s == "l" || s == "t" ? "before" : "after";
+			} else {
+				let e = i.getBoundingClientRect();
+				h.style = {
+					width: e.width,
+					height: e.height,
+					translate: `${e.x}px ${e.y}px`
+				}, h.rel = i, h.type = "inner";
+			}
+		},
+		dragend() {
+			m();
+		}
+	});
+	function m() {
+		h.drag?.removeAttribute("draggable"), h.drag && h.rel && f.dragend?.(), reconcile({})(h);
+	}
+	let h = createMutable({
+		style: void 0,
+		drag: void 0,
+		over: void 0,
+		rel: void 0,
+		type: ""
+	});
+	return memo(() => memo(() => !!h.style)() && createComponent(Portal, {
+		get mount() {
+			return access(l);
+		},
+		get children() {
+			var e = _tmpl$();
+			return spread(e, mergeProps(() => f.guideLine, { get style() {
+				return h.style;
+			} }), !1, !1), e;
+		}
+	})), h;
+};
+export { useSort };

package/dist/hooks/useVirtualizer.d.ts

@@ -0,0 +1,30 @@
+interface VirtualizerOptions {
+    enable?: boolean;
+    overscan?: number;
+    batch?: number;
+    getScrollElement: () => Element;
+    horizontal?: boolean;
+    count: number;
+    estimateSize: (i: number) => number;
+    extras?: (startIdx: number, endIdx: number) => number[];
+    indexAttribute?: string;
+    rangeExtractor?: (range: any) => number[];
+}
+export declare function useVirtualizer(opt: VirtualizerOptions): {
+    options: VirtualizerOptions;
+    startIdx: import("solid-js").Accessor<number>;
+    endIdx: import("solid-js").Accessor<number>;
+    getTotalSize: () => number;
+    resizeItem: (i: number, newSize: number) => void;
+    getVirtualItems: import("solid-js").Accessor<{
+        start: number;
+        end: number;
+        index: number;
+    }[]>;
+    getVirtualItem: (i: number) => {
+        start: number;
+        end: number;
+        index: number;
+    };
+};
+export {};

package/dist/hooks/useVirtualizer.js

@@ -0,0 +1,97 @@
+import { createComputed, createMemo, createSignal, mergeProps, untrack } from "solid-js";
+import { createElementSize } from "@solid-primitives/resize-observer";
+import { createScrollPosition } from "@solid-primitives/scroll";
+import { uniqBy } from "es-toolkit";
+var FenwickTree = class e {
+	constructor(e) {
+		this.n = e, this.tree = new Float64Array(e + 1);
+	}
+	add(e, a) {
+		for (e += 1; e <= this.n; e += e & -e) this.tree[e] += a;
+	}
+	sum(e) {
+		let a = 0;
+		for (e += 1; e > 0; e -= e & -e) a += this.tree[e];
+		return a;
+	}
+	total() {
+		return this.n > 0 ? this.sum(this.n - 1) : 0;
+	}
+	findByOffset(e) {
+		let a = 0;
+		for (let o = 1 << Math.floor(Math.log2(this.n || 1)); o > 0; o >>= 1) a + o <= this.n && this.tree[a + o] <= e && (a += o, e -= this.tree[a]);
+		return Math.min(a, this.n - 1);
+	}
+	static build(a) {
+		let o = a.length, s = new e(o);
+		for (let e = 0; e < o; e++) {
+			s.tree[e + 1] += a[e];
+			let c = e + 1 + (e + 1 & -(e + 1));
+			c <= o && (s.tree[c] += s.tree[e + 1]);
+		}
+		return s;
+	}
+};
+function useVirtualizer(l) {
+	l = mergeProps({
+		overscan: 0,
+		batch: 0,
+		enable: !0
+	}, l);
+	let u = createElementSize(l.getScrollElement), d = createScrollPosition(l.getScrollElement), f = createMemo(() => l.horizontal ? d.x : d.y), p = createMemo(() => l.horizontal ? u.width : u.height), m = [], h = new FenwickTree(0), [g, _] = createSignal(void 0, { equals: !1 });
+	createComputed(() => {
+		let { count: e } = l;
+		untrack(() => {
+			if (e !== m.length) {
+				if (e > m.length) for (let a = m.length; a < e; a++) m.push(l.estimateSize(a));
+				else m.length = e;
+				h = FenwickTree.build(m.slice(0, e)), _();
+			}
+		});
+	});
+	let v = (e) => ({
+		index: e,
+		start: e > 0 ? h.sum(e - 1) : 0,
+		end: h.sum(e)
+	}), y = createMemo((e) => {
+		g();
+		let { batch: a, overscan: o = 0 } = l, s = h.findByOffset(f()) - o;
+		return a && (s > e ? s = s <= e + a ? e : s > e + a * 2 ? s : e + a : s -= a), Math.max(s, 0);
+	}, 0), b = createMemo((e) => {
+		g();
+		let { batch: a, overscan: o = 0 } = l, s = h.findByOffset(f() + p()) + o;
+		return a && (s < e ? s = s >= e - a ? e : s < e - a * 2 ? s : e - a : s += a), Math.min(s, l.count - 1);
+	}, 0), x = createMemo(() => {
+		if (g(), !l.enable) return Array.from({ length: l.count }, (e, a) => v(a));
+		let e = [];
+		for (let a = y(); a <= b(); a++) e.push(v(a));
+		return l.extras && (e.push(...l.extras(y(), b())?.map((e) => v(e)) || []), e = uniqBy(e, (e) => e.index).sort((e, a) => e.index - a.index)), e;
+	});
+	return {
+		options: l,
+		startIdx: y,
+		endIdx: b,
+		getTotalSize: () => (g(), h.total()),
+		resizeItem: (e, a) => {
+			let o = m[e] ?? 0;
+			if (o !== a) {
+				if (e < y()) {
+					let e = l.getScrollElement();
+					(l.horizontal ? e.scrollLeft : e.scrollTop) !== 0 && (l.horizontal ? e.scrollLeft += a - o : e.scrollTop += a - o);
+				}
+				h.add(e, a - o), m[e] = a, _();
+			}
+		},
+		getVirtualItems: x,
+		getVirtualItem: (() => {
+			let e = createMemo(() => {
+				g();
+				let e = {};
+				for (let a of x()) e[a.index] = a;
+				return e;
+			});
+			return (a) => e()[a];
+		})()
+	};
+}
+export { useVirtualizer };

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { type JSX, type Component } from 'solid-js';
+import 'virtual:uno.css';
+import './style.scss';
+import './plugins/CellSelectionPlugin';
+import './plugins/CopyPastePlugin';
+import './plugins/EditablePlugin';
+import './plugins/RenderPlugin';
+import './plugins/MenuPlugin';
+import './plugins/CommandPlugin';
+import './plugins/RowSelectionPlugin';
+import './plugins/ResizePlugin';
+import './plugins/DragPlugin';
+import './plugins/RowGroupPlugin';
+import './plugins/ExpandPlugin';
+import './plugins/CellMergePlugin';
+import './plugins/TreePlugin';
+import './plugins/HeaderGroup';
+export declare const Ctx: import("solid-js").Context<{
+    props: TableProps2;
+    store: TableStore;
+}>;
+type Requireds<T, K extends keyof T> = Pri<Omit<T, K> & Required<Pick<T, K>>>;
+type Pri<T> = {
+    [K in keyof T]: T[K];
+};
+type TableProps2 = Requireds<TableProps, ('Table' | 'Thead' | 'Tbody' | 'Tr' | 'Th' | 'Td' | 'EachRows' | 'EachCells' | 'rowKey' | 'data' | 'columns' | 'newRow')>;
+type Each<T = any> = (props: {
+    each: T[];
+    children: (e: () => any, i: () => number) => JSX.Element;
+}) => JSX.Element;
+type ProcessProps = {
+    [K in keyof TableProps]?: (prev: TableProps2, ctx: {
+        store: TableStore;
+    }) => TableProps[K];
+};
+export interface Plugin {
+    name: string;
+    priority?: number;
+    store?: (store: TableStore) => Partial<TableStore> | void;
+    rewriteProps?: ProcessProps;
+    layers?: Component<TableStore>[];
+    onMount?: (store: TableStore) => void;
+    /**
+     * Declare keyboard shortcuts for this plugin.
+     * Collected and registered as a **single** keydown listener by CommandPlugin.
+     * Keys use tinykeys syntax, e.g. `'$mod+Z'`, `'$mod+Shift+K'`.
+     */
+    keybindings?: (store: TableStore) => Record<string, (e?: KeyboardEvent) => void>;
+}
+export type Plugin$0 = Plugin | ((store: TableStore) => Plugin);
+export interface TableProps {
+    columns?: TableColumn[];
+    data?: any[];
+    index?: boolean;
+    border?: boolean;
+    stickyHeader?: boolean;
+    class?: any;
+    style?: any;
+    rowKey?: any;
+    size?: string;
+    newRow?: (i: number) => any;
+    Table?: Component<any>;
+    Thead?: Component<any>;
+    Tbody?: Component<any>;
+    Td?: TD;
+    Th?: Component<THProps>;
+    Tr?: Component<{
+        y?: number;
+        data?: any;
+        style?: any;
+        children: JSX.Element;
+    }>;
+    EachRows?: Each;
+    EachCells?: Each<TableColumn>;
+    cellClass?: ((props: Omit<TDProps, 'y' | 'data'> & {
+        y?: number;
+        data?: any;
+    }) => string) | string;
+    cellStyle?: ((props: Omit<TDProps, 'y' | 'data'> & {
+        y?: number;
+        data?: any;
+    }) => string) | string;
+    renderer?: (comp: (props: any) => JSX.Element) => ((props: any) => JSX.Element);
+    plugins?: Plugin$0[];
+    /**
+     * Override or disable individual plugin keybindings.
+     * - Override: `{ '$mod+Z': (e) => myUndo() }`
+     * - Disable:  `{ '$mod+Z': false }`
+     */
+    keybindings?: Record<string, ((e?: KeyboardEvent) => void) | false>;
+    onDataChange?: (data: any[]) => void;
+}
+export type THProps = {
+    x: number;
+    col: TableColumn;
+    children: JSX.Element;
+    rowspan?: number;
+    colspan?: number;
+    style?: any;
+};
+export type TDProps = {
+    x: number;
+    y: number;
+    data: any;
+    col: TableColumn;
+    children: JSX.Element;
+    rowspan?: number;
+    colspan?: number;
+};
+export type TD = Component<TDProps>;
+type Obj = Record<string | symbol, any>;
+export interface TableColumn extends Obj {
+    id?: any;
+    name?: string;
+    width?: number;
+    fixed?: 'left' | 'right';
+    class?: any;
+    style?: any;
+    props?: (props: any) => JSX.HTMLAttributes<any>;
+}
+type Nullable<T> = T | undefined;
+export interface TableStore extends Obj {
+    scroll_el?: HTMLElement;
+    table: HTMLElement;
+    thead: HTMLElement;
+    tbody: HTMLElement;
+    ths: Nullable<Element>[];
+    thSizes: Nullable<{
+        width: number;
+        height: number;
+    }>[];
+    trs: Nullable<Element>[];
+    trSizes: Nullable<{
+        width: number;
+        height: number;
+    }>[];
+    internal: symbol;
+    raw: symbol;
+    props: TableProps2;
+    rawProps: TableProps;
+    plugins: Plugin[];
+}
+export declare const Intable: (props: TableProps) => JSX.Element;
+export default Intable;
+declare function BasePlugin(): Plugin$0;
+export declare const ScrollPlugin: Plugin;
+export declare const defaultsPlugins: (Plugin$0 | typeof BasePlugin)[];