@sellgar/kit 0.0.176 → 0.0.178

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sellgar/kit",
   "type": "module",
-  "version": "0.0.176",
+  "version": "0.0.178",
   "description": "Sellgar kit",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -44,7 +44,8 @@
     "overlayscrollbars": "2.14.0",
     "overlayscrollbars-react": "0.5.6",
     "react-baron": "3.0.0",
-    "react-slider": "2.0.6"
+    "react-slider": "2.0.6",
+    "stickybits": "3.7.11"
   },
   "peerDependencies": {
     "react": "^19",

package/types/components/table/components/tbody/cell/cell.d.ts

@@ -6,6 +6,10 @@ interface IProps<T> {
     collapse?: boolean;
     data: ITableNode<T>;
     className?: string;
+    cellRef?: React.Ref<HTMLTableCellElement>;
+    onClick?: React.MouseEventHandler<HTMLTableCellElement>;
+    onDoubleClick?: React.MouseEventHandler<HTMLTableCellElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLTableCellElement>;
 }
 export declare const Cell: <T>(props: React.PropsWithChildren<IProps<T>>) => React.JSX.Element;
 export {};

package/types/components/table/configuration/cell/cell.d.ts

@@ -1,8 +1,11 @@
 import { default as React } from 'react';
-export interface IProps {
+import { ITableNode } from '../../table.types.ts';
+export interface IProps<T = any> {
     className?: string;
+    render?(node: ITableNode<T>): React.ReactNode;
 }
-interface ITableCellPropsWithDisplayName extends React.FC<React.PropsWithChildren<IProps>> {
+interface ITableCellPropsWithDisplayName {
+    <T = any>(props: React.PropsWithChildren<IProps<T>>): React.ReactNode;
     displayName: string;
 }
 export declare const Cell: ITableCellPropsWithDisplayName;

package/types/components/table/configuration/column/column.d.ts

@@ -5,7 +5,7 @@ export interface ISort {
     onReset?(): void;
 }
 export interface IProps {
-    width?: number;
+    width?: number | string;
     align?: 'left' | 'center' | 'right';
     pinLeft?: boolean;
     pinRight?: boolean;

package/types/components/table/configuration/create-columns-config.d.ts

@@ -1,15 +1,16 @@
 import { default as React } from 'react';
 import { ISort } from './column';
+import { ITableNode } from '../table.types.ts';
 export interface IConfigColumn<T> {
     label: React.ReactNode;
     align?: 'left' | 'center' | 'right';
     sort?: ISort;
-    width?: number;
+    width?: number | string;
     collapse?: boolean;
     pinLeft?: boolean;
     pinRight?: boolean;
     pinSource?: 'user' | 'system';
     cellClassName?: string;
-    renderCell: (nodes: T) => React.ReactNode;
+    renderCell: (node: ITableNode<T>) => React.ReactNode;
 }
 export declare const createColumnConfig: <T>(children: React.ReactNode) => IConfigColumn<T>[];

package/types/components/table/configuration/create-empty-config.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface IConfigEmpty {
+    renderEmpty: () => React.ReactNode;
+}
+export declare const createEmptyConfig: (children: React.ReactNode) => IConfigEmpty | null;

package/types/components/table/configuration/empty/empty.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface IEmptyProps {
+}
+interface IEmptyPropsWithDisplayName extends React.FC<React.PropsWithChildren<IEmptyProps>> {
+    displayName: string;
+}
+export declare const Empty: IEmptyPropsWithDisplayName;
+export {};

package/types/components/table/feature/row-events/index.d.ts

@@ -0,0 +1,3 @@
+export { RowEventsProvider } from './row-events.provider.tsx';
+export { useRowEventsContext } from './row-events.context.ts';
+export type { IRowConfig, IRowEventPayload, IRowHandlers, TRowTrigger } from './row-events.types.ts';

package/types/components/table/feature/row-events/row-events.context.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { TNodeId } from '../../table.types.ts';
+interface IRowEventsContext<T> {
+    onRowClick(event: React.MouseEvent<HTMLTableCellElement>, node: T, id: TNodeId, index: number): void;
+    onRowDoubleClick(event: React.MouseEvent<HTMLTableCellElement>, node: T, id: TNodeId, index: number): void;
+    onRowContextMenu(event: React.MouseEvent<HTMLTableCellElement>, node: T, id: TNodeId, index: number): void;
+}
+export declare const RowEventsContext: React.Context<IRowEventsContext<any> | null>;
+export declare const useRowEventsContext: <T>(source?: string) => IRowEventsContext<T>;
+export {};

package/types/components/table/feature/row-events/row-events.provider.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { IRowConfig } from './row-events.types.ts';
+interface IProps<T> {
+    config?: IRowConfig<T>;
+}
+export declare const RowEventsProvider: <T>(props: React.PropsWithChildren<IProps<T>>) => React.JSX.Element;
+export {};

package/types/components/table/feature/row-events/row-events.types.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { TNodeId } from '../../table.types.ts';
+export type TRowTrigger = 'click' | 'doubleClick' | 'contextMenu';
+export interface IRowEventPayload<T> {
+    node: T;
+    id: TNodeId;
+    index: number;
+    trigger: TRowTrigger;
+    nativeEvent: React.MouseEvent<HTMLTableCellElement>;
+}
+export interface IRowHandlers<T> {
+    click?(payload: IRowEventPayload<T>): void;
+    doubleClick?(payload: IRowEventPayload<T>): void;
+    contextMenu?(payload: IRowEventPayload<T>): void;
+}
+export interface IRowConfig<T> {
+    handlers?: IRowHandlers<T>;
+    isInteractiveTarget?(target: EventTarget | null): boolean;
+    disableDefaultInteractiveGuard?: boolean;
+    getRowId?(node: T): TNodeId;
+    lastRowTrigger?: {
+        onLastRowVisible(node: T): void;
+        rootMargin?: number;
+    };
+}

package/types/components/table/table.context.d.ts

@@ -2,16 +2,21 @@ import { default as React } from 'react';
 import { IData } from './table.tsx';
 import { ITableNode, TNodeId } from './table.types.ts';
 import { IConfigColumn } from './configuration/create-columns-config.ts';
+import { IRowConfig } from './feature/row-events';
 interface IContext<T> {
     data: IData<ITableNode<T>>;
     columns: IConfigColumn<T>[];
     columnsWidth: number[];
     resolveNodeId(node: T): TNodeId | undefined;
+    row?: IRowConfig<T>;
     expand?: {
         isExpanded(id: TNodeId): boolean;
         toggleById(id: TNodeId): void;
         renderExpanded(node: T): React.ReactNode;
     };
+    empty?: {
+        renderEmpty(): React.ReactNode;
+    };
 }
 export declare const TableContext: React.Context<IContext<any> | null>;
 export declare const useTableContext: <T>(source?: string) => IContext<T>;

package/types/components/table/table.d.ts

@@ -3,8 +3,9 @@ import { Cell } from './configuration/cell';
 import { Head } from './configuration/head';
 import { Column } from './configuration/column';
 import { Expand } from './configuration/expand/expand';
+import { Empty } from './configuration/empty/empty';
 import { ExpandTrigger } from './feature/expand';
-import { TNodeId } from './table.types.ts';
+import { IRowConfig, IRowEventPayload, IRowHandlers, TRowTrigger } from './feature/row-events';
 export interface IData<T> {
     nodes: T[];
 }
@@ -21,16 +22,18 @@ interface IProps<T> {
     data: IData<T>;
     tree?: ITreeProps<T>;
     select?: ISelectProps<T>;
+    row?: IRowConfig<T>;
     isBordered?: boolean;
-    getRowId?(node: T): TNodeId;
+    useInternalScroll?: boolean;
 }
 export declare const TableComponent: <T>(props: React.PropsWithChildren<IProps<T>>) => React.JSX.Element;
+export type { IRowConfig, IRowEventPayload, IRowHandlers, TRowTrigger };
 type TTable = typeof TableComponent & {
     Column: typeof Column;
     Head: typeof Head;
     Cell: typeof Cell;
     Expand: typeof Expand;
+    Empty: typeof Empty;
     ExpandTrigger: typeof ExpandTrigger;
 };
 export declare const Table: TTable;
-export {};

package/types/components/wrappers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './field';
 export * from './drop-down';
 export * from './scrollbar';
+export * from './sticky-layout';

package/types/components/wrappers/sticky-layout/index.d.ts

@@ -0,0 +1 @@
+export { StickyLayout } from './sticky-layout.wrapper.tsx';

package/types/components/wrappers/sticky-layout/sticky-layout.wrapper.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+type TStickybitsVerticalPosition = 'top' | 'bottom';
+type TStickyDirection = 'top' | 'bottom' | 'left' | 'right';
+interface IStickyLayoutProps extends React.HTMLAttributes<HTMLDivElement> {
+    gap?: number | string;
+    scrollbarClassName?: string;
+    scrollbarStyle?: React.CSSProperties;
+    stickyAutoOffsetPadding?: number;
+    stickyAutoOffsetGap?: number;
+}
+interface IStickyLayoutStaticProps extends React.HTMLAttributes<HTMLDivElement> {
+    zIndex?: number;
+}
+interface IStickyLayoutStickyProps extends React.HTMLAttributes<HTMLDivElement> {
+    offset?: number;
+    autoOffset?: boolean;
+    zIndex?: number;
+    direction?: TStickyDirection[];
+    useStickyClasses?: boolean;
+    noStyles?: boolean;
+    useFixed?: boolean;
+    useGetBoundingClientRect?: boolean;
+    verticalPosition?: TStickybitsVerticalPosition;
+    parentClass?: string;
+    stickyClass?: string;
+    stuckClass?: string;
+    stickyChangeClass?: string;
+    customStickyChangeNumber?: number;
+    scrollEl?: Window | HTMLElement | string;
+}
+declare const StickyLayoutComponent: React.FC<React.PropsWithChildren<IStickyLayoutProps>>;
+declare const StickyLayoutStatic: React.FC<React.PropsWithChildren<IStickyLayoutStaticProps>>;
+declare const StickyLayoutSticky: React.FC<React.PropsWithChildren<IStickyLayoutStickyProps>>;
+type TStickyLayout = typeof StickyLayoutComponent & {
+    Static: typeof StickyLayoutStatic;
+    Sticky: typeof StickyLayoutSticky;
+};
+export declare const StickyLayout: TStickyLayout;
+export {};