@codezee/sixtify-brahma 0.2.207 → 0.2.209

package/packages/shared-components/dist/SmartGrid/hooks/useGetFacetedFilter.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetFacetedFilter = void 0;
-const date_fns_1 = require("date-fns");
-const react_1 = require("react");
-const useGetFacetedFilter = ({ columns, }) => {
-    const includesSome = (row, columnId, filterValue) => {
-        if (!filterValue ||
-            (Array.isArray(filterValue) && filterValue.length === 0)) {
-            return true;
-        }
-        const cellValue = row.getValue(columnId);
-        const cellValueStr = cellValue != null ? String(cellValue) : "";
-        if (Array.isArray(filterValue)) {
-            return filterValue.some((filterVal) => String(filterVal) === cellValueStr);
-        }
-        return String(filterValue) === cellValueStr;
-    };
-    const combinedFilter = (row, columnId, filterValue) => {
-        if (!filterValue) {
-            return true;
-        }
-        const cellValue = row.getValue(columnId);
-        const cellValueStr = cellValue != null ? String(cellValue) : "";
-        // Handle combined filter object
-        if (typeof filterValue === "object" && !Array.isArray(filterValue)) {
-            const combinedFilterValue = filterValue;
-            const { facets, search } = combinedFilterValue;
-            let matches = true;
-            // Check search filter
-            if (search && search.trim() !== "") {
-                matches =
-                    matches && cellValueStr.toLowerCase().includes(search.toLowerCase());
-            }
-            // Check facets filter
-            if (facets && facets.length > 0) {
-                matches =
-                    matches &&
-                        facets.some((filterVal) => String(filterVal) === cellValueStr);
-            }
-            return matches;
-        }
-        // Fallback to original logic for backward compatibility
-        if (Array.isArray(filterValue)) {
-            return filterValue.some((filterVal) => String(filterVal) === cellValueStr);
-        }
-        return String(filterValue) === cellValueStr;
-    };
-    const parseToDate = (value) => {
-        if (value instanceof Date) {
-            return value;
-        }
-        if (typeof value === "string") {
-            const parsed = (0, date_fns_1.parseISO)(value);
-            if ((0, date_fns_1.isValid)(parsed)) {
-                return parsed;
-            }
-        }
-        return null;
-    };
-    const dateRangeFilter = (row, columnId, filterValue) => {
-        if (!Array.isArray(filterValue) || filterValue.length === 0) {
-            return true;
-        }
-        const [startValue, endValue] = filterValue;
-        const startDate = parseToDate(startValue);
-        const endDate = parseToDate(endValue ?? startValue);
-        if (!startDate || !endDate) {
-            return true;
-        }
-        const normalizedStart = new Date(startDate);
-        normalizedStart.setHours(0, 0, 0, 0);
-        const normalizedEnd = new Date(endDate);
-        normalizedEnd.setHours(23, 59, 59, 999);
-        const cellValue = row.getValue(columnId);
-        const cellDate = parseToDate(cellValue);
-        if (!cellDate) {
-            const cellString = cellValue != null ? String(cellValue) : "";
-            const startString = String(startValue ?? "");
-            const endString = typeof endValue === "string" && endValue ? endValue : startString;
-            return cellString >= startString && cellString <= endString;
-        }
-        const cellTime = new Date(cellDate).getTime();
-        return (cellTime >= normalizedStart.getTime() &&
-            cellTime <= normalizedEnd.getTime());
-    };
-    const processedColumns = (0, react_1.useMemo)(() => {
-        return columns.map((col) => {
-            const appCol = col;
-            const { facetedFilter, filterVariant } = appCol;
-            // If column has both facetedFilter and filterVariant, use combined filter
-            if (facetedFilter && filterVariant) {
-                return {
-                    ...col,
-                    filterFn: "combinedFilter",
-                };
-            }
-            if (filterVariant === "smartDateFilter") {
-                return {
-                    ...col,
-                    filterFn: "dateRangeFilter",
-                };
-            }
-            // If only faceted filter, use includesSome
-            if (facetedFilter) {
-                return {
-                    ...col,
-                    filterFn: "includesSome",
-                };
-            }
-            return col;
-        });
-    }, [columns]);
-    return { combinedFilter, dateRangeFilter, includesSome, processedColumns };
-};
-exports.useGetFacetedFilter = useGetFacetedFilter;

package/packages/shared-components/dist/SmartGrid/hooks/useGetGroupedColumn.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetGroupedColumn = void 0;
-const core_1 = require("@dnd-kit/core");
-const sortable_1 = require("@dnd-kit/sortable");
-const react_1 = require("react");
-const useGetGroupedColumn = ({ table, swipeableColumns, setActiveDragId, currentGrouping, handleColumnReorder, filterHeaders, isHeaderReorderable, propsColumns, defaultGrouping, }) => {
-    const { getColumn, getHeaderGroups, setGrouping } = table;
-    const headerGroups = getHeaderGroups();
-    // Handler to remove column from grouping
-    const handleRemoveGroup = (0, react_1.useCallback)((columnId) => {
-        const currentGroupingArray = currentGrouping;
-        const newGrouping = currentGroupingArray.filter((id) => id !== columnId);
-        setGrouping(newGrouping);
-    }, [currentGrouping, table]);
-    // Helper: Reorder chips within grouping panel
-    const handleChipReorder = (0, react_1.useCallback)((activeId, overId, groupingArray) => {
-        const oldIndex = groupingArray.indexOf(activeId);
-        const newIndex = groupingArray.indexOf(overId);
-        const newGrouping = (0, sortable_1.arrayMove)(groupingArray, oldIndex, newIndex);
-        setGrouping(newGrouping);
-    }, [table]);
-    // Helper: Add column to grouping
-    const handleAddToGrouping = (0, react_1.useCallback)((activeId, groupingArray) => {
-        const column = getColumn(activeId);
-        if (!column) {
-            return false;
-        }
-        const columnDef = column.columnDef;
-        // If defaultGrouping exists and enableGrouping is true, prohibit adding to grouping
-        if (defaultGrouping.length > 0 && columnDef.enableGrouping === true) {
-            return false;
-        }
-        if (columnDef.enableGrouping !== true) {
-            return false;
-        }
-        const accessorKey = columnDef.accessorKey;
-        const isAlreadyGrouped = groupingArray.includes(activeId) ||
-            (accessorKey && groupingArray.includes(accessorKey));
-        if (isAlreadyGrouped) {
-            return false;
-        }
-        const MAX_GROUPING_COLUMNS = 4;
-        if (groupingArray.length >= MAX_GROUPING_COLUMNS) {
-            return false;
-        }
-        const groupingId = accessorKey ?? activeId;
-        setGrouping([...groupingArray, groupingId]);
-        return true;
-    }, [table, defaultGrouping]);
-    // Handle drag start
-    const handleDragStart = (0, react_1.useCallback)((event) => {
-        setActiveDragId(String(event.active.id));
-    }, []);
-    // Main drag end handler
-    const handleDragEnd = (0, react_1.useCallback)((event) => {
-        setActiveDragId(null);
-        const { active, over } = event;
-        if (!over) {
-            return;
-        }
-        const activeId = String(active.id);
-        const overId = String(over.id);
-        const groupingArray = currentGrouping;
-        const isActiveGrouped = groupingArray.includes(activeId);
-        // Case 1: Reordering chips within grouping panel
-        if (isActiveGrouped && groupingArray.includes(overId)) {
-            handleChipReorder(activeId, overId, groupingArray);
-            return;
-        }
-        // Case 2: Dragging grouped chip over panel (no-op)
-        if (isActiveGrouped && overId === "grouping-panel") {
-            return;
-        }
-        // Case 3: Dragging header to grouping panel
-        if (overId === "grouping-panel") {
-            handleAddToGrouping(activeId, groupingArray);
-            return;
-        }
-        // Case 4: Column reordering (when swipeableColumns is enabled)
-        if (swipeableColumns) {
-            handleColumnReorder(event);
-        }
-    }, [
-        currentGrouping,
-        swipeableColumns,
-        handleColumnReorder,
-        handleChipReorder,
-        handleAddToGrouping,
-    ]);
-    // Get ALL draggable column IDs for unified SortableContext
-    // This includes: groupable headers, reorderable headers, and grouped chips
-    const allDraggableIds = (0, react_1.useMemo)(() => {
-        const ids = new Set();
-        // Add all visible center headers that are either groupable or reorderable
-        headerGroups.forEach((headerGroup) => {
-            const filteredHeaders = filterHeaders(headerGroup.headers, currentGrouping);
-            filteredHeaders.forEach((header) => {
-                // Skip pinned columns and group column
-                if (header.column.getIsPinned() || header.column.id === "grouped_by") {
-                    return;
-                }
-                const columnDef = header.column.columnDef;
-                const isGroupable = columnDef.enableGrouping === true;
-                const isReorderable = swipeableColumns && isHeaderReorderable(header, true);
-                if (isGroupable || isReorderable) {
-                    ids.add(header.column.id);
-                }
-            });
-        });
-        // Add already grouped columns (for reordering chips in the panel)
-        currentGrouping.forEach((groupId) => {
-            ids.add(groupId);
-        });
-        return Array.from(ids);
-    }, [
-        headerGroups,
-        currentGrouping,
-        filterHeaders,
-        swipeableColumns,
-        isHeaderReorderable,
-    ]);
-    const customCollisionDetection = (0, react_1.useCallback)((args) => {
-        const { active } = args;
-        const activeId = String(active.id);
-        const groupingArray = currentGrouping;
-        const isDraggingChip = groupingArray.includes(activeId);
-        // Get all collisions using rectIntersection
-        const rectCollisions = (0, core_1.rectIntersection)(args);
-        // If dragging a chip (reordering within panel)
-        if (isDraggingChip) {
-            // Find collisions with other chips (not the panel itself)
-            const chipCollisions = rectCollisions.filter((collision) => groupingArray.includes(String(collision.id)) &&
-                String(collision.id) !== activeId);
-            // If hovering over another chip, prioritize chip-to-chip collision
-            if (chipCollisions.length > 0) {
-                return chipCollisions;
-            }
-            // Otherwise return panel collision if over panel
-            const panelCollision = rectCollisions.find((collision) => collision.id === "grouping-panel");
-            return panelCollision ? [panelCollision] : rectCollisions;
-        }
-        // If dragging a header (adding to grouping)
-        // Check if pointer is within the grouping panel
-        const pointerCollisions = (0, core_1.pointerWithin)(args);
-        const groupingPanelCollision = pointerCollisions.find((collision) => collision.id === "grouping-panel");
-        // If pointer is over the grouping panel, prioritize it
-        if (groupingPanelCollision) {
-            return [groupingPanelCollision];
-        }
-        // Otherwise use rectIntersection for column swapping
-        return rectCollisions;
-    }, [currentGrouping]);
-    const hasGroupableColumns = (0, react_1.useMemo)(() => {
-        return propsColumns.some((column) => {
-            const columnDef = column;
-            return columnDef.enableGrouping === true || !!defaultGrouping.length;
-        });
-    }, [propsColumns, defaultGrouping]);
-    return {
-        handleDragEnd,
-        handleDragStart,
-        handleRemoveGroup,
-        allDraggableIds,
-        hasGroupableColumns,
-        customCollisionDetection,
-    };
-};
-exports.useGetGroupedColumn = useGetGroupedColumn;

package/packages/shared-components/dist/SmartGrid/hooks/useGetPinStyle.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetPinStyle = void 0;
-const material_1 = require("@mui/material");
-const react_1 = require("react");
-const useGetPinStyle = () => {
-    const theme = (0, material_1.useTheme)();
-    const { iron } = theme.palette.app.color;
-    const getPinStyle = (0, react_1.useCallback)((cell, cellIndex, allCells) => {
-        const isPinned = cell.column.getIsPinned();
-        if (isPinned === "left") {
-            const nextCell = allCells[cellIndex + 1];
-            const isLastLeft = !nextCell || nextCell.column.getIsPinned() !== "left";
-            return {
-                left: cell.column.getStart("left"),
-                position: "sticky",
-                zIndex: 2,
-                ...(isLastLeft ? { borderRight: `1px solid ${iron[700]}` } : {}),
-            };
-        }
-        if (isPinned === "right") {
-            const prevCell = allCells[cellIndex - 1];
-            const isFirstRight = !prevCell || prevCell.column.getIsPinned() !== "right";
-            return {
-                position: "sticky",
-                right: cell.column.getAfter("right"),
-                zIndex: 2,
-                ...(isFirstRight ? { borderLeft: `1px solid ${iron[700]}` } : {}),
-            };
-        }
-        // no pin style
-        return {};
-    }, [iron]);
-    return getPinStyle;
-};
-exports.useGetPinStyle = useGetPinStyle;

package/packages/shared-components/dist/SmartGrid/hooks/useGetPinningColumns.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetPinningColumns = void 0;
-const react_1 = require("react");
-const useGetPinningColumns = ({ columns, }) => {
-    const initialPinning = (0, react_1.useMemo)(() => {
-        const left = [];
-        const right = [];
-        columns.forEach(({ accessorKey, id, pinned }) => {
-            if (pinned === "left") {
-                left.push(id ?? accessorKey);
-            }
-            if (pinned === "right") {
-                right.push(id ?? accessorKey);
-            }
-        });
-        return { left, right };
-    }, [columns]);
-    const hasPinnedColumns = (0, react_1.useMemo)(() => {
-        return columns.some(({ pinned }) => pinned === "left" || pinned === "right");
-    }, [columns]);
-    return { hasPinnedColumns, initialPinning };
-};
-exports.useGetPinningColumns = useGetPinningColumns;

package/packages/shared-components/dist/SmartGrid/hooks/useGetRowSelection.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetRowSelection = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-const IndeterminateCheckbox_1 = require("../Components/IndeterminateCheckbox");
-const useGetRowSelection = ({ defaultColumn, dynamicRowSelection, rowSelection, }) => {
-    // Stable cell renderer
-    const renderSelectionCell = (0, react_1.useCallback)((info) => {
-        // Check if row is selectable
-        const isSelectable = dynamicRowSelection
-            ? dynamicRowSelection(info.row.original)
-            : true;
-        if (!isSelectable) {
-            return null;
-        }
-        return ((0, jsx_runtime_1.jsx)(IndeterminateCheckbox_1.IndeterminateCheckbox, { checked: info.row.getIsSelected(), disabled: !info.row.getCanSelect(), indeterminate: info.row.getIsSomeSelected(), onChange: info.row.getToggleSelectedHandler() }));
-    }, []);
-    // Stable header renderer
-    const renderSelectionHeader = (0, react_1.useCallback)((info) => {
-        if (!dynamicRowSelection) {
-            // Fast path: no dynamic selection
-            return ((0, jsx_runtime_1.jsx)(IndeterminateCheckbox_1.IndeterminateCheckbox, { checked: info.table.getIsAllRowsSelected(), indeterminate: info.table.getIsSomeRowsSelected(), onChange: info.table.getToggleAllRowsSelectedHandler() }));
-        }
-        // Use a simple event handler that doesn't rely on state
-        const handleToggleAll = (e) => {
-            const { checked } = e.target;
-            const rows = info.table.getRowModel().rows;
-            // Use table's batch selection for better performance
-            info.table.setRowSelection((old) => {
-                const newSelection = { ...old };
-                // eslint-disable-next-line sonarjs/no-nested-functions
-                rows.forEach((row) => {
-                    if (dynamicRowSelection(row.original)) {
-                        if (checked) {
-                            newSelection[row.id] = true;
-                        }
-                        else {
-                            delete newSelection[row.id];
-                        }
-                    }
-                });
-                return newSelection;
-            });
-        };
-        // Calculate state only when rendering, not in event handler
-        const rows = info.table.getRowModel().rows;
-        const rowSelection = info.table.getState().rowSelection;
-        let selectableCount = 0;
-        let selectedCount = 0;
-        for (const row of rows) {
-            if (dynamicRowSelection(row.original)) {
-                selectableCount++;
-                if (rowSelection[row.id]) {
-                    selectedCount++;
-                }
-            }
-        }
-        const allSelected = selectableCount > 0 && selectedCount === selectableCount;
-        const someSelected = selectedCount > 0 && selectedCount < selectableCount;
-        return ((0, jsx_runtime_1.jsx)(IndeterminateCheckbox_1.IndeterminateCheckbox, { checked: allSelected, indeterminate: someSelected, disabled: selectableCount === 0, onChange: handleToggleAll }));
-    }, []);
-    const dynamicColumns = (0, react_1.useMemo)(() => {
-        return defaultColumn.map((col) => {
-            if (col.filterVariant === "smartNumberFilter" && !col.filterFn) {
-                return { ...col, filterFn: "includesString" };
-            }
-            return col;
-        });
-    }, [defaultColumn]);
-    const columns = (0, react_1.useMemo)(() => {
-        if (!rowSelection) {
-            return dynamicColumns;
-        }
-        const selectionColumn = {
-            cell: renderSelectionCell,
-            enableSorting: false,
-            header: renderSelectionHeader,
-            id: "select",
-            maxSize: 30,
-            minSize: 30,
-        };
-        return [selectionColumn, ...dynamicColumns];
-    }, [
-        dynamicColumns,
-        rowSelection,
-        renderSelectionCell,
-        renderSelectionHeader,
-    ]);
-    return { columns };
-};
-exports.useGetRowSelection = useGetRowSelection;

package/packages/shared-components/dist/SmartGrid/hooks/useGetSortedColumn.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useGetSortedColumn = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const icons_material_1 = require("@mui/icons-material");
-const react_1 = require("react");
-const sortIcons = {
-    asc: (0, jsx_runtime_1.jsx)(icons_material_1.ArrowUpward, { sx: { fontSize: 16 } }),
-    desc: (0, jsx_runtime_1.jsx)(icons_material_1.ArrowDownward, { sx: { fontSize: 16 } }),
-};
-const useGetSortedColumn = ({ header, }) => {
-    const { getCanSort, getIsSorted, getSortIndex } = header.column;
-    const isSortable = getCanSort();
-    const sortableIcon = (0, react_1.useMemo)(() => {
-        const sortDirection = getIsSorted();
-        return sortDirection && sortDirection in sortIcons
-            ? sortIcons[sortDirection]
-            : null;
-    }, [getIsSorted()]);
-    const mutipleSortCounts = getSortIndex();
-    return { isSortable, mutipleSortCounts, sortableIcon };
-};
-exports.useGetSortedColumn = useGetSortedColumn;

package/packages/shared-components/dist/SmartGrid/hooks/useTableState.js

@@ -1,112 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTableState = void 0;
-const react_table_1 = require("@tanstack/react-table");
-const react_1 = require("react");
-const useGetFacetedFilter_1 = require("./useGetFacetedFilter");
-const useGetPinningColumns_1 = require("./useGetPinningColumns");
-const useTableState = (props) => {
-    const { columns, data } = props;
-    const [sorting, setSorting] = (0, react_1.useState)([]);
-    const [grouping, setGrouping] = (0, react_1.useState)(props.defaultGrouping ?? []);
-    const { combinedFilter, dateRangeFilter, includesSome, processedColumns } = (0, useGetFacetedFilter_1.useGetFacetedFilter)({
-        columns,
-    });
-    const [expanded, setExpanded] = (0, react_1.useState)(true);
-    const [rowSelection, setRowSelection] = (0, react_1.useState)({});
-    const { hasPinnedColumns, initialPinning } = (0, useGetPinningColumns_1.useGetPinningColumns)({
-        columns,
-    });
-    const [columnPinning, setColumnPinning] = (0, react_1.useState)(initialPinning);
-    const [columnFilters, setColumnFilters] = (0, react_1.useState)([]);
-    const [columnOrder, setColumnOrder] = (0, react_1.useState)([]);
-    // Wrap setColumnOrder to ensure group column is always first when grouping is active
-    const handleColumnOrderChange = (updater) => {
-        setColumnOrder((oldOrder) => {
-            const newOrder = typeof updater === "function" ? updater(oldOrder) : updater;
-            const hasGrouping = grouping.length > 0;
-            const groupColumnId = "grouped_by";
-            if (hasGrouping && newOrder.includes(groupColumnId)) {
-                // Ensure group column is always first
-                const orderWithoutGroup = newOrder.filter((id) => id !== groupColumnId);
-                return [groupColumnId, ...orderWithoutGroup];
-            }
-            return newOrder;
-        });
-    };
-    const { enableExpanding = true, enableGrouping = true, enablePinning = hasPinnedColumns, enableRowSelection = true, enableSorting = true, } = props;
-    const table = (0, react_table_1.useReactTable)({
-        autoResetExpanded: false,
-        columnResizeDirection: "ltr",
-        columnResizeMode: "onChange",
-        columns: processedColumns,
-        data,
-        defaultColumn: { maxSize: 500, minSize: 100, size: 150 },
-        enableExpanding,
-        enableGrouping,
-        enablePinning,
-        enableRowSelection,
-        enableSorting,
-        filterFns: {
-            combinedFilter,
-            dateRangeFilter,
-            includesSome,
-        },
-        getCoreRowModel: (0, react_table_1.getCoreRowModel)(),
-        getExpandedRowModel: (0, react_table_1.getExpandedRowModel)(),
-        getFacetedMinMaxValues: (0, react_table_1.getFacetedMinMaxValues)(),
-        getFacetedRowModel: (0, react_table_1.getFacetedRowModel)(),
-        getFacetedUniqueValues: (0, react_table_1.getFacetedUniqueValues)(),
-        getFilteredRowModel: (0, react_table_1.getFilteredRowModel)(),
-        getGroupedRowModel: (0, react_table_1.getGroupedRowModel)(),
-        getSortedRowModel: (0, react_table_1.getSortedRowModel)(),
-        onColumnFiltersChange: setColumnFilters,
-        onColumnOrderChange: handleColumnOrderChange,
-        onColumnPinningChange: setColumnPinning,
-        onExpandedChange: setExpanded,
-        onGroupingChange: setGrouping,
-        onRowSelectionChange: setRowSelection,
-        onSortingChange: setSorting,
-        state: {
-            columnFilters,
-            columnOrder,
-            columnPinning,
-            expanded,
-            grouping,
-            rowSelection,
-            sorting,
-        },
-    });
-    (0, react_1.useEffect)(() => {
-        setExpanded(true);
-    }, [grouping, data.length]);
-    // Fix column order when grouping changes (in case columnOrder was set before grouping)
-    (0, react_1.useEffect)(() => {
-        const hasGrouping = grouping.length > 0;
-        const groupColumnId = "grouped_by";
-        if (hasGrouping) {
-            const currentOrder = table.getState().columnOrder;
-            const allColumns = table.getAllLeafColumns().map((col) => col.id);
-            const hasGroupColumn = allColumns.includes(groupColumnId);
-            if (hasGroupColumn) {
-                // If columnOrder is empty, use natural order but ensure group column is first
-                if (!currentOrder.length) {
-                    const orderWithoutGroup = allColumns.filter((id) => id !== groupColumnId);
-                    setColumnOrder([groupColumnId, ...orderWithoutGroup]);
-                }
-                else if (currentOrder.includes(groupColumnId) &&
-                    currentOrder[0] !== groupColumnId) {
-                    // If group column exists but not first, move it to first
-                    const orderWithoutGroup = currentOrder.filter((id) => id !== groupColumnId);
-                    setColumnOrder([groupColumnId, ...orderWithoutGroup]);
-                }
-                else if (!currentOrder.includes(groupColumnId)) {
-                    // If group column doesn't exist in order, add it at first
-                    setColumnOrder([groupColumnId, ...currentOrder]);
-                }
-            }
-        }
-    }, [grouping, table]);
-    return { table };
-};
-exports.useTableState = useTableState;

package/packages/shared-components/dist/SmartGrid/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./SmartGrid"), exports);
-__exportStar(require("./types/index"), exports);
-__exportStar(require("./hooks/useExportToExcel"), exports);
-__exportStar(require("./Components"), exports);

package/packages/shared-components/dist/SmartGrid/types/index.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/packages/shared-components/dist/SmartGrid/utils/helper.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFullISODate = exports.formatDateValue = void 0;
-const luxon_1 = require("luxon");
-const formatDateValue = (value) => {
-    const date = luxon_1.DateTime.fromISO(value);
-    // Check if the string is a valid ISO date
-    if (date.isValid) {
-        return date.toFormat("dd-MM-yyyy"); // Example: "15-11-2025"
-    }
-    return value; // Return original value if not a valid date
-};
-exports.formatDateValue = formatDateValue;
-const isFullISODate = (value) => /^\d{4}-\d{2}-\d{2}/.test(value);
-exports.isFullISODate = isFullISODate;

package/packages/shared-components/dist/SmartGrid/utils/summaryCalculations.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculationHelpers = void 0;
-exports.calculateDynamicSummary = calculateDynamicSummary;
-function calculateDynamicSummary(rows, configs) {
-    const result = {};
-    const leafRows = rows.flatMap((row) => {
-        const { getIsGrouped, subRows } = row;
-        if (getIsGrouped()) {
-            return subRows.flatMap((subRow) => {
-                if (subRow.getIsGrouped()) {
-                    return subRow.subRows;
-                }
-                return [subRow];
-            });
-        }
-        return [row];
-    });
-    const data = leafRows.map((row) => row.original);
-    configs.forEach((config) => {
-        const calculatedValue = config.calculation(data);
-        const formattedValue = typeof calculatedValue === "number" && config.formatter
-            ? config.formatter(calculatedValue)
-            : calculatedValue;
-        // Type assertion: ensure field key matches Path<T> for typed access
-        result[config.field] = {
-            value: formattedValue,
-        };
-    });
-    return result;
-}
-exports.calculationHelpers = {
-    average: (field) => (data) => {
-        if (data.length === 0) {
-            return 0;
-        }
-        const sum = data.reduce((sum, item) => {
-            const value = item[field];
-            return sum + (typeof value === "number" ? value : 0);
-        }, 0);
-        return sum / data.length;
-    },
-    count: () => (data) => {
-        return data.length;
-    },
-    multiplyAndSum: (field, multiplier) => (data) => {
-        return data.reduce((sum, item) => {
-            const value = item[field];
-            return sum + (typeof value === "number" ? value * multiplier : 0);
-        }, 0);
-    },
-    sum: (field) => (data) => {
-        return data.reduce((sum, item) => {
-            const value = item[field];
-            return sum + (typeof value === "number" ? value : 0);
-        }, 0);
-    },
-};