@bit.rhplus/ui.grid-layout 0.0.63 → 0.0.65

package/dist/useGridLayout.js

@@ -1,849 +0,0 @@
-/* eslint-disable */
-/**
- * Hlavní hook pro správu grid layout - automatické ukládání a načítání rozvržení sloupců
- * Kombinuje AG-Grid API s Grid Layout službou pro persistence uživatelských preferencí
- *
- * ARCHITEKTURA - ZERO RE-RENDER PATTERN:
- * ─────────────────────────────────────
- * Při drag/resize/auto-save se NEPOUŽÍVÁ žádný useState.
- * Všechny "pozadí" operace (save, detekce změn) běží přes useRef.
- * Re-rendery se spouštějí POUZE při explicitních akcích (init, reload, editor save).
- *
- * preTransformedColumnDefs se po inicializaci ZAMKNE (stabilní reference).
- * Zámek se uvolní jen při: změně columnDefs od parenta, editor save, reload.
- * Tím se zabrání tomu, aby AG-Grid dostal columnDefs s původním pořadím.
- */
-import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
-import { useGridLayoutApi } from './useGridLayoutApi';
-import { debounce } from 'lodash';
-// ============================================================================
-// HELPER FUNKCE
-// ============================================================================
-/**
- * Porovnání dvou column state pro detekci skutečných změn
- */
-const isColumnStateEqual = (state1, state2) => {
-    if (!state1 || !state2)
-        return false;
-    if (state1.length !== state2.length)
-        return false;
-    for (let i = 0; i < state1.length; i++) {
-        const col1 = state1[i];
-        const col2 = state2[i];
-        if (col1.colId !== col2.colId)
-            return false;
-        if (col1.width !== col2.width)
-            return false;
-        if (col1.hide !== col2.hide)
-            return false;
-        if (col1.pinned !== col2.pinned)
-            return false;
-    }
-    return true;
-};
-/**
- * Získá API objekt s metodou applyColumnState (AG Grid v31+ nebo starší)
- */
-const getApplyApi = (gridApiRef, columnApiRef) => {
-    if (gridApiRef.current?.applyColumnState)
-        return gridApiRef.current;
-    if (columnApiRef.current?.applyColumnState)
-        return columnApiRef.current;
-    return null;
-};
-/**
- * Získá aktuální column state z AG-Grid (AG Grid v31+ nebo starší)
- */
-const getColumnState = (gridApiRef, columnApiRef) => {
-    try {
-        if (gridApiRef.current?.getColumnState)
-            return gridApiRef.current.getColumnState();
-        if (columnApiRef.current?.getColumnState)
-            return columnApiRef.current.getColumnState();
-    }
-    catch (e) {
-        console.error('[GridLayout] Chyba při čtení column state:', e);
-    }
-    return null;
-};
-/**
- * Získá API objekt s metodou resetColumnState
- */
-const getResetApi = (gridApiRef, columnApiRef) => {
-    if (gridApiRef.current?.resetColumnState)
-        return gridApiRef.current;
-    if (columnApiRef.current?.resetColumnState)
-        return columnApiRef.current;
-    return null;
-};
-// ============================================================================
-// HLAVNÍ HOOK
-// ============================================================================
-export const useGridLayout = ({ userKey, applicationName, gridName, filterName, enabled = true, autoSave = true, autoSaveDelay = 500, columnDefs = [], accessToken, waitForSavedFields = false, onLayoutLoaded, onLayoutSaved, onError, }) => {
-    // Validace columnDefs
-    if (columnDefs !== undefined && columnDefs !== null && !Array.isArray(columnDefs)) {
-        console.error('[GridLayout] columnDefs is not an array:', typeof columnDefs, columnDefs);
-        throw new Error('useGridLayout: columnDefs musí být array');
-    }
-    // ==========================================================================
-    // REFS - stabilní reference pro event handlery a save funkce
-    // ==========================================================================
-    const gridApiRef = useRef(null);
-    const columnApiRef = useRef(null);
-    const columnWidthRefsMap = useRef(new Map()); // fieldId -> aktuální šířka
-    const headerNameMapRef = useRef(new Map()); // fieldId -> aktuální headerName
-    const lastKnownColumnStateRef = useRef(null); // Poslední známý stav pro detekci změn
-    const isInitializedRef = useRef(false);
-    const enabledRef = useRef(enabled);
-    const isGridReadyRef = useRef(false);
-    const autoSaveRef = useRef(autoSave);
-    const stableColumnDefsRef = useRef(columnDefs);
-    const stableGridLayoutApiRef = useRef(null);
-    const stableOnLayoutSavedRef = useRef(onLayoutSaved);
-    const stableOnErrorRef = useRef(onError);
-    const stableOnLayoutLoadedRef = useRef(onLayoutLoaded);
-    // "Pozadí" refs - ŽÁDNÉ useState pro tyto hodnoty (zero re-render pattern)
-    const isSavingRef = useRef(false);
-    const hasUnsavedChangesRef = useRef(false);
-    const isApplyingLayoutRef = useRef(false);
-    // Zámek pro preTransformedColumnDefs (stabilní reference po inicializaci)
-    const lockedColumnDefsRef = useRef(null);
-    const lockedForColumnDefsRef = useRef(null);
-    const lockedForFrozenRecordsRef = useRef(null);
-    // ==========================================================================
-    // STATE - POUZE pro hodnoty kde re-render je žádoucí
-    // ==========================================================================
-    const [isInitialized, setIsInitialized] = useState(false);
-    const [isGridReady, setIsGridReady] = useState(false);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [isColumnEditorOpen, setIsColumnEditorOpen] = useState(false);
-    const [columnWidthsVersion, setColumnWidthsVersion] = useState(0);
-    // Zamrazené savedFields records - aktualizují se POUZE při init, reload a editor save
-    const [frozenSavedRecords, setFrozenSavedRecords] = useState(null);
-    // ==========================================================================
-    // API HOOK & QUERY
-    // ==========================================================================
-    const gridLayoutApi = useGridLayoutApi({
-        userKey,
-        applicationName,
-        gridName,
-        filterName,
-        accessToken,
-    });
-    const { data: savedFields, isLoading: isFieldsLoading, error: fieldsError, refetch: refetchFields, } = gridLayoutApi.useUserFields((columnDefs || []).map((colDef, index) => ({
-        name: colDef.field || colDef.colId || `column_${index}`,
-        displayName: colDef.headerName || colDef.field || colDef.colId || `Column ${index + 1}`,
-        dataType: colDef.type || 'string',
-        isVisible: !colDef.hide,
-        width: colDef.width || 100,
-        order: index,
-    })), {
-        enabled: enabled &&
-            !!userKey &&
-            !!gridName &&
-            Array.isArray(columnDefs) &&
-            columnDefs.length > 0,
-    });
-    // ==========================================================================
-    // SYNCHRONIZACE REFS
-    // ==========================================================================
-    useEffect(() => { enabledRef.current = enabled; }, [enabled]);
-    useEffect(() => { isGridReadyRef.current = isGridReady; }, [isGridReady]);
-    useEffect(() => { autoSaveRef.current = autoSave; }, [autoSave]);
-    useEffect(() => { isInitializedRef.current = isInitialized; }, [isInitialized]);
-    useEffect(() => { stableGridLayoutApiRef.current = gridLayoutApi; }, [gridLayoutApi]);
-    useEffect(() => {
-        stableOnLayoutSavedRef.current = onLayoutSaved;
-        stableOnErrorRef.current = onError;
-        stableOnLayoutLoadedRef.current = onLayoutLoaded;
-    }, [onLayoutSaved, onError, onLayoutLoaded]);
-    // Synchronizace columnDefs ref + zachování existujících šířek
-    useEffect(() => {
-        if (columnDefs !== stableColumnDefsRef.current) {
-            const newWidthMap = new Map();
-            if (Array.isArray(columnDefs)) {
-                columnDefs.forEach(colDef => {
-                    const fieldId = colDef.field || colDef.colId;
-                    if (fieldId) {
-                        const existingWidth = columnWidthRefsMap.current.get(fieldId);
-                        if (existingWidth !== undefined) {
-                            newWidthMap.set(fieldId, existingWidth);
-                        }
-                        else if (colDef.width) {
-                            newWidthMap.set(fieldId, colDef.width);
-                        }
-                    }
-                });
-            }
-            columnWidthRefsMap.current = newWidthMap;
-            setColumnWidthsVersion(prev => prev + 1);
-        }
-        stableColumnDefsRef.current = columnDefs;
-    }, [columnDefs]);
-    // ==========================================================================
-    // HEADER NAME MAPA - plní se z savedFields při načtení
-    // ==========================================================================
-    useEffect(() => {
-        if (savedFields?.records && Array.isArray(savedFields.records)) {
-            savedFields.records.forEach(field => {
-                if (field.fieldName && field.headerName) {
-                    headerNameMapRef.current.set(field.fieldName, field.headerName);
-                }
-            });
-        }
-    }, [savedFields?.records]);
-    // ==========================================================================
-    // FROZEN SAVED RECORDS - aktualizují se pouze při prvním načtení
-    // ==========================================================================
-    useEffect(() => {
-        if (!frozenSavedRecords && savedFields?.records?.length > 0) {
-            setFrozenSavedRecords(savedFields.records);
-        }
-    }, [savedFields?.records, frozenSavedRecords]);
-    // ==========================================================================
-    // ERROR HANDLER (pouze pro explicitní akce - ne auto-save)
-    // ==========================================================================
-    const handleError = useCallback((error, context = '') => {
-        setError(error);
-        if (stableOnErrorRef.current) {
-            stableOnErrorRef.current(error, context);
-        }
-    }, []);
-    // ==========================================================================
-    // SAVE CURRENT LAYOUT
-    // ZERO RE-RENDER: používá POUZE refs, žádné setState
-    // ==========================================================================
-    const saveCurrentLayout = useCallback(async () => {
-        if (!enabledRef.current || !gridApiRef.current || !isInitializedRef.current) {
-            return;
-        }
-        // Ochrana proti souběžným uložením
-        if (isSavingRef.current)
-            return;
-        try {
-            isSavingRef.current = true; // ref only → žádný re-render
-            const columnState = getColumnState(gridApiRef, columnApiRef);
-            if (!columnState || !Array.isArray(columnState) || columnState.length === 0) {
-                return;
-            }
-            // Obohatíme column state o headerName z ref mapy (BEZ čtení z DOM)
-            const enrichedColumnState = columnState.map(colState => {
-                const savedHeaderName = headerNameMapRef.current.get(colState.colId);
-                if (savedHeaderName) {
-                    return { ...colState, headerName: savedHeaderName };
-                }
-                return colState;
-            });
-            const columnDefsToUse = stableColumnDefsRef.current;
-            if (!columnDefsToUse || !Array.isArray(columnDefsToUse) || columnDefsToUse.length === 0) {
-                return;
-            }
-            const fields = stableGridLayoutApiRef.current.transformColumnStateToFields(enrichedColumnState, columnDefsToUse);
-            if (!fields || fields.length === 0) {
-                return;
-            }
-            const result = await stableGridLayoutApiRef.current.saveGridLayout(fields);
-            if (result.success) {
-                hasUnsavedChangesRef.current = false; // ref only → žádný re-render
-                if (stableOnLayoutSavedRef.current) {
-                    stableOnLayoutSavedRef.current(fields, enrichedColumnState);
-                }
-            }
-        }
-        catch (error) {
-            console.error('[GridLayout] Chyba při ukládání layoutu:', error);
-            // Při auto-save NENASTAVUJEME error state (žádný re-render)
-            // Error se loguje do konzole a volá se onError callback
-            if (stableOnErrorRef.current) {
-                stableOnErrorRef.current(error, 'při ukládání layoutu');
-            }
-        }
-        finally {
-            isSavingRef.current = false; // ref only → žádný re-render
-        }
-    }, []); // PRÁZDNÉ DEPS → stabilní funkce
-    // ==========================================================================
-    // DEBOUNCED SAVE
-    // ==========================================================================
-    const saveCurrentLayoutRef = useRef(saveCurrentLayout);
-    useEffect(() => {
-        saveCurrentLayoutRef.current = saveCurrentLayout;
-    }, [saveCurrentLayout]);
-    const debouncedSave = useMemo(() => {
-        return debounce(() => {
-            saveCurrentLayoutRef.current();
-        }, autoSaveDelay);
-    }, [autoSaveDelay]);
-    const debouncedSaveRef = useRef(debouncedSave);
-    useEffect(() => {
-        debouncedSaveRef.current = debouncedSave;
-    }, [debouncedSave]);
-    useEffect(() => {
-        return () => { debouncedSave.cancel(); };
-    }, [debouncedSave]);
-    // ==========================================================================
-    // APPLY SAVED LAYOUT (pouze při inicializaci - re-render je OK)
-    // ==========================================================================
-    const applySavedLayout = useCallback((forceApply = false) => {
-        if (!savedFields?.records || savedFields.records.length === 0 || (!forceApply && isInitialized)) {
-            return;
-        }
-        const applyApi = getApplyApi(gridApiRef, columnApiRef);
-        if (!applyApi) {
-            return;
-        }
-        try {
-            setIsLoading(true);
-            isApplyingLayoutRef.current = true;
-            const columnDefsToUse = stableColumnDefsRef.current || columnDefs;
-            const columnState = gridLayoutApi.transformFieldsToColumnState(savedFields.records, columnDefsToUse);
-            if (!columnState || columnState.length === 0) {
-                return;
-            }
-            // Inicializace width ref mapy s API šířkami
-            if (!isInitialized) {
-                columnState.forEach(colState => {
-                    if (colState.colId && colState.width) {
-                        columnWidthRefsMap.current.set(colState.colId, colState.width);
-                    }
-                });
-            }
-            // Sestavení headerName mapy z API dat
-            const headerNameMap = new Map();
-            savedFields.records.forEach(field => {
-                if (field.fieldName && field.headerName) {
-                    headerNameMap.set(field.fieldName, field.headerName);
-                    headerNameMapRef.current.set(field.fieldName, field.headerName);
-                }
-            });
-            // Adjusted column state (s ref šířkami pro re-apply)
-            const adjustedColumnState = columnState.map(colState => {
-                const refWidth = columnWidthRefsMap.current.get(colState.colId);
-                if (refWidth !== undefined && isInitialized) {
-                    return { ...colState, width: refWidth };
-                }
-                return colState;
-            });
-            const applyFunction = () => {
-                try {
-                    // KROK 1: Aktualizace headerName přes setColumnDefs PRVNÍ
-                    if (headerNameMap.size > 0 && gridApiRef.current) {
-                        try {
-                            const currentColDefs = gridApiRef.current.getColumnDefs?.();
-                            if (currentColDefs && Array.isArray(currentColDefs)) {
-                                let hasHeaderChanges = false;
-                                const updatedColDefs = currentColDefs.map(colDef => {
-                                    const fieldName = colDef.field;
-                                    if (fieldName && headerNameMap.has(fieldName)) {
-                                        const newName = headerNameMap.get(fieldName);
-                                        if (colDef.headerName !== newName) {
-                                            hasHeaderChanges = true;
-                                            return { ...colDef, headerName: newName };
-                                        }
-                                    }
-                                    return colDef;
-                                });
-                                if (hasHeaderChanges && typeof gridApiRef.current.setColumnDefs === 'function') {
-                                    gridApiRef.current.setColumnDefs(updatedColDefs);
-                                }
-                            }
-                        }
-                        catch (e) {
-                            console.error('[GridLayout] Chyba při aktualizaci headerName:', e);
-                        }
-                    }
-                    // KROK 2: Aplikovat column state (pořadí, šířky) PO setColumnDefs
-                    const applyOrderEnabled = !waitForSavedFields;
-                    applyApi.applyColumnState({
-                        state: adjustedColumnState,
-                        applyOrder: applyOrderEnabled,
-                        defaultState: { sort: null, sortIndex: null, pivot: null, rowGroup: null },
-                    });
-                    lastKnownColumnStateRef.current = adjustedColumnState;
-                    try {
-                        gridApiRef.current?.refreshHeader?.();
-                    }
-                    catch (e) { /* ignorujeme */ }
-                    if (stableOnLayoutLoadedRef.current) {
-                        stableOnLayoutLoadedRef.current(savedFields.records, columnState);
-                    }
-                }
-                catch (error) {
-                    console.error('[GridLayout] Chyba při aplikování layoutu:', error);
-                    handleError(error, 'při aplikování layoutu');
-                }
-                finally {
-                    isApplyingLayoutRef.current = false;
-                }
-            };
-            if (waitForSavedFields) {
-                applyFunction();
-            }
-            else {
-                setTimeout(applyFunction, 100);
-            }
-        }
-        catch (error) {
-            console.error('[GridLayout] Chyba při přípravě layoutu:', error);
-            handleError(error, 'při aplikování layoutu');
-            isApplyingLayoutRef.current = false;
-        }
-        finally {
-            setIsInitialized(true);
-            setIsGridReady(true);
-            setIsLoading(false);
-        }
-    }, [savedFields, gridLayoutApi, isInitialized, handleError, columnDefs, waitForSavedFields]);
-    // ==========================================================================
-    // AG-GRID EVENT HANDLERS
-    // ZERO RE-RENDER: všechny mají prázdné deps a používají POUZE refs
-    // ==========================================================================
-    const handleColumnMoved = useCallback(() => {
-        if (!enabledRef.current || !isGridReadyRef.current)
-            return;
-        hasUnsavedChangesRef.current = true; // ref only → žádný re-render
-    }, []);
-    const handleDragStopped = useCallback(() => {
-        if (!enabledRef.current || !isGridReadyRef.current)
-            return;
-        // Detekce skutečné změny
-        try {
-            const currentColumnState = getColumnState(gridApiRef, columnApiRef);
-            if (currentColumnState && Array.isArray(currentColumnState)) {
-                if (isColumnStateEqual(lastKnownColumnStateRef.current, currentColumnState)) {
-                    return; // Žádná změna → skip
-                }
-                lastKnownColumnStateRef.current = currentColumnState;
-                currentColumnState.forEach(colState => {
-                    if (colState.colId && colState.width) {
-                        columnWidthRefsMap.current.set(colState.colId, colState.width);
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.error('[GridLayout] Chyba při detekci změn v handleDragStopped:', error);
-        }
-        hasUnsavedChangesRef.current = true; // ref only → žádný re-render
-        if (!isInitializedRef.current) {
-            const checkInterval = setInterval(() => {
-                if (isInitializedRef.current) {
-                    clearInterval(checkInterval);
-                    if (autoSaveRef.current && debouncedSaveRef.current) {
-                        debouncedSaveRef.current();
-                    }
-                }
-            }, 100);
-            setTimeout(() => clearInterval(checkInterval), 5000);
-            return;
-        }
-        if (autoSaveRef.current && debouncedSaveRef.current) {
-            debouncedSaveRef.current();
-        }
-    }, []);
-    const handleColumnResized = useCallback((event) => {
-        if (!enabledRef.current || !isGridReadyRef.current)
-            return;
-        if (!event || event.finished !== true)
-            return;
-        hasUnsavedChangesRef.current = true; // ref only → žádný re-render
-        try {
-            const currentColumnState = getColumnState(gridApiRef, columnApiRef);
-            if (currentColumnState && Array.isArray(currentColumnState)) {
-                currentColumnState.forEach(colState => {
-                    if (colState.colId && colState.width) {
-                        columnWidthRefsMap.current.set(colState.colId, colState.width);
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.error('[GridLayout] Chyba při aktualizaci šířek v handleColumnResized:', error);
-        }
-        if (autoSaveRef.current && isInitializedRef.current && debouncedSaveRef.current) {
-            debouncedSaveRef.current();
-        }
-    }, []);
-    const handleColumnVisible = useCallback(() => {
-        if (!enabledRef.current || !isGridReadyRef.current)
-            return;
-        hasUnsavedChangesRef.current = true; // ref only → žádný re-render
-        if (autoSaveRef.current && isInitializedRef.current && debouncedSaveRef.current) {
-            debouncedSaveRef.current();
-        }
-    }, []);
-    const handleColumnPinned = useCallback(() => {
-        if (!enabledRef.current || !isGridReadyRef.current)
-            return;
-        hasUnsavedChangesRef.current = true; // ref only → žádný re-render
-        if (autoSaveRef.current && isInitializedRef.current && debouncedSaveRef.current) {
-            debouncedSaveRef.current();
-        }
-    }, []);
-    // ==========================================================================
-    // AG-GRID READY HANDLER
-    // ==========================================================================
-    const handleGridReady = useCallback((params) => {
-        if (!enabledRef.current)
-            return;
-        gridApiRef.current = params.api;
-        columnApiRef.current = params.columnApi || params.api;
-        setIsGridReady(true);
-    }, []);
-    // ==========================================================================
-    // EFFECTS
-    // ==========================================================================
-    useEffect(() => {
-        if (savedFields?.records !== undefined && gridApiRef.current && !isInitialized) {
-            if (savedFields.records.length > 0) {
-                applySavedLayout();
-            }
-            else {
-                setIsInitialized(true);
-                setIsGridReady(true);
-            }
-        }
-    }, [savedFields?.records, isInitialized, applySavedLayout]);
-    useEffect(() => {
-        if (fieldsError) {
-            handleError(fieldsError, 'při načítání saved layoutu');
-        }
-    }, [fieldsError, handleError]);
-    // ==========================================================================
-    // MANUÁLNÍ AKCE (re-render je zde OK - explicitní uživatelská akce)
-    // ==========================================================================
-    const resetToDefault = useCallback(async () => {
-        if (!enabled)
-            return;
-        const resetApi = getResetApi(gridApiRef, columnApiRef);
-        if (!resetApi)
-            return;
-        try {
-            setIsLoading(true);
-            resetApi.resetColumnState();
-            headerNameMapRef.current.clear();
-            if (autoSave) {
-                await saveCurrentLayout();
-            }
-            else {
-                hasUnsavedChangesRef.current = true;
-            }
-        }
-        catch (error) {
-            handleError(error, 'při resetování layoutu');
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [enabled, autoSave, saveCurrentLayout, handleError]);
-    const saveLayout = useCallback(async () => {
-        await saveCurrentLayout();
-    }, [saveCurrentLayout]);
-    const reloadLayout = useCallback(async () => {
-        try {
-            const savedGridApi = gridApiRef.current;
-            const savedColumnApi = columnApiRef.current;
-            // Reset zámku - při reloadu chceme přepočítat preTransformedColumnDefs
-            lockedColumnDefsRef.current = null;
-            setIsInitialized(false);
-            setIsGridReady(false);
-            const freshData = await refetchFields();
-            if (!gridApiRef.current && savedGridApi)
-                gridApiRef.current = savedGridApi;
-            if (!columnApiRef.current && savedColumnApi)
-                columnApiRef.current = savedColumnApi;
-            if (freshData?.data?.records) {
-                setFrozenSavedRecords(freshData.data.records);
-            }
-            setIsInitialized(true);
-            setIsGridReady(true);
-        }
-        catch (error) {
-            handleError(error, 'při reload layoutu');
-        }
-    }, [refetchFields, handleError]);
-    // ==========================================================================
-    // COLUMN EDITOR
-    // ==========================================================================
-    const getCurrentColumnsForEditor = useCallback(() => {
-        const validColumnDefs = Array.isArray(columnDefs) ? columnDefs : [];
-        try {
-            const currentColumnState = getColumnState(gridApiRef, columnApiRef);
-            if (!Array.isArray(currentColumnState) || currentColumnState.length === 0) {
-                return validColumnDefs.map((col, index) => ({
-                    id: col.field,
-                    field: col.field,
-                    headerName: col.headerName || col.field,
-                    originalHeaderName: col.headerName || col.field,
-                    width: col.width || 100,
-                    originalWidth: col.width || 100,
-                    visible: !col.hide,
-                    order: index,
-                    originalOrder: index,
-                }));
-            }
-            return currentColumnState.map((columnStateItem, index) => {
-                const colDef = validColumnDefs.find((cd) => cd.field === columnStateItem.colId || cd.colId === columnStateItem.colId) || {};
-                const savedField = savedFields?.records?.find((sf) => sf.fieldName === columnStateItem.colId);
-                const headerName = headerNameMapRef.current.get(columnStateItem.colId) ||
-                    savedField?.headerName ||
-                    colDef.headerName ||
-                    columnStateItem.colId;
-                const originalIndex = validColumnDefs.findIndex((cd) => (cd.field || cd.colId) === columnStateItem.colId);
-                return {
-                    id: columnStateItem.colId,
-                    field: columnStateItem.colId,
-                    headerName,
-                    originalHeaderName: colDef.headerName || columnStateItem.colId,
-                    width: columnStateItem.width || colDef.width || 100,
-                    originalWidth: colDef.width || 100,
-                    visible: !columnStateItem.hide,
-                    order: index,
-                    originalOrder: originalIndex !== -1 ? originalIndex : index,
-                };
-            });
-        }
-        catch (error) {
-            console.error('[GridLayout] Chyba v getCurrentColumnsForEditor:', error);
-            return validColumnDefs.map((col, index) => ({
-                id: col.field || col.colId,
-                field: col.field || col.colId,
-                headerName: col.headerName || col.field || col.colId,
-                originalHeaderName: col.headerName || col.field || col.colId,
-                width: col.width || 100,
-                originalWidth: col.width || 100,
-                visible: !col.hide,
-                order: index,
-                originalOrder: index,
-            }));
-        }
-    }, [columnDefs, savedFields]);
-    const openColumnEditor = useCallback(() => {
-        setIsColumnEditorOpen(true);
-    }, []);
-    const closeColumnEditor = useCallback(() => {
-        setIsColumnEditorOpen(false);
-    }, []);
-    const saveColumnEditorChanges = async (editedColumns) => {
-        if (!enabled)
-            return;
-        try {
-            setIsLoading(true);
-            isSavingRef.current = true;
-            const validColumns = editedColumns.filter(col => col.field && col.field !== undefined);
-            const completeUserFields = validColumns.map((col, index) => ({
-                Id: 0,
-                UserKey: userKey,
-                ApplicationName: applicationName,
-                GridName: gridName,
-                FilterName: filterName || null,
-                FieldName: col.field,
-                HeaderName: col.headerName || col.field,
-                Order: index,
-                Show: col.visible,
-                Width: col.width != null ? col.width : null,
-                System: false,
-            }));
-            // Aktualizace headerName ref mapy
-            validColumns.forEach(col => {
-                if (col.field && col.headerName) {
-                    headerNameMapRef.current.set(col.field, col.headerName);
-                }
-            });
-            const result = await gridLayoutApi.saveGridLayout(completeUserFields);
-            if (result.success) {
-                hasUnsavedChangesRef.current = false;
-                try {
-                    const freshFields = await refetchFields();
-                    // Reset zámku a aktualizace frozenSavedRecords → uvolní zámek v preTransformedColumnDefs
-                    lockedColumnDefsRef.current = null;
-                    if (freshFields?.data?.records) {
-                        setFrozenSavedRecords(freshFields.data.records);
-                    }
-                    // Aplikujeme nový layout na grid
-                    setTimeout(() => {
-                        if (gridApiRef.current && freshFields?.data?.records) {
-                            const columnState = gridLayoutApi.transformFieldsToColumnState(freshFields.data.records, columnDefs);
-                            if (columnState && columnState.length > 0) {
-                                const applyApi = getApplyApi(gridApiRef, columnApiRef);
-                                if (applyApi) {
-                                    // KROK 1: Aktualizace headerName
-                                    try {
-                                        const currentColDefs = gridApiRef.current.getColumnDefs?.();
-                                        if (currentColDefs && Array.isArray(currentColDefs)) {
-                                            const updatedColDefs = currentColDefs.map(colDef => {
-                                                const fieldName = colDef.field;
-                                                const newName = headerNameMapRef.current.get(fieldName);
-                                                if (newName && colDef.headerName !== newName) {
-                                                    return { ...colDef, headerName: newName };
-                                                }
-                                                return colDef;
-                                            });
-                                            if (typeof gridApiRef.current.setColumnDefs === 'function') {
-                                                gridApiRef.current.setColumnDefs(updatedColDefs);
-                                            }
-                                        }
-                                    }
-                                    catch (e) {
-                                        console.error('[GridLayout] Chyba při aktualizaci headerName v editoru:', e);
-                                    }
-                                    // KROK 2: Aplikovat column state
-                                    applyApi.applyColumnState({
-                                        state: columnState,
-                                        applyOrder: true,
-                                        defaultState: { sort: null, sortIndex: null, pivot: null, rowGroup: null },
-                                    });
-                                    try {
-                                        gridApiRef.current?.refreshHeader?.();
-                                    }
-                                    catch (e) { /* ignorujeme */ }
-                                }
-                            }
-                        }
-                    }, 150);
-                }
-                catch (refreshError) {
-                    console.error('[GridLayout] Chyba při obnově po uložení z editoru:', refreshError);
-                    setTimeout(() => {
-                        if (gridApiRef.current)
-                            applySavedLayout(true);
-                    }, 200);
-                }
-                if (onLayoutSaved) {
-                    onLayoutSaved(completeUserFields);
-                }
-            }
-        }
-        catch (error) {
-            handleError(error, 'při ukládání změn z Column Editoru');
-        }
-        finally {
-            setIsLoading(false);
-            isSavingRef.current = false;
-        }
-    };
-    // ==========================================================================
-    // PRE-TRANSFORMED COLUMN DEFS
-    // ZAMKNUTÍ PO INICIALIZACI → stabilní reference, žádné zbytečné přepočty
-    // ==========================================================================
-    const shouldShowColumns = useMemo(() => {
-        if (!waitForSavedFields)
-            return true;
-        return !isFieldsLoading && !isLoading;
-    }, [waitForSavedFields, isFieldsLoading, isLoading]);
-    const preTransformedColumnDefs = useMemo(() => {
-        // ── ZÁMEK: Po inicializaci vrátíme zamknutou referenci ──
-        // Zámek se uvolní jen při: změně columnDefs od parenta, frozenSavedRecords (editor/reload)
-        // Tím se zabrání tomu, aby AG-Grid dostal nové columnDefs při jakémkoliv re-renderu
-        if (isInitialized
-            && lockedColumnDefsRef.current
-            && lockedForColumnDefsRef.current === columnDefs
-            && lockedForFrozenRecordsRef.current === frozenSavedRecords) {
-            return lockedColumnDefsRef.current;
-        }
-        // ── Normální výpočet ──
-        const columnDefsToUse = stableColumnDefsRef.current;
-        let baseColumnDefs = columnDefsToUse;
-        // Pro waitForSavedFields: seřadíme columnDefs podle frozenSavedRecords
-        if (waitForSavedFields && frozenSavedRecords && Array.isArray(columnDefsToUse)) {
-            const columnState = gridLayoutApi.transformFieldsToColumnState(frozenSavedRecords, columnDefsToUse);
-            if (columnState && columnState.length > 0) {
-                const columnStateMap = new Map();
-                columnState.forEach((colState, index) => {
-                    columnStateMap.set(colState.colId, { ...colState, __order: index });
-                });
-                const headerNameMap = new Map();
-                frozenSavedRecords.forEach(field => {
-                    if (field.fieldName && field.headerName) {
-                        headerNameMap.set(field.fieldName, field.headerName);
-                    }
-                });
-                baseColumnDefs = [...columnDefsToUse]
-                    .sort((a, b) => {
-                    const fieldA = a.field || a.colId;
-                    const fieldB = b.field || b.colId;
-                    const aOrder = columnStateMap.get(fieldA)?.__order ?? 999;
-                    const bOrder = columnStateMap.get(fieldB)?.__order ?? 999;
-                    return aOrder - bOrder;
-                })
-                    .map(colDef => {
-                    const fieldId = colDef.field || colDef.colId;
-                    const columnStateItem = columnStateMap.get(fieldId);
-                    return {
-                        ...colDef,
-                        ...(headerNameMap.has(fieldId) && { headerName: headerNameMap.get(fieldId) }),
-                        ...(columnStateItem && { hide: columnStateItem.hide }),
-                        ...(columnStateItem?.width && { width: columnStateItem.width }),
-                    };
-                });
-            }
-        }
-        // Konverze ColumnBuilder na array
-        if (!Array.isArray(baseColumnDefs)) {
-            if (baseColumnDefs && typeof baseColumnDefs.build === 'function') {
-                baseColumnDefs = baseColumnDefs.build();
-            }
-            else {
-                return [];
-            }
-        }
-        // Aplikace ref šířek (POUZE po inicializaci)
-        const finalColumnDefs = baseColumnDefs.map(colDef => {
-            const fieldId = colDef.field || colDef.colId;
-            const refWidth = columnWidthRefsMap.current.get(fieldId);
-            if (refWidth !== undefined && isInitialized) {
-                return { ...colDef, width: refWidth };
-            }
-            return colDef;
-        });
-        // ── Zamknout po inicializaci ──
-        if (isInitialized) {
-            lockedColumnDefsRef.current = finalColumnDefs;
-            lockedForColumnDefsRef.current = columnDefs;
-            lockedForFrozenRecordsRef.current = frozenSavedRecords;
-        }
-        return finalColumnDefs;
-    }, [waitForSavedFields, frozenSavedRecords, columnDefs, gridLayoutApi, columnWidthsVersion, isInitialized]);
-    // ==========================================================================
-    // RETURN - API interface
-    // Pozadí hodnoty se čtou z refs (aktuální hodnota v okamžiku renderu)
-    // ==========================================================================
-    return {
-        // State (re-render pouze při explicitních akcích)
-        isLoading: isLoading || isFieldsLoading,
-        error,
-        isInitialized,
-        isGridReady,
-        shouldShowColumns,
-        preTransformedColumnDefs,
-        // Refs čtené při renderu (ŽÁDNÝ re-render při změně)
-        isSaving: isSavingRef.current,
-        hasUnsavedChanges: hasUnsavedChangesRef.current,
-        isApplyingLayout: isApplyingLayoutRef.current,
-        // AG-Grid event handlers (stabilní - prázdné deps)
-        onGridReady: handleGridReady,
-        onColumnMoved: handleColumnMoved,
-        onDragStopped: handleDragStopped,
-        onColumnResized: handleColumnResized,
-        onColumnVisible: handleColumnVisible,
-        onColumnPinned: handleColumnPinned,
-        // Manuální akce
-        saveLayout,
-        resetToDefault,
-        reloadLayout,
-        // Column Editor
-        isColumnEditorOpen,
-        openColumnEditor,
-        closeColumnEditor,
-        saveColumnEditorChanges,
-        getCurrentColumnsForEditor,
-        // Data
-        savedFields: savedFields?.records || [],
-        columnDefs,
-        // Utils
-        gridLayoutApi,
-    };
-};
-export default useGridLayout;
-//# sourceMappingURL=useGridLayout.js.map