indas-ui 0.0.1 → 0.1.1

package/dist/cjs/hooks/useColumnFreezing.js

@@ -0,0 +1,204 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useColumnFreezing = useColumnFreezing;
+const react_1 = require("react");
+/**
+ * Hook for managing frozen/pinned columns with advanced positioning
+ * Supports both left and right frozen columns
+ */
+function useColumnFreezing({ columns, maxFrozenLeft = 3, maxFrozenRight = 2, onFreezingChange }) {
+    const [frozenLeft, setFrozenLeft] = (0, react_1.useState)([]);
+    const [frozenRight, setFrozenRight] = (0, react_1.useState)([]);
+    // Get column IDs for validation
+    const columnIds = (0, react_1.useMemo)(() => columns.map(col => col.id || col.accessorKey).filter(Boolean), [columns]);
+    // Calculate frozen state
+    const frozenState = (0, react_1.useMemo)(() => ({
+        frozenLeft,
+        frozenRight,
+        isFrozen: (columnId) => frozenLeft.includes(columnId) || frozenRight.includes(columnId),
+        getFrozenPosition: (columnId) => {
+            if (frozenLeft.includes(columnId))
+                return 'left';
+            if (frozenRight.includes(columnId))
+                return 'right';
+            return null;
+        }
+    }), [frozenLeft, frozenRight]);
+    // Freeze column to the left
+    const freezeLeft = (0, react_1.useCallback)((columnId) => {
+        if (!columnIds.includes(columnId))
+            return false;
+        setFrozenLeft(prev => {
+            // Remove from right if it's there
+            setFrozenRight(right => right.filter(id => id !== columnId));
+            // Add to left if not already there and under limit
+            if (!prev.includes(columnId) && prev.length < maxFrozenLeft) {
+                const newFrozenLeft = [...prev, columnId];
+                onFreezingChange?.(newFrozenLeft, frozenRight);
+                return newFrozenLeft;
+            }
+            return prev;
+        });
+        return true;
+    }, [columnIds, maxFrozenLeft, frozenRight, onFreezingChange]);
+    // Freeze column to the right
+    const freezeRight = (0, react_1.useCallback)((columnId) => {
+        if (!columnIds.includes(columnId))
+            return false;
+        setFrozenRight(prev => {
+            // Remove from left if it's there
+            setFrozenLeft(left => left.filter(id => id !== columnId));
+            // Add to right if not already there and under limit
+            if (!prev.includes(columnId) && prev.length < maxFrozenRight) {
+                const newFrozenRight = [...prev, columnId];
+                onFreezingChange?.(frozenLeft, newFrozenRight);
+                return newFrozenRight;
+            }
+            return prev;
+        });
+        return true;
+    }, [columnIds, maxFrozenRight, frozenLeft, onFreezingChange]);
+    // Unfreeze column
+    const unfreeze = (0, react_1.useCallback)((columnId) => {
+        let changed = false;
+        setFrozenLeft(prev => {
+            if (prev.includes(columnId)) {
+                changed = true;
+                return prev.filter(id => id !== columnId);
+            }
+            return prev;
+        });
+        setFrozenRight(prev => {
+            if (prev.includes(columnId)) {
+                changed = true;
+                return prev.filter(id => id !== columnId);
+            }
+            return prev;
+        });
+        if (changed) {
+            // Use setTimeout to ensure state updates are complete
+            setTimeout(() => {
+                onFreezingChange?.(frozenLeft.filter(id => id !== columnId), frozenRight.filter(id => id !== columnId));
+            }, 0);
+        }
+        return changed;
+    }, [frozenLeft, frozenRight, onFreezingChange]);
+    // Toggle freeze state (defaults to left)
+    const toggleFreeze = (0, react_1.useCallback)((columnId, position = 'left') => {
+        if (frozenState.isFrozen(columnId)) {
+            return unfreeze(columnId);
+        }
+        else {
+            return position === 'left' ? freezeLeft(columnId) : freezeRight(columnId);
+        }
+    }, [frozenState, unfreeze, freezeLeft, freezeRight]);
+    // Clear all frozen columns
+    const clearAllFrozen = (0, react_1.useCallback)(() => {
+        setFrozenLeft([]);
+        setFrozenRight([]);
+        onFreezingChange?.([], []);
+    }, [onFreezingChange]);
+    // Reorder frozen columns
+    const reorderFrozen = (0, react_1.useCallback)((columnId, newIndex, position) => {
+        const setter = position === 'left' ? setFrozenLeft : setFrozenRight;
+        const currentList = position === 'left' ? frozenLeft : frozenRight;
+        if (!currentList.includes(columnId))
+            return false;
+        setter(prev => {
+            const filtered = prev.filter(id => id !== columnId);
+            const clampedIndex = Math.max(0, Math.min(newIndex, filtered.length));
+            const newList = [
+                ...filtered.slice(0, clampedIndex),
+                columnId,
+                ...filtered.slice(clampedIndex)
+            ];
+            // Update callback
+            if (position === 'left') {
+                onFreezingChange?.(newList, frozenRight);
+            }
+            else {
+                onFreezingChange?.(frozenLeft, newList);
+            }
+            return newList;
+        });
+        return true;
+    }, [frozenLeft, frozenRight, onFreezingChange]);
+    // Get CSS properties for frozen columns
+    const getFrozenStyle = (0, react_1.useCallback)((columnId, columnWidth = 150) => {
+        const position = frozenState.getFrozenPosition(columnId);
+        if (!position)
+            return {};
+        let offset = 0;
+        const targetList = position === 'left' ? frozenLeft : frozenRight;
+        if (position === 'left') {
+            const index = targetList.indexOf(columnId);
+            offset = index * columnWidth;
+            return {
+                position: 'sticky',
+                left: offset,
+                zIndex: 10,
+                backgroundColor: 'var(--grid-header-bg)',
+                boxShadow: '2px 0 4px rgba(0,0,0,0.1)'
+            };
+        }
+        else {
+            const index = targetList.indexOf(columnId);
+            offset = index * columnWidth;
+            return {
+                position: 'sticky',
+                right: offset,
+                zIndex: 10,
+                backgroundColor: 'var(--grid-header-bg)',
+                boxShadow: '-2px 0 4px rgba(0,0,0,0.1)'
+            };
+        }
+    }, [frozenState, frozenLeft, frozenRight]);
+    // Utility functions
+    const canFreezeLeft = frozenLeft.length < maxFrozenLeft;
+    const canFreezeRight = frozenRight.length < maxFrozenRight;
+    const totalFrozen = frozenLeft.length + frozenRight.length;
+    return {
+        // State
+        ...frozenState,
+        canFreezeLeft,
+        canFreezeRight,
+        totalFrozen,
+        // Actions
+        freezeLeft,
+        freezeRight,
+        unfreeze,
+        toggleFreeze,
+        clearAllFrozen,
+        reorderFrozen,
+        // Utilities
+        getFrozenStyle,
+        // For integration with table libraries
+        getColumnProps: (columnId, width) => ({
+            style: getFrozenStyle(columnId, width),
+            className: frozenState.isFrozen(columnId) ? 'column-frozen' : '',
+            'data-frozen': frozenState.getFrozenPosition(columnId) || 'none'
+        }),
+        // Bulk operations
+        bulkOperations: {
+            freezeMultiple: (columnIds, position = 'left') => {
+                columnIds.forEach(id => {
+                    if (position === 'left' && canFreezeLeft) {
+                        freezeLeft(id);
+                    }
+                    else if (position === 'right' && canFreezeRight) {
+                        freezeRight(id);
+                    }
+                });
+            },
+            unfreezeMultiple: (columnIds) => {
+                columnIds.forEach(unfreeze);
+            },
+            setFrozenColumns: (left, right) => {
+                setFrozenLeft(left.slice(0, maxFrozenLeft));
+                setFrozenRight(right.slice(0, maxFrozenRight));
+                onFreezingChange?.(left, right);
+            }
+        }
+    };
+}

package/dist/cjs/hooks/useColumnMetadata.js

@@ -0,0 +1,48 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useColumnMetadata = useColumnMetadata;
+exports.isNumericContent = isNumericContent;
+const react_1 = require("react");
+/**
+ * Pre-compute column metadata to avoid repeated calculations during renders
+ */
+function useColumnMetadata(columns, mainColumnsArray, frozenColumnPositions) {
+    return (0, react_1.useMemo)(() => {
+        const metadataMap = new Map();
+        columns.forEach((column) => {
+            const columnKey = column.id || column.accessorKey || '';
+            const isSelectColumn = column.meta?.isSelectColumn ||
+                column.meta?.skipSearch ||
+                column.id === 'select' ||
+                columnKey === 'select';
+            const isMainColumn = !isSelectColumn && columnKey && mainColumnsArray.includes(columnKey);
+            const isFrozen = frozenColumnPositions.has(columnKey);
+            metadataMap.set(columnKey, {
+                isNumeric: false, // Will be determined per cell value
+                isFrozen,
+                isSelectColumn,
+                isMainColumn,
+                columnKey,
+                alignment: 'left' // Default alignment
+            });
+        });
+        return metadataMap;
+    }, [columns, mainColumnsArray, frozenColumnPositions]);
+}
+/**
+ * Check if a cell value should be right-aligned (numeric content)
+ */
+function isNumericContent(cellValue) {
+    const cellString = String(cellValue || '').trim();
+    return typeof cellValue === 'number' ||
+        (!isNaN(Number(cellString)) && cellString !== '' && cellString !== 'null' && cellString !== 'undefined') ||
+        /^\d*\.?\d+%$/.test(cellString) ||
+        /^[\$€£¥₹₽]\s?\d/.test(cellString) ||
+        /^\d[\d,]*\.?\d*\s?[\$€£¥₹₽]$/.test(cellString) ||
+        /^\(\d/.test(cellString) ||
+        /^\d{1,3}(,\d{3})*(\.\d+)?$/.test(cellString) ||
+        /^\d+\.?\d*[eE][+-]?\d+$/.test(cellString) ||
+        /^\d+\/\d+$/.test(cellString) ||
+        /^[+\-=<>≤≥≠±∞]/.test(cellString);
+}

package/dist/cjs/hooks/useConditionalFormatting.js

@@ -0,0 +1,197 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STYLE_PRESETS = void 0;
+exports.useConditionalFormatting = useConditionalFormatting;
+const react_1 = require("react");
+// Predefined style presets
+exports.STYLE_PRESETS = {
+    success: {
+        backgroundColor: '#dcfce7',
+        textColor: '#166534',
+        borderColor: '#22c55e'
+    },
+    warning: {
+        backgroundColor: '#fef3c7',
+        textColor: '#92400e',
+        borderColor: '#f59e0b'
+    },
+    error: {
+        backgroundColor: '#fee2e2',
+        textColor: '#dc2626',
+        borderColor: '#ef4444'
+    },
+    info: {
+        backgroundColor: '#dbeafe',
+        textColor: '#1d4ed8',
+        borderColor: '#3b82f6'
+    },
+    highlight: {
+        backgroundColor: '#fef3c7',
+        fontWeight: 'bold',
+        borderColor: '#f59e0b',
+        borderWidth: 2
+    },
+    muted: {
+        opacity: 0.6,
+        fontStyle: 'italic'
+    },
+    important: {
+        backgroundColor: '#fecaca',
+        textColor: '#991b1b',
+        fontWeight: 'bold'
+    }
+};
+// Evaluation functions for each operator
+function evaluateCondition(cellValue, operator, ruleValue, secondValue) {
+    // Handle null/undefined values
+    const isEmptyValue = cellValue === null || cellValue === undefined || cellValue === '';
+    if (operator === 'is_empty') {
+        return isEmptyValue;
+    }
+    if (operator === 'is_not_empty') {
+        return !isEmptyValue;
+    }
+    if (isEmptyValue) {
+        return false;
+    }
+    // Convert to strings for string operations
+    const cellStr = String(cellValue).toLowerCase();
+    const ruleStr = String(ruleValue).toLowerCase();
+    // Convert to numbers for numeric operations
+    const cellNum = Number(cellValue);
+    const ruleNum = Number(ruleValue);
+    const isNumericComparison = !isNaN(cellNum) && !isNaN(ruleNum);
+    switch (operator) {
+        case 'equals':
+            return isNumericComparison ? cellNum === ruleNum : cellStr === ruleStr;
+        case 'not_equals':
+            return isNumericComparison ? cellNum !== ruleNum : cellStr !== ruleStr;
+        case 'greater_than':
+            return isNumericComparison ? cellNum > ruleNum : cellStr > ruleStr;
+        case 'less_than':
+            return isNumericComparison ? cellNum < ruleNum : cellStr < ruleStr;
+        case 'greater_than_or_equal':
+            return isNumericComparison ? cellNum >= ruleNum : cellStr >= ruleStr;
+        case 'less_than_or_equal':
+            return isNumericComparison ? cellNum <= ruleNum : cellStr <= ruleStr;
+        case 'contains':
+            return cellStr.includes(ruleStr);
+        case 'not_contains':
+            return !cellStr.includes(ruleStr);
+        case 'starts_with':
+            return cellStr.startsWith(ruleStr);
+        case 'ends_with':
+            return cellStr.endsWith(ruleStr);
+        case 'between':
+            if (secondValue === undefined)
+                return false;
+            const secondNum = Number(secondValue);
+            if (isNumericComparison && !isNaN(secondNum)) {
+                return cellNum >= Math.min(ruleNum, secondNum) && cellNum <= Math.max(ruleNum, secondNum);
+            }
+            return cellStr >= ruleStr && cellStr <= String(secondValue).toLowerCase();
+        case 'in_list':
+            const list = Array.isArray(ruleValue) ? ruleValue : String(ruleValue).split(',');
+            return list.some(item => isNumericComparison ? cellNum === Number(item) : cellStr === String(item).toLowerCase());
+        default:
+            return false;
+    }
+}
+/**
+ * Hook for conditional formatting in data grids
+ * Evaluates formatting rules against cell values and returns appropriate styles
+ */
+function useConditionalFormatting(data, rules) {
+    const enabledRules = (0, react_1.useMemo)(() => rules
+        .filter(rule => rule.enabled !== false)
+        .sort((a, b) => (b.priority || 0) - (a.priority || 0)), [rules]);
+    // Get styles for a specific cell
+    const getCellStyle = (0, react_1.useMemo)(() => (rowData, columnId) => {
+        for (const rule of enabledRules) {
+            // Skip if rule is for a specific column and doesn't match
+            if (rule.columnId && rule.columnId !== columnId) {
+                continue;
+            }
+            const cellValue = rowData[columnId];
+            if (evaluateCondition(cellValue, rule.operator, rule.value, rule.secondValue)) {
+                return rule.style;
+            }
+        }
+        return null;
+    }, [enabledRules]);
+    // Get CSS properties object for a cell
+    const getCellCSSProperties = (0, react_1.useMemo)(() => (rowData, columnId) => {
+        const style = getCellStyle(rowData, columnId);
+        if (!style)
+            return {};
+        return {
+            backgroundColor: style.backgroundColor,
+            color: style.textColor,
+            fontWeight: style.fontWeight,
+            fontStyle: style.fontStyle,
+            borderColor: style.borderColor,
+            borderWidth: style.borderWidth ? `${style.borderWidth}px` : undefined,
+            borderStyle: style.borderColor || style.borderWidth ? 'solid' : undefined,
+            opacity: style.opacity
+        };
+    }, [getCellStyle]);
+    // Get CSS class name for a cell
+    const getCellClassName = (0, react_1.useMemo)(() => (rowData, columnId) => {
+        const style = getCellStyle(rowData, columnId);
+        return style?.className || '';
+    }, [getCellStyle]);
+    // Get combined props for a cell
+    const getCellProps = (0, react_1.useMemo)(() => (rowData, columnId) => ({
+        style: getCellCSSProperties(rowData, columnId),
+        className: getCellClassName(rowData, columnId)
+    }), [getCellCSSProperties, getCellClassName]);
+    // Utility functions for creating common rules
+    const createRule = {
+        // Highlight cells above/below threshold
+        threshold: (columnId, threshold, operator = 'greater_than', style = exports.STYLE_PRESETS.warning) => ({
+            id: `threshold-${columnId}-${threshold}`,
+            name: `${columnId} ${operator} ${threshold}`,
+            columnId,
+            operator,
+            value: threshold,
+            style
+        }),
+        // Highlight specific values
+        valueMatch: (columnId, value, style = exports.STYLE_PRESETS.highlight) => ({
+            id: `value-${columnId}-${value}`,
+            name: `${columnId} equals ${value}`,
+            columnId,
+            operator: 'equals',
+            value,
+            style
+        }),
+        // Highlight empty cells
+        emptyValues: (columnId, style = exports.STYLE_PRESETS.error) => ({
+            id: `empty-${columnId}`,
+            name: `${columnId} is empty`,
+            columnId,
+            operator: 'is_empty',
+            value: null,
+            style
+        }),
+        // Range highlighting
+        range: (columnId, min, max, style = exports.STYLE_PRESETS.success) => ({
+            id: `range-${columnId}-${min}-${max}`,
+            name: `${columnId} between ${min} and ${max}`,
+            columnId,
+            operator: 'between',
+            value: min,
+            secondValue: max,
+            style
+        })
+    };
+    return {
+        getCellStyle,
+        getCellCSSProperties,
+        getCellClassName,
+        getCellProps,
+        createRule,
+        STYLE_PRESETS: exports.STYLE_PRESETS
+    };
+}

package/dist/cjs/hooks/useDebounce.js

@@ -0,0 +1,49 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDebounce = useDebounce;
+exports.useDebouncedValue = useDebouncedValue;
+const react_1 = require("react");
+/**
+ * Custom hook for debouncing function calls
+ * @param callback - The function to debounce
+ * @param delay - Delay in milliseconds
+ * @returns Debounced function
+ */
+function useDebounce(callback, delay) {
+    const timeoutRef = (0, react_1.useRef)();
+    const debouncedCallback = (0, react_1.useCallback)((...args) => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            callback(...args);
+        }, delay);
+    }, [callback, delay]);
+    (0, react_1.useEffect)(() => {
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    return debouncedCallback;
+}
+/**
+ * Custom hook for debouncing state values
+ * @param value - The value to debounce
+ * @param delay - Delay in milliseconds
+ * @returns Debounced value
+ */
+function useDebouncedValue(value, delay) {
+    const [debouncedValue, setDebouncedValue] = (0, react_1.useState)(value);
+    (0, react_1.useEffect)(() => {
+        const handler = setTimeout(() => {
+            setDebouncedValue(value);
+        }, delay);
+        return () => {
+            clearTimeout(handler);
+        };
+    }, [value, delay]);
+    return debouncedValue;
+}

package/dist/cjs/hooks/useDraft.js

@@ -0,0 +1,181 @@
+'use client';
+"use strict";
+/**
+ * useDraft Hook - Milestone Based
+ *
+ * React hook for milestone-based draft management.
+ * User manually saves at important points (milestones) during estimation.
+ *
+ * Usage:
+ * ```typescript
+ * const {
+ *   saveDraft,
+ *   loadDraft,
+ *   deleteDraft,
+ *   listDrafts,
+ *   drafts,
+ *   lastSaved,
+ *   isSaving
+ * } = useDraft('ESTIMATION', currentEstimationState)
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDraft = useDraft;
+const react_1 = require("react");
+const react_2 = require("next-auth/react");
+const draft_1 = require("../lib/api/draft/index.js");
+/**
+ * useDraft Hook - Milestone Based
+ */
+function useDraft(module, currentState) {
+    const { data: session } = (0, react_2.useSession)();
+    // State
+    const [drafts, setDrafts] = (0, react_1.useState)([]);
+    const [isLoadingDrafts, setIsLoadingDrafts] = (0, react_1.useState)(false);
+    const [lastSaved, setLastSaved] = (0, react_1.useState)(null);
+    const [isSaving, setIsSaving] = (0, react_1.useState)(false);
+    const [currentDraftId, setCurrentDraftId] = (0, react_1.useState)(null);
+    const [currentDraftDocumentId, setCurrentDraftDocumentId] = (0, react_1.useState)(null);
+    /**
+     * Save a draft (milestone-based)
+     */
+    const saveDraft = (0, react_1.useCallback)(async (draftName, documentId, documentName, remark) => {
+        if (!session)
+            return false;
+        setIsSaving(true);
+        try {
+            // Smart draft ID logic:
+            // Only use currentDraftId if the document ID matches (same quote)
+            // If document ID changed, create a NEW draft instead of updating old one
+            const shouldUpdateExistingDraft = currentDraftId &&
+                currentDraftDocumentId === documentId;
+            const draftIdToUse = shouldUpdateExistingDraft ? currentDraftId : null;
+            const response = await draft_1.DraftAPI.saveDraft(draftName, currentState, module, documentId || null, documentName || null, draftIdToUse, // Only update if same document
+            session, remark);
+            if (response.success && response.data) {
+                setLastSaved(new Date());
+                setCurrentDraftId(response.data.draftId);
+                setCurrentDraftDocumentId(documentId || null); // Track which quote this draft belongs to
+                return true;
+            }
+            else {
+                console.error('❌ [DRAFT] Save failed - API response:', response.error || 'No error message');
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ [DRAFT] Save exception:', error);
+            return false;
+        }
+        finally {
+            setIsSaving(false);
+        }
+    }, [session, currentState, module, currentDraftId, currentDraftDocumentId]);
+    /**
+     * Load a draft
+     */
+    const loadDraft = (0, react_1.useCallback)(async (draftId) => {
+        if (!session)
+            return null;
+        try {
+            const response = await draft_1.DraftAPI.loadDraft(draftId, session);
+            if (response.success && response.data) {
+                setCurrentDraftId(draftId);
+                setLastSaved(new Date(response.data.lastSaved));
+                // Extract documentId from draftData to track which quote this draft belongs to
+                const documentId = response.data.draftData?.quoteNumber || null;
+                setCurrentDraftDocumentId(documentId);
+                return response.data.draftData;
+            }
+            else {
+                return null;
+            }
+        }
+        catch (error) {
+            return null;
+        }
+    }, [session]);
+    /**
+     * Delete a draft
+     */
+    const deleteDraft = (0, react_1.useCallback)(async (draftId) => {
+        if (!session)
+            return false;
+        try {
+            const response = await draft_1.DraftAPI.deleteDraft(draftId, session);
+            if (response.success) {
+                await listDrafts();
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }, [session]);
+    /**
+     * Rename a draft
+     */
+    const renameDraft = (0, react_1.useCallback)(async (draftId, newName) => {
+        if (!session)
+            return false;
+        try {
+            const response = await draft_1.DraftAPI.renameDraft(draftId, newName, session);
+            if (response.success) {
+                await listDrafts();
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }, [session]);
+    /**
+     * List all drafts for current module
+     */
+    const listDrafts = (0, react_1.useCallback)(async () => {
+        if (!session)
+            return;
+        setIsLoadingDrafts(true);
+        try {
+            const response = await draft_1.DraftAPI.listDrafts(module, session);
+            if (response.success && response.data) {
+                setDrafts(response.data);
+            }
+            else {
+                setDrafts([]);
+            }
+        }
+        catch (error) {
+            setDrafts([]);
+        }
+        finally {
+            setIsLoadingDrafts(false);
+        }
+    }, [session, module]);
+    /**
+     * Load drafts on mount
+     */
+    (0, react_1.useEffect)(() => {
+        if (session) {
+            listDrafts();
+        }
+    }, [session, listDrafts]);
+    return {
+        saveDraft,
+        loadDraft,
+        deleteDraft,
+        renameDraft,
+        listDrafts,
+        drafts,
+        isLoadingDrafts,
+        lastSaved,
+        isSaving,
+        currentDraftId
+    };
+}