indas-ui 0.0.1 → 0.1.0

package/dist/lib/utils/device-detection.js

@@ -0,0 +1,105 @@
+'use client';
+/**
+ * Device Detection Utility
+ * Detects browser, OS, and device type from user agent
+ */
+export function detectDevice() {
+    if (typeof window === 'undefined') {
+        return {
+            browser: 'Unknown',
+            os: 'Unknown',
+            deviceType: 'desktop'
+        };
+    }
+    const userAgent = window.navigator.userAgent;
+    const platform = window.navigator.platform;
+    // Detect Browser
+    let browser = 'Unknown';
+    if (userAgent.includes('Chrome') && !userAgent.includes('Edg')) {
+        browser = 'Chrome';
+    }
+    else if (userAgent.includes('Edg')) {
+        browser = 'Edge';
+    }
+    else if (userAgent.includes('Safari') && !userAgent.includes('Chrome')) {
+        browser = 'Safari';
+    }
+    else if (userAgent.includes('Firefox')) {
+        browser = 'Firefox';
+    }
+    else if (userAgent.includes('MSIE') || userAgent.includes('Trident')) {
+        browser = 'Internet Explorer';
+    }
+    else if (userAgent.includes('Opera') || userAgent.includes('OPR')) {
+        browser = 'Opera';
+    }
+    // Detect OS
+    let os = 'Unknown';
+    if (platform.includes('Win')) {
+        os = 'Windows';
+    }
+    else if (platform.includes('Mac')) {
+        os = 'macOS';
+    }
+    else if (platform.includes('Linux')) {
+        os = 'Linux';
+    }
+    else if (userAgent.includes('Android')) {
+        os = 'Android';
+    }
+    else if (userAgent.includes('iOS') || userAgent.includes('iPhone') || userAgent.includes('iPad')) {
+        os = 'iOS';
+    }
+    // Detect Device Type
+    let deviceType = 'desktop';
+    if (/Mobi|Android/i.test(userAgent)) {
+        deviceType = 'mobile';
+    }
+    else if (/Tablet|iPad/i.test(userAgent)) {
+        deviceType = 'tablet';
+    }
+    return {
+        browser,
+        os,
+        deviceType
+    };
+}
+/**
+ * Get device ID from browser fingerprint
+ * Uses a combination of user agent, screen resolution, and timezone
+ */
+export function getDeviceId() {
+    if (typeof window === 'undefined') {
+        return 'server';
+    }
+    const components = [
+        window.navigator.userAgent,
+        window.screen.width,
+        window.screen.height,
+        window.screen.colorDepth,
+        new Date().getTimezoneOffset(),
+        window.navigator.language
+    ];
+    // Simple hash function
+    const hash = components.join('|').split('').reduce((acc, char) => {
+        const chr = char.charCodeAt(0);
+        acc = ((acc << 5) - acc) + chr;
+        return acc & acc;
+    }, 0);
+    return `device-${Math.abs(hash).toString(36)}`;
+}
+/**
+ * Get device name based on browser and OS
+ */
+export function getDeviceName() {
+    const { browser, os, deviceType } = detectDevice();
+    if (deviceType === 'mobile') {
+        return `${os} Mobile`;
+    }
+    else if (deviceType === 'tablet') {
+        return `${os} Tablet`;
+    }
+    else {
+        return `${browser} on ${os}`;
+    }
+}

package/dist/lib/utils/logout-cleanup.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Comprehensive logout cleanup utility
+ * Clears all client-side storage, cookies, caches, and databases
+ */
+/**
+ * Clear all cookies including NextAuth cookies
+ * Handles all domain/path/security variations
+ */
+export declare function clearAllCookies(): void;
+/**
+ * Clear all Cache Storage entries
+ */
+export declare function clearCacheStorage(): Promise<void>;
+/**
+ * Clear all IndexedDB databases
+ */
+export declare function clearIndexedDB(): Promise<void>;
+/**
+ * Clear localStorage EXCEPT user preferences
+ * Preserves: theme, language, currency, sidebar preferences, search preferences
+ */
+export declare function clearLocalStorage(): void;
+/**
+ * Clear sessionStorage completely
+ */
+export declare function clearSessionStorage(): void;
+/**
+ * Clear React Query cache if present
+ */
+export declare function clearReactQueryCache(): void;
+/**
+ * Clear Next.js router cache
+ */
+export declare function clearNextRouterCache(): void;
+/**
+ * Unregister service workers
+ */
+export declare function unregisterServiceWorkers(): Promise<void>;
+/**
+ * Clear browser back/forward cache (bfcache)
+ */
+export declare function clearBFCache(): void;
+/**
+ * Clear HttpOnly cookies via API
+ */
+export declare function clearHttpOnlyCookies(): Promise<void>;
+/**
+ * Clear ALL localStorage including user preferences (no preservation).
+ * Use this when the user explicitly asks to wipe everything.
+ */
+export declare function clearAllLocalStorage(): void;
+/**
+ * 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.
+ */
+export declare function performFullDataWipe(): Promise<boolean>;
+/**
+ * Perform complete logout cleanup
+ * Call this before signOut() for thorough cleanup
+ * @returns Promise<boolean> - true if cleanup successful, false otherwise
+ */
+export declare function performLogoutCleanup(): Promise<boolean>;

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

@@ -0,0 +1,297 @@
+'use client';
+/**
+ * Comprehensive logout cleanup utility
+ * Clears all client-side storage, cookies, caches, and databases
+ */
+/**
+ * Clear all cookies including NextAuth cookies
+ * Handles all domain/path/security variations
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export function clearSessionStorage() {
+    if (typeof window === 'undefined')
+        return;
+    sessionStorage.clear();
+}
+/**
+ * Clear React Query cache if present
+ */
+export 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
+ */
+export 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
+ */
+export 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)
+ */
+export 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
+ */
+export 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.
+ */
+export 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.
+ */
+export 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
+ */
+export 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/lib/utils/planning-prefs.d.ts

@@ -0,0 +1,10 @@
+export interface PlanningPrefs {
+    planningOptions: string[];
+    reelPlanOnSpecialSize: boolean;
+    paperPlanOnSpecialSize: boolean;
+    shipperPalletizeAll: boolean;
+    shipperSpecialSize: boolean;
+    gridIncludeMaterials: boolean;
+}
+export declare function getPlanningPrefs(): Partial<PlanningPrefs>;
+export declare function savePlanningPref<K extends keyof PlanningPrefs>(key: K, value: PlanningPrefs[K]): void;

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

@@ -0,0 +1,27 @@
+'use client';
+// 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.
+const KEY = 'estimo:planning-prefs';
+export function getPlanningPrefs() {
+    if (typeof window === 'undefined')
+        return {};
+    try {
+        const raw = window.localStorage.getItem(KEY);
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+}
+export 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/lib/utils.d.ts

@@ -0,0 +1,20 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+export declare function formatCurrency(amount: number, currency?: string): string;
+export declare function formatDate(date: Date | string): string;
+export declare function formatNumber(num: number, decimals?: number): string;
+export declare function formatPercentage(value: number, decimals?: number): string;
+/**
+ * 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)
+ */
+export declare function getLocalDateString(date: Date): string;
+/**
+ * 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.
+ */
+export declare function getModuleRoutePath(moduleName: string): string;
+export declare function naturalCompare(a: unknown, b: unknown): number;

package/dist/lib/utils.js

@@ -0,0 +1,60 @@
+'use client';
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+export function formatCurrency(amount, currency = 'USD') {
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency,
+    }).format(amount);
+}
+export function formatDate(date) {
+    return new Intl.DateTimeFormat('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    }).format(new Date(date));
+}
+export function formatNumber(num, decimals = 0) {
+    return new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals,
+    }).format(num);
+}
+export 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)
+ */
+export 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.
+ */
+export 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".
+export function naturalCompare(a, b) {
+    return naturalCollator.compare(String(a ?? ''), String(b ?? ''));
+}

package/dist/lib/vision/dieline-extractor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Vision LLM dieline extractor — reads L/W/H + content type from a dieline image.
+ *
+ * Two-pass extraction grounded in real keyline geometry:
+ *   Pass 1 (triage): user image + composite reference grid of all known
+ *                    content-type keylines → model returns top-5 candidates
+ *                    + L/W/H read from the user's labels.
+ *   Pass 2 (refine): user image + only the top-5 individual thumbnails →
+ *                    model picks the single best match with confidence.
+ *
+ * The reference grid is built once client-side from real DB keyline data
+ * (see reference-grid.ts), cached in IndexedDB. Per-type rendered thumbnails
+ * come from that same grid build, so pass 2 reuses already-rendered images.
+ */
+export type VisionProvider = 'backend' | 'claude';
+export interface ExtractedSpecs {
+    L: number | null;
+    W: number | null;
+    H: number | null;
+    contentType: string | null;
+    notes?: string;
+    /** Top candidates from pass 1, in confidence order. Useful for UI override. */
+    candidates?: string[];
+}
+export interface ExtractRequest {
+    file: File;
+    provider: VisionProvider;
+    /** Required only for provider='claude'. */
+    apiKey?: string;
+    contentTypes: string[];
+    /** Required — used both for the backend session AND to fetch keyline coords. */
+    session: any;
+    /** Grain used when fetching reference keylines (default 'With Grain'). */
+    grain?: string;
+}
+export declare function extractDielineSpecs(req: ExtractRequest): Promise<ExtractedSpecs>;
+/** Re-export so the UI can offer a "rebuild reference grid" button. */
+export { clearReferenceGridCache } from './reference-grid.js';