@bit.rhplus/ag-grid 0.0.114 → 0.0.116

package/dist/index.js

@@ -0,0 +1,868 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable */
+import * as React from 'react';
+import { AgGridReact } from 'ag-grid-react';
+import { AgGridColumns } from './AgGridColumn';
+import { RhPlusOnCellEditingStarted } from './OnCellEditingStarted';
+import { RhPlusOnCellDoubleClicked } from './OnCellDoubleClicked';
+import { RhPlusOnCellValueChanged } from './OnCellValueChanged';
+import { AgGridPostSort } from './AgGridPostSort';
+import { AgGridOnRowDataChanged } from './AgGridOnRowDataChanged';
+import { AgGridOnRowDataUpdated } from './AgGridOnRowDataUpdated';
+import CheckboxRenderer from './Renderers/CheckboxRenderer';
+import BooleanRenderer from './Renderers/BooleanRenderer';
+import { createGridComparison } from '@bit.rhplus/react-memo';
+import IconRenderer from './Renderers/IconRenderer';
+import ImageRenderer from './Renderers/ImageRenderer';
+import StateRenderer from './Renderers/StateRenderer';
+import SelectRenderer from './Renderers/SelectRenderer';
+import ButtonRenderer from './Renderers/ButtonRenderer';
+import CountrySelectRenderer from './Renderers/CountrySelectRenderer';
+import ObjectRenderer from './Renderers/ObjectRenderer';
+import LinkRenderer from './Renderers/LinkRenderer';
+import NotificationOptionsInit from "./NotificationOptions";
+import AggregationStatusBar from "./AggregationStatusBar";
+import { notification, Button } from "antd";
+import { CompressOutlined } from '@ant-design/icons';
+import Aggregations, { hashRanges } from "./Aggregations";
+import { useBulkCellEdit, BulkEditButton } from './BulkEdit';
+import { ModuleRegistry, themeAlpine, themeBalham, themeMaterial, themeQuartz, ClientSideRowModelModule, QuickFilterModule, ValidationModule, CsvExportModule, TooltipModule, } from "ag-grid-community";
+import { ExcelExportModule } from "ag-grid-enterprise";
+// Registrace AG-Grid modulů (nutné pro Quick Filter, export a další funkce)
+ModuleRegistry.registerModules([
+    QuickFilterModule,
+    ClientSideRowModelModule,
+    CsvExportModule,
+    ExcelExportModule,
+    TooltipModule,
+    ...(process.env.NODE_ENV !== "production" ? [ValidationModule] : []),
+]);
+const themes = [
+    { id: "themeQuartz", theme: themeQuartz },
+    { id: "themeBalham", theme: themeBalham },
+    { id: "themeMaterial", theme: themeMaterial },
+    { id: "themeAlpine", theme: themeAlpine },
+];
+const AgGrid = React.forwardRef((props, ref) => {
+    const internalRef = React.useRef();
+    const { theme = "themeAlpine", // Default theme
+    rowData = [], newRowFlash = true, updatedRowFlash = false, onGridReady, 
+    // Notification props
+    notificationMode = 'full', // 'full' | 'simple' | 'none'
+    notificationOptions: { notificationHead = NotificationOptionsInit.head, notificationBody = NotificationOptionsInit.body, style = NotificationOptionsInit.style, placement = NotificationOptionsInit.placement, } = {}, 
+    // Status Bar props (pro simple mode)
+    statusBarMetrics = [
+        'count',
+        'sum',
+        'min',
+        'max',
+        'avg',
+        'median',
+        'range',
+        'geometry',
+        'dateRange'
+    ], statusBarHeight = 36, 
+    // Bulk Edit props
+    enableBulkEdit = false, bulkEditOptions = {}, bulkEditAccessToken, onBulkEditStart, onBulkEditComplete, 
+    // SignalR transaction support
+    queryKey, // Identifikátor pro SignalR transactions
+    // Quick Filter
+    quickFilterText = "", // Text pro fulltextové vyhledávání
+     } = props;
+    // Najít theme objekt podle názvu z props
+    const themeObject = React.useMemo(() => {
+        const foundTheme = themes.find(t => t.id === theme);
+        return foundTheme ? foundTheme.theme : themeQuartz; // Fallback na themeQuartz
+    }, [theme]);
+    const [, setIsGridReady] = React.useState(false);
+    const isSelectingRef = React.useRef(false); // ✅ FIX: Změna ze state na ref pro eliminaci rerenderů
+    const aggregationDataRef = React.useRef(null); // // Pro simple mode status bar
+    const activeNotificationModeRef = React.useRef(notificationMode); // // Aktivní mód (může být dočasně přepsán uživatelem)
+    const previousRowDataRef = React.useRef(rowData);
+    // Synchronizovat activeNotificationModeRef s notificationMode prop
+    React.useEffect(() => {
+        activeNotificationModeRef.current = notificationMode;
+    }, [notificationMode]);
+    // Bulk Edit hook
+    const { floatingButton, editPopover, handleRangeChange, handleOpenPopover, handleSubmitEdit, handleCancelEdit, handleValueChange, } = useBulkCellEdit(internalRef, {
+        enabled: enableBulkEdit,
+        accessToken: bulkEditAccessToken,
+        onBulkEditStart,
+        onBulkEditComplete,
+        ...bulkEditOptions,
+    });
+    // ========== PERFORMANCE OPTIMIZATION: Shallow comparison helper ==========
+    // Shallow porovnání objektů - 100x rychlejší než JSON.stringify
+    const shallowEqual = React.useCallback((obj1, obj2) => {
+        if (obj1 === obj2)
+            return true;
+        if (!obj1 || !obj2)
+            return false;
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+        if (keys1.length !== keys2.length)
+            return false;
+        for (let key of keys1) {
+            if (obj1[key] !== obj2[key])
+                return false;
+        }
+        return true;
+    }, []);
+    // Memoizované funkce pro detekci změn v rowData
+    const findNewRows = React.useCallback((oldData, newData) => {
+        const oldIds = new Set(oldData.map((row) => row.id));
+        return newData.filter((row) => !oldIds.has(row.id));
+    }, []);
+    const findUpdatedRows = React.useCallback((oldData, newData) => {
+        const oldDataMap = new Map(oldData.map((row) => [row.id, row]));
+        return newData.filter((newRow) => {
+            const oldRow = oldDataMap.get(newRow.id);
+            if (!oldRow)
+                return false; // Nový řádek, ne aktualizovaný
+            // ✅ OPTIMALIZACE: Shallow comparison místo JSON.stringify (100x rychlejší!)
+            return !shallowEqual(oldRow, newRow);
+        });
+    }, [shallowEqual]);
+    React.useImperativeHandle(ref, () => internalRef.current, [internalRef]);
+    // Throttle timer pro notifikace - zobrazuje se BĚHEM označování s 100ms throttle
+    const notificationThrottleRef = React.useRef(null);
+    const notificationLastCallRef = React.useRef(0);
+    const lastRangeHashRef = React.useRef(null);
+    // ✅ Callback pro přepnutí z full na simple mód
+    const handleSwitchToSimple = React.useCallback(() => {
+        const gridId = props.gridName || props.id || 'default';
+        const key = `aggregation-grid-${gridId}`;
+        // Zavřít full notifikaci
+        notification.destroy(key);
+        // Znovu spočítat a zobrazit simple status bar
+        if (internalRef?.current?.api) {
+            const ranges = internalRef.current.api.getCellRanges();
+            if (ranges && ranges.length > 0 && ranges[0]?.startRow) {
+                const messageInfo = Aggregations(internalRef);
+                if (messageInfo.count > 1) {
+                    aggregationDataRef.current = messageInfo;
+                }
+            }
+        }
+        activeNotificationModeRef.current = 'simple';
+    }, [props, internalRef]);
+    // ✅ Helper funkce pro vytvoření custom description s tlačítkem pro přepnutí na simple
+    const createNotificationDescription = React.useCallback((messageInfo, showSwitchButton = false) => {
+        const bodyContent = notificationBody(messageInfo);
+        if (!showSwitchButton) {
+            return bodyContent;
+        }
+        return (_jsxs("div", { children: [bodyContent, _jsx("div", { style: { marginTop: '12px', borderTop: '1px solid #f0f0f0', paddingTop: '8px' }, children: _jsx(Button, { type: "link", size: "small", icon: _jsx(CompressOutlined, {}), onClick: handleSwitchToSimple, style: { padding: 0 }, children: "Zobrazit kompaktn\u00ED re\u017Eim" }) })] }));
+    }, [notificationBody, handleSwitchToSimple]);
+    // ✅ Callback pro přepnutí z simple na full mód
+    const handleSwitchToFull = React.useCallback(() => {
+        if (!aggregationDataRef.current)
+            return;
+        const gridId = props.gridName || props.id || 'default';
+        const key = `aggregation-grid-${gridId}`;
+        // Zobrazit full notifikaci s aktuálními daty a tlačítkem pro přepnutí
+        notification.info({
+            key,
+            message: notificationHead(aggregationDataRef.current),
+            description: createNotificationDescription(aggregationDataRef.current, true),
+            duration: 0,
+            style,
+            placement,
+        });
+        // Skrýt simple status bar
+        aggregationDataRef.current = null;
+        activeNotificationModeRef.current = 'full';
+    }, [props, notificationHead, createNotificationDescription, style, placement]);
+    // ========== PERFORMANCE FIX: Stabilní refs pro updateAggregationNotification ==========
+    // ✅ FIX: isSelectingRef je už deklarovaný na řádku 107 jako React.useRef(false)
+    const notificationHeadRef = React.useRef(notificationHead);
+    const createNotificationDescriptionRef = React.useRef(createNotificationDescription);
+    const styleRef = React.useRef(style);
+    const placementRef = React.useRef(placement);
+    const propsRef = React.useRef(props);
+    // ✅ FIX: Odstraněn useEffect pro isSelecting - isSelectingRef je nyní řízený přímo v updatePointerEventsForSelecting
+    React.useEffect(() => {
+        notificationHeadRef.current = notificationHead;
+    }, [notificationHead]);
+    React.useEffect(() => {
+        createNotificationDescriptionRef.current = createNotificationDescription;
+    }, [createNotificationDescription]);
+    React.useEffect(() => {
+        styleRef.current = style;
+    }, [style]);
+    React.useEffect(() => {
+        placementRef.current = placement;
+    }, [placement]);
+    React.useEffect(() => {
+        propsRef.current = props;
+    }, [props]);
+    // ✅ OPTIMALIZACE: Helper funkce pro aktualizaci aggregace notifikace s cache check
+    // Volá se BĚHEM označování s 100ms throttle pro real-time feedback
+    // STABILNÍ callback - používá pouze refs!
+    const updateAggregationNotification = React.useCallback((event) => {
+        // Pokud je notificationMode 'none', nedělat nic
+        if (notificationModeRef.current === 'none') {
+            return;
+        }
+        // Lightweight cache check PŘED voláním Aggregations()
+        const ranges = event.api.getCellRanges();
+        const currentRangeHash = hashRanges(ranges);
+        // Žádné ranges nebo jen jedna buňka - vyčistit vše
+        if (!ranges || ranges.length === 0 || !ranges[0]?.startRow) {
+            lastRangeHashRef.current = null;
+            // V 'full' módu zavřít notifikaci
+            if (activeNotificationModeRef.current === 'full') {
+                const gridId = propsRef.current.gridName || propsRef.current.id || 'default';
+                const key = `aggregation-grid-${gridId}`;
+                notification.destroy(key);
+            }
+            // V 'simple' módu vyčistit aggregationData
+            if (activeNotificationModeRef.current === 'simple') {
+                aggregationDataRef.current = null;
+            }
+            return;
+        }
+        // Cache hit - ranges se nezměnily, skip
+        if (currentRangeHash === lastRangeHashRef.current) {
+            return;
+        }
+        // Cache miss - spočítat aggregace
+        const messageInfo = Aggregations(internalRef);
+        if (messageInfo.count > 1) {
+            // Uložit hash pro příští porovnání
+            lastRangeHashRef.current = currentRangeHash;
+            // Zavolat onAggregationChanged callback pokud existuje
+            if (propsRef.current.onAggregationChanged) {
+                propsRef.current.onAggregationChanged(messageInfo);
+            }
+            // Podle aktivního módu zobrazit buď notifikaci nebo aktualizovat status bar
+            if (activeNotificationModeRef.current === 'full') {
+                // FULL mód - zobrazit plovoucí notifikaci s tlačítkem pro přepnutí na simple
+                const gridId = propsRef.current.gridName || propsRef.current.id || 'default';
+                const key = `aggregation-grid-${gridId}`;
+                const dynamicStyle = {
+                    ...styleRef.current,
+                    pointerEvents: isSelectingRef.current ? 'none' : 'auto'
+                };
+                notification.info({
+                    key,
+                    message: notificationHeadRef.current(messageInfo),
+                    description: createNotificationDescriptionRef.current(messageInfo, true),
+                    duration: 0,
+                    style: dynamicStyle,
+                    placement: placementRef.current,
+                });
+            }
+            else if (activeNotificationModeRef.current === 'simple') {
+                // SIMPLE mód - aktualizovat state pro status bar
+                aggregationDataRef.current = messageInfo;
+            }
+        }
+        else {
+            // Jen jedna buňka - zavřít/vyčistit vše
+            lastRangeHashRef.current = null;
+            if (activeNotificationModeRef.current === 'full') {
+                const gridId = propsRef.current.gridName || propsRef.current.id || 'default';
+                const key = `aggregation-grid-${gridId}`;
+                notification.destroy(key);
+            }
+            if (activeNotificationModeRef.current === 'simple') {
+                aggregationDataRef.current = null;
+            }
+        }
+    }, [internalRef]); // ✅ Pouze internalRef v dependencies!
+    // Helper funkce pro nastavení pointer-events na notifikace
+    const setNotificationPointerEvents = React.useCallback((enable) => {
+        const notifications = document.querySelectorAll('.ant-notification');
+        notifications.forEach((notif) => {
+            if (enable) {
+                // Obnovit pointer-events na notifikaci
+                const original = notif.dataset.originalPointerEvents || 'auto';
+                notif.style.pointerEvents = original;
+                notif.style.removeProperty('pointer-events');
+                delete notif.dataset.originalPointerEvents;
+                // Obnovit pointer-events na všechny child elementy
+                const allChildren = notif.querySelectorAll('*');
+                allChildren.forEach((child) => {
+                    child.style.removeProperty('pointer-events');
+                    delete child.dataset.originalPointerEvents;
+                });
+            }
+            else {
+                // Zakázat pointer-events na notifikaci
+                if (!notif.dataset.originalPointerEvents) {
+                    notif.dataset.originalPointerEvents = notif.style.pointerEvents || 'auto';
+                }
+                notif.style.setProperty('pointer-events', 'none', 'important');
+                // Zakázat pointer-events na všechny child elementy
+                const allChildren = notif.querySelectorAll('*');
+                allChildren.forEach((child) => {
+                    if (!child.dataset.originalPointerEvents) {
+                        child.dataset.originalPointerEvents = child.style.pointerEvents || '';
+                    }
+                    child.style.setProperty('pointer-events', 'none', 'important');
+                });
+            }
+        });
+    }, []);
+    // ✅ FIX: Helper funkce pro update isSelecting bez state změny (eliminuje rerender)
+    const updatePointerEventsForSelecting = React.useCallback((selecting) => {
+        isSelectingRef.current = selecting;
+        if (selecting) {
+            document.body.classList.add('ag-grid-selecting');
+            setNotificationPointerEvents(false);
+            // KRITICKÉ: Sledovat DOM změny - když se objeví nová notifikace během označování
+            const observer = new MutationObserver((mutations) => {
+                mutations.forEach((mutation) => {
+                    mutation.addedNodes.forEach((node) => {
+                        if (node.nodeType === 1) {
+                            if (node.classList?.contains('ant-notification') ||
+                                node.querySelector?.('.ant-notification')) {
+                                setNotificationPointerEvents(false);
+                            }
+                        }
+                    });
+                });
+            });
+            observer.observe(document.body, {
+                childList: true,
+                subtree: true
+            });
+            // Uložit observer do ref pro případný cleanup
+            if (!updatePointerEventsForSelecting.observer) {
+                updatePointerEventsForSelecting.observer = observer;
+            }
+        }
+        else {
+            document.body.classList.remove('ag-grid-selecting');
+            // Cleanup observer
+            if (updatePointerEventsForSelecting.observer) {
+                updatePointerEventsForSelecting.observer.disconnect();
+                updatePointerEventsForSelecting.observer = null;
+            }
+            setTimeout(() => setNotificationPointerEvents(true), 100);
+        }
+    }, [setNotificationPointerEvents]);
+    // Detekce konce označování pomocí mouseup event
+    React.useEffect(() => {
+        const handleMouseUp = () => {
+            // ✅ FIX: Ukončit isSelecting pomocí ref (bez state update → žádný rerender)
+            setTimeout(() => {
+                updatePointerEventsForSelecting(false);
+                // ✅ FIX: Zkontrolovat jestli jsou stále nějaké ranges, pokud ne - vyčistit status bar
+                if (internalRef?.current?.api && activeNotificationModeRef.current === 'simple') {
+                    const ranges = internalRef.current.api.getCellRanges();
+                    if (!ranges || ranges.length === 0 || !ranges[0]?.startRow) {
+                        aggregationDataRef.current = null;
+                        // Reset na původní notificationMode když jsou všechny buňky odznačeny
+                        activeNotificationModeRef.current = notificationMode;
+                    }
+                }
+            }, 50);
+        };
+        document.addEventListener('mouseup', handleMouseUp);
+        document.addEventListener('touchend', handleMouseUp); // Pro touch zařízení
+        return () => {
+            document.removeEventListener('mouseup', handleMouseUp);
+            document.removeEventListener('touchend', handleMouseUp);
+        };
+    }, [notificationMode, internalRef, updatePointerEventsForSelecting]);
+    // Cleanup notifikací a timerů při zničení komponenty
+    React.useEffect(() => {
+        return () => {
+            // Clear throttle timer
+            if (notificationThrottleRef.current) {
+                clearTimeout(notificationThrottleRef.current);
+            }
+            if (notificationMode === 'full') {
+                const gridId = props.gridName || props.id || 'default';
+                const key = `aggregation-grid-${gridId}`;
+                notification.destroy(key);
+            }
+            // Cleanup SignalR transaction callback při unmount
+            if (queryKey && window.agGridTransactionCallbacks) {
+                delete window.agGridTransactionCallbacks[queryKey];
+            }
+        };
+    }, [notificationMode, props.gridName, props.id, queryKey]);
+    React.useEffect(() => {
+        // VYPNUTO: Cell flash je globálně vypnutý
+        return;
+        if (!newRowFlash && !updatedRowFlash)
+            return;
+        const previousRowData = previousRowDataRef.current;
+        const addedRows = newRowFlash ? findNewRows(previousRowData, rowData) : [];
+        const updatedRows = updatedRowFlash ? findUpdatedRows(previousRowData, rowData) : [];
+        if (addedRows.length > 0 || updatedRows.length > 0) {
+            setTimeout(() => {
+                try {
+                    // Bezpečnostní kontrola API dostupnosti
+                    if (!internalRef.current?.api || internalRef.current.api.isDestroyed?.()) {
+                        return;
+                    }
+                    // Modern AG-Grid (33+): getColumnState() moved to main api
+                    const columnApi = internalRef.current?.columnApi || internalRef.current?.api;
+                    if (!columnApi?.getColumnState) {
+                        return;
+                    }
+                    const columnStates = columnApi.getColumnState();
+                    const allColumns = columnStates
+                        .filter(colState => colState.colId) // Filtrujeme pouze platné colId
+                        .map((colState) => colState.colId);
+                    // Kontrola, že máme platné sloupce
+                    if (allColumns.length === 0) {
+                        return;
+                    }
+                    // Flash efekt pro nové řádky (používá defaultní zelená barva AG Grid)
+                    if (addedRows.length > 0) {
+                        const newRowNodes = [];
+                        internalRef.current.api.forEachNode((node) => {
+                            if (addedRows.some((row) => row.id === node.data.id)) {
+                                newRowNodes.push(node);
+                            }
+                        });
+                        if (newRowNodes.length > 0) {
+                            internalRef.current.api.flashCells({
+                                rowNodes: newRowNodes,
+                                columns: allColumns,
+                                flashDelay: 0,
+                                fadeDelay: 1000,
+                            });
+                        }
+                    }
+                    // Flash efekt pro aktualizované řádky (modrá barva)
+                    if (updatedRows.length > 0) {
+                        const updatedRowNodes = [];
+                        internalRef.current.api.forEachNode((node) => {
+                            if (updatedRows.some((row) => row.id === node.data.id)) {
+                                updatedRowNodes.push(node);
+                            }
+                        });
+                        if (updatedRowNodes.length > 0) {
+                            // Použijeme vlastní CSS animaci pro modrou flash
+                            updatedRowNodes.forEach(node => {
+                                const rowElement = node.eGridRow || document.querySelector(`[row-id="${node.data.id}"]`);
+                                if (rowElement) {
+                                    rowElement.classList.add('ag-row-flash-updated');
+                                    setTimeout(() => {
+                                        rowElement.classList.remove('ag-row-flash-updated');
+                                    }, 1000);
+                                }
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    // Ignorujeme chybu a pokračujeme bez crash aplikace
+                }
+            }, 100); // Zvýšený timeout pro stabilizaci gridu
+        }
+        previousRowDataRef.current = rowData;
+    }, [rowData, newRowFlash, updatedRowFlash]);
+    // ========== PERFORMANCE FIX: Stabilní ref pattern pro callbacks ==========
+    // Refs pro aktuální hodnoty - zabraňuje re-creation RhPlusRangeSelectionChanged při změně stavu
+    const notificationModeRef = React.useRef(notificationMode);
+    const enableBulkEditRef = React.useRef(enableBulkEdit);
+    const handleRangeChangeRef = React.useRef(handleRangeChange);
+    const onRangeSelectionChangedRef = React.useRef(props.onRangeSelectionChanged);
+    const updateAggregationNotificationRef = React.useRef(updateAggregationNotification);
+    // ✅ FIX #12: Refs pro grid layout handlery (eliminuje rerendery při změně props)
+    const onColumnMovedRef = React.useRef(props.onColumnMoved);
+    const onDragStoppedRef = React.useRef(props.onDragStopped);
+    const onColumnVisibleRef = React.useRef(props.onColumnVisible);
+    const onColumnPinnedRef = React.useRef(props.onColumnPinned);
+    const onColumnResizedRef = React.useRef(props.onColumnResized);
+    // Aktualizovat refs při změně hodnot
+    React.useEffect(() => {
+        notificationModeRef.current = notificationMode;
+    }, [notificationMode]);
+    React.useEffect(() => {
+        enableBulkEditRef.current = enableBulkEdit;
+    }, [enableBulkEdit]);
+    React.useEffect(() => {
+        handleRangeChangeRef.current = handleRangeChange;
+    }, [handleRangeChange]);
+    React.useEffect(() => {
+        onRangeSelectionChangedRef.current = props.onRangeSelectionChanged;
+    }, [props.onRangeSelectionChanged]);
+    React.useEffect(() => {
+        updateAggregationNotificationRef.current = updateAggregationNotification;
+    }, [updateAggregationNotification]);
+    // ✅ FIX #12: Aktualizovat grid layout handler refs
+    React.useEffect(() => {
+        onColumnMovedRef.current = props.onColumnMoved;
+    }, [props.onColumnMoved]);
+    React.useEffect(() => {
+        onDragStoppedRef.current = props.onDragStopped;
+    }, [props.onDragStopped]);
+    React.useEffect(() => {
+        onColumnVisibleRef.current = props.onColumnVisible;
+    }, [props.onColumnVisible]);
+    React.useEffect(() => {
+        onColumnPinnedRef.current = props.onColumnPinned;
+    }, [props.onColumnPinned]);
+    React.useEffect(() => {
+        onColumnResizedRef.current = props.onColumnResized;
+    }, [props.onColumnResized]);
+    // Stabilní callback s prázdnými dependencies - používá pouze refs
+    const RhPlusRangeSelectionChanged = React.useCallback((event) => {
+        // ✅ FIX: Detekovat začátek označování pomocí ref (bez state update → žádný rerender)
+        updatePointerEventsForSelecting(true);
+        // 1. ✅ OPTIMALIZACE: Zobrazení notifikace BĚHEM označování s THROTTLE
+        // Simple mode: 300ms throttle (méně častá aktualizace, lepší výkon)
+        // Full mode: 100ms throttle (rychlejší feedback, plovoucí notifikace je levná)
+        if (notificationModeRef.current !== 'none') {
+            const throttleInterval = notificationModeRef.current === 'simple' ? 300 : 100;
+            const now = Date.now();
+            const timeSinceLastCall = now - notificationLastCallRef.current;
+            // První volání NEBO uplynul throttle interval
+            if (timeSinceLastCall >= throttleInterval) {
+                // Okamžité volání
+                notificationLastCallRef.current = now;
+                if (internalRef?.current) {
+                    updateAggregationNotificationRef.current(event);
+                }
+            }
+            else {
+                // Naplánovat volání za zbývající čas (trailing edge)
+                if (notificationThrottleRef.current) {
+                    clearTimeout(notificationThrottleRef.current);
+                }
+                notificationThrottleRef.current = setTimeout(() => {
+                    notificationLastCallRef.current = Date.now();
+                    if (internalRef?.current) {
+                        updateAggregationNotificationRef.current(event);
+                    }
+                }, throttleInterval - timeSinceLastCall);
+            }
+        }
+        // 2. ✅ OPTIMALIZACE: Bulk edit handler BEZ debounce - okamžité zobrazení ikony
+        // Lightweight validace v useBulkCellEdit zajistí okamžité zobrazení
+        // Těžká validace proběhne s 15ms debounce uvnitř useBulkCellEdit
+        if (enableBulkEditRef.current) {
+            handleRangeChangeRef.current(event);
+        }
+        // 3. Custom onRangeSelectionChanged callback - bez debounce
+        if (onRangeSelectionChangedRef.current) {
+            onRangeSelectionChangedRef.current(event);
+        }
+    }, [] // ✅ PRÁZDNÉ dependencies - stabilní reference!
+    );
+    // ✅ FIX #12: Stabilní wrappery pro grid layout handlery (prázdné dependencies)
+    const stableOnColumnMoved = React.useCallback((params) => {
+        if (onColumnMovedRef.current) {
+            onColumnMovedRef.current(params);
+        }
+    }, []);
+    const stableOnDragStopped = React.useCallback((params) => {
+        if (onDragStoppedRef.current) {
+            onDragStoppedRef.current(params);
+        }
+    }, []);
+    const stableOnColumnVisible = React.useCallback((params) => {
+        if (onColumnVisibleRef.current) {
+            onColumnVisibleRef.current(params);
+        }
+    }, []);
+    const stableOnColumnPinned = React.useCallback((params) => {
+        if (onColumnPinnedRef.current) {
+            onColumnPinnedRef.current(params);
+        }
+    }, []);
+    const stableOnColumnResized = React.useCallback((params) => {
+        if (onColumnResizedRef.current) {
+            onColumnResizedRef.current(params);
+        }
+    }, []);
+    const AgGridOnGridReady = (event, options) => {
+        if (onGridReady) {
+            onGridReady(event, options);
+        }
+        // Nejprve nastavíme API reference pro interní použití
+        if (internalRef.current) {
+            internalRef.current.api = event.api;
+            internalRef.current.columnApi = event.columnApi || event.api; // fallback for modern AG-Grid
+        }
+        // Nastavíme API ready flag pro quick filter useEffect
+        setIsApiReady(true);
+        // Registruj callback pro AG Grid transactions (SignalR optimalizace)
+        // Inicializace globálního registru pro více AG-Grid instancí
+        if (!window.agGridTransactionCallbacks) {
+            window.agGridTransactionCallbacks = {};
+        }
+        // Registrace callbacku pro tuto konkrétní AG-Grid instanci (podle queryKey)
+        if (event.api && queryKey) {
+            window.agGridTransactionCallbacks[queryKey] = (transactionData) => {
+                try {
+                    if (!event.api || event.api.isDestroyed?.())
+                        return;
+                    const { operation, records } = transactionData;
+                    switch (operation) {
+                        case 'add':
+                            // Nastavíme flag _rh_plus_ag_grid_signal_new (NE _rh_plus_ag_grid_new_item),
+                            // aby postSort přesunul řádek na začátek, ale renderery obsah nezahovaly
+                            const addRecords = records.map(r => ({ ...r, _rh_plus_ag_grid_signal_new: true }));
+                            event.api.applyTransaction({ add: addRecords, addIndex: 0 });
+                            // Flash efekt pro nové řádky + po 5s odebrat signal flag a re-sort
+                            setTimeout(() => {
+                                records.forEach(record => {
+                                    const rowNode = event.api.getRowNode(record.id);
+                                    if (rowNode) {
+                                        if (rowNode.rowElement) {
+                                            rowNode.rowElement.classList.add('ag-row-flash-created');
+                                            setTimeout(() => {
+                                                rowNode.rowElement.classList.remove('ag-row-flash-created');
+                                            }, 1000);
+                                        }
+                                        // Po 5 sekundách odebrat signal flag a refreshnout sort
+                                        setTimeout(() => {
+                                            if (rowNode.data) {
+                                                delete rowNode.data._rh_plus_ag_grid_signal_new;
+                                                // Refresh sort, aby se řádek zařadil podle aktuálního řazení
+                                                if (event.api && !event.api.isDestroyed?.()) {
+                                                    event.api.refreshClientSideRowModel('sort');
+                                                }
+                                            }
+                                        }, 5000);
+                                    }
+                                });
+                            }, 100);
+                            break;
+                        case 'update':
+                            event.api.applyTransaction({ update: records });
+                            // Flash efekt pro aktualizované řádky
+                            setTimeout(() => {
+                                records.forEach(record => {
+                                    const rowNode = event.api.getRowNode(record.id);
+                                    if (rowNode && rowNode.rowElement) {
+                                        rowNode.rowElement.classList.add('ag-row-flash-updated');
+                                        setTimeout(() => {
+                                            rowNode.rowElement.classList.remove('ag-row-flash-updated');
+                                        }, 1000);
+                                    }
+                                });
+                            }, 100);
+                            break;
+                        case 'remove':
+                            // Flash efekt před smazáním
+                            records.forEach(record => {
+                                const rowNode = event.api.getRowNode(record.id);
+                                if (rowNode && rowNode.rowElement) {
+                                    rowNode.rowElement.classList.add('ag-row-flash-deleted');
+                                }
+                            });
+                            setTimeout(() => {
+                                event.api.applyTransaction({ remove: records });
+                            }, 500); // Krátké zpoždění pro zobrazení flash efektu
+                            break;
+                    }
+                }
+                catch (error) {
+                    // Ignorujeme chyby
+                }
+            };
+        }
+        // Pak zavoláme parent onGridReady handler, pokud existuje
+        // Toto je kritické pro správné fungování bit/ui/grid a GridLayout
+        if (options.onGridReady) {
+            try {
+                options.onGridReady(event);
+            }
+            catch (error) {
+                // Error handling without console output
+            }
+        }
+        // Nakonec nastavíme grid ready state s timeout
+        setTimeout(() => {
+            setIsGridReady(true);
+        }, 1000);
+    };
+    const components = React.useMemo(() => {
+        return {
+            checkboxRenderer: CheckboxRenderer,
+            selectRenderer: SelectRenderer,
+            countrySelectRenderer: CountrySelectRenderer,
+            booleanRenderer: BooleanRenderer,
+            buttonRenderer: ButtonRenderer,
+            iconRenderer: IconRenderer,
+            imageRenderer: ImageRenderer,
+            stateRenderer: StateRenderer,
+            objectRenderer: ObjectRenderer,
+            linkRenderer: LinkRenderer,
+            ...props.frameworkComponents,
+        };
+    }, [props.frameworkComponents]);
+    // ========== PERFORMANCE OPTIMIZATION: Memoizované event handlers ==========
+    const memoizedOnCellEditingStarted = React.useCallback((event) => RhPlusOnCellEditingStarted(event, props), [props.onCellEditingStarted]);
+    const memoizedOnCellDoubleClicked = React.useCallback((event) => RhPlusOnCellDoubleClicked(event, props), [props.onCellDoubleClicked]);
+    const memoizedOnCellValueChanged = React.useCallback((event) => RhPlusOnCellValueChanged(event, props), [props.onCellValueChanged]);
+    const memoizedPostSort = React.useCallback((event) => AgGridPostSort(event, props), [props.postSort]);
+    const memoizedOnGridReady = React.useCallback((event, options) => AgGridOnGridReady(event, props), [onGridReady]);
+    const memoizedOnRowDataChanged = React.useCallback((event) => AgGridOnRowDataChanged(event, props), [props.onRowDataChanged]);
+    const memoizedOnRowDataUpdated = React.useCallback((event) => AgGridOnRowDataUpdated(event, props), [props.onRowDataUpdated]);
+    // Memoizovaný context object
+    // ✅ OPTIMALIZACE: Použít pouze relevantní props pro context - neměnit při změně props
+    const memoizedContext = React.useMemo(() => ({
+        componentParent: props
+    }), [props.context, props.gridName, props.id]);
+    // Memoizovaný defaultColDef
+    const memoizedDefaultColDef = React.useMemo(() => ({
+        filter: 'agTextColumnFilter',
+        floatingFilter: true,
+        filterParams: {
+            defaultOption: 'contains',
+        },
+        ...props.defaultColDef,
+        suppressHeaderMenuButton: true,
+        suppressHeaderFilterButton: true,
+        suppressMenu: true,
+        // ✅ FIX AG-Grid v35: Bezpečné zpracování null hodnot v Quick Filter
+        // AG-Grid v35 změnil implementaci Quick Filter - nyní volá .toString() na hodnotách buněk bez null check
+        // Tento callback zajistí že nikdy nedojde k chybě "Cannot read properties of null (reading 'toString')"
+        getQuickFilterText: (params) => {
+            const value = params.value;
+            // Null/undefined → prázdný string (bez chyby)
+            if (value == null)
+                return '';
+            // Objekty a pole → JSON string
+            if (typeof value === 'object') {
+                try {
+                    return JSON.stringify(value);
+                }
+                catch {
+                    // Cirkulární reference nebo jiná chyba při serializaci → prázdný string
+                    return '';
+                }
+            }
+            // Primitivní typy → toString
+            return value.toString();
+        },
+    }), [props.defaultColDef]);
+    // ========== PERFORMANCE FIX: Memoizovat columnDefs ==========
+    // AgGridColumns vrací nový array při každém volání, i když jsou vstupy stejné
+    const memoizedColumnDefs = React.useMemo(() => {
+        return AgGridColumns(props.columnDefs, props);
+    }, [props.columnDefs, props.getRowId, props.frameworkComponents]);
+    // ========== CRITICAL FIX: Stabilní allGridProps objekt pomocí ref ==========
+    // Problém: Jakékoli použití useMemo vytváří nový objekt při změně dependencies
+    // Řešení: Použít ref pro VŽDY stejný objekt
+    // AG-Grid САМО detekuje změny rowData a columnDefs → NENÍ potřeba forceUpdate!
+    const allGridPropsRef = React.useRef(null);
+    // Inicializace objektu
+    if (!allGridPropsRef.current) {
+        allGridPropsRef.current = {};
+    }
+    // ✅ Aktualizovat props v EXISTUJÍCÍM objektu (mutace)
+    // AG Grid interně detekuje změny props, nepotřebuje nový objekt
+    allGridPropsRef.current.ref = internalRef;
+    allGridPropsRef.current.rowData = props.rowData;
+    allGridPropsRef.current.getRowId = props.getRowId;
+    allGridPropsRef.current.theme = themeObject;
+    allGridPropsRef.current.columnDefs = memoizedColumnDefs;
+    allGridPropsRef.current.defaultColDef = memoizedDefaultColDef;
+    allGridPropsRef.current.onCellEditingStarted = memoizedOnCellEditingStarted;
+    allGridPropsRef.current.onCellDoubleClicked = memoizedOnCellDoubleClicked;
+    allGridPropsRef.current.onCellValueChanged = memoizedOnCellValueChanged;
+    allGridPropsRef.current.postSort = memoizedPostSort;
+    allGridPropsRef.current.onGridReady = memoizedOnGridReady;
+    allGridPropsRef.current.onRowDataChanged = memoizedOnRowDataChanged;
+    allGridPropsRef.current.onRowDataUpdated = memoizedOnRowDataUpdated;
+    allGridPropsRef.current.onRangeSelectionChanged = RhPlusRangeSelectionChanged;
+    allGridPropsRef.current.context = memoizedContext;
+    allGridPropsRef.current.components = components;
+    // Další AG Grid props
+    allGridPropsRef.current.rowModelType = props.rowModelType;
+    allGridPropsRef.current.rowSelection = props.rowSelection;
+    allGridPropsRef.current.enableRangeSelection = props.enableRangeSelection;
+    allGridPropsRef.current.enableRangeHandle = props.enableRangeHandle;
+    allGridPropsRef.current.enableFillHandle = props.enableFillHandle;
+    allGridPropsRef.current.suppressRowClickSelection = props.suppressRowClickSelection;
+    allGridPropsRef.current.singleClickEdit = props.singleClickEdit;
+    allGridPropsRef.current.stopEditingWhenCellsLoseFocus = props.stopEditingWhenCellsLoseFocus;
+    allGridPropsRef.current.rowClass = props.rowClass;
+    allGridPropsRef.current.rowStyle = props.rowStyle;
+    allGridPropsRef.current.getRowClass = props.getRowClass;
+    allGridPropsRef.current.getRowStyle = props.getRowStyle;
+    allGridPropsRef.current.animateRows = props.animateRows;
+    allGridPropsRef.current.suppressCellFocus = props.suppressCellFocus;
+    allGridPropsRef.current.suppressMenuHide = props.suppressMenuHide;
+    allGridPropsRef.current.enableCellTextSelection = props.enableCellTextSelection;
+    allGridPropsRef.current.ensureDomOrder = props.ensureDomOrder;
+    allGridPropsRef.current.suppressRowTransform = props.suppressRowTransform;
+    allGridPropsRef.current.suppressColumnVirtualisation = props.suppressColumnVirtualisation;
+    allGridPropsRef.current.suppressRowVirtualisation = props.suppressRowVirtualisation;
+    allGridPropsRef.current.tooltipShowDelay = props.tooltipShowDelay;
+    allGridPropsRef.current.tooltipHideDelay = props.tooltipHideDelay;
+    allGridPropsRef.current.tooltipMouseTrack = props.tooltipMouseTrack;
+    allGridPropsRef.current.gridId = props.gridId;
+    allGridPropsRef.current.id = props.id;
+    allGridPropsRef.current.gridName = props.gridName;
+    allGridPropsRef.current.getContextMenuItems = props.getContextMenuItems;
+    allGridPropsRef.current.rowClassRules = props.rowClassRules;
+    allGridPropsRef.current.isRowSelectable = props.isRowSelectable;
+    // Grid Layout event handlers - stabilní wrappery (eliminuje rerendery)
+    // ✅ FIX #12: Používáme stabilní wrappery místo props → eliminuje rerendery při změně props
+    allGridPropsRef.current.onColumnMoved = stableOnColumnMoved;
+    allGridPropsRef.current.onDragStopped = stableOnDragStopped;
+    allGridPropsRef.current.onColumnVisible = stableOnColumnVisible;
+    allGridPropsRef.current.onColumnPinned = stableOnColumnPinned;
+    allGridPropsRef.current.onColumnResized = stableOnColumnResized;
+    // ✅ gridOptions support - spread additional AG-Grid props
+    // Přidává POUZE hodnoty které ještě NEJSOU nastaveny výše (nejnižší priorita)
+    if (props.gridOptions && typeof props.gridOptions === 'object') {
+        for (const key in props.gridOptions) {
+            if (props.gridOptions[key] !== undefined && allGridPropsRef.current[key] === undefined) {
+                allGridPropsRef.current[key] = props.gridOptions[key];
+            }
+        }
+    }
+    // ✅ AG-Grid САМО detekuje změny rowData a columnDefs
+    // NENÍ potřeba forceUpdate - AG-Grid reaguje na změny v props automaticky!
+    // ✅ Vracíme VŽDY stejný objekt (stabilní reference)
+    const allGridProps = allGridPropsRef.current;
+    // State pro sledování, kdy je API ready
+    const [isApiReady, setIsApiReady] = React.useState(false);
+    // Nastavení Quick Filter přes API (podle AG-Grid v33 dokumentace)
+    // Tento useEffect se volá při změně quickFilterText NEBO když API je ready
+    React.useEffect(() => {
+        if (internalRef.current?.api && !internalRef.current.api.isDestroyed?.()) {
+            // ✅ FIX AG-Grid v35: Zajistit že quickFilterText není null/undefined
+            // AG-Grid v35 interně volá .toString() na této hodnotě bez null checku
+            const safeQuickFilterText = quickFilterText ?? '';
+            internalRef.current.api.setGridOption("quickFilterText", safeQuickFilterText);
+        }
+    }, [quickFilterText, isApiReady]);
+    // Status bar se zobrazuje pouze v simple mode
+    const showStatusBar = notificationMode === 'simple' && aggregationDataRef.current;
+    // ✅ FIX: Rezervovat místo pro status bar pouze když má data
+    // Grid se dynamicky rozšíří/zmenší podle přítomnosti status baru
+    const shouldReserveSpace = showStatusBar;
+    const gridContainerStyle = shouldReserveSpace
+        ? { height: `calc(100% - ${statusBarHeight}px)`, width: '100%', position: 'relative' }
+        : { height: '100%', width: '100%', position: 'relative' };
+    return (_jsxs("div", { style: { height: '100%', width: '100%', position: 'relative' }, children: [_jsx("div", { style: gridContainerStyle, children: _jsx(AgGridReact, { ...allGridProps }) }), shouldReserveSpace && (_jsx("div", { style: {
+                    position: 'absolute',
+                    bottom: 0,
+                    left: 0,
+                    right: 0,
+                    height: `${statusBarHeight}px`,
+                    opacity: showStatusBar ? 1 : 0,
+                    visibility: showStatusBar ? 'visible' : 'hidden',
+                    pointerEvents: showStatusBar ? 'auto' : 'none',
+                    zIndex: 10,
+                    // GPU acceleration pro plynulejší zobrazení
+                    transform: 'translateZ(0)',
+                    willChange: 'opacity'
+                }, children: _jsx(AggregationStatusBar, { data: aggregationDataRef.current || {}, metrics: statusBarMetrics, height: statusBarHeight, onSwitchToFull: handleSwitchToFull }) })), enableBulkEdit && floatingButton.visible && (_jsx(BulkEditButton, { visible: floatingButton.visible, position: floatingButton.position, range: floatingButton.range, column: floatingButton.column, cellCount: floatingButton.cellCount, rowsContainer: floatingButton.rowsContainer, gridApi: internalRef.current?.api, editPopover: editPopover, onOpenPopover: handleOpenPopover, onValueChange: handleValueChange, onSubmit: handleSubmitEdit, onCancel: handleCancelEdit }))] }));
+});
+// ========== PERFORMANCE OPTIMIZATION: React.memo ==========
+// Refactored: Používá createGridComparison utility místo manuálního deep comparison
+// Eliminováno ~120 řádků duplicitního kódu, zachována stejná funkcionalita
+// Diagnostic mode: zapnutý pouze ve development módu
+export default React.memo(AgGrid, createGridComparison(process.env.NODE_ENV !== 'production' // Diagnostic mode pouze ve development
+));
+export { useBulkCellEdit, BulkEditButton, BulkEditPopover, BulkEditSelect, BulkEditDatePicker, BulkEditModule, BulkEditInput, BulkEditTagsSelect } from './BulkEdit';
+export { default as CheckboxRenderer } from './Renderers/CheckboxRenderer';
+export * from './Renderers';
+export * from './Editors';
+//# sourceMappingURL=index.js.map