intable 0.0.8 → 0.0.9

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)[];