indas-ui 0.0.1 → 0.1.1

package/dist/cjs/lib/utils/logout-cleanup.js

@@ -0,0 +1,312 @@
+'use client';
+"use strict";
+/**
+ * Comprehensive logout cleanup utility
+ * Clears all client-side storage, cookies, caches, and databases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAllCookies = clearAllCookies;
+exports.clearCacheStorage = clearCacheStorage;
+exports.clearIndexedDB = clearIndexedDB;
+exports.clearLocalStorage = clearLocalStorage;
+exports.clearSessionStorage = clearSessionStorage;
+exports.clearReactQueryCache = clearReactQueryCache;
+exports.clearNextRouterCache = clearNextRouterCache;
+exports.unregisterServiceWorkers = unregisterServiceWorkers;
+exports.clearBFCache = clearBFCache;
+exports.clearHttpOnlyCookies = clearHttpOnlyCookies;
+exports.clearAllLocalStorage = clearAllLocalStorage;
+exports.performFullDataWipe = performFullDataWipe;
+exports.performLogoutCleanup = performLogoutCleanup;
+/**
+ * Clear all cookies including NextAuth cookies
+ * Handles all domain/path/security variations
+ */
+function clearAllCookies() {
+    if (typeof window === 'undefined')
+        return;
+    const cookies = document.cookie.split(";");
+    const hostname = window.location.hostname;
+    const paths = ['/', '/api', '/api/auth'];
+    // Get all possible domain variations
+    const domains = ['', hostname];
+    const hostParts = hostname.split('.');
+    if (hostParts.length > 1) {
+        // Add root domain (e.g., .example.com)
+        domains.push('.' + hostParts.slice(-2).join('.'));
+    }
+    // Clear each cookie with all possible variations
+    cookies.forEach((cookie) => {
+        const cookieName = cookie.split("=")[0].trim();
+        if (!cookieName)
+            return;
+        paths.forEach((path) => {
+            domains.forEach((domain) => {
+                // Basic clear
+                document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path}`;
+                // With Secure flag
+                document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};Secure`;
+                // With SameSite variations
+                document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};SameSite=Lax`;
+                document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};SameSite=Strict`;
+                document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};SameSite=None;Secure`;
+                if (domain) {
+                    document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};domain=${domain}`;
+                    document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};domain=${domain};Secure`;
+                    document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};domain=${domain};SameSite=Lax`;
+                }
+            });
+        });
+    });
+    // Explicitly clear NextAuth cookies
+    const nextAuthCookies = [
+        'next-auth.session-token',
+        'next-auth.csrf-token',
+        'next-auth.callback-url',
+        '__Secure-next-auth.session-token',
+        '__Secure-next-auth.csrf-token',
+        '__Secure-next-auth.callback-url',
+        '__Host-next-auth.csrf-token'
+    ];
+    nextAuthCookies.forEach((cookieName) => {
+        paths.forEach((path) => {
+            document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path}`;
+            document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};Secure`;
+            document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};SameSite=Lax`;
+            domains.forEach((domain) => {
+                if (domain) {
+                    document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};domain=${domain}`;
+                    document.cookie = `${cookieName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=${path};domain=${domain};Secure`;
+                }
+            });
+        });
+    });
+}
+/**
+ * Clear all Cache Storage entries
+ */
+async function clearCacheStorage() {
+    if (typeof window === 'undefined' || !('caches' in window))
+        return;
+    try {
+        const cacheNames = await caches.keys();
+        await Promise.all(cacheNames.map(cacheName => caches.delete(cacheName)));
+    }
+    catch (error) {
+        console.error('Error clearing Cache Storage:', error);
+    }
+}
+/**
+ * Clear all IndexedDB databases
+ */
+async function clearIndexedDB() {
+    if (typeof window === 'undefined' || !('indexedDB' in window))
+        return;
+    try {
+        const databases = await indexedDB.databases();
+        await Promise.all(databases.map((db) => {
+            if (db.name) {
+                return new Promise((resolve) => {
+                    const request = indexedDB.deleteDatabase(db.name);
+                    request.onsuccess = () => {
+                        resolve();
+                    };
+                    request.onerror = () => {
+                        console.error(`Error deleting IndexedDB ${db.name}:`, request.error);
+                        resolve(); // Continue anyway
+                    };
+                    request.onblocked = () => {
+                        resolve(); // Continue anyway
+                    };
+                });
+            }
+            return Promise.resolve();
+        }));
+    }
+    catch (error) {
+        console.error('Error clearing IndexedDB:', error);
+    }
+}
+/**
+ * Clear localStorage EXCEPT user preferences
+ * Preserves: theme, language, currency, sidebar preferences, search preferences
+ */
+function clearLocalStorage() {
+    if (typeof window === 'undefined')
+        return;
+    // Keys to PRESERVE (user preferences from settings page)
+    const preserveKeys = [
+        'erp-theme', // Theme preference (ThemeContext)
+        'app-language', // Language preference (LanguageContext)
+        'selectedCurrency', // Currency preference (CurrencyContext)
+        'sidebarPreferences', // Sidebar state (SidebarPreferencesContext)
+        'searchPreferences', // Search preferences (SearchPreferencesContext)
+        'bottom-nav-quick-tabs-v4' // Mobile bottom-nav quick tabs (bottom-nav.tsx)
+    ];
+    // Per-user keys (dashboard Quick Actions, home/quick-actions.tsx) — matched by prefix.
+    // 'datagrid-view:' keeps DataGrid view prefs (column order/visibility/width/sort)
+    // across logins — they're device-level, like theme/language.
+    const preservePrefixes = ['estimo_quick_actions_v3_', 'estimo_quick_starred_v3_', 'datagrid-view:'];
+    // Get all current values to preserve
+    const preservedValues = {};
+    Object.keys(localStorage).forEach(key => {
+        if (preserveKeys.includes(key) || preservePrefixes.some(p => key.startsWith(p))) {
+            preservedValues[key] = localStorage.getItem(key);
+        }
+    });
+    // Clear ALL localStorage
+    localStorage.clear();
+    // Restore preserved values
+    Object.entries(preservedValues).forEach(([key, value]) => {
+        if (value !== null)
+            localStorage.setItem(key, value);
+    });
+}
+/**
+ * Clear sessionStorage completely
+ */
+function clearSessionStorage() {
+    if (typeof window === 'undefined')
+        return;
+    sessionStorage.clear();
+}
+/**
+ * Clear React Query cache if present
+ */
+function clearReactQueryCache() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        // Check for React Query global cache
+        const queryClient = window.__REACT_QUERY_CLIENT__
+            || window.queryClient
+            || window.__TANSTACK_QUERY_CLIENT__;
+        if (queryClient && typeof queryClient.clear === 'function') {
+            queryClient.clear();
+        }
+    }
+    catch (error) {
+        // Silently ignore if React Query is not available
+    }
+}
+/**
+ * Clear Next.js router cache
+ */
+function clearNextRouterCache() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        // Clear Next.js router cache by replacing state
+        window.history.replaceState(null, '', window.location.pathname);
+    }
+    catch (error) {
+        console.error('Error clearing Next.js router cache:', error);
+    }
+}
+/**
+ * Unregister service workers
+ */
+async function unregisterServiceWorkers() {
+    if (typeof window === 'undefined' || !('serviceWorker' in navigator))
+        return;
+    try {
+        const registrations = await navigator.serviceWorker.getRegistrations();
+        await Promise.all(registrations.map(registration => registration.unregister()));
+    }
+    catch (error) {
+        console.error('Error unregistering service workers:', error);
+    }
+}
+/**
+ * Clear browser back/forward cache (bfcache)
+ */
+function clearBFCache() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        // Add event listener to prevent bfcache restoration
+        const handlePageShow = (event) => {
+            if (event.persisted) {
+                // Page was restored from bfcache, reload to clear it
+                window.location.reload();
+            }
+        };
+        window.addEventListener('pageshow', handlePageShow);
+    }
+    catch (error) {
+        console.error('Error setting up bfcache prevention:', error);
+    }
+}
+/**
+ * Clear HttpOnly cookies via API
+ */
+async function clearHttpOnlyCookies() {
+    try {
+        await fetch('/api/auth/remember', { method: 'DELETE' });
+    }
+    catch (error) {
+        console.error('Error clearing HttpOnly cookies:', error);
+    }
+}
+/**
+ * Clear ALL localStorage including user preferences (no preservation).
+ * Use this when the user explicitly asks to wipe everything.
+ */
+function clearAllLocalStorage() {
+    if (typeof window === 'undefined')
+        return;
+    localStorage.clear();
+}
+/**
+ * Wipe every client-side data store: cookies, localStorage (incl. preferences),
+ * sessionStorage, Cache Storage, IndexedDB, React Query cache, service workers.
+ * Used by the "Clear all data" button in Settings.
+ */
+async function performFullDataWipe() {
+    try {
+        clearSessionStorage();
+        clearAllLocalStorage();
+        clearAllCookies();
+        clearReactQueryCache();
+        clearNextRouterCache();
+        await Promise.all([
+            clearHttpOnlyCookies(),
+            clearCacheStorage(),
+            clearIndexedDB(),
+            unregisterServiceWorkers()
+        ]);
+        return true;
+    }
+    catch (error) {
+        console.error('Full data wipe failed:', error);
+        return false;
+    }
+}
+/**
+ * Perform complete logout cleanup
+ * Call this before signOut() for thorough cleanup
+ * @returns Promise<boolean> - true if cleanup successful, false otherwise
+ */
+async function performLogoutCleanup() {
+    try {
+        // Clear all storage synchronously first
+        clearSessionStorage();
+        clearLocalStorage();
+        clearAllCookies();
+        clearReactQueryCache();
+        clearNextRouterCache();
+        clearBFCache();
+        // Clear async storage
+        await Promise.all([
+            clearHttpOnlyCookies(),
+            clearCacheStorage(),
+            clearIndexedDB(),
+            unregisterServiceWorkers()
+        ]);
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Logout cleanup failed:', error);
+        return false;
+    }
+}

package/dist/cjs/lib/utils/planning-prefs.js

@@ -0,0 +1,31 @@
+'use client';
+"use strict";
+// Remembers the user's last planning checkbox selections (global, per-browser) so a
+// fresh estimation / reel / shipper view re-checks what they used last. Loaded
+// quotations always win over these defaults — only apply on new/empty state.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlanningPrefs = getPlanningPrefs;
+exports.savePlanningPref = savePlanningPref;
+const KEY = 'estimo:planning-prefs';
+function getPlanningPrefs() {
+    if (typeof window === 'undefined')
+        return {};
+    try {
+        const raw = window.localStorage.getItem(KEY);
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function savePlanningPref(key, value) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const current = getPlanningPrefs();
+        window.localStorage.setItem(KEY, JSON.stringify({ ...current, [key]: value }));
+    }
+    catch {
+        // localStorage unavailable (private mode / quota) — preferences are best-effort.
+    }
+}

package/dist/cjs/lib/utils.js

@@ -0,0 +1,70 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cn = cn;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatNumber = formatNumber;
+exports.formatPercentage = formatPercentage;
+exports.getLocalDateString = getLocalDateString;
+exports.getModuleRoutePath = getModuleRoutePath;
+exports.naturalCompare = naturalCompare;
+const clsx_1 = require("clsx");
+const tailwind_merge_1 = require("tailwind-merge");
+function cn(...inputs) {
+    return (0, tailwind_merge_1.twMerge)((0, clsx_1.clsx)(inputs));
+}
+function formatCurrency(amount, currency = 'USD') {
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency,
+    }).format(amount);
+}
+function formatDate(date) {
+    return new Intl.DateTimeFormat('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    }).format(new Date(date));
+}
+function formatNumber(num, decimals = 0) {
+    return new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals,
+    }).format(num);
+}
+function formatPercentage(value, decimals = 1) {
+    return `${(value * 100).toFixed(decimals)}%`;
+}
+/**
+ * Converts a Date object to YYYY-MM-DD string using local timezone
+ * Avoids UTC conversion issues that occur with toISOString()
+ * @param date - Date object to convert
+ * @returns Date string in YYYY-MM-DD format (local timezone)
+ */
+function getLocalDateString(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+/**
+ * Convert module name to route path.
+ * ModuleName from DB is already a path (e.g. /home, /enquiry).
+ * Fallback handles legacy display names by converting to kebab-case.
+ */
+function getModuleRoutePath(moduleName) {
+    if (moduleName.startsWith('/'))
+        return moduleName;
+    if (moduleName.includes('.aspx'))
+        return '#';
+    const normalizedModuleName = moduleName.toLowerCase().trim();
+    if (['rapid estimation', 'rapid-estimation', 'rapid', 'estimation-steps', 'estimation steps', 'step estimation', 'estimation-mobile', 'estimation mobile', 'dynamic fill', 'dynamic fill costing'].includes(normalizedModuleName))
+        return '/costing/estimation/rapid';
+    return `/${moduleName.toLowerCase().trim().replace(/\s+/g, '-')}`;
+}
+const naturalCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+// Numeric-aware string compare so "10" sorts after "9", not after "1".
+function naturalCompare(a, b) {
+    return naturalCollator.compare(String(a ?? ''), String(b ?? ''));
+}