indas-ui 0.0.1 → 0.1.0

package/dist/cjs/hooks/useRowSelection.js

@@ -0,0 +1,150 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRowSelection = useRowSelection;
+const react_1 = require("react");
+/**
+ * Hook for managing row selection state with batch operations
+ * Optimized for performance with large datasets
+ */
+function useRowSelection({ data, getRowId = (row) => row.id || Math.random().toString(), enableMultiSelect = true, onSelectionChange }) {
+    const [selectedRowIds, setSelectedRowIds] = (0, react_1.useState)(new Set());
+    // Memoized row ID map for performance
+    const rowIdMap = (0, react_1.useMemo)(() => {
+        const map = new Map();
+        data.forEach((row) => {
+            const id = getRowId(row);
+            map.set(id, row);
+        });
+        return map;
+    }, [data, getRowId]);
+    // Calculate selection state
+    const selectionState = (0, react_1.useMemo)(() => {
+        const selectedData = Array.from(selectedRowIds)
+            .map(id => rowIdMap.get(id))
+            .filter(Boolean);
+        const isAllSelected = data.length > 0 && selectedRowIds.size === data.length;
+        const isIndeterminate = selectedRowIds.size > 0 && selectedRowIds.size < data.length;
+        return {
+            selectedRows: selectedRowIds,
+            selectedData,
+            isAllSelected,
+            isIndeterminate
+        };
+    }, [selectedRowIds, rowIdMap, data.length]);
+    // Select/deselect a single row
+    const toggleRowSelection = (0, react_1.useCallback)((rowOrId, forceValue) => {
+        const id = typeof rowOrId === 'string' ? rowOrId : getRowId(rowOrId);
+        setSelectedRowIds(prev => {
+            const newSet = new Set(prev);
+            const isCurrentlySelected = newSet.has(id);
+            const shouldSelect = forceValue !== undefined ? forceValue : !isCurrentlySelected;
+            if (shouldSelect) {
+                if (!enableMultiSelect) {
+                    newSet.clear();
+                }
+                newSet.add(id);
+            }
+            else {
+                newSet.delete(id);
+            }
+            // Trigger callback with new selection
+            const selectedData = Array.from(newSet)
+                .map(id => rowIdMap.get(id))
+                .filter(Boolean);
+            onSelectionChange?.(selectedData);
+            return newSet;
+        });
+    }, [getRowId, enableMultiSelect, rowIdMap, onSelectionChange]);
+    // Select multiple rows
+    const selectRows = (0, react_1.useCallback)((rows, replace = false) => {
+        setSelectedRowIds(prev => {
+            const newSet = replace ? new Set() : new Set(prev);
+            rows.forEach(row => {
+                const id = getRowId(row);
+                newSet.add(id);
+            });
+            // Trigger callback
+            const selectedData = Array.from(newSet)
+                .map(id => rowIdMap.get(id))
+                .filter(Boolean);
+            onSelectionChange?.(selectedData);
+            return newSet;
+        });
+    }, [getRowId, rowIdMap, onSelectionChange]);
+    // Select all rows
+    const selectAll = (0, react_1.useCallback)(() => {
+        const allIds = data.map((row) => getRowId(row));
+        setSelectedRowIds(new Set(allIds));
+        onSelectionChange?.(data);
+    }, [data, getRowId, onSelectionChange]);
+    // Clear selection
+    const clearSelection = (0, react_1.useCallback)(() => {
+        setSelectedRowIds(new Set());
+        onSelectionChange?.([]);
+    }, [onSelectionChange]);
+    // Toggle all selection
+    const toggleAllSelection = (0, react_1.useCallback)(() => {
+        if (selectionState.isAllSelected) {
+            clearSelection();
+        }
+        else {
+            selectAll();
+        }
+    }, [selectionState.isAllSelected, clearSelection, selectAll]);
+    // Check if a row is selected
+    const isRowSelected = (0, react_1.useCallback)((rowOrId) => {
+        const id = typeof rowOrId === 'string' ? rowOrId : getRowId(rowOrId);
+        return selectedRowIds.has(id);
+    }, [selectedRowIds, getRowId]);
+    // Select rows by condition
+    const selectWhere = (0, react_1.useCallback)((predicate, replace = false) => {
+        const matchingRows = data.filter(predicate);
+        selectRows(matchingRows, replace);
+    }, [data, selectRows]);
+    // Batch operations
+    const batchOperations = {
+        selectRange: (startIndex, endIndex) => {
+            const start = Math.max(0, Math.min(startIndex, endIndex));
+            const end = Math.min(data.length - 1, Math.max(startIndex, endIndex));
+            const rangeRows = data.slice(start, end + 1);
+            selectRows(rangeRows);
+        },
+        invertSelection: () => {
+            const unselectedRows = data.filter(row => !isRowSelected(row));
+            selectRows(unselectedRows, true);
+        },
+        selectByIndices: (indices) => {
+            const rows = indices
+                .filter(i => i >= 0 && i < data.length)
+                .map(i => data[i]);
+            selectRows(rows);
+        }
+    };
+    return {
+        // State
+        ...selectionState,
+        // Actions
+        toggleRowSelection,
+        selectRows,
+        selectAll,
+        clearSelection,
+        toggleAllSelection,
+        selectWhere,
+        // Utilities
+        isRowSelected,
+        batchOperations,
+        // For integration with table libraries
+        getRowSelectionProps: (row) => ({
+            checked: isRowSelected(row),
+            onChange: (checked) => toggleRowSelection(row, checked),
+            'aria-label': `Select row ${getRowId(row)}`
+        }),
+        getSelectAllProps: () => ({
+            checked: selectionState.isAllSelected,
+            indeterminate: selectionState.isIndeterminate,
+            onChange: toggleAllSelection,
+            'aria-label': 'Select all rows'
+        })
+    };
+}

package/dist/cjs/hooks/useSignalR.js

@@ -0,0 +1,53 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignalR = useSignalR;
+const react_1 = require("react");
+const signalr_1 = require("@microsoft/signalr");
+const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL || '';
+/**
+ * Hook to manage a SignalR connection for real-time notifications.
+ *
+ * Connects to /hubs/notifications with companyId/userId as query params.
+ * Auto-reconnects with backoff: [0s, 2s, 5s, 10s, 30s].
+ * Uses ref pattern to avoid stale closure issues with the callback.
+ */
+function useSignalR({ session, onReceiveNotification }) {
+    const connectionRef = (0, react_1.useRef)(null);
+    const onReceiveRef = (0, react_1.useRef)(onReceiveNotification);
+    // Keep callback ref current without re-connecting
+    (0, react_1.useEffect)(() => {
+        onReceiveRef.current = onReceiveNotification;
+    }, [onReceiveNotification]);
+    (0, react_1.useEffect)(() => {
+        if (!session?.user || !API_BASE_URL)
+            return;
+        const companyId = session.user.CompanyID || session.user.companyID;
+        const userId = session.user.UserID || session.user.userID;
+        if (!companyId || !userId)
+            return;
+        const hubUrl = `${API_BASE_URL}/hubs/notifications?companyId=${companyId}&userId=${userId}`;
+        const connection = new signalr_1.HubConnectionBuilder()
+            .withUrl(hubUrl)
+            .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
+            .configureLogging(signalr_1.LogLevel.None)
+            .build();
+        connection.on('ReceiveNotification', (data) => {
+            onReceiveRef.current(data);
+        });
+        connection.onreconnecting(() => { });
+        connection.onreconnected(() => { });
+        connection.onclose(() => { });
+        connection
+            .start()
+            .catch(() => {
+            // Silent fail — auto-reconnect will retry
+        });
+        connectionRef.current = connection;
+        return () => {
+            if (connection.state !== signalr_1.HubConnectionState.Disconnected) {
+                connection.stop();
+            }
+        };
+    }, [session?.user?.CompanyID, session?.user?.companyID, session?.user?.UserID, session?.user?.userID]);
+}

package/dist/cjs/hooks/useTheme.js

@@ -0,0 +1,268 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTheme = useTheme;
+exports.useThemeState = useThemeState;
+exports.useCustomThemeGenerator = useCustomThemeGenerator;
+exports.useThemeTransitions = useThemeTransitions;
+exports.useThemePersistence = useThemePersistence;
+const react_1 = require("react");
+const utils_1 = require("../lib/theme/utils.js");
+const types_1 = require("../lib/theme/types.js");
+const ThemeContext_1 = require("../contexts/ThemeContext.js");
+// Default theme
+const DEFAULT_THEME = {
+    variant: 'default',
+    mode: 'light',
+    fontFamily: 'system',
+    fontSize: 'normal'
+};
+/**
+ * Hook for managing theme state
+ * This is the main interface for theme management in the application
+ */
+function useTheme() {
+    const context = (0, react_1.useContext)(ThemeContext_1.ThemeContext);
+    if (!context) {
+        throw new Error('useTheme must be used within a ThemeProvider');
+    }
+    return context;
+}
+/**
+ * Low-level theme hook for internal use or when provider is not needed
+ * Most components should use useTheme() instead
+ */
+function useThemeState(defaultTheme = DEFAULT_THEME, storageKey = types_1.THEME_CONFIG.storageKey, enableSystem = true) {
+    const [theme, setThemeState] = (0, react_1.useState)(defaultTheme);
+    const [customTheme, setCustomThemeState] = (0, react_1.useState)(null);
+    const [isSystemPreference, setIsSystemPreference] = (0, react_1.useState)(false);
+    const [isInitialized, setIsInitialized] = (0, react_1.useState)(false);
+    // Create storage instance only once to prevent infinite re-renders
+    const storage = (0, react_1.useState)(() => new types_1.LocalThemeStorage())[0];
+    // Initialize theme from storage or system preference
+    (0, react_1.useEffect)(() => {
+        const initializeTheme = async () => {
+            try {
+                // Try to load saved theme
+                const savedTheme = await storage.getTheme(storageKey);
+                const savedCustomTheme = await storage.getCustomTheme(storageKey);
+                if (savedTheme) {
+                    setThemeState(savedTheme);
+                    if (savedCustomTheme) {
+                        setCustomThemeState(savedCustomTheme);
+                        (0, utils_1.applyCustomTheme)(savedCustomTheme);
+                    }
+                }
+                else if (enableSystem) {
+                    // Fall back to system preference
+                    const systemMode = (0, utils_1.getSystemTheme)();
+                    const systemTheme = { ...defaultTheme, mode: systemMode };
+                    setThemeState(systemTheme);
+                    setIsSystemPreference(true);
+                }
+            }
+            catch (error) {
+                // Fall back to default
+                setThemeState(defaultTheme);
+            }
+            finally {
+                setIsInitialized(true);
+            }
+        };
+        initializeTheme();
+    }, [defaultTheme, storageKey, enableSystem, storage]);
+    // Apply theme to document
+    (0, react_1.useEffect)(() => {
+        if (!isInitialized)
+            return;
+        const root = document.documentElement;
+        const themeClass = (0, utils_1.getThemeClassName)(theme);
+        // Remove all existing theme classes
+        const existingClasses = Array.from(root.classList).filter(cls => cls.startsWith('theme-') || cls === 'light' || cls === 'dark');
+        root.classList.remove(...existingClasses);
+        // Add new theme classes
+        root.classList.add(...themeClass.split(' '));
+        // Apply custom theme if needed
+        if (theme.variant === 'custom' && customTheme) {
+            (0, utils_1.applyCustomTheme)(customTheme);
+        }
+        else {
+            (0, utils_1.removeCustomTheme)();
+        }
+        // Apply font family CSS variable
+        const fontFamily = theme.fontFamily || 'system';
+        const fontConfig = types_1.FONT_FAMILIES[fontFamily];
+        root.style.setProperty('--font-family-base', fontConfig.value);
+        // Apply font size scale CSS variable
+        // Priority: custom fontScale > fontSize preset
+        if (theme.fontScale !== undefined) {
+            const scale = theme.fontScale / 100;
+            root.style.setProperty('--font-scale', scale.toString());
+        }
+        else {
+            const fontSize = theme.fontSize || 'normal';
+            const scaleConfig = types_1.FONT_SCALES[fontSize];
+            root.style.setProperty('--font-scale', scaleConfig.scale.toString());
+        }
+    }, [theme, customTheme, isInitialized]);
+    // Listen for system theme changes
+    (0, react_1.useEffect)(() => {
+        if (!enableSystem || !isSystemPreference)
+            return;
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        const handleChange = (e) => {
+            const newMode = e.matches ? 'dark' : 'light';
+            setThemeState(prev => ({ ...prev, mode: newMode }));
+        };
+        mediaQuery.addEventListener('change', handleChange);
+        return () => mediaQuery.removeEventListener('change', handleChange);
+    }, [enableSystem, isSystemPreference]);
+    // Theme setters
+    const setTheme = (0, react_1.useCallback)(async (newTheme) => {
+        setThemeState(newTheme);
+        setIsSystemPreference(false);
+        try {
+            await storage.setTheme(storageKey, newTheme);
+        }
+        catch (error) {
+            console.error('Failed to save theme:', error);
+        }
+    }, [storageKey, storage]);
+    const setVariant = (0, react_1.useCallback)((variant) => {
+        setTheme({ ...theme, variant });
+    }, [theme, setTheme]);
+    const setMode = (0, react_1.useCallback)((mode) => {
+        setTheme({ ...theme, mode });
+    }, [theme, setTheme]);
+    const toggleMode = (0, react_1.useCallback)(() => {
+        const newMode = theme.mode === 'light' ? 'dark' : 'light';
+        setMode(newMode);
+    }, [theme.mode, setMode]);
+    const setFontFamily = (0, react_1.useCallback)((fontFamily) => {
+        setTheme({ ...theme, fontFamily });
+    }, [theme, setTheme]);
+    const setFontSize = (0, react_1.useCallback)((fontSize) => {
+        setTheme({ ...theme, fontSize, fontScale: undefined }); // Clear custom scale when using preset
+    }, [theme, setTheme]);
+    const setFontScale = (0, react_1.useCallback)((scale) => {
+        // Clamp scale to valid range (80-150)
+        const clampedScale = Math.max(80, Math.min(150, scale));
+        setTheme({ ...theme, fontScale: clampedScale, fontSize: undefined }); // Clear preset when using custom scale
+    }, [theme, setTheme]);
+    // Custom theme management
+    const setCustomTheme = (0, react_1.useCallback)(async (colors, name) => {
+        // Validate the custom theme
+        const validation = (0, utils_1.validateTheme)(colors, theme.mode);
+        if (!validation.isValid) {
+            // You might want to show user feedback here
+        }
+        const newCustomTheme = {
+            ...colors,
+            name: name || 'Custom Theme',
+            id: `custom-${Date.now()}`,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        setCustomThemeState(newCustomTheme);
+        await setTheme({ ...theme, variant: 'custom' });
+        try {
+            await storage.setCustomTheme(storageKey, newCustomTheme);
+        }
+        catch (error) {
+            console.error('Failed to save custom theme:', error);
+        }
+    }, [theme, setTheme, storageKey, storage]);
+    const removeCustomThemeCallback = (0, react_1.useCallback)(async () => {
+        setCustomThemeState(null);
+        (0, utils_1.removeCustomTheme)();
+        // Switch to default theme as fallback
+        await setTheme({ ...theme, variant: 'default' });
+        try {
+            const currentTheme = await storage.getTheme(storageKey);
+            if (currentTheme) {
+                await storage.setTheme(storageKey, { ...currentTheme, variant: 'default' });
+            }
+        }
+        catch (error) {
+            console.error('Failed to remove custom theme:', error);
+        }
+    }, [theme, setTheme, storageKey, storage]);
+    return {
+        theme,
+        setTheme,
+        setVariant,
+        setMode,
+        toggleMode,
+        setFontFamily,
+        setFontSize,
+        setFontScale,
+        customTheme,
+        setCustomTheme,
+        removeCustomTheme: removeCustomThemeCallback,
+        isDark: theme.mode === 'dark',
+        isSystemPreference,
+        availableThemes: [...types_1.THEME_CONFIG.variants],
+        currentThemeClass: (0, utils_1.getThemeClassName)(theme),
+    };
+}
+/**
+ * Hook for generating custom themes from a base color
+ */
+function useCustomThemeGenerator() {
+    const { setCustomTheme } = useTheme();
+    const generateFromColor = (0, react_1.useCallback)((baseColor, name) => {
+        try {
+            const variants = (0, utils_1.generateColorVariants)(baseColor);
+            setCustomTheme(variants, name);
+            return { success: true, variants };
+        }
+        catch (error) {
+            console.error('Failed to generate custom theme:', error);
+            return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    }, [setCustomTheme]);
+    const validateColor = (0, react_1.useCallback)((colors, mode = 'light') => {
+        return (0, utils_1.validateTheme)(colors, mode);
+    }, []);
+    return {
+        generateFromColor,
+        validateColor,
+        generateColorVariants: utils_1.generateColorVariants,
+    };
+}
+/**
+ * Hook for theme-aware animations
+ */
+function useThemeTransitions() {
+    const { isDark } = useTheme();
+    const [isTransitioning, setIsTransitioning] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        setIsTransitioning(true);
+        const timeout = setTimeout(() => setIsTransitioning(false), 150);
+        return () => clearTimeout(timeout);
+    }, [isDark]);
+    return {
+        isTransitioning,
+        transitionClass: isTransitioning ? 'transition-colors duration-150' : ''
+    };
+}
+/**
+ * Hook for persisting theme across sessions (multi-tenant support)
+ */
+function useThemePersistence(tenantId) {
+    const { theme, setTheme } = useTheme();
+    const storageKey = tenantId ? `${types_1.THEME_CONFIG.storageKey}-${tenantId}` : types_1.THEME_CONFIG.storageKey;
+    const saveThemeForTenant = (0, react_1.useCallback)(async (theme) => {
+        const storage = new types_1.LocalThemeStorage();
+        await storage.setTheme(storageKey, theme);
+    }, [storageKey]);
+    const loadThemeForTenant = (0, react_1.useCallback)(async () => {
+        const storage = new types_1.LocalThemeStorage();
+        return await storage.getTheme(storageKey);
+    }, [storageKey]);
+    return {
+        saveThemeForTenant,
+        loadThemeForTenant,
+        currentStorageKey: storageKey,
+    };
+}

package/dist/cjs/hooks/useTranslation.js

@@ -0,0 +1,20 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTranslation = useTranslation;
+const LanguageContext_1 = require("../contexts/LanguageContext.js");
+function useTranslation() {
+    const { translations, language, setLanguage } = (0, LanguageContext_1.useLanguage)();
+    const t = (text, options) => {
+        // If language is English, return text as is (with interpolation)
+        let result = language === 'en' ? text : (translations[text] || text);
+        // Handle interpolation
+        if (options) {
+            Object.keys(options).forEach(key => {
+                result = result.replace(new RegExp(`{{${key}}}`, 'g'), String(options[key]));
+            });
+        }
+        return result;
+    };
+    return { t, language, setLanguage };
+}

package/dist/cjs/hooks/useUnsavedChanges.js

@@ -0,0 +1,88 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUnsavedChanges = useUnsavedChanges;
+exports.usePreventDataLoss = usePreventDataLoss;
+exports.useFormProtection = useFormProtection;
+const react_1 = require("react");
+/**
+ * Hook to detect unsaved changes in a form or modal
+ * Compares current data with initial data to determine if changes exist
+ *
+ * @param currentData - Current form/modal data
+ * @param isOpen - Whether the modal/form is open
+ * @returns boolean indicating if there are unsaved changes
+ *
+ * @example
+ * ```tsx
+ * const hasUnsavedChanges = useUnsavedChanges(formData, isModalOpen)
+ * ```
+ */
+function useUnsavedChanges(currentData, isOpen = true) {
+    // Store initial data on mount/open
+    const initialDataRef = (0, react_1.useRef)(null);
+    // Reset initial data when modal opens
+    (0, react_1.useEffect)(() => {
+        if (isOpen && !initialDataRef.current) {
+            initialDataRef.current = JSON.parse(JSON.stringify(currentData));
+        }
+        // Clear on close
+        if (!isOpen) {
+            initialDataRef.current = null;
+        }
+    }, [isOpen]);
+    // Detect changes by comparing current data with initial data
+    const hasChanges = (0, react_1.useMemo)(() => {
+        if (!initialDataRef.current)
+            return false;
+        return JSON.stringify(currentData) !== JSON.stringify(initialDataRef.current);
+    }, [currentData]);
+    return hasChanges;
+}
+/**
+ * Hook to prevent data loss when user tries to leave page/close tab
+ * Shows browser confirmation dialog when unsaved changes exist
+ *
+ * @param hasUnsavedChanges - Boolean indicating if there are unsaved changes
+ * @param isEnabled - Whether to enable the protection (default: true)
+ *
+ * @example
+ * ```tsx
+ * usePreventDataLoss(hasUnsavedChanges, isModalOpen)
+ * ```
+ */
+function usePreventDataLoss(hasUnsavedChanges, isEnabled = true) {
+    (0, react_1.useEffect)(() => {
+        if (!isEnabled || !hasUnsavedChanges)
+            return;
+        const handleBeforeUnload = (e) => {
+            if (hasUnsavedChanges) {
+                e.preventDefault();
+                // Modern browsers require returnValue to be set
+                e.returnValue = '';
+                return '';
+            }
+        };
+        window.addEventListener('beforeunload', handleBeforeUnload);
+        return () => {
+            window.removeEventListener('beforeunload', handleBeforeUnload);
+        };
+    }, [hasUnsavedChanges, isEnabled]);
+}
+/**
+ * Combined hook that provides both unsaved changes detection and data loss prevention
+ *
+ * @param currentData - Current form/modal data
+ * @param isOpen - Whether the modal/form is open
+ * @returns boolean indicating if there are unsaved changes
+ *
+ * @example
+ * ```tsx
+ * const hasUnsavedChanges = useFormProtection(formData, isModalOpen)
+ * ```
+ */
+function useFormProtection(currentData, isOpen = true) {
+    const hasUnsavedChanges = useUnsavedChanges(currentData, isOpen);
+    usePreventDataLoss(hasUnsavedChanges, isOpen);
+    return hasUnsavedChanges;
+}

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+'use client';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Components
+__exportStar(require("./components/index.js"), exports);
+// Contexts, providers, session adapter, utils (also available as 'indas-ui/providers')
+__exportStar(require("./providers.js"), exports);

package/dist/cjs/lib/api/activity/audit/audit.js

@@ -0,0 +1,51 @@
+'use client';
+"use strict";
+/**
+ * Audit API Client
+ *
+ * logAction: POST /api/auditlog — fire-and-forget business/security event logging
+ * getStats: GET /api/auditlog/stats — dashboard statistics
+ *
+ * The audit logs page fetches directly via APIClient — no wrapper needed.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessAuditAPI = exports.AuditAPI = void 0;
+const client_1 = __importDefault(require("../../core/client.js"));
+class AuditAPI {
+    /**
+     * Log an audit event (business action or security event)
+     */
+    static async logAction(request, session) {
+        try {
+            const response = await client_1.default.post('/api/auditlog', request, session);
+            if (response.success && response.data) {
+                return { success: true, data: { auditLogId: response.data.auditLogId } };
+            }
+            return { success: false, error: response.error || 'Failed to log audit event' };
+        }
+        catch (error) {
+            // Silent — audit failure must never break business flows
+            return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    }
+    /**
+     * Get audit log statistics
+     */
+    static async getStats(startDate, session) {
+        try {
+            const queryParams = new URLSearchParams();
+            if (startDate)
+                queryParams.append('startDate', startDate);
+            return await client_1.default.get(`/api/auditlog/stats?${queryParams.toString()}`, session);
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    }
+}
+exports.AuditAPI = AuditAPI;
+exports.BusinessAuditAPI = AuditAPI;
+exports.default = AuditAPI;

package/dist/cjs/lib/api/activity/audit/index.js

@@ -0,0 +1,29 @@
+'use client';
+"use strict";
+/**
+ * Audit API Module
+ * Exports audit logging functionality
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessAuditAPI = exports.AuditAPI = void 0;
+var audit_1 = require("./audit.js");
+Object.defineProperty(exports, "AuditAPI", { enumerable: true, get: function () { return __importDefault(audit_1).default; } });
+Object.defineProperty(exports, "BusinessAuditAPI", { enumerable: true, get: function () { return audit_1.BusinessAuditAPI; } });
+__exportStar(require("./send.js"), exports);