indas-ui 0.0.1 → 0.1.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,23 @@
+export { useClientId, useUniqueId } from './useId.js';
+export { useTheme } from './useTheme.js';
+export { useDebounce, useDebouncedValue } from './useDebounce.js';
+export { useColumnMetadata } from './useColumnMetadata.js';
+export { useGridSettings } from './useGridSettings.js';
+export { useKeyboardNavigation } from './useKeyboardNavigation.js';
+export { useConditionalFormatting, STYLE_PRESETS } from './useConditionalFormatting.js';
+export { useGridTheme, getThemeClasses, THEME_PRESETS } from './useGridTheme.js';
+export { useRowSelection } from './useRowSelection.js';
+export { useColumnFreezing } from './useColumnFreezing.js';
+export { useBacchaSearch } from './useBacchaSearch.js';
+export { useIntelligentColumnSizing, COLUMN_SIZING_PRESETS, createIntelligentColumn } from './useIntelligentColumnSizing.js';
+export { useUnsavedChanges, usePreventDataLoss, useFormProtection } from './useUnsavedChanges.js';
+export { usePrevious } from './usePrevious.js';
+export { useNotifications, formatTimeAgo, getNotificationIcon, getIconBoxColors } from './useNotifications.js';
+export { useSignalR } from './useSignalR.js';
+export { useFormValidation } from './useFormValidation.js';
+export type { FormattingRule, ConditionalStyle, ConditionOperator } from './useConditionalFormatting.js';
+export type { GridTheme } from './useGridTheme.js';
+export type { RowSelectionState, UseRowSelectionOptions } from './useRowSelection.js';
+export type { FrozenColumnState, UseColumnFreezingOptions } from './useColumnFreezing.js';
+export type { SearchFilter, SearchOptions, SearchState } from './useBacchaSearch.js';
+export type { ColumnSizingConfig, ColumnSizeConstraints } from './useIntelligentColumnSizing.js';

package/dist/hooks/index.js

@@ -0,0 +1,18 @@
+'use client';
+export { useClientId, useUniqueId } from './useId.js';
+export { useTheme } from './useTheme.js';
+export { useDebounce, useDebouncedValue } from './useDebounce.js';
+export { useColumnMetadata } from './useColumnMetadata.js';
+export { useGridSettings } from './useGridSettings.js';
+export { useKeyboardNavigation } from './useKeyboardNavigation.js';
+export { useConditionalFormatting, STYLE_PRESETS } from './useConditionalFormatting.js';
+export { useGridTheme, getThemeClasses, THEME_PRESETS } from './useGridTheme.js';
+export { useRowSelection } from './useRowSelection.js';
+export { useColumnFreezing } from './useColumnFreezing.js';
+export { useBacchaSearch } from './useBacchaSearch.js';
+export { useIntelligentColumnSizing, COLUMN_SIZING_PRESETS, createIntelligentColumn } from './useIntelligentColumnSizing.js';
+export { useUnsavedChanges, usePreventDataLoss, useFormProtection } from './useUnsavedChanges.js';
+export { usePrevious } from './usePrevious.js';
+export { useNotifications, formatTimeAgo, getNotificationIcon, getIconBoxColors } from './useNotifications.js';
+export { useSignalR } from './useSignalR.js';
+export { useFormValidation } from './useFormValidation.js';

package/dist/hooks/useApproval.d.ts

@@ -0,0 +1,47 @@
+/**
+ * useApproval Hook
+ *
+ * React hook for managing approval workflows.
+ * Handles requesting, approving, rejecting, and escalating approvals.
+ *
+ * Usage:
+ * ```typescript
+ * const {
+ *   requestApproval,
+ *   approveQuotation,
+ *   rejectQuotation,
+ *   escalateQuotation,
+ *   withdrawApproval,
+ *   getApprovalChain,
+ *   pendingApprovals,
+ *   isLoading
+ * } = useApproval()
+ * ```
+ */
+import type { ApprovalWorkflow, ApprovalChain } from '../types/approval.js';
+export interface UseApprovalReturn {
+    /** Request approval for an entity */
+    requestApproval: (entityType: string, entityId: number, comments?: string, metadata?: Record<string, any>) => Promise<boolean>;
+    /** Approve a quotation/entity */
+    approveQuotation: (approvalId: number, comments?: string) => Promise<boolean>;
+    /** Reject a quotation/entity */
+    rejectQuotation: (approvalId: number, comments?: string) => Promise<boolean>;
+    /** Escalate approval to another user */
+    escalateQuotation: (approvalId: number, toUserId: number, reason?: string) => Promise<boolean>;
+    /** Withdraw an approval request */
+    withdrawApproval: (approvalId: number, reason?: string) => Promise<boolean>;
+    /** Get approval chain for an entity */
+    getApprovalChain: (entityType: string, entityId: number) => Promise<ApprovalChain | null>;
+    /** Refresh pending approvals */
+    refreshPendingApprovals: () => Promise<void>;
+    /** List of pending approvals for current user */
+    pendingApprovals: ApprovalWorkflow[];
+    /** Whether an operation is in progress */
+    isLoading: boolean;
+    /** Whether pending approvals are being loaded */
+    isLoadingPending: boolean;
+}
+/**
+ * useApproval Hook
+ */
+export declare function useApproval(): UseApprovalReturn;

package/dist/hooks/useApproval.js

@@ -0,0 +1,247 @@
+'use client';
+/**
+ * useApproval Hook
+ *
+ * React hook for managing approval workflows.
+ * Handles requesting, approving, rejecting, and escalating approvals.
+ *
+ * Usage:
+ * ```typescript
+ * const {
+ *   requestApproval,
+ *   approveQuotation,
+ *   rejectQuotation,
+ *   escalateQuotation,
+ *   withdrawApproval,
+ *   getApprovalChain,
+ *   pendingApprovals,
+ *   isLoading
+ * } = useApproval()
+ * ```
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { useSession } from 'next-auth/react';
+import { ApprovalAPI } from '../lib/api/approval/index.js';
+/**
+ * useApproval Hook
+ */
+export function useApproval() {
+    const { data: session } = useSession();
+    // State
+    const [pendingApprovals, setPendingApprovals] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingPending, setIsLoadingPending] = useState(false);
+    /**
+     * Request approval for an entity
+     */
+    const requestApproval = useCallback(async (entityType, entityId, comments, metadata) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await ApprovalAPI.requestApproval(entityType, entityId, comments, metadata, session);
+            if (response.success) {
+                return true;
+            }
+            else {
+                console.error('❌ [useApproval] Failed to request approval:', response.error);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ [useApproval] Error requesting approval:', error);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [session]);
+    /**
+     * Approve a quotation/entity
+     */
+    const approveQuotation = useCallback(async (approvalId, comments) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await ApprovalAPI.approve(approvalId, comments, session);
+            if (response.success) {
+                // Refresh pending approvals
+                await refreshPendingApprovals();
+                return true;
+            }
+            else {
+                console.error('❌ [useApproval] Failed to approve:', response.error);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ [useApproval] Error approving:', error);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [session]);
+    /**
+     * Reject a quotation/entity
+     */
+    const rejectQuotation = useCallback(async (approvalId, comments) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await ApprovalAPI.reject(approvalId, comments, session);
+            if (response.success) {
+                // Refresh pending approvals
+                await refreshPendingApprovals();
+                return true;
+            }
+            else {
+                console.error('❌ [useApproval] Failed to reject:', response.error);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ [useApproval] Error rejecting:', error);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [session]);
+    /**
+     * Escalate approval to another user
+     */
+    const escalateQuotation = useCallback(async (approvalId, toUserId, reason) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await ApprovalAPI.escalate(approvalId, toUserId, reason, session);
+            if (response.success) {
+                // Refresh pending approvals
+                await refreshPendingApprovals();
+                return true;
+            }
+            else {
+                console.error('❌ [useApproval] Failed to escalate:', response.error);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ [useApproval] Error escalating:', error);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [session]);
+    /**
+     * Withdraw an approval request
+     */
+    const withdrawApproval = useCallback(async (approvalId, reason) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await ApprovalAPI.withdraw(approvalId, reason, session);
+            if (response.success) {
+                // Refresh pending approvals
+                await refreshPendingApprovals();
+                return true;
+            }
+            else {
+                console.error('❌ [useApproval] Failed to withdraw:', response.error);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('❌ [useApproval] Error withdrawing:', error);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [session]);
+    /**
+     * Get approval chain for an entity
+     */
+    const getApprovalChain = useCallback(async (entityType, entityId) => {
+        if (!session) {
+            return null;
+        }
+        try {
+            const response = await ApprovalAPI.getApprovalChain(entityType, entityId, session);
+            if (response.success && response.data) {
+                return response.data;
+            }
+            else {
+                console.error('❌ [useApproval] Failed to get approval chain:', response.error);
+                return null;
+            }
+        }
+        catch (error) {
+            console.error('❌ [useApproval] Error getting approval chain:', error);
+            return null;
+        }
+    }, [session]);
+    /**
+     * Refresh pending approvals
+     */
+    const refreshPendingApprovals = useCallback(async () => {
+        if (!session) {
+            return;
+        }
+        setIsLoadingPending(true);
+        try {
+            const response = await ApprovalAPI.getPendingApprovals(session);
+            if (response.success && response.data) {
+                setPendingApprovals(response.data);
+            }
+            else {
+                // Silently fail if endpoint doesn't exist (404)
+                if (response.error && response.error.includes('No HTTP resource was found')) {
+                    // Backend endpoint not implemented yet - use empty array
+                    setPendingApprovals([]);
+                }
+                else {
+                    console.error('❌ [useApproval] Failed to get pending approvals:', response.error);
+                    setPendingApprovals([]);
+                }
+            }
+        }
+        catch (error) {
+            // Silently fail if endpoint doesn't exist
+            setPendingApprovals([]);
+        }
+        finally {
+            setIsLoadingPending(false);
+        }
+    }, [session]);
+    /**
+     * Load pending approvals on mount and when session changes
+     */
+    useEffect(() => {
+        if (session) {
+            refreshPendingApprovals();
+        }
+    }, [session, refreshPendingApprovals]);
+    return {
+        requestApproval,
+        approveQuotation,
+        rejectQuotation,
+        escalateQuotation,
+        withdrawApproval,
+        getApprovalChain,
+        refreshPendingApprovals,
+        pendingApprovals,
+        isLoading,
+        isLoadingPending
+    };
+}

package/dist/hooks/useBacchaSearch.d.ts

@@ -0,0 +1,57 @@
+export interface SearchFilter {
+    id: string;
+    columnId?: string;
+    value: string;
+    operator: 'contains' | 'equals' | 'starts_with' | 'ends_with' | 'greater_than' | 'less_than';
+    caseSensitive?: boolean;
+}
+export interface SearchOptions {
+    globalSearch?: boolean;
+    columnSearch?: boolean;
+    debounceMs?: number;
+    caseSensitive?: boolean;
+    highlightMatches?: boolean;
+    searchOperator?: 'contains' | 'equals' | 'starts_with' | 'ends_with';
+}
+export interface SearchState {
+    globalTerm: string;
+    columnFilters: Record<string, string>;
+    activeFilters: SearchFilter[];
+    matchCount: number;
+    hasActiveSearch: boolean;
+}
+/**
+ * Advanced search hook with global and column-specific filtering
+ * Supports multiple search operators and debounced performance
+ */
+export declare function useBacchaSearch<TData>(data: TData[], columns: any[], options?: SearchOptions): {
+    filteredData: TData[];
+    originalData: TData[];
+    searchState: SearchState;
+    globalTerm: string;
+    columnFilters: Record<string, string>;
+    setGlobalSearch: (value: string) => void;
+    setColumnFilter: (columnId: string, value: string) => void;
+    clearColumnFilter: (columnId: string) => void;
+    clearAllFilters: () => void;
+    addCustomFilter: (filter: Omit<SearchFilter, "id">) => string;
+    removeCustomFilter: (filterId: string) => void;
+    updateCustomFilter: (filterId: string, updates: Partial<SearchFilter>) => void;
+    highlightText: (text: string, searchTerm: string) => string;
+    quickSearch: {
+        findEmpty: (columnId: string) => string;
+        findInRange: (columnId: string, min: number, max: number) => string[];
+        findExact: (columnId: string, value: string) => string;
+        findAcrossColumns: (columnIds: string[], value: string) => string[];
+    };
+    matchesOperator: (cellValue: any, searchValue: string, operator: string, isCaseSensitive?: boolean) => boolean;
+    searchableColumns: any[];
+    options: {
+        globalSearch: boolean;
+        columnSearch: boolean;
+        debounceMs: number;
+        caseSensitive: boolean;
+        highlightMatches: boolean;
+        searchOperator: "equals" | "contains" | "starts_with" | "ends_with";
+    };
+};

package/dist/hooks/useBacchaSearch.js

@@ -0,0 +1,254 @@
+'use client';
+import { useState, useMemo, useCallback } from 'react';
+import { useDebouncedValue } from './useDebounce.js';
+/**
+ * Advanced search hook with global and column-specific filtering
+ * Supports multiple search operators and debounced performance
+ */
+export function useBacchaSearch(data, columns, options = {}) {
+    const { globalSearch = true, columnSearch = true, debounceMs = 300, caseSensitive = false, highlightMatches = true, searchOperator = 'contains' } = options;
+    const [globalTerm, setGlobalTerm] = useState('');
+    const [columnFilters, setColumnFilters] = useState({});
+    const [customFilters, setCustomFilters] = useState([]);
+    // Debounced search terms for performance
+    const debouncedGlobalTerm = useDebouncedValue(globalTerm, debounceMs);
+    const debouncedColumnFilters = useDebouncedValue(columnFilters, debounceMs);
+    // Get searchable columns
+    const searchableColumns = useMemo(() => columns.filter(col => !col.meta?.skipSearch &&
+        col.id !== 'select' &&
+        !col.meta?.isSelectColumn), [columns]);
+    // Apply search operator
+    const matchesOperator = useCallback((cellValue, searchValue, operator, isCaseSensitive = false) => {
+        if (!searchValue)
+            return true;
+        if (cellValue == null)
+            return false;
+        const cellStr = isCaseSensitive ? String(cellValue) : String(cellValue).toLowerCase();
+        const searchStr = isCaseSensitive ? searchValue : searchValue.toLowerCase();
+        switch (operator) {
+            case 'contains':
+                return cellStr.includes(searchStr);
+            case 'equals':
+                return cellStr === searchStr;
+            case 'starts_with':
+                return cellStr.startsWith(searchStr);
+            case 'ends_with':
+                return cellStr.endsWith(searchStr);
+            case 'greater_than':
+                const cellNum = Number(cellValue);
+                const searchNum = Number(searchValue);
+                return !isNaN(cellNum) && !isNaN(searchNum) && cellNum > searchNum;
+            case 'less_than':
+                const cellNum2 = Number(cellValue);
+                const searchNum2 = Number(searchValue);
+                return !isNaN(cellNum2) && !isNaN(searchNum2) && cellNum2 < searchNum2;
+            default:
+                return cellStr.includes(searchStr);
+        }
+    }, []);
+    // Filter data based on search criteria
+    const filteredData = useMemo(() => {
+        let filtered = data;
+        // Apply global search
+        if (globalSearch && debouncedGlobalTerm) {
+            filtered = filtered.filter(row => searchableColumns.some(column => {
+                const columnKey = column.accessorKey || column.id;
+                const cellValue = row[columnKey];
+                return matchesOperator(cellValue, debouncedGlobalTerm, searchOperator, caseSensitive);
+            }));
+        }
+        // Apply column-specific filters
+        if (columnSearch) {
+            Object.entries(debouncedColumnFilters).forEach(([columnId, filterValue]) => {
+                if (filterValue) {
+                    filtered = filtered.filter(row => {
+                        const cellValue = row[columnId];
+                        return matchesOperator(cellValue, filterValue, searchOperator, caseSensitive);
+                    });
+                }
+            });
+        }
+        // Apply custom filters
+        customFilters.forEach(filter => {
+            if (filter.value) {
+                filtered = filtered.filter(row => {
+                    if (filter.columnId) {
+                        const cellValue = row[filter.columnId];
+                        return matchesOperator(cellValue, filter.value, filter.operator, filter.caseSensitive ?? caseSensitive);
+                    }
+                    else {
+                        // Global filter
+                        return searchableColumns.some(column => {
+                            const columnKey = column.accessorKey || column.id;
+                            const cellValue = row[columnKey];
+                            return matchesOperator(cellValue, filter.value, filter.operator, filter.caseSensitive ?? caseSensitive);
+                        });
+                    }
+                });
+            }
+        });
+        return filtered;
+    }, [
+        data,
+        debouncedGlobalTerm,
+        debouncedColumnFilters,
+        customFilters,
+        searchableColumns,
+        globalSearch,
+        columnSearch,
+        searchOperator,
+        caseSensitive,
+        matchesOperator
+    ]);
+    // Search state
+    const searchState = useMemo(() => {
+        const activeFilters = [];
+        // Add global filter
+        if (debouncedGlobalTerm) {
+            activeFilters.push({
+                id: 'global',
+                value: debouncedGlobalTerm,
+                operator: searchOperator,
+                caseSensitive
+            });
+        }
+        // Add column filters
+        Object.entries(debouncedColumnFilters).forEach(([columnId, value]) => {
+            if (value) {
+                activeFilters.push({
+                    id: `column-${columnId}`,
+                    columnId,
+                    value,
+                    operator: searchOperator,
+                    caseSensitive
+                });
+            }
+        });
+        // Add custom filters
+        activeFilters.push(...customFilters.filter(f => f.value));
+        return {
+            globalTerm: debouncedGlobalTerm,
+            columnFilters: debouncedColumnFilters,
+            activeFilters,
+            matchCount: filteredData.length,
+            hasActiveSearch: activeFilters.length > 0
+        };
+    }, [
+        debouncedGlobalTerm,
+        debouncedColumnFilters,
+        customFilters,
+        filteredData.length,
+        searchOperator,
+        caseSensitive
+    ]);
+    // Actions
+    const setGlobalSearch = useCallback((value) => {
+        setGlobalTerm(value);
+    }, []);
+    const setColumnFilter = useCallback((columnId, value) => {
+        setColumnFilters(prev => ({
+            ...prev,
+            [columnId]: value
+        }));
+    }, []);
+    const clearColumnFilter = useCallback((columnId) => {
+        setColumnFilters(prev => {
+            const { [columnId]: _, ...rest } = prev;
+            return rest;
+        });
+    }, []);
+    const clearAllFilters = useCallback(() => {
+        setGlobalTerm('');
+        setColumnFilters({});
+        setCustomFilters([]);
+    }, []);
+    const addCustomFilter = useCallback((filter) => {
+        const newFilter = {
+            ...filter,
+            id: `custom-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+        };
+        setCustomFilters(prev => [...prev, newFilter]);
+        return newFilter.id;
+    }, []);
+    const removeCustomFilter = useCallback((filterId) => {
+        setCustomFilters(prev => prev.filter(f => f.id !== filterId));
+    }, []);
+    const updateCustomFilter = useCallback((filterId, updates) => {
+        setCustomFilters(prev => prev.map(f => f.id === filterId ? { ...f, ...updates } : f));
+    }, []);
+    // Highlight function for matched text
+    const highlightText = useCallback((text, searchTerm) => {
+        if (!highlightMatches || !searchTerm || !text)
+            return text;
+        const regex = new RegExp(`(${searchTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, caseSensitive ? 'g' : 'gi');
+        return text.replace(regex, '<mark class="bg-yellow-200 dark:bg-yellow-800">$1</mark>');
+    }, [highlightMatches, caseSensitive]);
+    // Quick search presets
+    const quickSearch = {
+        // Search for empty values
+        findEmpty: (columnId) => addCustomFilter({
+            columnId,
+            value: '',
+            operator: 'equals'
+        }),
+        // Search for numeric ranges
+        findInRange: (columnId, min, max) => {
+            const minFilterId = addCustomFilter({
+                columnId,
+                value: min.toString(),
+                operator: 'greater_than'
+            });
+            const maxFilterId = addCustomFilter({
+                columnId,
+                value: max.toString(),
+                operator: 'less_than'
+            });
+            return [minFilterId, maxFilterId];
+        },
+        // Search for specific values
+        findExact: (columnId, value) => addCustomFilter({
+            columnId,
+            value,
+            operator: 'equals',
+            caseSensitive: true
+        }),
+        // Search across multiple columns
+        findAcrossColumns: (columnIds, value) => columnIds.map(columnId => addCustomFilter({
+            columnId,
+            value,
+            operator: 'contains'
+        }))
+    };
+    return {
+        // Data
+        filteredData,
+        originalData: data,
+        // State
+        searchState,
+        // Search terms (immediate, not debounced)
+        globalTerm,
+        columnFilters,
+        // Actions
+        setGlobalSearch,
+        setColumnFilter,
+        clearColumnFilter,
+        clearAllFilters,
+        addCustomFilter,
+        removeCustomFilter,
+        updateCustomFilter,
+        // Utilities
+        highlightText,
+        quickSearch,
+        matchesOperator,
+        // Configuration
+        searchableColumns,
+        options: {
+            globalSearch,
+            columnSearch,
+            debounceMs,
+            caseSensitive,
+            highlightMatches,
+            searchOperator
+        }
+    };
+}

package/dist/hooks/useBusinessAudit.d.ts

@@ -0,0 +1,24 @@
+/**
+ * useBusinessAudit Hook
+ *
+ * React hook for logging business actions.
+ *
+ * Usage:
+ * ```typescript
+ * const { logAction, isLogging } = useBusinessAudit()
+ * await logAction('CREATE', 'ESTIMATION', {
+ *   documentName: 'Quotation',
+ *   documentId: 123,
+ * })
+ * ```
+ */
+import type { AuditModule, AuditAction } from '../types/audit.js';
+export declare function useBusinessAudit(): {
+    logAction: (action: AuditAction, module: AuditModule, details: {
+        documentName: string;
+        documentId?: number;
+        comments?: string;
+        metadata?: Record<string, any>;
+    }) => Promise<boolean>;
+    isLogging: boolean;
+};