indas-ui 0.0.1 → 0.1.1

package/dist/cjs/hooks/useApproval.js

@@ -0,0 +1,250 @@
+'use client';
+"use strict";
+/**
+ * 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()
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useApproval = useApproval;
+const react_1 = require("react");
+const react_2 = require("next-auth/react");
+const approval_1 = require("../lib/api/approval/index.js");
+/**
+ * useApproval Hook
+ */
+function useApproval() {
+    const { data: session } = (0, react_2.useSession)();
+    // State
+    const [pendingApprovals, setPendingApprovals] = (0, react_1.useState)([]);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [isLoadingPending, setIsLoadingPending] = (0, react_1.useState)(false);
+    /**
+     * Request approval for an entity
+     */
+    const requestApproval = (0, react_1.useCallback)(async (entityType, entityId, comments, metadata) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await approval_1.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 = (0, react_1.useCallback)(async (approvalId, comments) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await approval_1.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 = (0, react_1.useCallback)(async (approvalId, comments) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await approval_1.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 = (0, react_1.useCallback)(async (approvalId, toUserId, reason) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await approval_1.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 = (0, react_1.useCallback)(async (approvalId, reason) => {
+        if (!session) {
+            return false;
+        }
+        setIsLoading(true);
+        try {
+            const response = await approval_1.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 = (0, react_1.useCallback)(async (entityType, entityId) => {
+        if (!session) {
+            return null;
+        }
+        try {
+            const response = await approval_1.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 = (0, react_1.useCallback)(async () => {
+        if (!session) {
+            return;
+        }
+        setIsLoadingPending(true);
+        try {
+            const response = await approval_1.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
+     */
+    (0, react_1.useEffect)(() => {
+        if (session) {
+            refreshPendingApprovals();
+        }
+    }, [session, refreshPendingApprovals]);
+    return {
+        requestApproval,
+        approveQuotation,
+        rejectQuotation,
+        escalateQuotation,
+        withdrawApproval,
+        getApprovalChain,
+        refreshPendingApprovals,
+        pendingApprovals,
+        isLoading,
+        isLoadingPending
+    };
+}

package/dist/cjs/hooks/useBacchaSearch.js

@@ -0,0 +1,257 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBacchaSearch = useBacchaSearch;
+const react_1 = require("react");
+const useDebounce_1 = require("./useDebounce.js");
+/**
+ * Advanced search hook with global and column-specific filtering
+ * Supports multiple search operators and debounced performance
+ */
+function useBacchaSearch(data, columns, options = {}) {
+    const { globalSearch = true, columnSearch = true, debounceMs = 300, caseSensitive = false, highlightMatches = true, searchOperator = 'contains' } = options;
+    const [globalTerm, setGlobalTerm] = (0, react_1.useState)('');
+    const [columnFilters, setColumnFilters] = (0, react_1.useState)({});
+    const [customFilters, setCustomFilters] = (0, react_1.useState)([]);
+    // Debounced search terms for performance
+    const debouncedGlobalTerm = (0, useDebounce_1.useDebouncedValue)(globalTerm, debounceMs);
+    const debouncedColumnFilters = (0, useDebounce_1.useDebouncedValue)(columnFilters, debounceMs);
+    // Get searchable columns
+    const searchableColumns = (0, react_1.useMemo)(() => columns.filter(col => !col.meta?.skipSearch &&
+        col.id !== 'select' &&
+        !col.meta?.isSelectColumn), [columns]);
+    // Apply search operator
+    const matchesOperator = (0, react_1.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 = (0, react_1.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 = (0, react_1.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 = (0, react_1.useCallback)((value) => {
+        setGlobalTerm(value);
+    }, []);
+    const setColumnFilter = (0, react_1.useCallback)((columnId, value) => {
+        setColumnFilters(prev => ({
+            ...prev,
+            [columnId]: value
+        }));
+    }, []);
+    const clearColumnFilter = (0, react_1.useCallback)((columnId) => {
+        setColumnFilters(prev => {
+            const { [columnId]: _, ...rest } = prev;
+            return rest;
+        });
+    }, []);
+    const clearAllFilters = (0, react_1.useCallback)(() => {
+        setGlobalTerm('');
+        setColumnFilters({});
+        setCustomFilters([]);
+    }, []);
+    const addCustomFilter = (0, react_1.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 = (0, react_1.useCallback)((filterId) => {
+        setCustomFilters(prev => prev.filter(f => f.id !== filterId));
+    }, []);
+    const updateCustomFilter = (0, react_1.useCallback)((filterId, updates) => {
+        setCustomFilters(prev => prev.map(f => f.id === filterId ? { ...f, ...updates } : f));
+    }, []);
+    // Highlight function for matched text
+    const highlightText = (0, react_1.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/cjs/hooks/useBusinessAudit.js

@@ -0,0 +1,54 @@
+'use client';
+"use strict";
+/**
+ * useBusinessAudit Hook
+ *
+ * React hook for logging business actions.
+ *
+ * Usage:
+ * ```typescript
+ * const { logAction, isLogging } = useBusinessAudit()
+ * await logAction('CREATE', 'ESTIMATION', {
+ *   documentName: 'Quotation',
+ *   documentId: 123,
+ * })
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBusinessAudit = useBusinessAudit;
+const react_1 = require("react");
+const react_2 = require("next-auth/react");
+const audit_1 = require("../lib/api/activity/audit/index.js");
+function useBusinessAudit() {
+    const { data: session } = (0, react_2.useSession)();
+    const [isLogging, setIsLogging] = (0, react_1.useState)(false);
+    const logAction = (0, react_1.useCallback)(async (action, module, details) => {
+        if (!session)
+            return false;
+        setIsLogging(true);
+        try {
+            const response = await audit_1.BusinessAuditAPI.logAction({
+                Event: 'BUSINESS_ACTION',
+                Username: session.user?.UserName || session.user?.name || 'Unknown',
+                UserID: (session.user?.UserID || 0).toString(),
+                CompanyID: (session.user?.CompanyID || 0).toString(),
+                UserAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
+                Success: true,
+                Module: module,
+                Action: action,
+                DocumentName: details.documentName,
+                DocumentID: details.documentId?.toString(),
+                Comments: details.comments,
+                Metadata: details.metadata,
+            }, session);
+            return response.success;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            setIsLogging(false);
+        }
+    }, [session]);
+    return { logAction, isLogging };
+}