@intable/react 0.0.8 → 0.0.10

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 huodoushigemi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 huodoushigemi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -3,24 +3,24 @@ import { createElement, useEffect, useRef } from "react";
 import { createRoot } from "react-dom/client";
 import { flushSync } from "react-dom";
 import "intable/wc";
-import { onCleanup } from "solid-js";
-const Intable = (a) => {
-	let o = useRef(null);
+import { createComputed, onCleanup } from "solid-js";
+const Intable = (o) => {
+	let s = useRef(null);
 	return useEffect(() => {
-		o.current && (o.current.options = {
-			...a,
-			renderer: component,
-			plugins: [...a.plugins || []]
+		s.current && (s.current.options = {
+			class: o.className,
+			...o,
+			renderer: component
 		});
-	}, [a]), createElement("wc-table", {
-		ref: o,
+	}, [o]), createElement("wc-table", {
+		ref: s,
 		style: { display: "contents" }
 	});
-}, component = (r) => (i) => {
-	let s = document.createElement("div");
-	s.remove ??= () => {};
-	let c = createRoot(s);
-	return flushSync(() => c.render(createElement(r, i))), onCleanup(() => c.unmount()), s;
+}, component = (i) => (a) => {
+	let c = document.createDocumentFragment();
+	c.remove ??= () => {}, c.removeChild = (e) => e.parentElement?.removeChild(e);
+	let l = createRoot(c);
+	return createComputed(() => flushSync(() => l.render(createElement(i, a)))), onCleanup(() => l.unmount()), c;
 };
 var src_default = Intable;
 export { Intable, component, src_default as default };

package/dist/intable/src/components/Menu.d.ts

@@ -0,0 +1 @@
+export declare function Menu(props: any): import("solid-js").JSX.Element;

package/dist/intable/src/components/Popover.d.ts

@@ -0,0 +1,14 @@
+import { type JSX } from 'solid-js';
+import { type createFloatingProps, type ReferenceType } from 'floating-ui-solid';
+import type { AutoUpdateOptions } from '@floating-ui/dom';
+export declare function Popover(attrs: FloatingProps): JSX.Element;
+type FloatingProps = {
+    reference: ReferenceType;
+    floating?: JSX.Element | (() => JSX.Element);
+    portal?: HTMLElement;
+    trigger?: 'click' | 'hover';
+} & createFloatingProps;
+export declare function Floating(attrs: FloatingProps & {
+    update?: Partial<AutoUpdateOptions>;
+}): JSX.Element;
+export {};

package/dist/intable/src/components/Render.d.ts

@@ -0,0 +1,4 @@
+export declare function createRender({ is, processProps }?: {
+    processProps?: (e: any) => any;
+}): (props: any) => import("solid-js").JSX.Element;
+export declare const Render: (props: any) => import("solid-js").JSX.Element;

package/dist/intable/src/components/utils.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from 'solid-js';
+export declare function solidComponent<T extends (...arg: any[]) => JSX.Element>(comp: T): T;
+export declare function renderComponent(Comp: any, props: any, renderer: any): JSX.Element;

package/dist/intable/src/hooks/index.d.ts

@@ -0,0 +1,41 @@
+import { type Signal } from 'solid-js';
+import { type Many, type MaybeAccessor } from '@solid-primitives/utils';
+interface UseMoveOptions {
+    preventDefault?: boolean;
+    start?(e: PointerEvent, move: (cb: MoveCB) => void, end: (cb: EndCb) => void): void;
+}
+type MoveCB = (e: PointerEvent, o: {
+    sx: number;
+    sy: number;
+    ox: number;
+    oy: number;
+}) => void;
+type EndCb = (e: PointerEvent) => void;
+export declare function usePointerDrag(el: MaybeAccessor<HTMLElement | undefined>, options: UseMoveOptions): void;
+export declare function model(el: any, value: () => [() => string, (v: string) => any]): void;
+export declare function toSignle<T extends Record<string, any>>(state: T, k: keyof T): ((v: any) => any)[];
+export declare function useDark(): [get: import("solid-js").Accessor<boolean>, set: import("solid-js").Setter<boolean>, init: string | Promise<string>];
+export declare function useMemoAsync<T>(fn: (prev?: T) => Promise<T> | T, init?: Awaited<T>): import("solid-js").Accessor<Awaited<T>>;
+export declare function useSignle2<T>(v: T | (() => T), opt?: {
+    before?: (v: T) => Promise<T | void> | T;
+}): Signal<T>;
+type Reactive<T extends object> = {
+    [K in keyof T]: T[K] extends () => infer V ? V : T[K];
+};
+export declare function toReactive<T extends object>(fn: (() => T) | T): Reactive<T>;
+export declare function useMemo<T>(fn: () => T): import("solid-js").Accessor<T>;
+export declare function useHover(el: MaybeAccessor<Many<HTMLElement | undefined>>): import("solid-js").Accessor<boolean>;
+export declare function useMouseDown(el: MaybeAccessor<Many<HTMLElement | undefined>>): import("solid-js").Accessor<boolean>;
+export declare function useClicked(el: MaybeAccessor<Many<HTMLElement | undefined>>): import("solid-js").Accessor<boolean>;
+export declare function useMutation<T>(initial: MaybeAccessor<Node | Node[]>, options: MutationObserverInit, cb: () => T): import("solid-js").Accessor<T>;
+export declare function useTinykeys(el: MaybeAccessor<HTMLElement | undefined>, handlers: any): void;
+export declare function useHistory([val, setVal]: [any, any]): {
+    undo: () => any;
+    redo: () => any;
+    clear: () => any[];
+    readonly index: number;
+    readonly history: any[];
+};
+export declare function createShallowState(state: any): any;
+export declare function useMemoState(fn: any): any;
+export {};

package/dist/intable/src/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/intable/src/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/intable/src/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/intable/src/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)[];

package/dist/intable/src/plugins/CellMergePlugin.d.ts

@@ -0,0 +1,45 @@
+import { createMemo } from 'solid-js';
+import { type Plugin } from '../index';
+declare module '../index' {
+    interface TableProps {
+        /**
+         * Per-cell merge config. Return `{ rowspan?, colspan? }` for an anchor cell.
+         * Covered cells are hidden automatically.
+         *
+         * @example
+         * merge={(row, col, y, x) => {
+         *   if (col.id === 'name' && row.name === data[y - 1]?.name) return null
+         *   if (col.id === 'name') {
+         *     let rowspan = 1
+         *     while (data[y + rowspan]?.name === row.name) rowspan++
+         *     return rowspan > 1 ? { rowspan } : null
+         *   }
+         * }}
+         */
+        merge?: (row: any, col: TableColumn, y: number, x: number) => {
+            rowspan?: number;
+            colspan?: number;
+        } | null | void;
+    }
+    interface TableColumn {
+        /**
+         * Shorthand: auto-merge consecutive rows in this column that share the same cell value.
+         * Equivalent to writing a `merge` function that compares adjacent row values.
+         */
+        mergeRow?: boolean;
+    }
+    interface TableStore {
+        /** Pre-computed merge result: anchor spans and covered cell keys. */
+        _mergeMap?: ReturnType<typeof createMemo<MergeMap>>;
+    }
+}
+type CellKey = `${number},${number}`;
+interface MergeMap {
+    spans: Map<CellKey, {
+        rowspan: number;
+        colspan: number;
+    }>;
+    covered: Set<CellKey>;
+}
+export declare const CellMergePlugin: Plugin;
+export {};

package/dist/intable/src/plugins/CellSelectionPlugin.d.ts

@@ -0,0 +1,15 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+    }
+    interface TableStore {
+        selected: {
+            start: number[];
+            end: number[];
+        };
+    }
+    interface Commands {
+        getAreaRows(): any[];
+    }
+}
+export declare const CellSelectionPlugin: Plugin;

package/dist/intable/src/plugins/CommandPlugin.d.ts

@@ -0,0 +1,14 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+    }
+    interface TableStore {
+        commands: Commands;
+    }
+    interface Plugin {
+        commands?: (store: TableStore, commands: Partial<Commands>) => Partial<Commands> & Record<string, any>;
+    }
+    interface Commands {
+    }
+}
+export declare const CommandPlugin: Plugin;

package/dist/intable/src/plugins/CopyPastePlugin.d.ts

@@ -0,0 +1,14 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+    }
+    interface TableStore {
+    }
+    interface Plugin {
+    }
+    interface Commands {
+        copy: () => void;
+        paste: () => void;
+    }
+}
+export declare const ClipboardPlugin: Plugin;

package/dist/intable/src/plugins/DragPlugin.d.ts

@@ -0,0 +1,14 @@
+import { type Plugin } from "../index";
+declare module '../index' {
+    interface TableProps {
+        colDrag?: boolean;
+        rowDrag?: boolean;
+    }
+    interface TableColumn {
+    }
+    interface TableStore {
+    }
+    interface Commands {
+    }
+}
+export declare const DragPlugin: Plugin;

package/dist/intable/src/plugins/EditablePlugin.d.ts

@@ -0,0 +1,51 @@
+import { type JSX } from 'solid-js';
+import { type Plugin, type TableColumn } from '..';
+declare module '../index' {
+    interface TableProps {
+        validator?: (value: any, data: any, col: TableColumn) => string | boolean | Promise<string | boolean>;
+    }
+    interface TableColumn {
+        editable?: boolean;
+        editor?: string | Editor;
+        editorProps?: any;
+        editorPopup?: boolean;
+        validator?: (value: any, rowData: any, col: TableColumn) => boolean | string | Promise<boolean | string>;
+    }
+    interface TableStore {
+        editors: {
+            [key: string]: Editor;
+        };
+    }
+}
+export type Editor = (props: EditorOpt) => {
+    el: JSX.Element;
+    getValue: () => any;
+    destroy: () => void;
+    focus?: () => void;
+    blur?: () => void;
+};
+export interface EditorOpt {
+    col: TableColumn;
+    data: any;
+    value: any;
+    eventKey?: string;
+    onChange?: (value: any) => void;
+    ok: () => void;
+    cancel: () => void;
+    props?: any;
+}
+export declare const EditablePlugin: Plugin;
+export declare const editors: {
+    text: Editor;
+    number: Editor;
+    range: Editor;
+    date: Editor;
+    time: Editor;
+    datetime: Editor;
+    color: Editor;
+    tel: Editor;
+    password: Editor;
+    file: Editor;
+    checkbox: Editor;
+    select: Editor;
+};

package/dist/intable/src/plugins/ExpandPlugin.d.ts

@@ -0,0 +1,18 @@
+import type { JSX } from 'solid-js';
+import { type Plugin } from '..';
+import { useSelector } from '../hooks/useSelector';
+declare module '../index' {
+    interface TableProps {
+        expand?: {
+            enable?: boolean;
+            render?: (props: {
+                data: any;
+                y: number;
+            }) => JSX.Element;
+        };
+    }
+    interface Commands {
+        expand: ReturnType<typeof useSelector<any[]>>;
+    }
+}
+export declare const ExpandPlugin: Plugin;

package/dist/intable/src/plugins/HeaderGroup.d.ts

@@ -0,0 +1,11 @@
+import { type Plugin$0 } from '..';
+declare module '../index' {
+    interface TableColumn {
+        children?: TableColumn[];
+    }
+    interface TableStore {
+        /** Returns column indices of group anchors whose span overlaps [xStart, xEnd]. */
+        _headerGroupAnchors?: (xStart: number, xEnd: number) => number[];
+    }
+}
+export declare const HeaderGroupPlugin: Plugin$0;

package/dist/intable/src/plugins/MenuPlugin.d.ts

@@ -0,0 +1,19 @@
+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;
+        moveRows: (ii: number[], to: number) => void;
+    }
+}
+export declare const MenuPlugin: Plugin;

package/dist/intable/src/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/intable/src/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/intable/src/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/intable/src/plugins/RowGroupPlugin.d.ts

@@ -0,0 +1,18 @@
+import { type Plugin } from '..';
+declare module '../index' {
+    interface TableProps {
+        rowGroup?: {
+            fields?: string[];
+        };
+    }
+    interface TableStore {
+        rowGroup: {
+            /** Plain-object map used as Set<string>; property access is tracked by createMutable */
+            expandKeys: Record<string, true | undefined>;
+            isExpand: (data: any) => boolean;
+            expand: (data: any, r?: any) => void;
+            toggleExpand: (data: any) => void;
+        };
+    }
+}
+export declare const RowGroupPlugin: Plugin;

package/dist/intable/src/plugins/RowSelectionPlugin.d.ts

@@ -0,0 +1,20 @@
+import { type Plugin } from '..';
+import { useSelector } from '../hooks/useSelector';
+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;

package/dist/intable/src/plugins/TreePlugin.d.ts

@@ -0,0 +1,24 @@
+import { type Plugin$0 } from '../index';
+import { useSelector } from '../hooks/useSelector';
+declare module '../index' {
+    interface TableProps {
+        tree?: {
+            /** Field name that holds children rows. Default: `'children'`. */
+            children?: string;
+        };
+    }
+    interface TableStore {
+        tree: ReturnType<typeof useSelector<any[]>>;
+        /**
+         * Lookup map populated as a side-effect of the `data` rewriteProp.
+         * Maps each row's rowKey → its tree metadata.
+         * Written via createMutable so reads are reactive.
+         */
+        _treeMeta: Map<any, {
+            depth: number;
+            hasChildren: boolean;
+            parentKey: any;
+        }>;
+    }
+}
+export declare const TreePlugin: Plugin$0;

package/dist/intable/src/tree.d.ts

@@ -0,0 +1 @@
+export declare const findParent: (data: any[], cb: any, childrenField?: string) => any;

package/dist/intable/src/utils.d.ts

@@ -0,0 +1,31 @@
+export * as tree from './tree';
+export declare function file2base64(file: File): Promise<string>;
+export declare function chooseFile(opts: {
+    accept?: string;
+    multiple?: false;
+}): Promise<File>;
+export declare function chooseFile(opts: {
+    accept?: string;
+    multiple: true;
+}): Promise<File[]>;
+export declare function chooseImage(): Promise<File>;
+export declare function print(html: string): Promise<void>;
+export declare function mergeRect(rect1: DOMRect, rect2: DOMRect): DOMRect;
+export declare function getStyles(el?: ParentNode): string;
+export declare const unFn: (fn: any, ...args: any[]) => any;
+export declare const log: (...args: any[]) => any;
+export declare const toArr: (v: any) => any[];
+export declare const parseStyle: (s: any) => any;
+export declare function findret<T, R>(arr: readonly T[], cb: (e: T, i: number) => R): R | undefined;
+export declare function emptyObject(o: any): any;
+export declare function findAsync<T>(arr: T[], cb: (e: T, i: number) => Promise<boolean> | boolean): Promise<T>;
+type Fnable<T> = T | (() => T);
+type Awatable<T> = T | Promise<T>;
+type BaseType = string | number | boolean | null;
+export declare function resolveOptions(opts: Fnable<Awatable<Record<string, any> | ({
+    label: any;
+    value: any;
+} | BaseType)[]>>): {
+    label: any;
+    value: any;
+}[];

package/dist/intable/src/wc.d.ts

@@ -0,0 +1 @@
+export declare const TableElement: CustomElementConstructor;

package/dist/{index.d.ts → react/src/index.d.ts}

@@ -1,7 +1,8 @@
 import { type FC } from 'react';
 import { type TableProps } from 'intable';
+import '../../intable/src/wc';
 import 'intable/wc';
 import './style.scss';
 export declare const Intable: FC<TableProps>;
-export declare const component: <T extends Record<string, any>>(Comp: FC<T>) => (props: T) => HTMLDivElement;
+export declare const component: <T extends Record<string, any>>(Comp: FC<T>) => (props: T) => DocumentFragment;
 export default Intable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intable/react",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,7 +18,7 @@
   ],
   "dependencies": {
     "solid-js": "^1.9.9",
-    "intable": "^0.0.8"
+    "intable": "^0.0.10"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0 || ^20.0.0",