@dashadmin/dash-admin 1.3.73 → 1.3.74-srcfree.2

package/src/hooks/useBreadcrumbs.tsx

@@ -1,329 +0,0 @@
-import { useCallback, useEffect, useMemo } from 'react';
-import { useLocation, useParams } from 'react-router-dom';
-import { useDispatch, useSelector } from 'react-redux';
-import { useStore } from 'react-admin';
-import { IBreadcrumbItem, IDASHAppState, DASH_REDUX_ACTIONS, IPageState } from 'dash-admin-state';
-import { IDashAutoAdminResourceConfig } from 'dash-auto-admin';
-import { DASHAdminSystemConstants } from 'dash-constants';
-
-// ============================================================================
-// TYPES & INTERFACES
-// ============================================================================
-
-export interface UseBreadcrumbsOptions {
-    /** Whether to auto-update breadcrumbs on route change */
-    autoUpdate?: boolean;
-    /** Custom label map for route segments */
-    labelMap?: Record<string, string>;
-    /** Whether to include the home item */
-    includeHome?: boolean;
-    /** Home path */
-    homePath?: string;
-    /** Home label */
-    homeLabel?: string;
-    /** Custom breadcrumb generator function */
-    customGenerator?: (pathname: string, resourceConfig?: IDashAutoAdminResourceConfig) => IBreadcrumbItem[];
-    /** Whether to fetch record name for detail pages */
-    fetchRecordName?: boolean;
-    /** Field to use as record name (default: 'name') */
-    recordNameField?: string;
-}
-
-export interface UseBreadcrumbsResult {
-    /** Current breadcrumbs */
-    breadcrumbs: IBreadcrumbItem[];
-    /** Manually set breadcrumbs */
-    setBreadcrumbs: (items: IBreadcrumbItem[]) => void;
-    /** Add a breadcrumb item */
-    addBreadcrumb: (item: IBreadcrumbItem) => void;
-    /** Clear all breadcrumbs */
-    clearBreadcrumbs: () => void;
-    /** Current pathname */
-    pathname: string;
-}
-
-// ============================================================================
-// DEFAULT LABEL MAPPINGS
-// ============================================================================
-
-const defaultLabelMap: Record<string, string> = {
-    // Common actions
-    'create': 'Crear',
-    'edit': 'Editar',
-    'show': 'Ver',
-    'list': 'Lista',
-    'inline': 'Detalle',
-    'trash': 'Papelera',
-    
-    // Common routes
-    'admin': 'Admin',
-    'system': 'Sistema',
-    'settings': 'Configuración',
-    'users': 'Usuarios',
-    'roles': 'Roles',
-    'permissions': 'Permisos',
-    'tenants': 'Tenants',
-    'profile': 'Perfil',
-    'dashboard': 'Dashboard',
-};
-
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-
-/**
- * Parse a route segment into a readable label
- */
-const parseSegmentLabel = (
-    segment: string, 
-    labelMap: Record<string, string>,
-    resourceConfig?: IDashAutoAdminResourceConfig
-): string => {
-    // Check custom label map first
-    if (labelMap[segment]) {
-        return labelMap[segment];
-    }
-    
-    // Check default label map
-    if (defaultLabelMap[segment]) {
-        return defaultLabelMap[segment];
-    }
-    
-    // Check if segment matches resource model
-    if (resourceConfig && resourceConfig.model?.includes(segment)) {
-        return resourceConfig.label || segment;
-    }
-    
-    // Convert kebab-case or snake_case to Title Case
-    return segment
-        .replace(/[-_]/g, ' ')
-        .replace(/\b\w/g, char => char.toUpperCase());
-};
-
-/**
- * Check if a segment is an ID (numeric or UUID-like)
- */
-const isIdSegment = (segment: string): boolean => {
-    // Check for numeric ID
-    if (/^\d+$/.test(segment)) {
-        return true;
-    }
-    // Check for UUID
-    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment)) {
-        return true;
-    }
-    // Check for short hash-like IDs
-    if (/^[a-z0-9]{20,}$/i.test(segment)) {
-        return true;
-    }
-    return false;
-};
-
-/**
- * Generate breadcrumbs from pathname
- */
-const generateBreadcrumbsFromPath = (
-    pathname: string,
-    labelMap: Record<string, string>,
-    resourceConfig?: IDashAutoAdminResourceConfig,
-    includeHome?: boolean,
-    homePath?: string,
-    homeLabel?: string,
-    recordName?: string
-): IBreadcrumbItem[] => {
-    const URL_PREFIX = DASHAdminSystemConstants.system.URL_PREFIX || '';
-    
-    // Remove URL prefix and clean path
-    let cleanPath = pathname;
-    if (URL_PREFIX && cleanPath.startsWith(URL_PREFIX)) {
-        cleanPath = cleanPath.slice(URL_PREFIX.length);
-    }
-    
-    // Split into segments and filter empty ones
-    const segments = cleanPath.split('/').filter(Boolean);
-    
-    if (segments.length === 0) {
-        return [];
-    }
-    
-    const breadcrumbs: IBreadcrumbItem[] = [];
-    
-    // Add home item if requested
-    if (includeHome) {
-        breadcrumbs.push({
-            label: homeLabel || 'Home',
-            path: homePath || '/',
-        });
-    }
-    
-    let currentPath = URL_PREFIX;
-    
-    // Ensure path starts with slash if prefix doesn't have one
-    if (currentPath && !currentPath.startsWith('/')) {
-        currentPath = `/${currentPath}`;
-    }
-
-    let lastIdIndex = -1;
-    
-    segments.forEach((segment, index) => {
-        currentPath += `/${segment}`;
-        const isLast = index === segments.length - 1;
-        const isId = isIdSegment(segment);
-        
-        // Skip adding ID segments directly, we'll handle them specially
-        if (isId) {
-            lastIdIndex = index;
-            // If we have a record name and this is related to the last ID, use it
-            if (recordName && isLast) {
-                breadcrumbs.push({
-                    label: recordName,
-                    path: isLast ? undefined : currentPath,
-                    isActive: isLast,
-                });
-            } else {
-                // Use a generic "Record #ID" label
-                breadcrumbs.push({
-                    label: `#${segment.substring(0, 8)}${segment.length > 8 ? '...' : ''}`,
-                    path: isLast ? undefined : currentPath,
-                    isActive: isLast,
-                    data: { id: segment },
-                });
-            }
-            return;
-        }
-        
-        // Get the label for this segment
-        const label = parseSegmentLabel(segment, labelMap, resourceConfig);
-        
-        breadcrumbs.push({
-            label,
-            path: isLast ? undefined : currentPath,
-            isActive: isLast,
-        });
-    });
-    
-    return breadcrumbs;
-};
-
-// ============================================================================
-// HOOK
-// ============================================================================
-
-export const useBreadcrumbs = (options: UseBreadcrumbsOptions = {}): UseBreadcrumbsResult => {
-    const {
-        autoUpdate = true,
-        labelMap = {},
-        includeHome = false,
-        homePath = '/',
-        homeLabel = 'Home',
-        customGenerator,
-        fetchRecordName = true,
-        recordNameField = 'name',
-    } = options;
-    
-    const dispatch = useDispatch();
-    const location = useLocation();
-    const params = useParams();
-    
-    // Get resource config from store
-    const [resourceConfig] = useStore<IDashAutoAdminResourceConfig>('resourceConfig');
-    
-    // Get current page state including existing breadcrumbs
-    const pageState: IPageState = useSelector(
-        (state: IDASHAppState<any, any, IDashAutoAdminResourceConfig>) => state.page
-    );
-    
-    // Note: Record context is not available at the layout level
-    // Use the record prop in options if you need to pass record data
-    const record: any = null;
-    
-    // Merge label maps
-    const mergedLabelMap = useMemo(() => ({
-        ...defaultLabelMap,
-        ...labelMap,
-    }), [labelMap]);
-    
-    // Get record name from record context
-    const recordName = useMemo(() => {
-        if (!fetchRecordName || !record) return undefined;
-        
-        // Try common name fields
-        const nameFields = [recordNameField, 'name', 'title', 'label', 'displayName', 'username'];
-        for (const field of nameFields) {
-            if (record[field]) {
-                return String(record[field]);
-            }
-        }
-        
-        // Use recordRepresentation if available
-        if (resourceConfig?.recordRepresentation) {
-            const repr = resourceConfig.recordRepresentation;
-            if (typeof repr === 'string' && record[repr]) {
-                return String(record[repr]);
-            }
-        }
-        
-        return undefined;
-    }, [record, fetchRecordName, recordNameField, resourceConfig]);
-    
-    // Generate breadcrumbs
-    const breadcrumbs = useMemo(() => {
-        if (customGenerator) {
-            return customGenerator(location.pathname, resourceConfig);
-        }
-        
-        return generateBreadcrumbsFromPath(
-            location.pathname,
-            mergedLabelMap,
-            resourceConfig,
-            includeHome,
-            homePath,
-            homeLabel,
-            recordName
-        );
-    }, [
-        location.pathname,
-        mergedLabelMap,
-        resourceConfig,
-        includeHome,
-        homePath,
-        homeLabel,
-        recordName,
-        customGenerator,
-    ]);
-    
-    // Set breadcrumbs action
-    const setBreadcrumbs = useCallback((items: IBreadcrumbItem[]) => {
-        dispatch(DASH_REDUX_ACTIONS.updatePage({ breadcrumbs: items }));
-    }, [dispatch]);
-    
-    // Add breadcrumb action
-    const addBreadcrumb = useCallback((item: IBreadcrumbItem) => {
-        const currentBreadcrumbs = pageState.breadcrumbs || [];
-        dispatch(DASH_REDUX_ACTIONS.updatePage({ 
-            breadcrumbs: [...currentBreadcrumbs, item] 
-        }));
-    }, [dispatch, pageState.breadcrumbs]);
-    
-    // Clear breadcrumbs action
-    const clearBreadcrumbs = useCallback(() => {
-        dispatch(DASH_REDUX_ACTIONS.updatePage({ breadcrumbs: [] }));
-    }, [dispatch]);
-    
-    // Auto-update breadcrumbs on route change
-    useEffect(() => {
-        if (autoUpdate && breadcrumbs.length > 0) {
-            setBreadcrumbs(breadcrumbs);
-        }
-    }, [autoUpdate, breadcrumbs, setBreadcrumbs]);
-    
-    return {
-        breadcrumbs: pageState.breadcrumbs || breadcrumbs,
-        setBreadcrumbs,
-        addBreadcrumb,
-        clearBreadcrumbs,
-        pathname: location.pathname,
-    };
-};
-
-export default useBreadcrumbs;

package/src/hooks/useClickOutside.tsx

@@ -1,57 +0,0 @@
-import { useEffect, useRef } from 'react';
-
-/**
- * Closes a dropdown/menu when the user interacts outside of it.
- *
- * Takes an ARRAY of refs on purpose: these menus render their content via
- * `ReactDOM.createPortal(..., document.body)`, so the trigger (e.g. the
- * avatar) and the menu content are two separate DOM subtrees — a click
- * inside the portal is not a descendant of the trigger ref, so checking
- * only the trigger would treat every click inside the menu itself as
- * "outside" and close it immediately. Pass every root that should count as
- * "inside" (trigger + portal content).
- *
- * Listens on 'mousedown'/'touchstart' rather than 'click': the containment
- * check already excludes clicks on the trigger itself (so it never
- * self-closes the menu it just opened), and the earlier event avoids fights
- * with libraries that stopPropagation() on 'click'.
- *
- * `enabled` lets the caller skip attaching the listener entirely while the
- * menu is closed (pass the same `open` state driving the menu) instead of
- * registering a global document listener for the lifetime of the component.
- */
-const useClickOutside = (
-    refs: React.RefObject<HTMLElement>[],
-    onClickOutside: () => void,
-    enabled: boolean = true,
-) => {
-    // Ref so the effect doesn't need to re-subscribe every time the caller
-    // passes a new callback identity (common here since these callbacks
-    // close over component state).
-    const callbackRef = useRef(onClickOutside);
-    callbackRef.current = onClickOutside;
-
-    useEffect(() => {
-        if (!enabled) return;
-
-        const handlePointerDown = (e: MouseEvent | TouchEvent) => {
-            const target = e.target as Node;
-            const isInside = refs.some((ref) => ref.current && ref.current.contains(target));
-            if (!isInside) {
-                callbackRef.current();
-            }
-        };
-
-        document.addEventListener('mousedown', handlePointerDown);
-        document.addEventListener('touchstart', handlePointerDown);
-        return () => {
-            document.removeEventListener('mousedown', handlePointerDown);
-            document.removeEventListener('touchstart', handlePointerDown);
-        };
-        // eslint-disable-next-line react-hooks/exhaustive-deps -- `refs` are
-        // stable useRef objects from the caller; only `enabled` should
-        // re-trigger (re)subscription.
-    }, [enabled]);
-};
-
-export default useClickOutside;

package/src/hooks/useFormPersistance.tsx

@@ -1,150 +0,0 @@
-import { useEffect, useCallback, useRef } from 'react';
-import { useFormContext } from 'react-hook-form';
-import { useParams } from 'react-router-dom';
-import { dashStorage } from 'dash-utils';
-interface FormPersistenceOptions {
-    persistState?: boolean;
-    storageKey?: string;
-    debounceMs?: number;
-    excludeFields?: string[];
-}
-
-export const useFormPersistence = (options: FormPersistenceOptions = {}) => {
-    const {
-        persistState = false,
-        storageKey,
-        debounceMs = 1000,
-        excludeFields = []
-    } = options;
-
-    const { watch, setValue, getValues } = useFormContext();
-    const { id: tabId } = useParams();
-    const debounceRef = useRef<ReturnType<typeof setTimeout>>(null);
-    
-    // Generate storage key
-    const finalStorageKey = storageKey || `tab-form-${tabId}`;
-
-    // Save form data to localStorage
-    const saveFormData = useCallback((data: any) => {
-        if (!persistState) return;
-        
-        try {
-            // Filter out excluded fields
-            const filteredData = { ...data };
-            excludeFields.forEach(field => {
-                delete filteredData[field];
-            });
-
-            const persistData = {
-                formData: filteredData,
-                timestamp: Date.now(),
-                tabId
-            };
-
-            dashStorage.setItem(finalStorageKey, JSON.stringify(persistData));
-            console.log('📦 Form data persisted:', finalStorageKey);
-        } catch (error) {
-            console.error('Failed to persist form data:', error);
-        }
-    }, [persistState, finalStorageKey, excludeFields, tabId]);
-
-    // Load form data from localStorage
-    const loadFormData = useCallback(() => {
-        if (!persistState) return null;
-
-        try {
-            const stored = dashStorage.getItem(finalStorageKey);
-            if (!stored) return null;
-
-            const persistData = JSON.parse(stored);
-            
-            // Check if data is not too old (optional: 24 hours)
-            const maxAge = 24 * 60 * 60 * 1000; // 24 hours
-            if (Date.now() - persistData.timestamp > maxAge) {
-                dashStorage.removeItem(finalStorageKey);
-                return null;
-            }
-
-            console.log('📦 Form data loaded from storage:', finalStorageKey);
-            return persistData.formData;
-        } catch (error) {
-            console.error('Failed to load form data:', error);
-            return null;
-        }
-    }, [persistState, finalStorageKey]);
-
-    // Restore form data
-    const restoreFormData = useCallback(() => {
-        const savedData = loadFormData();
-        if (!savedData) return false;
-
-        try {
-            // Restore each field
-            Object.keys(savedData).forEach(fieldName => {
-                setValue(fieldName, savedData[fieldName], {
-                    shouldDirty: true,
-                    shouldTouch: true,
-                    shouldValidate: false
-                });
-            });
-
-            console.log('✅ Form data restored successfully');
-            return true;
-        } catch (error) {
-            console.error('Failed to restore form data:', error);
-            return false;
-        }
-    }, [loadFormData, setValue]);
-
-    // Clear persisted data
-    const clearPersistedData = useCallback(() => {
-        try {
-            dashStorage.removeItem(finalStorageKey);
-            console.log('🗑️ Persisted form data cleared:', finalStorageKey);
-        } catch (error) {
-            console.error('Failed to clear persisted data:', error);
-        }
-    }, [finalStorageKey]);
-
-    // Watch for form changes and save with debouncing
-    useEffect(() => {
-        if (!persistState) return;
-
-        const subscription = watch((data) => {
-            // Clear existing timeout
-            if (debounceRef.current) {
-                clearTimeout(debounceRef.current);
-            }
-
-            // Set new timeout
-            debounceRef.current = setTimeout(() => {
-                saveFormData(data);
-            }, debounceMs);
-        });
-
-        return () => {
-            subscription.unsubscribe();
-            if (debounceRef.current) {
-                clearTimeout(debounceRef.current);
-            }
-        };
-    }, [watch, persistState, saveFormData, debounceMs]);
-
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            if (debounceRef.current) {
-                clearTimeout(debounceRef.current);
-            }
-        };
-    }, []);
-
-    return {
-        restoreFormData,
-        clearPersistedData,
-        loadFormData,
-        saveFormData: () => saveFormData(getValues())
-    };
-};
-
-export default useFormPersistence;

package/src/hooks/useGlobalErrorMediator.tsx

@@ -1,43 +0,0 @@
-import { random } from 'lodash';
-import React, { useState } from 'react';
-import { dashStorage } from 'dash-utils';
-const useGlobalErrorMediator = () => {
-	const [error, setError] = React.useState<any>(null);
-	const errorChangeHandler = React.useCallback((e) => {
-		if (dashStorage.getItem('lastGlobalError') === JSON.stringify(e.data)) {
-			return;
-		}
-
-		setError(e.data);
-		dashStorage.setItem('lastGlobalError', JSON.stringify(e.data));
-
-		setTimeout(() => {
-			dashStorage.setItem('lastGlobalError', JSON.stringify({}));
-		}, 1000);
-	}, []);
-
-	React.useEffect(() => {
-		dashStorage.setItem('lastGlobalError', JSON.stringify({}));
-        
-		window.addEventListener('GlobalError', errorChangeHandler);
-		return () => {
-			dashStorage.setItem('lastGlobalError', JSON.stringify({}));
-			window.removeEventListener('GlobalError', errorChangeHandler);
-		};
-	}, []);
-
-	const _update = React.useCallback(
-		(newError) => {
-			window.dispatchEvent(new MessageEvent('GlobalError', { data: {error:newError} }));
-		},
-		[error],
-	);
-
-	const sendError = (error: any) => {
-		_update(error);
-	};
-
-	return { error, sendError };
-};
-
-export default useGlobalErrorMediator;

package/src/hooks/useGlobalLoaderMgr.tsx

@@ -1,21 +0,0 @@
-import React, { useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
-
-const useGlobalLoaderMgr = () => {
-	const useLoader = useState<boolean>(false);
-	React.useEffect(() => {
- 
-		window.addEventListener('dash-global-loader', (e: any) => {
-            
-			return useLoader[1](e.data)
-        });
-		return () => {
-			window.removeEventListener('dash-global-loader', (e: any) =>
-				useLoader[1](e.data),
-			);
-		};
-	}, []);
-	return useLoader;
-};
-
-export default useGlobalLoaderMgr;

package/src/hooks/useHash.tsx

@@ -1,27 +0,0 @@
-import React from 'react';
-
-const useHash = () => {
-	const [hash, setHash] = React.useState(() => window.location.hash);
-
-	const hashChangeHandler = React.useCallback(() => {
-		setHash(window.location.hash);
-	}, []);
-
-	React.useEffect(() => {
-		window.addEventListener('hashchange', hashChangeHandler);
-		return () => {
-			window.removeEventListener('hashchange', hashChangeHandler);
-		};
-	}, []);
-
-	const updateHash = React.useCallback(
-		(newHash) => {
-			/*if (newHash !== hash)*/ window.location.hash = newHash;
-		},
-		[hash],
-	);
-
-	return [hash, updateHash];
-};
-
-export default useHash;