@toolbox-web/grid 1.31.1 → 1.31.3

package/lib/core/internal/shell.d.ts

@@ -285,3 +285,23 @@ export declare function buildGridDOMIntoElement(renderRoot: Element, shellConfig
     expand?: IconValue;
     collapse?: IconValue;
 }): boolean;
+/**
+ * Surgically rebuild only the shell wrapper (header + tool panel) while
+ * preserving the existing `.tbw-grid-root` element and its `.tbw-grid-content`
+ * child with all descendants and event listeners intact.
+ *
+ * This avoids the full `replaceChildren()` nuke that `buildGridDOMIntoElement`
+ * performs, so event listeners bound to `.tbw-grid-root` or its grid content
+ * descendants (e.g. tooltip's delegated mouseover) remain intact.
+ *
+ * If no existing `.tbw-grid-root` is found (first render), falls back to
+ * `buildGridDOMIntoElement` for a full rebuild.
+ */
+export declare function rebuildShellDOM(renderRoot: Element, shellConfig: ShellConfig | undefined, runtimeState: {
+    isPanelOpen: boolean;
+    expandedSections: Set<string>;
+}, icons?: {
+    toolPanel?: IconValue;
+    expand?: IconValue;
+    collapse?: IconValue;
+}): boolean;

package/lib/core/internal/sorting.d.ts

@@ -74,5 +74,9 @@ export declare function reapplyCoreSort<T>(grid: InternalGrid<T>, rows: T[]): T[
  *
  * Uses custom sortHandler from gridConfig if provided, otherwise uses built-in sorting.
  * Supports both sync and async handlers (for server-side sorting).
+ *
+ * When row-model plugins are active (grouping, tree, pivot), delegates to the render
+ * scheduler so the full pipeline (reapplyCoreSort → processRows) runs on base rows.
+ * This prevents sorting from corrupting plugin-generated row structures.
  */
 export declare function applySort(grid: GridHost, col: ColumnConfig<any>, dir: 1 | -1): void;

package/lib/core/plugin/base-plugin.d.ts

@@ -275,6 +275,18 @@ export interface PluginManifest<TConfig = unknown> {
      * ```
      */
     events?: EventDefinition[];
+    /**
+     * Whether this plugin's `processRows` hook injects or removes rows
+     * (group headers, tree nodes, pivot aggregates, placeholders, etc.).
+     *
+     * When true, the core sorting module delegates to the render scheduler
+     * instead of sorting `_rows` in-place, because `_rows` may contain
+     * plugin-generated marker objects that would be corrupted by a direct sort.
+     *
+     * Plugins that only **filter** or **reorder** existing rows (e.g. Filtering,
+     * MultiSort) should leave this unset or set it to `false`.
+     */
+    modifiesRowStructure?: boolean;
 }
 /** Convert camelCase icon key to kebab-case data-icon attribute value. */
 export declare function toIconAttr(key: string): string;

package/lib/core/plugin/plugin-manager.d.ts

@@ -24,7 +24,10 @@ export declare class PluginManager {
     /** Cached hook presence flags — invalidated on plugin attach/detach */
     private _hasAfterCellRender;
     private _hasAfterRowRender;
-    private _hasProcessRows;
+    /** Whether any plugin has a processRows hook. */
+    _hasProcessRows: boolean;
+    /** Whether any plugin with `modifiesRowStructure` is attached. Exposed for the sorting module. */
+    _hasRowStructurePlugins: boolean;
     /**
      * Event listeners indexed by event type.
      * Maps event type → Map<plugin instance → callback>.

package/lib/core/plugin/types.d.ts

@@ -351,6 +351,8 @@ export interface GridElementRef {
         subscribe(plugin: unknown, eventType: string, callback: (detail: unknown) => void): void;
         unsubscribe(plugin: unknown, eventType: string): void;
         emitPluginEvent<T>(eventType: string, detail: T): void;
+        /** Whether any attached plugin injects/removes rows (group headers, tree nodes, etc.). */
+        _hasRowStructurePlugins: boolean;
     };
     /**
      * Query all plugins with a generic query and collect responses.

package/lib/core/types.d.ts

@@ -463,6 +463,10 @@ export interface InternalGrid<T = any> extends PublicGrid<T>, GridConfig<T> {
     __hasSpecialColumns?: boolean;
     /** Cached flag for whether any plugin has renderRow hooks. @internal */
     __hasRenderRowPlugins?: boolean;
+    /** @internal Access the plugin manager's cached state. */
+    _pluginManager?: {
+        _hasRowStructurePlugins: boolean;
+    };
     _gridTemplate: string;
     _virtualization: VirtualState;
     _focusRow: number;
@@ -1197,6 +1201,19 @@ export interface CellRenderContext<TRow = any, TValue = any> {
     field: keyof TRow & string;
     /** Column configuration reference. */
     column: ColumnConfig<TRow>;
+    /**
+     * The grid element that owns this cell.
+     * Use to access public grid API (e.g., `getPluginByName()`) from custom renderers.
+     *
+     * @example
+     * ```typescript
+     * const renderer: ColumnViewRenderer<MyRow> = (ctx) => {
+     *   const tree = ctx.grid?.getPluginByName('tree');
+     *   // ...
+     * };
+     * ```
+     */
+    grid?: DataGridElement;
     /**
      * The cell DOM element being rendered into.
      * Framework adapters can use this to cache per-cell state (e.g., React roots).
@@ -1438,9 +1455,11 @@ export interface FrameworkAdapter {
      * Used by Angular's `GridTypeRegistry` and React's `GridTypeProvider`.
      *
      * @param type - The column type (e.g., 'date', 'currency', 'country')
+     * @param gridEl - The owning `<tbw-grid>` element. Helps adapters resolve
+     *   the correct context provider in multi-grid scenarios.
      * @returns Type defaults for renderer/editor, or undefined if not registered
      */
-    getTypeDefault?<TRow = unknown>(type: string): TypeDefault<TRow> | undefined;
+    getTypeDefault?<TRow = unknown>(type: string, gridEl?: HTMLElement): TypeDefault<TRow> | undefined;
     /**
      * Pre-process a grid config before the grid core applies it.
      * Framework adapters use this to convert framework-specific component references