@1771technologies/lytenyte-pro 1.0.20 → 2.0.0-dev.1

package/dist/root/root.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fallback, LnInternalShareProvider, Root as RootCore, usePiece, } from "@1771technologies/lytenyte-core/internal";
+import { forwardRef, memo, useEffect, useMemo, useRef, useState, } from "react";
+import { useProAPI } from "./hooks/use-pro-api.js";
+import { ProRootProvider } from "./context.js";
+import { hasAValidLicense, licenseState } from "../license.js";
+import { useControlled, useEvent, useRoot } from "@1771technologies/lytenyte-core/internal";
+import { splitCellSelectionRect } from "../cell-selection/index.js";
+import { CellSelectionDriver } from "../cell-selection/cell-selection-driver/cell-selection-driver.js";
+import { CellSelectionBottom, CellSelectionCenter, CellSelectionTop, } from "../cell-selection/cell-selection-containers.js";
+const RootWrapper = ({ children, ...p }, forwarded) => {
+    useEffect(() => {
+        if (hasAValidLicense)
+            return;
+        const existing = document.getElementById("lng1771-watermark");
+        if (existing)
+            return;
+        const invalidLicenseWatermark = document.createElement("div");
+        invalidLicenseWatermark.style.position = "fixed";
+        invalidLicenseWatermark.style.bottom = "0px";
+        invalidLicenseWatermark.style.insetInlineEnd = "0px";
+        invalidLicenseWatermark.style.background = "rgb(255, 167, 167)";
+        invalidLicenseWatermark.style.color = "black";
+        invalidLicenseWatermark.style.fontSize = "1.2rem";
+        invalidLicenseWatermark.style.fontWeight = "bold";
+        invalidLicenseWatermark.style.border = "1px solid black";
+        invalidLicenseWatermark.style.padding = "16px";
+        if (licenseState === "expired")
+            invalidLicenseWatermark.innerHTML = `LyteNyte Grid: License key expired. Your license covers earlier versions only.`;
+        else if (licenseState === "invalid")
+            invalidLicenseWatermark.innerHTML = `LyteNyte Grid: Invalid license key. Please verify the key and try again.`;
+        else
+            invalidLicenseWatermark.innerHTML = `LyteNyte Grid PRO is being used for evaluation. 
+      <a href="https://1771Technologies.com/pricing">Click here</a> to secure your license.`;
+        document.body.appendChild(invalidLicenseWatermark);
+        return () => invalidLicenseWatermark.remove();
+    }, []);
+    const components = p.cellSelectionMode !== "none"
+        ? {
+            ln_topComponent: CellSelectionTop,
+            ln_bottomComponent: CellSelectionBottom,
+            ln_centerComponent: CellSelectionCenter,
+        }
+        : {};
+    return (_jsx(RootCore, { ref: forwarded, ...p, ...components, __noFallback: true, children: _jsx(RootImpl, { ...p, children: children }) }));
+};
+const RootImpl = ({ children, ...p }) => {
+    const { view, source } = useRoot();
+    const cellSelectionMode = p.cellSelectionMode ?? "none";
+    const [cellSelections, setCellSelections] = useControlled({
+        controlled: p.cellSelections,
+        default: [],
+    });
+    const onCellSelectionChange = useEvent((rects) => {
+        p.onCellSelectionChange?.(rects);
+        setCellSelections(rects);
+    });
+    const api = useProAPI(cellSelections);
+    const [cellSelectionPivot, setSelectionPivot] = useState(null);
+    const [cellSelectionAdditiveRects, setCellSelectionAdditiveRects] = useState(null);
+    const cellSelectionIsDeselect = useRef(false);
+    const topCount = source.useTopCount();
+    const rowCount = source.useRowCount();
+    const botCount = source.useBottomCount();
+    const cellSelectionSplits = useMemo(() => {
+        const centerCount = rowCount - topCount - botCount;
+        const selections = cellSelections;
+        const splits = selections.flatMap((rect) => {
+            return splitCellSelectionRect({
+                rect,
+                rowTopCount: topCount,
+                rowCenterCount: centerCount,
+                colStartCount: view.startCount,
+                colCenterCount: view.centerCount,
+            });
+        });
+        return splits;
+    }, [botCount, cellSelections, rowCount, topCount, view.centerCount, view.startCount]);
+    const excludeMarker = Boolean(p.columnMarker?.on && p.cellSelectionExcludeMarker);
+    const value = useMemo(() => {
+        return {
+            api,
+            excludeMarker,
+            keepSelection: p.cellSelectionMaintainOnNonCellPosition ?? false,
+            cellSelectionMode,
+            cellSelections,
+            cellSelectionPivot,
+            setSelectionPivot: setSelectionPivot,
+            onCellSelectionChange,
+            cellSelectionAdditiveRects,
+            setCellSelectionAdditiveRects,
+            cellSelectionIsDeselect,
+            cellSelectionSplits,
+        };
+    }, [
+        api,
+        excludeMarker,
+        p.cellSelectionMaintainOnNonCellPosition,
+        cellSelectionMode,
+        cellSelections,
+        cellSelectionPivot,
+        onCellSelectionChange,
+        cellSelectionAdditiveRects,
+        cellSelectionSplits,
+    ]);
+    const cellSelectionsPiece = usePiece(cellSelections);
+    return (_jsx(LnInternalShareProvider, { value: useMemo(() => ({
+            cellSelections: cellSelectionsPiece,
+            hasCellSelection: (p.cellSelectionMode ?? "none") !== "none",
+        }), [cellSelectionsPiece, p.cellSelectionMode]), children: _jsxs(ProRootProvider, { value: value, children: [cellSelectionMode !== "none" && _jsx(CellSelectionDriver, {}), children ?? _jsx(Fallback, {})] }) }));
+};
+export const Root = memo(forwardRef(RootWrapper));

package/dist/types/api.d.ts

@@ -0,0 +1,100 @@
+import type { ColumnView, PositionFullWidthRow, PositionGridCell, PositionUnion, RowAggregated, RowGroup, RowLeaf, RowNode, RowSource } from "@1771technologies/lytenyte-shared";
+import type { Column } from "./column.js";
+import type { GridSpec } from "./grid.js";
+import type { Piece, useDraggable, UseDraggableProps } from "@1771technologies/lytenyte-core/internal";
+import type { Props } from "./props.js";
+type WithId = {
+    readonly id: string;
+};
+type RowSourceOmits = "onRowGroupExpansionsChange" | "onRowsUpdated" | "onRowsSelected";
+export interface DataRect {
+    readonly rowStart: number;
+    readonly rowEnd: number;
+    readonly columnStart: number;
+    readonly columnEnd: number;
+}
+export interface ExportDataRectResult<Spec extends GridSpec = GridSpec> {
+    readonly headers: string[];
+    readonly groupHeaders: (string | null)[][];
+    readonly data: unknown[][];
+    readonly columns: Column<Spec>[];
+}
+export type API<Spec extends GridSpec = GridSpec> = {
+    readonly cellSelections: () => DataRect[];
+    readonly positionFromElement: (el: HTMLElement) => PositionUnion | null;
+    readonly xPositions$: Piece<Uint32Array>;
+    readonly yPositions$: Piece<Uint32Array>;
+    readonly viewport$: Piece<HTMLElement | null>;
+    readonly cellRoot: (row: number, column: number) => PositionGridCell | PositionFullWidthRow | null;
+    readonly columnById: (id: string) => Column<Spec> | null;
+    readonly columnByIndex: (index: number) => Column<Spec> | null;
+    readonly columnField: (columnOrId: string | WithId, row: RowNode<Spec["data"]>) => unknown;
+    readonly columnMove: (params: {
+        readonly moveColumns: (string | WithId)[];
+        readonly moveTarget: string | number | WithId;
+        readonly before?: boolean;
+        readonly updatePinState?: boolean;
+    }) => void;
+    readonly columnResize: (sizes: Record<string, number>) => void;
+    readonly columnAutosize: (params?: {
+        readonly dryRun?: boolean;
+        readonly includeHeader?: boolean;
+        readonly columns?: (string | number | WithId)[];
+    }) => Record<string, number>;
+    readonly columnUpdate: (updates: Record<string, Omit<Partial<Column<Spec>>, "id">>) => void;
+    readonly columnToggleGroup: (group: string | string[], state?: boolean) => void;
+    readonly columnView: () => ColumnView;
+    readonly rowDetailHeight: (rowId: WithId | string) => number;
+    readonly rowDetailExpanded: (rowOrId: RowNode<Spec["data"]> | string | number) => boolean;
+    readonly rowDetailToggle: (rowOrId: string | RowNode<Spec["data"]>, state?: boolean) => void;
+    readonly rowGroupToggle: (rowOrId: RowNode<Spec["data"]> | string, state?: boolean) => void;
+    readonly rowIsLeaf: (row: RowNode<Spec["data"]>) => row is RowLeaf<Spec["data"]>;
+    readonly rowIsGroup: (row: RowNode<Spec["data"]>) => row is RowGroup;
+    readonly rowIsAggregated: (row: RowNode<Spec["data"]>) => row is RowAggregated;
+    readonly rowIsExpanded: (row: RowNode<Spec["data"]>) => boolean;
+    readonly rowIsExpandable: (row: RowNode<Spec["data"]>) => boolean;
+    readonly rowView: () => {
+        rowCount: number;
+        topCount: number;
+        bottomCount: number;
+        centerCount: number;
+    };
+    readonly exportData: (params?: {
+        readonly rect?: DataRect;
+    }) => Promise<ExportDataRectResult<Spec>>;
+    readonly scrollIntoView: (params: {
+        readonly column?: number | string | WithId;
+        readonly row?: number;
+        readonly behavior?: "smooth" | "auto" | "instant";
+    }) => void;
+    readonly viewport: () => HTMLElement | null;
+    readonly editBegin: (params: {
+        readonly init?: any;
+        readonly column: WithId | string | number;
+        readonly rowIndex: number;
+        readonly focusIfNotEditable?: boolean;
+    }) => void;
+    readonly editEnd: (cancel?: boolean) => void;
+    readonly editIsCellActive: (params: {
+        readonly column: WithId | string | number;
+        readonly rowIndex: number;
+    }) => boolean;
+    readonly editUpdateRows: (rows: Map<string | number, unknown>) => true | Map<string | number, boolean | Record<string, unknown>>;
+    readonly editUpdateCells: (cells: Map<string | number, {
+        value: any;
+        column: Column<Spec> | string | number;
+    }[]>) => true | Map<string | number, boolean | Record<string, unknown>>;
+    readonly rowSelect: (params: {
+        readonly selected: string | [start: string, end: string] | Set<string> | "all";
+        readonly deselect?: boolean;
+    }) => void;
+    readonly rowHandleSelect: (params: {
+        readonly target: EventTarget;
+        readonly shiftKey: boolean;
+    }) => void;
+    readonly useRowDrag: (params: Partial<Pick<UseDraggableProps, "data" | "placeholder">> & {
+        rowIndex: number;
+    }) => ReturnType<typeof useDraggable>;
+    readonly props: () => Props<Spec>;
+} & Omit<RowSource, RowSourceOmits> & (undefined extends Spec["source"] ? object : Omit<Spec["source"], RowSourceOmits>) & Spec["api"];
+export {};

package/dist/types/api.js

@@ -0,0 +1 @@
+export {};

package/dist/types/column.d.ts

@@ -0,0 +1,73 @@
+import type { ReactNode } from "react";
+import type { ColumnAbstract, LayoutCell, LayoutFullWidthRow, RowNode } from "@1771technologies/lytenyte-shared";
+import type { GridSpec } from "./grid.js";
+import type { API } from "./api.js";
+export type PathField = {
+    kind: "path";
+    path: string;
+};
+export interface RowParams<Spec extends GridSpec = GridSpec> {
+    readonly rowIndex: number;
+    readonly row: RowNode<Spec["data"]>;
+    readonly api: API<Spec>;
+}
+export interface RowFullWidthRendererParams<Spec extends GridSpec = GridSpec> extends RowParams<Spec> {
+    readonly layout: LayoutFullWidthRow;
+}
+export interface HeaderParams<Spec extends GridSpec = GridSpec> {
+    readonly column: Column<Spec>;
+    readonly api: API<Spec>;
+}
+export interface HeaderGroupParams<Spec extends GridSpec = GridSpec> {
+    readonly collapsible: boolean;
+    readonly collapsed: boolean;
+    readonly groupPath: string[];
+    readonly columns: Column<Spec>[];
+    readonly api: API<Spec>;
+}
+export interface CellParams<Spec extends GridSpec = GridSpec> {
+    readonly row: RowNode<Spec["data"]>;
+    readonly column: Column<Spec>;
+    readonly api: API<Spec>;
+}
+export interface CellParamsWithIndex<Spec extends GridSpec = GridSpec> extends CellParams<Spec> {
+    readonly rowIndex: number;
+    readonly colIndex: number;
+}
+export interface CellRendererParams<Spec extends GridSpec = GridSpec> extends CellParamsWithIndex<Spec> {
+    readonly selected: boolean;
+    readonly indeterminate: boolean;
+    readonly detailExpanded: boolean;
+    readonly editData: unknown;
+    readonly layout: LayoutCell;
+}
+export interface EditParams<Spec extends GridSpec = GridSpec> extends CellParamsWithIndex<Spec> {
+    readonly editValue: unknown;
+    readonly changeValue: (value: unknown) => boolean | Record<string, unknown>;
+    readonly editData: unknown;
+    readonly editValidation: boolean | Record<string, unknown>;
+    readonly changeData: (data: unknown) => boolean | Record<string, unknown>;
+    readonly commit: () => boolean | Record<string, unknown>;
+    readonly cancel: () => void;
+    readonly layout: LayoutCell;
+}
+export type Field<T> = string | number | PathField | ((params: {
+    row: RowNode<T>;
+}) => unknown);
+interface ColumnUnextended<Spec extends GridSpec = GridSpec> extends ColumnAbstract {
+    readonly field?: Field<Spec["data"]>;
+    readonly colSpan?: number | ((params: CellParamsWithIndex<Spec>) => number);
+    readonly rowSpan?: number | ((params: CellParamsWithIndex<Spec>) => number);
+    readonly autosizeCellFn?: (params: CellParams<Spec>) => number | null | undefined;
+    readonly autosizeHeaderFn?: (params: HeaderParams<Spec>) => number | null | undefined;
+    readonly floatingCellRenderer?: (props: HeaderParams<Spec>) => ReactNode;
+    readonly headerRenderer?: (props: HeaderParams<Spec>) => ReactNode;
+    readonly cellRenderer?: (props: CellRendererParams<Spec>) => ReactNode;
+    readonly editOnPrintable?: boolean;
+    readonly editRenderer?: (props: EditParams<Spec>) => ReactNode;
+    readonly editable?: boolean | ((params: CellParamsWithIndex<Spec>) => boolean);
+    readonly editSetter?: (params: Pick<EditParams<Spec>, "api" | "editValue" | "editData" | "row" | "column">) => unknown;
+    readonly editMutateCommit?: (params: Pick<EditParams<Spec>, "api" | "editData" | "row" | "column">) => void;
+}
+export type Column<Spec extends GridSpec = GridSpec> = ColumnUnextended<Spec> & Spec["column"];
+export {};

package/dist/types/column.js

@@ -0,0 +1 @@
+export {};

package/dist/types/events.d.ts

@@ -0,0 +1,56 @@
+import type { LayoutCell, LayoutFullWidthRow, LayoutHeaderCell, LayoutHeaderFloating, LayoutHeaderGroup, LayoutRowWithCells, RowNode } from "@1771technologies/lytenyte-shared";
+import type { Column } from "./column.js";
+import type { GridSpec } from "./grid.js";
+import type { JSX } from "react";
+import type { API } from "./api.js";
+export type Events = {
+    [key in keyof Required<JSX.IntrinsicElements["div"]> as key extends `on${string}` ? key : never]: JSX.IntrinsicElements["div"][key];
+};
+type CellEvents<Spec extends GridSpec = GridSpec> = {
+    [key in keyof Required<JSX.IntrinsicElements["div"]> as key extends `on${infer X}` ? Uncapitalize<X> : never]: (params: {
+        event: Parameters<JSX.IntrinsicElements["div"][key]>[0];
+        column: Column<Spec>;
+        row: RowNode<Spec["data"]>;
+        layout: LayoutCell;
+        api: API<Spec>;
+    }) => void;
+};
+type RowEvents<Spec extends GridSpec = GridSpec> = {
+    [key in keyof Required<JSX.IntrinsicElements["div"]> as key extends `on${infer X}` ? Uncapitalize<X> : never]: (params: {
+        event: Parameters<JSX.IntrinsicElements["div"][key]>[0];
+        row: RowNode<Spec["data"]>;
+        layout: LayoutRowWithCells | LayoutFullWidthRow;
+        api: API<Spec>;
+    }) => void;
+};
+type HeaderEvents<Spec extends GridSpec = GridSpec> = {
+    [key in keyof Required<JSX.IntrinsicElements["div"]> as key extends `on${infer X}` ? Uncapitalize<X> : never]: (params: {
+        event: Parameters<JSX.IntrinsicElements["div"][key]>[0];
+        layout: LayoutHeaderCell | LayoutHeaderFloating;
+        column: Column<Spec>;
+        api: API<Spec>;
+    }) => void;
+};
+type HeaderGroupEvents<Spec extends GridSpec = GridSpec> = {
+    [key in keyof Required<JSX.IntrinsicElements["div"]> as key extends `on${infer X}` ? Uncapitalize<X> : never]: (params: {
+        event: Parameters<JSX.IntrinsicElements["div"][key]>[0];
+        layout: LayoutHeaderGroup;
+        columns: Column<Spec>[];
+        api: API<Spec>;
+    }) => void;
+};
+type ViewportEvents<Spec extends GridSpec = GridSpec> = {
+    [key in keyof Required<JSX.IntrinsicElements["div"]> as key extends `on${infer X}` ? Uncapitalize<X> : never]: (params: {
+        event: Parameters<JSX.IntrinsicElements["div"][key]>[0];
+        viewport: HTMLElement;
+        api: API<Spec>;
+    }) => void;
+};
+export type GridEvents<Spec extends GridSpec = GridSpec> = {
+    readonly cell?: Partial<CellEvents<Spec>>;
+    readonly row?: Partial<RowEvents<Spec>>;
+    readonly headerCell?: Partial<HeaderEvents<Spec>>;
+    readonly headerGroup?: Partial<HeaderGroupEvents<Spec>>;
+    readonly viewport?: Partial<ViewportEvents<Spec>>;
+};
+export {};

package/dist/types/events.js

@@ -0,0 +1 @@
+export {};

package/dist/types/grid.d.ts

@@ -0,0 +1,47 @@
+import type { RowSource } from "@1771technologies/lytenyte-shared";
+import type { DataRect } from "./api";
+import type { CSSProperties } from "react";
+export interface GridSpec<Data = unknown, ColExt extends Record<string, any> = object, S extends RowSource<Data> = RowSource, Ext extends Record<string, any> = object> {
+    readonly data?: Data;
+    readonly column?: ColExt;
+    readonly source?: S;
+    readonly api?: Ext;
+}
+export interface VirtualTarget {
+    readonly getBoundingClientRect: () => Omit<DOMRect, "toJSON">;
+    readonly getClientRects?: () => Omit<DOMRect, "toJSON">[];
+    readonly contextElement?: HTMLElement;
+}
+export interface DataRectSplit extends DataRect {
+    readonly isUnit: boolean;
+    readonly borderTop?: boolean;
+    readonly borderBottom?: boolean;
+    readonly borderStart?: boolean;
+    readonly borderEnd?: boolean;
+}
+export type GridStyle = {
+    readonly viewport?: {
+        readonly style?: CSSProperties;
+        readonly className?: string;
+    };
+    readonly row?: {
+        readonly style?: CSSProperties;
+        readonly className?: string;
+    };
+    readonly header?: {
+        readonly style?: CSSProperties;
+        readonly className?: string;
+    };
+    readonly detail?: {
+        readonly style?: CSSProperties;
+        readonly className?: string;
+    };
+    readonly headerGroup?: {
+        readonly style?: CSSProperties;
+        readonly className?: string;
+    };
+    readonly cell?: {
+        readonly style?: CSSProperties;
+        readonly className?: string;
+    };
+};

package/dist/types/grid.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export type * from "./api.js";
+export type * from "./column.js";
+export type * from "./grid.js";
+export type * from "./props.js";
+export type { HavingFilterFn, PivotField, PivotModel, LabelFilter, } from "../data-source-client/use-client-data-source.js";
+export type { PivotState } from "../data-source-client/hooks/use-pivot/use-pivot-columns.js";
+export type { SortFn, GroupFn, DimensionSort, DimensionAgg, Dimension, FilterFn, AggregationFn, Aggregator, LeafIdFn, GroupIdFn, RowSelectionState, RowSelectionIsolated, RowSelectionLinked, RowSelectNode, RowNode, RowLeaf, RowGroup, RowAggregated, ColumnPin, LayoutCell, LayoutHeader, LayoutHeaderCell, LayoutHeaderGroup, LayoutHeaderFloating, LayoutFullWidthRow, LayoutRow, LayoutRowWithCells, PositionDetailCell, PositionFloatingCell, PositionFullWidthRow, PositionGridCell, PositionGridCellRoot, PositionHeaderCell, PositionHeaderGroupCell, PositionUnion, } from "@1771technologies/lytenyte-shared";

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/props.d.ts

@@ -0,0 +1,187 @@
+import type { RowHeight, RowNode } from "@1771technologies/lytenyte-shared";
+import type { ReactNode, Ref } from "react";
+import type { Column, EditParams, HeaderGroupParams, HeaderParams, RowFullWidthRendererParams, RowParams } from "./column.js";
+import type { GridSpec, GridStyle } from "./grid.js";
+import type { API, DataRect } from "./api.js";
+import type { ViewportShadowsProps } from "@1771technologies/lytenyte-core/components";
+import type { GridEvents } from "./events.js";
+export type Props<Spec extends GridSpec = GridSpec> = {
+    readonly cellSelectionMode?: "range" | "multi-range" | "none";
+    readonly cellSelections?: DataRect[];
+    readonly cellSelectionExcludeMarker?: boolean;
+    readonly cellSelectionMaintainOnNonCellPosition?: boolean;
+    readonly onCellSelectionChange?: (rects: DataRect[]) => void;
+    readonly columns?: Column<Spec>[] | null;
+    readonly columnBase?: Omit<Partial<Column<Spec>>, "id" | "pin" | "field" | "editSetter">;
+    readonly columnMarker?: Omit<Partial<Column<Spec>>, "id" | "field" | "pin"> & {
+        on?: boolean;
+    };
+    readonly columnGroupDefaultExpansion?: boolean;
+    readonly columnGroupExpansions?: Record<string, boolean>;
+    readonly columnGroupJoinDelimiter?: string;
+    readonly columnSizeToFit?: boolean;
+    readonly columnDoubleClickToAutosize?: boolean;
+    readonly columnMoveDragPlaceholder?: {
+        query: string;
+        offset?: [number, number];
+    } | string | ((props: HeaderParams<Spec> & {
+        readonly x: number;
+        readonly y: number;
+        readonly outside: boolean;
+    }) => ReactNode);
+    readonly columnGroupMoveDragPlaceholder?: {
+        query: string;
+        offset?: [number, number];
+    } | string | ((props: HeaderGroupParams<Spec> & {
+        readonly x: number;
+        readonly y: number;
+        readonly outside: boolean;
+    }) => ReactNode);
+    readonly columnGroupRenderer?: (props: HeaderGroupParams<Spec>) => ReactNode;
+    readonly gridId?: string;
+    readonly events?: GridEvents<Spec>;
+    readonly styles?: GridStyle;
+    readonly rtl?: boolean;
+    readonly headerHeight?: number;
+    readonly headerGroupHeight?: number;
+    readonly floatingRowHeight?: number;
+    readonly floatingRowEnabled?: boolean;
+    readonly rowOverscanTop?: number;
+    readonly rowOverscanBottom?: number;
+    readonly colOverscanStart?: number;
+    readonly colOverscanEnd?: number;
+    readonly virtualizeCols?: boolean;
+    readonly virtualizeRows?: boolean;
+    readonly rowAlternateAttr?: boolean;
+    readonly rowScanDistance?: number;
+    readonly rowSource?: Spec["source"];
+    readonly rowHeight?: RowHeight;
+    readonly rowGroupColumn?: false | Omit<Partial<Column<Spec>>, "field" | "id">;
+    readonly rowFullWidthPredicate?: null | ((params: RowParams<Spec>) => boolean);
+    readonly rowFullWidthRenderer?: (props: RowFullWidthRendererParams<Spec>) => ReactNode | null;
+    readonly rowSelectionMode?: "single" | "multiple" | "none";
+    readonly rowSelectionActivator?: "single-click" | "double-click" | "none";
+    readonly rowDetailExpansions?: Set<string>;
+    readonly rowDetailHeight?: number | "auto";
+    readonly rowDetailAutoHeightGuess?: number;
+    readonly rowDetailRenderer?: (props: RowParams<Spec>) => ReactNode | null;
+    readonly rowDropAccept?: string[];
+    readonly ref?: Ref<API<Spec>>;
+    readonly slotShadows?: (props: ViewportShadowsProps) => ReactNode;
+    readonly slotViewportOverlay?: ((props: {
+        api: API<Spec>;
+    }) => ReactNode) | ReactNode;
+    readonly slotRowsOverlay?: ((props: {
+        api: API<Spec>;
+    }) => ReactNode) | ReactNode;
+    readonly editRowValidatorFn?: (params: Pick<EditParams<Spec>, "api" | "editData" | "row">) => boolean | Record<string, unknown>;
+    readonly editClickActivator?: "single-click" | "double-click" | "none";
+    readonly editMode?: "cell" | "row" | "readonly";
+    readonly onColumnGroupExpansionChange?: (change: Record<string, boolean>) => void;
+    readonly onRowDetailExpansionsChange?: (change: Set<string>) => void;
+    readonly onColumnsChange?: (columns: Column<Spec>[]) => void;
+    readonly onRowGroupColumnChange?: (column: Omit<Column<Spec>, "field" | "id">) => void;
+    readonly onColumnMoveOutside?: (params: {
+        readonly api: API<Spec>;
+        readonly columns: Column<Spec>[];
+    }) => void;
+    readonly onEditBegin?: (params: {
+        readonly api: API<Spec>;
+        readonly preventDefault: () => void;
+        readonly row: RowNode<Spec["data"]>;
+        readonly column: Column<Spec>;
+        readonly editData: unknown;
+    }) => void;
+    readonly onEditEnd?: (params: {
+        readonly api: API<Spec>;
+        readonly preventDefault: () => void;
+        readonly row: RowNode<Spec["data"]>;
+        readonly column: Column<Spec>;
+        readonly editData: unknown;
+    }) => void;
+    readonly onEditCancel?: (params: {
+        readonly api: API<Spec>;
+        readonly row: RowNode<Spec["data"]>;
+        readonly column: Column<Spec>;
+        readonly editData: unknown;
+    }) => void;
+    readonly onEditFail?: (params: {
+        readonly api: API<Spec>;
+        readonly row: RowNode<Spec["data"]>;
+        readonly column: Column<Spec>;
+        readonly editData: unknown;
+        readonly validation: null | Record<string, unknown> | boolean;
+    }) => void;
+    readonly onRowSelect?: (params: {
+        readonly preventDefault: () => void;
+        readonly api: API<Spec>;
+        readonly rows: string[] | "all";
+        readonly deselect: boolean;
+    }) => void;
+    readonly onRowDrop?: (params: {
+        readonly source: {
+            id: string;
+            api: API<GridSpec>;
+            row: RowNode<any>;
+            rowIndex: number;
+            data?: any;
+        };
+        readonly over: {
+            kind: "viewport";
+            id: string;
+            element: HTMLElement;
+            api: API<GridSpec>;
+        } | {
+            kind: "row";
+            id: string;
+            api: API<GridSpec>;
+            row: RowNode<any>;
+            rowIndex: number;
+            element: HTMLElement;
+        };
+    }) => void;
+    readonly onRowDragEnter?: (params: {
+        readonly source: {
+            id: string;
+            api: API<GridSpec>;
+            row: RowNode<any>;
+            rowIndex: number;
+            data?: any;
+        };
+        readonly over: {
+            kind: "viewport";
+            id: string;
+            element: HTMLElement;
+            api: API<GridSpec>;
+        } | {
+            kind: "row";
+            id: string;
+            api: API<GridSpec>;
+            row: RowNode<any>;
+            rowIndex: number;
+            element: HTMLElement;
+        };
+    }) => void;
+    readonly onRowDragLeave?: (params: {
+        readonly source: {
+            id: string;
+            api: API<GridSpec>;
+            row: RowNode<any>;
+            rowIndex: number | null;
+            data?: any;
+        };
+        readonly over: {
+            kind: "viewport";
+            id: string;
+            element: HTMLElement;
+            api: API<GridSpec>;
+        } | {
+            kind: "row";
+            id: string;
+            api: API<GridSpec>;
+            row: RowNode<any>;
+            rowIndex: number | null;
+            element: HTMLElement;
+        };
+    }) => void;
+};

package/dist/types/props.js

@@ -0,0 +1 @@
+export {};