@tap-payments/os-micro-frontend-shared 0.1.212 → 0.1.213

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/hooks/useColumnResizeWithPinned.js

@@ -0,0 +1,29 @@
+import { useMemo } from 'react';
+import { getColumnId } from '../utils/resize';
+export const useColumnResizeWithPinned = ({ pinnedStartColumnsData, pinnedEndColumnsData, columnWidths }) => {
+    const pinnedStartColumnsWidth = useMemo(() => pinnedStartColumnsData.reduce((acc, col) => {
+        const columnId = getColumnId(col);
+        const width = columnWidths[columnId] || parseInt(String(col.width)) || 150;
+        return acc + width;
+    }, 0.2), [pinnedStartColumnsData, columnWidths]);
+    const pinnedEndColumnsWidth = useMemo(() => pinnedEndColumnsData.reduce((acc, col) => {
+        const columnId = getColumnId(col);
+        const width = columnWidths[columnId] || parseInt(String(col.width)) || 150;
+        return acc + width;
+    }, 0.2), [pinnedEndColumnsData, columnWidths]);
+    // Create updated column data with dynamic widths
+    const pinnedStartColumnsDataWithWidths = useMemo(() => pinnedStartColumnsData.map((col) => {
+        const columnId = getColumnId(col);
+        return Object.assign(Object.assign({}, col), { width: columnWidths[columnId] || col.width });
+    }), [pinnedStartColumnsData, columnWidths]);
+    const pinnedEndColumnsDataWithWidths = useMemo(() => pinnedEndColumnsData.map((col) => {
+        const columnId = getColumnId(col);
+        return Object.assign(Object.assign({}, col), { width: columnWidths[columnId] || col.width });
+    }), [pinnedEndColumnsData, columnWidths]);
+    return {
+        pinnedStartColumnsWidth,
+        pinnedEndColumnsWidth,
+        pinnedStartColumnsDataWithWidths,
+        pinnedEndColumnsDataWithWidths,
+    };
+};

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components';
+export * from './utils';
+export * from './hooks';
+export * from './types';

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/index.js

@@ -0,0 +1,4 @@
+export * from './components';
+export * from './utils';
+export * from './hooks';
+export * from './types';

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/styles.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+export declare const StyledResizeIcon: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & {
+    isResizing: boolean;
+    isLast: boolean;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const IndicatorLine: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & {
+    isVisible: boolean;
+    x: number;
+    height: number;
+    top: number;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const ResizeIcon: import("@emotion/styled").StyledComponent<import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme> & {
+    isVisible: boolean;
+    x: number;
+    y: number;
+    offsetX?: number | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/styles.js

@@ -0,0 +1,55 @@
+import { styled } from '@mui/material/styles';
+import { columnResizeIndicatorIcon } from '../../../../../constants/index.js';
+export const StyledResizeIcon = styled('div', {
+    shouldForwardProp: (prop) => prop !== 'isResizing' && prop !== 'isLast',
+})(({ isLast }) => ({
+    position: 'absolute',
+    top: 0,
+    right: isLast ? -10 : -11,
+    width: 20,
+    height: '100%',
+    backgroundColor: 'transparent',
+    zIndex: 100000,
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+}));
+export const IndicatorLine = styled('div', {
+    shouldForwardProp: (prop) => prop !== 'isVisible' && prop !== 'x' && prop !== 'height' && prop !== 'top',
+})(({ isVisible, x, height, top }) => ({
+    position: 'fixed',
+    left: x,
+    top: top,
+    width: 1,
+    height: `calc(${height}px - 14px)`,
+    backgroundColor: '#1F88D0',
+    zIndex: 9999,
+    pointerEvents: 'none',
+    opacity: isVisible ? 1 : 0,
+    transition: 'opacity 0.1s ease',
+    '&::before': {
+        content: '""',
+        position: 'absolute',
+        left: -1,
+        top: 0,
+        width: 1,
+        height: '100%',
+    },
+}));
+export const ResizeIcon = styled('div', {
+    shouldForwardProp: (prop) => prop !== 'isVisible' && prop !== 'x' && prop !== 'y' && prop !== 'offsetX',
+})(({ isVisible, x, y, offsetX = 0 }) => ({
+    position: 'fixed',
+    left: x + offsetX - 8,
+    top: y,
+    width: 20,
+    height: 16,
+    backgroundImage: `url(${columnResizeIndicatorIcon})`,
+    backgroundSize: 'contain',
+    backgroundRepeat: 'no-repeat',
+    backgroundPosition: 'center',
+    zIndex: 100000,
+    pointerEvents: 'none',
+    display: isVisible ? 'block' : 'none',
+    transform: 'translate(-50%, -50%)',
+}));

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/types/index.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="react" />
+import type { IColumnProps } from '../../../../../../types/index.js';
+export interface ColumnResizeState {
+    columnWidths: Record<string, number>;
+    isResizing: boolean;
+    resizingColumn: string | null;
+    startX: number;
+    startWidth: number;
+    resizeIndicatorX: number;
+    resizingColumnIndex?: number;
+    resizingColumnPinned?: 'start' | 'end';
+}
+export interface UseColumnResizeProps {
+    columns: IColumnProps[];
+    onColumnResize?: (columnId: string, newWidth: number) => void;
+    handleColumnClick: (columnIndex: number, event: React.MouseEvent, pinnedType?: 'start' | 'end') => void;
+    windowId?: string;
+    serviceCode?: string;
+    tableContainerRef?: React.RefObject<HTMLDivElement>;
+}
+export interface ColumnResizeProps {
+    columnId: string;
+    onStartResize: (e: React.MouseEvent, columnId: string) => void;
+    isResizing: boolean;
+    isLast?: boolean;
+}
+export interface ResizeIndicatorProps {
+    isVisible: boolean;
+    x: number;
+    height: number;
+    top?: number;
+}
+export interface FloatingResizeIconProps {
+    isVisible: boolean;
+    x: number;
+    y: number;
+}
+export interface ResizeOverlayProps {
+    isVisible: boolean;
+    indicatorX: number;
+    indicatorHeight: number;
+    indicatorTop: number;
+    iconX: number;
+    iconY: number;
+}

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/types/index.js

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

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './resize';

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/utils/index.js

@@ -0,0 +1 @@
+export * from './resize';

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/utils/resize.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { IColumnProps } from '../../../../../../types/index.js';
+import { ColumnResizeState } from '../types';
+export declare const parseColumnWidth: (width: React.CSSProperties['width']) => number;
+export declare const clampWidth: (width: number) => number;
+export declare const getColumnId: (column: {
+    id: string | number | symbol;
+    tableViewId?: string;
+}) => string;
+export declare const applyColumnWidths: (columns: IColumnProps[], columnWidths: Record<string, number>) => IColumnProps[];
+export declare const cleanupEventListeners: (mouseMoveRef: import("react").MutableRefObject<((e: MouseEvent) => void) | undefined>, mouseUpRef: import("react").MutableRefObject<((e: MouseEvent) => void) | undefined>) => void;
+export declare const createMouseUpHandler: (columnId: string, currentWidth: number, startX: number, windowId: string | undefined, serviceCode: string | undefined, onColumnResize: ((columnId: string, width: number) => void) | undefined, setResizeState: React.Dispatch<React.SetStateAction<ColumnResizeState>>, cleanupFn: () => void, clampedXRef: React.MutableRefObject<number>) => (mouseEvent: MouseEvent) => void;
+export declare const createMouseMoveHandler: (setResizeState: React.Dispatch<React.SetStateAction<ColumnResizeState>>, setCursorPosition: React.Dispatch<React.SetStateAction<{
+    x: number;
+    y: number;
+}>>, initialCursorYRef: React.MutableRefObject<number>, tableContainerRef?: React.RefObject<HTMLDivElement>, resizingColumnIndex?: number, resizingColumnPinned?: 'start' | 'end', clampedXRef?: React.MutableRefObject<number>) => (mouseEvent: MouseEvent) => void;
+export declare const getColumnWidthFromState: (columnWidths: Record<string, number>, columnId: string) => number;
+export declare const createResizeEndHandler: (windowId: string | undefined, serviceCode: string | undefined, onColumnResize: ((columnId: string, width: number) => void) | undefined, setResizeState: React.Dispatch<React.SetStateAction<ColumnResizeState>>, cleanupFn: () => void, isResizingRef: React.MutableRefObject<boolean>, clampedXRef: React.MutableRefObject<number>) => (columnId: string, currentWidth: number, startX: number) => (event: MouseEvent) => void;

package/build/components/VirtualTables/SheetViewVirtualTable/features/resize/utils/resize.js

@@ -0,0 +1,114 @@
+import { setColumnWidth } from '../../../../../../utils/index.js';
+import { COLUMN_WIDTH_CONSTRAINTS } from '../constants';
+export const parseColumnWidth = (width) => {
+    if (typeof width === 'string') {
+        const parsed = parseInt(width, 10);
+        return isNaN(parsed) ? COLUMN_WIDTH_CONSTRAINTS.DEFAULT_WIDTH : parsed;
+    }
+    return width || COLUMN_WIDTH_CONSTRAINTS.DEFAULT_WIDTH;
+};
+export const clampWidth = (width) => {
+    return Math.max(COLUMN_WIDTH_CONSTRAINTS.MIN_WIDTH, Math.min(COLUMN_WIDTH_CONSTRAINTS.MAX_WIDTH, width));
+};
+export const getColumnId = (column) => {
+    // Create a unique identifier by combining id and tableViewId
+    // This prevents conflicts when the same tableViewId is used in different columns
+    const baseId = String(column.id);
+    if (column.tableViewId) {
+        // Combine both id and tableViewId with a separator to ensure uniqueness
+        return `${baseId}_${column.tableViewId}`;
+    }
+    return baseId;
+};
+export const applyColumnWidths = (columns, columnWidths) => {
+    return columns.map((col) => {
+        const columnId = getColumnId(col);
+        return Object.assign(Object.assign({}, col), { width: columnWidths[columnId] || col.width });
+    });
+};
+// Event handler utilities
+export const cleanupEventListeners = (mouseMoveRef, mouseUpRef) => {
+    if (mouseMoveRef.current) {
+        document.removeEventListener('mousemove', mouseMoveRef.current);
+        mouseMoveRef.current = undefined;
+    }
+    if (mouseUpRef.current) {
+        document.removeEventListener('mouseup', mouseUpRef.current);
+        mouseUpRef.current = undefined;
+    }
+    document.body.style.cursor = '';
+    document.body.style.userSelect = '';
+};
+// Mouse event handler
+export const createMouseUpHandler = (columnId, currentWidth, startX, windowId, serviceCode, onColumnResize, setResizeState, cleanupFn, clampedXRef) => {
+    return (mouseEvent) => {
+        try {
+            // Use the clamped X position from the ref instead of raw mouse position
+            const deltaX = clampedXRef.current - startX;
+            const newWidth = clampWidth(currentWidth + deltaX);
+            setResizeState((prev) => (Object.assign(Object.assign({}, prev), { columnWidths: Object.assign(Object.assign({}, prev.columnWidths), { [columnId]: newWidth }), isResizing: false, resizingColumn: null, resizeIndicatorX: 0 })));
+            // Save to localStorage if windowId and serviceCode are provided
+            if (windowId && serviceCode) {
+                const success = setColumnWidth(windowId, serviceCode, String(columnId), newWidth);
+                if (!success) {
+                    console.warn(`Failed to persist column width for ${columnId}`);
+                }
+            }
+            onColumnResize === null || onColumnResize === void 0 ? void 0 : onColumnResize(columnId, newWidth);
+            // Prevent event bubbling
+            mouseEvent.stopPropagation();
+            mouseEvent.preventDefault();
+            cleanupFn();
+        }
+        catch (error) {
+            console.error('Error in mouse up handler:', error);
+            cleanupFn();
+        }
+    };
+};
+export const createMouseMoveHandler = (setResizeState, setCursorPosition, initialCursorYRef, tableContainerRef, resizingColumnIndex, resizingColumnPinned, clampedXRef) => {
+    return (mouseEvent) => {
+        try {
+            let clampedX = mouseEvent.clientX;
+            // Clamp the x position to stay within the table boundaries
+            if (tableContainerRef === null || tableContainerRef === void 0 ? void 0 : tableContainerRef.current) {
+                const tableRect = tableContainerRef.current.getBoundingClientRect();
+                const minX = tableRect.left;
+                let maxX = tableRect.right;
+                // Adjust maxX for second pinned start column (index 1)
+                if (resizingColumnPinned === 'start' && resizingColumnIndex === 1) {
+                    maxX = maxX - 44;
+                }
+                clampedX = Math.max(minX, Math.min(maxX, mouseEvent.clientX));
+            }
+            // Store the clamped X position in the ref for use in mouse up handler
+            if (clampedXRef) {
+                clampedXRef.current = clampedX;
+            }
+            setResizeState((prev) => (Object.assign(Object.assign({}, prev), { resizeIndicatorX: clampedX })));
+            setCursorPosition({
+                x: clampedX,
+                y: initialCursorYRef.current,
+            });
+        }
+        catch (error) {
+            console.error('Error in mouse move handler:', error);
+        }
+    };
+};
+// Column width utility
+export const getColumnWidthFromState = (columnWidths, columnId) => {
+    return columnWidths[columnId] || COLUMN_WIDTH_CONSTRAINTS.DEFAULT_WIDTH;
+};
+// Creates a mouse up handler that clears the resize flag after completion
+export const createResizeEndHandler = (windowId, serviceCode, onColumnResize, setResizeState, cleanupFn, isResizingRef, clampedXRef) => {
+    return (columnId, currentWidth, startX) => {
+        return (event) => {
+            createMouseUpHandler(columnId, currentWidth, startX, windowId, serviceCode, onColumnResize, setResizeState, cleanupFn, clampedXRef)(event);
+            // Clear resize flag to allow column selection after resize
+            setTimeout(() => {
+                isResizingRef.current = false;
+            }, 0);
+        };
+    };
+};

package/build/components/VirtualTables/SheetViewVirtualTable/hooks/index.d.ts

@@ -4,3 +4,4 @@ export { useTableState } from './useTableState';
 export { useTableData } from './useTableData';
 export { useVirtualTableContainer } from './useVirtualTableContainer';
 export { usePinnedColumnsWidths } from './usePinnedColumnsWidths';
+export { useTableDimensions } from './useTableDimensions';

package/build/components/VirtualTables/SheetViewVirtualTable/hooks/index.js

@@ -4,3 +4,4 @@ export { useTableState } from './useTableState';
 export { useTableData } from './useTableData';
 export { useVirtualTableContainer } from './useVirtualTableContainer';
 export { usePinnedColumnsWidths } from './usePinnedColumnsWidths';
+export { useTableDimensions } from './useTableDimensions';

package/build/components/VirtualTables/SheetViewVirtualTable/hooks/useTableDimensions.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+interface TableDimensions {
+    top: number;
+    height: number;
+}
+interface UseTableDimensionsProps {
+    tableContainerRef: RefObject<HTMLDivElement>;
+    showHeader: boolean;
+    isResizing: boolean;
+}
+export declare const useTableDimensions: ({ tableContainerRef, showHeader, isResizing }: UseTableDimensionsProps) => TableDimensions;
+export {};

package/build/components/VirtualTables/SheetViewVirtualTable/hooks/useTableDimensions.js

@@ -0,0 +1,26 @@
+import { SHEET_VIEW_TABLE_ROW_HEIGHT } from '../../../../constants/index.js';
+import { useEffect, useState } from 'react';
+export const useTableDimensions = ({ tableContainerRef, showHeader, isResizing }) => {
+    const [tableDimensions, setTableDimensions] = useState({ top: 0, height: 0 });
+    useEffect(() => {
+        const updateTableDimensions = () => {
+            if (tableContainerRef.current) {
+                const rect = tableContainerRef.current.getBoundingClientRect();
+                const headerHeight = showHeader ? SHEET_VIEW_TABLE_ROW_HEIGHT : 0; // Header height is 28px
+                setTableDimensions({
+                    top: rect.top + headerHeight,
+                    height: rect.height - headerHeight,
+                });
+            }
+        };
+        // Update dimensions on mount and when resizing starts
+        updateTableDimensions();
+        if (isResizing) {
+            // Update dimensions during resize to handle window resizing
+            const handleResize = () => updateTableDimensions();
+            window.addEventListener('resize', handleResize);
+            return () => window.removeEventListener('resize', handleResize);
+        }
+    }, [isResizing, showHeader, tableContainerRef]);
+    return tableDimensions;
+};

package/build/components/VirtualTables/SheetViewVirtualTable/style.js

@@ -55,6 +55,7 @@ export const SheetViewVirtualTableWrapper = styled('div')({
     width: '100%',
     height: '100%',
     overflow: 'hidden',
+    borderRadius: '12px',
 });
 const PinnedColumnBase = styled('div')(({ theme }) => ({
     width: 'auto',

package/build/components/VirtualTables/SheetViewVirtualTable/types.d.ts

@@ -6,6 +6,8 @@ export interface ISheetViewVirtualTable extends Omit<IVirtualTable, 'isSheetView
     isPinnable?: boolean;
     clearBackdropVisibilityTimeout?: number;
     overscanCount?: number;
+    windowId?: string;
+    serviceCode?: string;
 }
 export interface SheetViewTableHeaderProps {
     columns: IColumnProps[];
@@ -22,6 +24,9 @@ export interface SheetViewTableHeaderProps {
     tablePosition?: TablePosition;
     hasPinnedStart?: boolean;
     hasPinnedEnd?: boolean;
+    onStartResize?: (e: React.MouseEvent, columnId: string) => void;
+    isResizing?: boolean;
+    resizingColumn?: string | null;
 }
 export interface VirtualTableContainerProps {
     columnsData: IColumnProps[];
@@ -50,6 +55,9 @@ export interface CommonTableProps {
     tableMode?: string;
     showNoDataView: boolean;
     tableBodyStyles?: CSSProperties;
+    onStartResize?: (e: React.MouseEvent, columnId: string) => void;
+    isResizing?: boolean;
+    resizingColumn?: string | null;
 }
 export interface PinnedColumnProps extends CommonTableProps {
     position: 'start' | 'end';

package/build/components/VirtualTables/components/style.js

@@ -56,6 +56,7 @@ export const TableHeaderInner = styled(Box)(({ theme }) => ({
     display: 'flex',
     gap: theme.spacing(0.5),
     alignItems: 'center',
+    overflow: 'hidden !important',
 }));
 export const StyledVirtualList = styled(VirtualScrollList, {
     shouldForwardProp: (prop) => !['areTotalRowsNotFillingHeight', 'isSheetView'].includes(prop),

package/build/constants/assets.d.ts

@@ -456,6 +456,7 @@ export declare const fileDownloadBlueIcon: string;
 export declare const fileDownloadGreyIcon: string;
 export declare const metaIcon: string;
 export declare const darkFilterIcon: string;
+export declare const columnResizeIndicatorIcon: string;
 export declare const homeIcon: string;
 export declare const lockIcon: string;
 export declare const calenderIcon: string;

package/build/constants/assets.js

@@ -463,6 +463,7 @@ export const fileDownloadBlueIcon = `${appBaseUrl}/fileDownloadBlue.svg`;
 export const fileDownloadGreyIcon = `${appBaseUrl}/fileDownloadGrey.svg`;
 export const metaIcon = `${lightUrl}/meta.svg`;
 export const darkFilterIcon = `${lightUrl}/darkFilterIcon.svg`;
+export const columnResizeIndicatorIcon = `${lightUrl}/resize-icon.svg`;
 export const homeIcon = `${lightUrl}/home.svg`;
 export const lockIcon = `${lightUrl}/lockIcon.svg`;
 export const calenderIcon = `${lightUrl}/Calendar.svg`;

package/build/utils/columnResizeStorage.d.ts

@@ -0,0 +1,16 @@
+export interface ColumnSettings {
+    width: number;
+}
+export interface ColumnSettingsMap {
+    [columnId: string]: ColumnSettings;
+}
+export interface ServiceColumnsMap {
+    [serviceCode: string]: ColumnSettingsMap;
+}
+export interface SheetViewColumnsData {
+    [windowId: string]: ServiceColumnsMap;
+}
+export declare const getSheetViewColumns: () => SheetViewColumnsData;
+export declare const setSheetViewColumns: (data: SheetViewColumnsData) => boolean;
+export declare const getColumnWidth: (windowId: string, serviceCode: string, columnId: string, defaultWidth?: number) => number | undefined;
+export declare const setColumnWidth: (windowId: string, serviceCode: string, columnId: string, width: number) => boolean;

package/build/utils/columnResizeStorage.js

@@ -0,0 +1,96 @@
+import { getSheetViewColumnsStorage, setSheetViewColumnsStorage } from './localStorage';
+const isValidString = (value) => typeof value === 'string' && value.trim().length > 0;
+const isValidNumber = (value) => typeof value === 'number' && !isNaN(value) && isFinite(value) && value > 0;
+const isValidColumnSettings = (data) => {
+    if (!data || typeof data !== 'object')
+        return false;
+    const settings = data;
+    return 'width' in settings && isValidNumber(settings.width);
+};
+const isValidColumnSettingsMap = (data) => {
+    if (!data || typeof data !== 'object')
+        return false;
+    return Object.values(data).every(isValidColumnSettings);
+};
+const isValidServiceColumnsMap = (data) => {
+    if (!data || typeof data !== 'object')
+        return false;
+    return Object.values(data).every(isValidColumnSettingsMap);
+};
+const isValidSheetViewColumnsData = (data) => {
+    if (!data || typeof data !== 'object')
+        return false;
+    return Object.values(data).every(isValidServiceColumnsMap);
+};
+export const getSheetViewColumns = () => {
+    try {
+        const data = getSheetViewColumnsStorage();
+        if (!data)
+            return {};
+        const parsedData = data;
+        if (!isValidSheetViewColumnsData(parsedData)) {
+            console.warn('Invalid column settings in localStorage');
+            return {};
+        }
+        return parsedData;
+    }
+    catch (error) {
+        console.warn('Failed to get sheetview columns:', error);
+        return {};
+    }
+};
+export const setSheetViewColumns = (data) => {
+    if (!isValidSheetViewColumnsData(data)) {
+        console.warn('Invalid data structure for sheetview columns');
+        return false;
+    }
+    try {
+        setSheetViewColumnsStorage(data);
+        return true;
+    }
+    catch (error) {
+        console.warn('Failed to save sheetview columns:', error);
+        return false;
+    }
+};
+export const getColumnWidth = (windowId, serviceCode, columnId, defaultWidth) => {
+    var _a, _b, _c;
+    if (!isValidString(windowId) || !isValidString(serviceCode) || !isValidString(columnId)) {
+        return defaultWidth;
+    }
+    try {
+        const columnsData = getSheetViewColumns();
+        const width = (_c = (_b = (_a = columnsData[windowId]) === null || _a === void 0 ? void 0 : _a[serviceCode]) === null || _b === void 0 ? void 0 : _b[columnId]) === null || _c === void 0 ? void 0 : _c.width;
+        return width !== null && width !== void 0 ? width : defaultWidth;
+    }
+    catch (error) {
+        console.warn('Failed to get column width:', error);
+        return defaultWidth;
+    }
+};
+export const setColumnWidth = (windowId, serviceCode, columnId, width) => {
+    if (!isValidString(windowId) || !isValidString(serviceCode) || !isValidString(columnId) || !isValidNumber(width)) {
+        console.warn('Invalid parameters for setColumnWidth');
+        return false;
+    }
+    try {
+        const columnsData = getSheetViewColumns();
+        if (!columnsData[windowId]) {
+            columnsData[windowId] = {};
+        }
+        if (!columnsData[windowId][serviceCode]) {
+            columnsData[windowId][serviceCode] = {};
+        }
+        if (!columnsData[windowId][serviceCode][columnId]) {
+            columnsData[windowId][serviceCode][columnId] = { width };
+        }
+        else {
+            columnsData[windowId][serviceCode][columnId].width = width;
+        }
+        return setSheetViewColumns(columnsData);
+    }
+    catch (error) {
+        console.warn('Failed to set column width:', error);
+        return false;
+    }
+};

package/build/utils/index.d.ts

@@ -42,3 +42,4 @@ export * from './encrypt';
 export * from './day';
 export * from './style';
 export * from './boolean';
+export * from './columnResizeStorage';

package/build/utils/index.js

@@ -42,3 +42,4 @@ export * from './encrypt';
 export * from './day';
 export * from './style';
 export * from './boolean';
+export * from './columnResizeStorage';

package/build/utils/localStorage.d.ts

@@ -1,4 +1,5 @@
 import { AppDetails, Segment, TableMode, Timezone } from '../types/index.js';
+import { SheetViewColumnsData } from './columnResizeStorage';
 export declare function setSecretKey(): void;
 export declare function getSecretKey(): string | null;
 export declare function removeSecretKey(): void;
@@ -29,4 +30,6 @@ export declare const removeCalenderTimezoneHistory: () => void;
 export declare const setGlobalTableModeStorage: (mode: TableMode) => void;
 export declare const getGlobalTableModeStorage: () => TableMode;
 export declare const removeGlobalTableModeStorage: () => void;
+export declare const setSheetViewColumnsStorage: (data: SheetViewColumnsData) => void;
+export declare const getSheetViewColumnsStorage: () => SheetViewColumnsData;
 export declare const clearTapOsLocalStorage: () => void;

package/build/utils/localStorage.js

@@ -11,6 +11,7 @@ const APP_VERSION = 'tap-dashboard-app-version';
 const CALENDER_TIMEZONE = 'tap-dashboard-calender-timezone';
 const CALENDER_TIMEZONE_HISTORY = 'tap-dashboard-calender-timezone-history';
 const GLOBAL_TABLE_MODE_KEY = 'tap-dashboard-global-table-mode';
+const SHEETVIEW_COLUMNS_KEY = 'sheetview_columns';
 export function setSecretKey() {
     localStorage.setItem(SECRET_KEY_LOCAL_STORAGE, TEST_SECRET_KEY);
 }
@@ -166,6 +167,8 @@ export const getGlobalTableModeStorage = () => {
 export const removeGlobalTableModeStorage = () => {
     localStorage.removeItem(GLOBAL_TABLE_MODE_KEY);
 };
+export const setSheetViewColumnsStorage = (data) => localStorage.setItem(SHEETVIEW_COLUMNS_KEY, JSON.stringify(data));
+export const getSheetViewColumnsStorage = () => JSON.parse(localStorage.getItem(SHEETVIEW_COLUMNS_KEY) || '{}');
 export const clearTapOsLocalStorage = () => {
     removeSecretKey();
     removeConnectMetaData();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tap-payments/os-micro-frontend-shared",
   "description": "Shared components and utilities for Tap Payments micro frontends",
-  "version": "0.1.212",
+  "version": "0.1.213",
   "testVersion": 11,
   "type": "module",
   "main": "build/index.js",