@versini/ui-datagrid 0.1.0

package/dist/DataGridFooter/DataGridFooter.js

@@ -0,0 +1,81 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { DataGridContext } from "../DataGrid/DataGridContext.js";
+import { getStickyBlurClasses } from "../DataGrid/utilities.js";
+import { BlurEffects, CellWrapper } from "../DataGridConstants/DataGridConstants.js";
+
+;// CONCATENATED MODULE: external "react/jsx-runtime"
+
+;// CONCATENATED MODULE: external "clsx"
+
+;// CONCATENATED MODULE: external "../DataGrid/DataGridContext.js"
+
+;// CONCATENATED MODULE: external "../DataGrid/utilities.js"
+
+;// CONCATENATED MODULE: external "../DataGridConstants/DataGridConstants.js"
+
+;// CONCATENATED MODULE: ./src/DataGridFooter/DataGridFooter.tsx
+
+
+
+
+
+/**
+ * Generates classes for the DataGridFooter.
+ */ const getFooterClasses = ({ className, stickyFooter, mode, blurEffect })=>{
+    const hasBlur = blurEffect && blurEffect !== BlurEffects.NONE;
+    return clsx({
+        /**
+			 * Absolute positioning like Panel's footer: absolute left-0 right-0 z-20
+			 * bottom-0 rounded-b-lg to match the wrapper's rounded-lg corners.
+			 */ "absolute left-0 right-0 z-20 bottom-0 rounded-b-lg": stickyFooter,
+        // Shadow for visual depth (upward glow).
+        "shadow-[rgb(190_190_190_/20%)_0_-0.5rem_1rem]": stickyFooter && mode === "dark",
+        "shadow-[rgb(190_190_190_/20%)_0_-0.5rem_1rem] dark:shadow-[rgb(65_65_65_/30%)_0_-0.5rem_1rem]": stickyFooter && mode === "system",
+        "shadow-[rgb(65_65_65_/30%)_0_-0.5rem_1rem]": stickyFooter && mode === "light",
+        "shadow-[rgb(65_65_65_/30%)_0_-0.5rem_1rem] dark:shadow-[rgb(190_190_190_/20%)_0_-0.5rem_1rem]": stickyFooter && mode === "alt-system",
+        // Semi-transparent backgrounds for blur effect.
+        "bg-table-head-dark/50": hasBlur && stickyFooter && (mode === "dark" || mode === "system"),
+        "bg-table-head-light/50": hasBlur && stickyFooter && (mode === "light" || mode === "alt-system"),
+        "dark:bg-table-head-light/50": hasBlur && stickyFooter && mode === "system",
+        "dark:bg-table-head-dark/50": hasBlur && stickyFooter && mode === "alt-system",
+        // Solid backgrounds when no blur effect.
+        "bg-table-head-dark": !hasBlur && stickyFooter && (mode === "dark" || mode === "system"),
+        "bg-table-head-light": !hasBlur && stickyFooter && (mode === "light" || mode === "alt-system"),
+        "dark:bg-table-head-light": !hasBlur && stickyFooter && mode === "system",
+        "dark:bg-table-head-dark": !hasBlur && stickyFooter && mode === "alt-system"
+    }, stickyFooter && getStickyBlurClasses({
+        blurEffect
+    }), className);
+};
+/* =============================================================================
+ * DataGridFooter
+ * ========================================================================== */ const DataGridFooter = ({ className, children, ...rest })=>{
+    return /*#__PURE__*/ jsx(DataGridContext.Consumer, {
+        children: ({ mode, stickyFooter, blurEffect })=>/*#__PURE__*/ jsx(DataGridContext.Consumer, {
+                children: (ctx)=>/*#__PURE__*/ jsx(DataGridContext.Provider, {
+                        value: {
+                            ...ctx,
+                            cellWrapper: CellWrapper.FOOTER
+                        },
+                        children: /*#__PURE__*/ jsx("tfoot", {
+                            className: getFooterClasses({
+                                className,
+                                stickyFooter,
+                                mode,
+                                blurEffect
+                            }),
+                            ...rest,
+                            children: children
+                        })
+                    })
+            })
+    });
+};
+
+export { DataGridFooter, getFooterClasses };

package/dist/DataGridFooter/index.d.ts

@@ -0,0 +1 @@
+export { DataGridFooter } from "./DataGridFooter";

package/dist/DataGridFooter/index.js

@@ -0,0 +1,13 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { DataGridFooter } from "./DataGridFooter.js";
+
+;// CONCATENATED MODULE: external "./DataGridFooter.js"
+
+;// CONCATENATED MODULE: ./src/DataGridFooter/index.ts
+
+
+export { DataGridFooter };

package/dist/DataGridHeader/DataGridHeader.d.ts

@@ -0,0 +1,13 @@
+import type { DataGridHeaderProps } from "../DataGrid/DataGridTypes";
+import { type BlurEffect, type ThemeMode } from "../DataGridConstants/DataGridConstants";
+/**
+ * Generates classes for the DataGridHeader. Uses absolute positioning like
+ * Panel - header floats above the scrollable content.
+ */
+export declare const getHeaderClasses: ({ className, stickyHeader, mode, blurEffect, }: {
+    mode: ThemeMode;
+    blurEffect?: BlurEffect;
+    className?: string;
+    stickyHeader?: boolean;
+}) => string;
+export declare const DataGridHeader: ({ className, children, ...rest }: DataGridHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/DataGridHeader/DataGridHeader.js

@@ -0,0 +1,80 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { DataGridContext } from "../DataGrid/DataGridContext.js";
+import { getStickyBlurClasses } from "../DataGrid/utilities.js";
+import { BlurEffects, CellWrapper } from "../DataGridConstants/DataGridConstants.js";
+
+;// CONCATENATED MODULE: external "react/jsx-runtime"
+
+;// CONCATENATED MODULE: external "clsx"
+
+;// CONCATENATED MODULE: external "../DataGrid/DataGridContext.js"
+
+;// CONCATENATED MODULE: external "../DataGrid/utilities.js"
+
+;// CONCATENATED MODULE: external "../DataGridConstants/DataGridConstants.js"
+
+;// CONCATENATED MODULE: ./src/DataGridHeader/DataGridHeader.tsx
+
+
+
+
+
+/**
+ * Generates classes for the DataGridHeader. Uses absolute positioning like
+ * Panel - header floats above the scrollable content.
+ */ const getHeaderClasses = ({ className, stickyHeader, mode, blurEffect })=>{
+    const hasBlur = blurEffect && blurEffect !== BlurEffects.NONE;
+    return clsx({
+        /**
+			 * Absolute positioning like Panel's header: absolute left-0 right-0 z-20
+			 * top-0 rounded-t-lg to match the wrapper's rounded-lg corners.
+			 */ "absolute left-0 right-0 z-20 top-0 rounded-t-lg": stickyHeader,
+        // Shadow for visual depth (downward glow).
+        "shadow-[rgb(190_190_190_/20%)_0_0.5rem_1rem]": stickyHeader && mode === "dark",
+        "shadow-[rgb(190_190_190_/20%)_0_0.5rem_1rem] dark:shadow-[rgb(65_65_65_/30%)_0_0.5rem_1rem]": stickyHeader && mode === "system",
+        "shadow-[rgb(65_65_65_/30%)_0_0.5rem_1rem]": stickyHeader && mode === "light",
+        "shadow-[rgb(65_65_65_/30%)_0_0.5rem_1rem] dark:shadow-[rgb(190_190_190_/20%)_0_0.5rem_1rem]": stickyHeader && mode === "alt-system",
+        // Semi-transparent backgrounds for blur effect.
+        "bg-table-head-dark/50": hasBlur && stickyHeader && (mode === "dark" || mode === "system"),
+        "bg-table-head-light/50": hasBlur && stickyHeader && (mode === "light" || mode === "alt-system"),
+        "dark:bg-table-head-light/50": hasBlur && stickyHeader && mode === "system",
+        "dark:bg-table-head-dark/50": hasBlur && stickyHeader && mode === "alt-system",
+        // Solid backgrounds when no blur effect.
+        "bg-table-head-dark": !hasBlur && stickyHeader && (mode === "dark" || mode === "system"),
+        "bg-table-head-light": !hasBlur && stickyHeader && (mode === "light" || mode === "alt-system"),
+        "dark:bg-table-head-light": !hasBlur && stickyHeader && mode === "system",
+        "dark:bg-table-head-dark": !hasBlur && stickyHeader && mode === "alt-system"
+    }, stickyHeader && getStickyBlurClasses({
+        blurEffect
+    }), className);
+};
+/* =============================================================================
+ * DataGridHeader
+ * ========================================================================== */ const DataGridHeader = ({ className, children, ...rest })=>{
+    return /*#__PURE__*/ jsx(DataGridContext.Consumer, {
+        children: (ctx)=>/*#__PURE__*/ jsx(DataGridContext.Provider, {
+                value: {
+                    ...ctx,
+                    cellWrapper: CellWrapper.HEADER
+                },
+                children: /*#__PURE__*/ jsx("thead", {
+                    className: getHeaderClasses({
+                        className,
+                        stickyHeader: ctx.stickyHeader,
+                        mode: ctx.mode,
+                        blurEffect: ctx.blurEffect
+                    }),
+                    ...rest,
+                    children: children
+                })
+            })
+    });
+};
+
+export { DataGridHeader, getHeaderClasses };

package/dist/DataGridHeader/index.d.ts

@@ -0,0 +1 @@
+export { DataGridHeader } from "./DataGridHeader";

package/dist/DataGridHeader/index.js

@@ -0,0 +1,13 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { DataGridHeader } from "./DataGridHeader.js";
+
+;// CONCATENATED MODULE: external "./DataGridHeader.js"
+
+;// CONCATENATED MODULE: ./src/DataGridHeader/index.ts
+
+
+export { DataGridHeader };

package/dist/DataGridInfinite/InfiniteScrollMarker.d.ts

@@ -0,0 +1,35 @@
+export type InfiniteScrollMarkerProps = {
+    /**
+     * Number of columns in the table (for proper colspan).
+     */
+    colSpan?: number;
+    /**
+     * Custom class name for the row.
+     */
+    className?: string;
+    /**
+     * Whether to show the marker (for debugging). In production, the marker is
+     * invisible.
+     */
+    debug?: boolean;
+};
+/**
+ * Invisible marker row for infinite scroll. Place this at the end of your
+ * DataGridBody.
+ *
+ * @example
+ * ```tsx
+ * const { hasMore, markerRef } = useInfiniteScroll({ totalItems: data.length });
+ *
+ * return (
+ *   <DataGridBody>
+ *     {data.slice(0, visibleCount).map((item) => (
+ *       <DataGridRow key={item.id}>...</DataGridRow>
+ *     ))}
+ *     {hasMore && <InfiniteScrollMarker ref={markerRef} colSpan={5} />}
+ *   </DataGridBody>
+ * );
+ * ```
+ *
+ */
+export declare const InfiniteScrollMarker: import("react").ForwardRefExoticComponent<InfiniteScrollMarkerProps & import("react").RefAttributes<HTMLTableRowElement>>;

package/dist/DataGridInfinite/InfiniteScrollMarker.js

@@ -0,0 +1,53 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+
+;// CONCATENATED MODULE: external "react/jsx-runtime"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/DataGridInfinite/InfiniteScrollMarker.tsx
+
+
+/**
+ * Invisible marker row for infinite scroll. Place this at the end of your
+ * DataGridBody.
+ *
+ * @example
+ * ```tsx
+ * const { hasMore, markerRef } = useInfiniteScroll({ totalItems: data.length });
+ *
+ * return (
+ *   <DataGridBody>
+ *     {data.slice(0, visibleCount).map((item) => (
+ *       <DataGridRow key={item.id}>...</DataGridRow>
+ *     ))}
+ *     {hasMore && <InfiniteScrollMarker ref={markerRef} colSpan={5} />}
+ *   </DataGridBody>
+ * );
+ * ```
+ *
+ */ const InfiniteScrollMarker_InfiniteScrollMarker = /*#__PURE__*/ forwardRef(function InfiniteScrollMarker({ colSpan = 1, className, debug = false }, ref) {
+    return /*#__PURE__*/ jsx("tr", {
+        ref: ref,
+        className: className,
+        "aria-hidden": "true",
+        style: {
+            height: debug ? "40px" : "1px",
+            background: debug ? "red" : "transparent"
+        },
+        children: /*#__PURE__*/ jsx("td", {
+            colSpan: colSpan,
+            style: {
+                padding: 0,
+                border: 0
+            }
+        })
+    });
+});
+
+export { InfiniteScrollMarker_InfiniteScrollMarker as InfiniteScrollMarker };

package/dist/DataGridInfinite/index.d.ts

@@ -0,0 +1,4 @@
+export type { InfiniteScrollMarkerProps } from "./InfiniteScrollMarker";
+export { InfiniteScrollMarker } from "./InfiniteScrollMarker";
+export type { UseInfiniteScrollOptions, UseInfiniteScrollReturn, } from "./useInfiniteScroll";
+export { useInfiniteScroll } from "./useInfiniteScroll";

package/dist/DataGridInfinite/index.js

@@ -0,0 +1,17 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { InfiniteScrollMarker } from "./InfiniteScrollMarker.js";
+import { useInfiniteScroll } from "./useInfiniteScroll.js";
+
+;// CONCATENATED MODULE: external "./InfiniteScrollMarker.js"
+
+;// CONCATENATED MODULE: external "./useInfiniteScroll.js"
+
+;// CONCATENATED MODULE: ./src/DataGridInfinite/index.ts
+
+
+
+export { InfiniteScrollMarker, useInfiniteScroll };

package/dist/DataGridInfinite/useInfiniteScroll.d.ts

@@ -0,0 +1,81 @@
+export type UseInfiniteScrollOptions = {
+    /**
+     * Number of items to show initially and to add on each scroll.
+     * @default 20
+     */
+    batchSize?: number;
+    /**
+     * How many items before the end to trigger loading more.
+     * @default 5
+     */
+    threshold?: number;
+    /**
+     * IntersectionObserver root margin.
+     * @default "20px"
+     */
+    rootMargin?: string;
+    /**
+     * Total number of items in the dataset. Used to determine if more items can be
+     * loaded.
+     */
+    totalItems: number;
+    /**
+     * Initial number of visible items (optional). If not provided, uses batchSize.
+     * + threshold.
+     */
+    initialVisibleCount?: number;
+    /**
+     * Callback when more items are loaded.
+     */
+    onLoadMore?: (newVisibleCount: number) => void;
+};
+export type UseInfiniteScrollReturn = {
+    /**
+     * Current number of visible items.
+     */
+    visibleCount: number;
+    /**
+     * Whether there are more items to load.
+     */
+    hasMore: boolean;
+    /**
+     * Callback ref to attach to the marker element.
+     */
+    markerRef: (node: HTMLElement | null) => void;
+    /**
+     * Reset visible count to initial value.
+     */
+    reset: () => void;
+    /**
+     * Manually set the visible count (useful for scroll-to-item).
+     */
+    setVisibleCount: React.Dispatch<React.SetStateAction<number>>;
+    /**
+     * Expand visible count to include a specific index.
+     */
+    expandToInclude: (index: number) => void;
+};
+/**
+ * Hook for implementing infinite scroll with IntersectionObserver.
+ *
+ * @example
+ * ```tsx
+ * const { visibleCount, hasMore, markerRef } = useInfiniteScroll({
+ *   totalItems: data.length,
+ *   batchSize: 25,
+ * });
+ *
+ * return (
+ *   <DataGrid>
+ *     <DataGridBody>
+ *       {data.slice(0, visibleCount).map((item, index) => (
+ *         <DataGridRow key={item.id}>...</DataGridRow>
+ *       ))}
+ *       {hasMore && <InfiniteScrollMarker ref={markerRef} />}
+ *     </DataGridBody>
+ *   </DataGrid>
+ * );
+ * ```
+ *
+ */
+export declare function useInfiniteScroll({ batchSize, threshold, rootMargin, totalItems, initialVisibleCount, onLoadMore, }: UseInfiniteScrollOptions): UseInfiniteScrollReturn;

package/dist/DataGridInfinite/useInfiniteScroll.js

@@ -0,0 +1,117 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/DataGridInfinite/useInfiniteScroll.ts
+
+const DEFAULT_BATCH_SIZE = 20;
+const DEFAULT_THRESHOLD = 5;
+const DEFAULT_ROOT_MARGIN = "20px";
+/**
+ * Hook for implementing infinite scroll with IntersectionObserver.
+ *
+ * @example
+ * ```tsx
+ * const { visibleCount, hasMore, markerRef } = useInfiniteScroll({
+ *   totalItems: data.length,
+ *   batchSize: 25,
+ * });
+ *
+ * return (
+ *   <DataGrid>
+ *     <DataGridBody>
+ *       {data.slice(0, visibleCount).map((item, index) => (
+ *         <DataGridRow key={item.id}>...</DataGridRow>
+ *       ))}
+ *       {hasMore && <InfiniteScrollMarker ref={markerRef} />}
+ *     </DataGridBody>
+ *   </DataGrid>
+ * );
+ * ```
+ *
+ */ function useInfiniteScroll({ batchSize = DEFAULT_BATCH_SIZE, threshold = DEFAULT_THRESHOLD, rootMargin = DEFAULT_ROOT_MARGIN, totalItems, initialVisibleCount, onLoadMore }) {
+    const observerRef = useRef(null);
+    const initialCount = initialVisibleCount ?? batchSize + threshold;
+    const [visibleCount, setVisibleCount] = useState(Math.min(initialCount, totalItems));
+    const hasMore = visibleCount < totalItems;
+    /**
+	 * IntersectionObserver callback - triggered when marker becomes visible.
+	 */ const handleIntersection = useCallback((entries)=>{
+        const target = entries[0];
+        if (target?.isIntersecting) {
+            setVisibleCount((prev)=>{
+                const newCount = Math.min(prev + batchSize, totalItems);
+                if (onLoadMore && newCount > prev) {
+                    onLoadMore(newCount);
+                }
+                return newCount;
+            });
+        }
+    }, [
+        batchSize,
+        totalItems,
+        onLoadMore
+    ]);
+    /**
+	 * Callback ref for the marker element. Creates/disconnects observer as needed.
+	 */ const markerRef = useCallback((node)=>{
+        // Disconnect previous observer.
+        if (observerRef.current) {
+            observerRef.current.disconnect();
+            observerRef.current = null;
+        }
+        if (node && typeof IntersectionObserver !== "undefined") {
+            const options = {
+                rootMargin
+            };
+            observerRef.current = new IntersectionObserver(handleIntersection, options);
+            observerRef.current.observe(node);
+        }
+    }, [
+        handleIntersection,
+        rootMargin
+    ]);
+    /**
+	 * Reset to initial count.
+	 */ const reset = useCallback(()=>{
+        setVisibleCount(Math.min(initialCount, totalItems));
+    }, [
+        initialCount,
+        totalItems
+    ]);
+    /**
+	 * Expand visible count to include a specific index. Useful for scroll-to-row
+	 * functionality.
+	 */ const expandToInclude = useCallback((index)=>{
+        if (index >= visibleCount) {
+            setVisibleCount(index + threshold);
+        }
+    }, [
+        visibleCount,
+        threshold
+    ]);
+    /**
+	 * Cleanup observer on unmount.
+	 */ useEffect(()=>{
+        return ()=>{
+            if (observerRef.current) {
+                observerRef.current.disconnect();
+            }
+        };
+    }, []);
+    return {
+        visibleCount,
+        hasMore,
+        markerRef,
+        reset,
+        setVisibleCount,
+        expandToInclude
+    };
+}
+
+export { useInfiniteScroll };

package/dist/DataGridRow/DataGridRow.d.ts

@@ -0,0 +1,2 @@
+import type { DataGridRowProps } from "../DataGrid/DataGridTypes";
+export declare const DataGridRow: ({ className, children, ...rest }: DataGridRowProps) => import("react/jsx-runtime").JSX.Element;

package/dist/DataGridRow/DataGridRow.js

@@ -0,0 +1,75 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { DataGridContext } from "../DataGrid/DataGridContext.js";
+import { CellWrapper } from "../DataGridConstants/index.js";
+
+;// CONCATENATED MODULE: external "react/jsx-runtime"
+
+;// CONCATENATED MODULE: external "clsx"
+
+;// CONCATENATED MODULE: external "../DataGrid/DataGridContext.js"
+
+;// CONCATENATED MODULE: external "../DataGridConstants/index.js"
+
+;// CONCATENATED MODULE: ./src/DataGridRow/DataGridRow.tsx
+
+
+
+
+const getRowClasses = ({ mode, className, cellWrapper, stickyHeader, stickyFooter })=>{
+    if (cellWrapper === CellWrapper.HEADER || cellWrapper === CellWrapper.FOOTER) {
+        /**
+		 * When in a sticky header/footer, don't apply background to row since the
+		 * background is applied to thead/tfoot for blur effect to work.
+		 */ const isSticky = cellWrapper === CellWrapper.HEADER && stickyHeader || cellWrapper === CellWrapper.FOOTER && stickyFooter;
+        if (isSticky) {
+            // No background on row - it's on the thead/tfoot.
+            return clsx(className);
+        }
+        // Non-sticky header/footer still gets background on row.
+        return clsx({
+            "bg-table-head-dark": mode === "dark" || mode === "system",
+            "bg-table-head-light": mode === "light" || mode === "alt-system",
+            "dark:bg-table-head-light": mode === "system",
+            "dark:bg-table-head-dark": mode === "alt-system"
+        }, className);
+    }
+    return clsx("border-b last:border-0", {
+        "border-table-dark": mode === "dark" || mode === "system",
+        "border-table-light": mode === "light" || mode === "alt-system",
+        "dark:border-table-light": mode === "system",
+        "dark:border-table-dark": mode === "alt-system",
+        "odd:bg-table-dark-odd even:bg-table-dark-even": mode === "dark",
+        "hover:bg-table-dark-hover": mode === "dark",
+        "odd:bg-table-light-odd even:bg-table-light-even": mode === "light",
+        "hover:bg-table-light-hover": mode === "light",
+        "odd:bg-table-dark-odd even:bg-table-dark-even dark:odd:bg-table-light-odd dark:even:bg-table-light-even": mode === "system",
+        "hover:bg-table-dark-hover dark:hover:bg-table-light-hover": mode === "system",
+        "odd:bg-table-light-odd even:bg-table-light-even dark:odd:bg-table-dark-odd dark:even:bg-table-dark-even": mode === "alt-system",
+        "hover:bg-table-light-hover dark:hover:bg-table-dark-hover": mode === "alt-system"
+    }, className);
+};
+/* =============================================================================
+ * DataGridRow
+ * ========================================================================== */ const DataGridRow = ({ className, children, ...rest })=>{
+    return /*#__PURE__*/ jsx(DataGridContext.Consumer, {
+        children: ({ mode, cellWrapper, stickyHeader, stickyFooter })=>/*#__PURE__*/ jsx("tr", {
+                className: getRowClasses({
+                    mode,
+                    className,
+                    cellWrapper,
+                    stickyHeader,
+                    stickyFooter
+                }),
+                ...rest,
+                children: children
+            })
+    });
+};
+
+export { DataGridRow };

package/dist/DataGridRow/index.d.ts

@@ -0,0 +1 @@
+export { DataGridRow } from "./DataGridRow";

package/dist/DataGridRow/index.js

@@ -0,0 +1,13 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { DataGridRow } from "./DataGridRow.js";
+
+;// CONCATENATED MODULE: external "./DataGridRow.js"
+
+;// CONCATENATED MODULE: ./src/DataGridRow/index.ts
+
+
+export { DataGridRow };

package/dist/DataGridSorting/index.d.ts

@@ -0,0 +1,2 @@
+export { type SortDirection, SortDirections } from "../DataGridConstants";
+export { getNextSortConfig, getOppositeSortDirection, type SortComparator, type SortConfig, sortByBoolean, sortByDate, sortByNumber, sortByString, sortItems, toggleSortDirection, } from "./sortingUtils";

package/dist/DataGridSorting/index.js

@@ -0,0 +1,18 @@
+/*!
+  @versini/ui-datagrid v0.1.0
+  © 2026 gizmette.com
+*/
+
+import { SortDirections } from "../DataGridConstants/index.js";
+import { getNextSortConfig, getOppositeSortDirection, sortByBoolean, sortByDate, sortByNumber, sortByString, sortItems, toggleSortDirection } from "./sortingUtils.js";
+
+;// CONCATENATED MODULE: external "../DataGridConstants/index.js"
+
+;// CONCATENATED MODULE: external "./sortingUtils.js"
+
+;// CONCATENATED MODULE: ./src/DataGridSorting/index.ts
+// Re-export sort directions from constants for convenience.
+
+
+
+export { SortDirections, getNextSortConfig, getOppositeSortDirection, sortByBoolean, sortByDate, sortByNumber, sortByString, sortItems, toggleSortDirection };