@genesislcap/grid-pro 14.486.1 → 14.487.0

package/dist/esm/grid-pro-beta.js

@@ -10,7 +10,7 @@ import debounce from 'lodash.debounce';
 import { GridProCell } from './cell';
 import { DateEditor, MultiselectEditor, NumberEditor, SelectEditor, StringEditor, } from './cell-editors';
 import { ActionRenderer, ActionsMenuRenderer, BooleanRenderer, EditableRenderer, IconRenderer, SelectRenderer, StatusPillRenderer, } from './cell-renderers';
-import { GridProColumn } from './column';
+import { GridProColumn, resolveVisibleColumnFields } from './column';
 import { GridProClientSideDatasource, GridProServerSideDatasource } from './datasource';
 import { baseDatasourceEventNames } from './datasource/base.types';
 import { GridProGenesisDatasource, gridProGenesisDatasourceEventNames, } from './grid-pro-genesis-datasource';
@@ -93,6 +93,9 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         this.disposed = false;
         this.debouncedSaveColumnState = debounce(this.saveColumnState.bind(this), DEBOUNCE_TIME);
         this.debouncedSaveFilterModel = debounce(this.cacheFilterConfig.bind(this), DEBOUNCE_TIME);
+        // Coalesces bursts of column-visibility events (e.g. a "hide all" tool-panel toggle fires one
+        // per column) into a single datasource notification + reload.
+        this.debouncedNotifyDatasourceVisibleColumns = debounce(this.notifyDatasourceVisibleColumns.bind(this), DEBOUNCE_TIME);
         // Genesis-specific attrs
         this.autoCellRendererByType = false;
         this.onlyTemplateColDefs = false;
@@ -867,16 +870,41 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             this.querySelector('grid-pro-client-side-datasource') ||
             this.querySelector('grid-pro-server-side-datasource'));
     }
+    /**
+     * Reports the currently visible columns to the datasource. The datasource decides what to do with
+     * them (e.g. narrowing the server request); the grid stays agnostic of that behaviour.
+     * @internal
+     */
+    notifyDatasourceVisibleColumns() {
+        var _a, _b, _c, _d;
+        const datasource = this.gridProDatasource;
+        if (!datasource)
+            return;
+        const visibleFields = resolveVisibleColumnFields((_b = (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.getAllDisplayedColumns) === null || _b === void 0 ? void 0 : _b.call(_a), (_d = (_c = this.gridApi) === null || _c === void 0 ? void 0 : _c.getColumnDefs) === null || _d === void 0 ? void 0 : _d.call(_c));
+        // Skip empty results so we never overwrite a known visible set with nothing (e.g. when the
+        // grid API/defs aren't populated yet during early lifecycle).
+        if (!visibleFields.length)
+            return;
+        datasource.setVisibleColumns(visibleFields);
+    }
     set gridOptions(options) {
         if (!this.applyingDatasourceGridOptions && options) {
             this.userProvidedGridOptions = Object.assign({}, options);
         }
+        // Column move/resize/pin/sort don't change which fields are visible, so they only need the
+        // column-state/autosize bookkeeping below; visibility notification is wired separately (via
+        // onColumnVisible/onDisplayedColumnsChanged) so it isn't tied to unrelated grid interactions.
         const gridOnChangeCallback = () => {
             if (this.disposed || !this.isConnected)
                 return;
             this.debouncedSaveColumnState();
             this.debouncedColumnAutosize();
         };
+        const notifyVisibilityChanged = () => {
+            if (this.disposed || !this.isConnected)
+                return;
+            this.debouncedNotifyDatasourceVisibleColumns();
+        };
         // Collect attributes and map them to AG Grid properties
         Array.from(this.attributes).forEach((attribute) => {
             const attrName = this.agPropertiesMap[attribute.name];
@@ -884,7 +912,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                 return;
             this.agAttributes[attrName] = attribute.value;
         });
-        const { columnDefs, components, defaultColDef, getRowId, onGridReady, onFilterChanged } = options, rest = __rest(options, ["columnDefs", "components", "defaultColDef", "getRowId", "onGridReady", "onFilterChanged"]);
+        const { columnDefs, components, defaultColDef, getRowId, onGridReady, onFilterChanged, onFirstDataRendered } = options, rest = __rest(options, ["columnDefs", "components", "defaultColDef", "getRowId", "onGridReady", "onFilterChanged", "onFirstDataRendered"]);
         const derivedOptions = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.gridOptionsConfig), { defaultColDef: Object.assign({ enableCellChangeFlash: this.enableCellFlashing, filter: true, resizable: true, sortable: true }, defaultColDef), components: this.combineAllGridComponents(components), headerHeight: this.headerHeight, rowHeight: this.rowHeight, animateRows: false, suppressDragLeaveHidesColumns: true }), this.eventsAndCallbacks), { onGridReady: (event) => {
                 var _a, _b, _c;
                 this.gridApi = event.api;
@@ -914,6 +942,9 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                     event,
                     gridId: this.id,
                 });
+                // Seed the datasource with the initially visible columns before the load is kicked off, so
+                // a datasource that scopes its request to visible columns can narrow the first request.
+                this.notifyDatasourceVisibleColumns();
                 // TODO: prevent rendering datasource slot until grid is ready
                 // so there is no need for this even and handling it in datasources
                 (_c = this.gridProDatasource) === null || _c === void 0 ? void 0 : _c.$emit(datasourceEventNames.ready, {
@@ -922,7 +953,27 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                 this.restoreColumnState();
                 this.restoreCachedFilterConfig();
                 this.debouncedColumnAutosize();
-            }, onColumnPinned: gridOnChangeCallback, onColumnResized: gridOnChangeCallback, onColumnMoved: gridOnChangeCallback, onDisplayedColumnsChanged: gridOnChangeCallback, onFilterChanged: (filterChangedEvent) => {
+            }, onFirstDataRendered: (event) => {
+                // Safety net: by now the grid columns are populated, so (re)seed the datasource's visible
+                // columns in case the initial grid-ready seed ran before columns were available.
+                this.notifyDatasourceVisibleColumns();
+                if (onFirstDataRendered) {
+                    onFirstDataRendered(event);
+                }
+            }, onColumnPinned: gridOnChangeCallback, onColumnResized: gridOnChangeCallback, onColumnMoved: gridOnChangeCallback, 
+            // Primary visibility trigger: fires per-column on show/hide, from the tool panel, header
+            // menu, or API calls alike.
+            onColumnVisible: () => {
+                gridOnChangeCallback();
+                notifyVisibilityChanged();
+            }, 
+            // Fallback for bulk tool-panel operations (e.g. "select all") that may not cleanly emit one
+            // onColumnVisible per column across entry points; debounced alongside it so a burst still
+            // collapses into a single datasource reload.
+            onDisplayedColumnsChanged: () => {
+                gridOnChangeCallback();
+                notifyVisibilityChanged();
+            }, onFilterChanged: (filterChangedEvent) => {
                 if (this.disposed || !this.isConnected)
                     return;
                 this.debouncedSaveFilterModel();

package/dist/esm/grid-pro-genesis-datasource/grid-pro-genesis-datasource.js

@@ -48,6 +48,15 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
             addIndex: 0,
         };
         this.keepColDefsOnClearRowData = false;
+        /**
+         * When enabled and column definitions are provided, the datasource requests data only for the
+         * columns that are currently visible. The visible set is seeded from the column config (columns
+         * not flagged with `hide`) and updated by the host grid via `setVisibleColumns`; the data
+         * is reloaded whenever that set changes.
+         * @remarks DATASERVER only.
+         * @default false
+         */
+        this.requestVisibleColumnsOnly = false;
         this.requiresFullRowDataAndColDefs = true;
         this._lastMoreRows = false;
         this._isMoreRowsResult = false;
@@ -176,6 +185,7 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
             this.connectionSub = undefined;
         }
         this._sourceRef = undefined;
+        this._visibleColumns = undefined;
         this.clearRowData();
         this._lastMoreRows = false;
         this._isMoreRowsResult = false;
@@ -566,6 +576,84 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
         super.handleStreamDeletes(deletes);
         this.updateCachedRowArray();
     }
+    /**
+     * Extends the base options to constrain the requested fields to the visible columns when
+     * `requestVisibleColumnsOnly` is enabled.
+     * @remarks DATASERVER only; for other resource types the derived `fields` are ignored.
+     * @internal
+     */
+    datasourceOptions() {
+        const options = super.datasourceOptions();
+        if (this.requestVisibleColumnsOnly) {
+            const fields = this.getRequestedFields();
+            if (fields) {
+                options.fields = fields;
+            }
+        }
+        return options;
+    }
+    /**
+     * Builds the DATASERVER `FIELDS` string (space-separated) from the visible columns, always
+     * including the `rowId` so rows can be tracked.
+     * @internal
+     */
+    getRequestedFields() {
+        var _a;
+        const visibleColumns = ((_a = this._visibleColumns) === null || _a === void 0 ? void 0 : _a.length)
+            ? this._visibleColumns
+            : this.getConfiguredVisibleColumns();
+        if (!visibleColumns.length)
+            return undefined;
+        const fields = visibleColumns.includes(this.rowId)
+            ? visibleColumns
+            : [this.rowId, ...visibleColumns];
+        return fields.join(' ');
+    }
+    /**
+     * Returns the field names of the configured columns that are not hidden, used to seed the visible
+     * set before the host grid reports runtime visibility.
+     * @internal
+     */
+    getConfiguredVisibleColumns() {
+        var _a, _b;
+        const columnDefs = (_b = (_a = this.deferredGridOptions) === null || _a === void 0 ? void 0 : _a.columnDefs) !== null && _b !== void 0 ? _b : [];
+        return columnDefs
+            .filter((colDef) => !!colDef.field && !colDef.hide)
+            .map((colDef) => colDef.field);
+    }
+    /**
+     * Updates the set of visible columns and reloads the data when the set changes.
+     * @remarks Called by the host grid on column visibility changes; no-ops unless
+     * `requestVisibleColumnsOnly` is enabled. DATASERVER only; no-ops for other resource types.
+     * @param visibleFields - Field names of the currently visible columns.
+     * @public
+     */
+    setVisibleColumns(visibleFields) {
+        var _a;
+        if (!this.requestVisibleColumnsOnly)
+            return;
+        const previous = (_a = this._visibleColumns) !== null && _a !== void 0 ? _a : this.getConfiguredVisibleColumns();
+        // Always seed the visible set so the initial request can be narrowed, even before the
+        // datasource has initialized and its resource type is known.
+        this._visibleColumns = visibleFields;
+        // Narrowing applies to DATASERVER only; reload once initialized and the visible set changes.
+        if (this.datasource.resourceType !== ResourceType.DATASERVER ||
+            !this.datasource.initialized ||
+            !this.columnsChanged(previous, visibleFields)) {
+            return;
+        }
+        this.reloadResourceData();
+    }
+    /**
+     * Compares two column field lists irrespective of order.
+     * @internal
+     */
+    columnsChanged(previous, next) {
+        if (previous.length !== next.length)
+            return true;
+        const previousSet = new Set(previous);
+        return next.some((field) => !previousSet.has(field));
+    }
     loadMore() {
         switch (this.datasource.resourceType) {
             case ResourceType.DATASERVER:
@@ -598,6 +686,9 @@ let GridProGenesisDatasource = class GridProGenesisDatasource extends LifecycleM
 __decorate([
     attr({ mode: 'boolean', attribute: 'keep-col-defs-on-clear-row-data' })
 ], GridProGenesisDatasource.prototype, "keepColDefsOnClearRowData", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'request-visible-columns-only' })
+], GridProGenesisDatasource.prototype, "requestVisibleColumnsOnly", void 0);
 GridProGenesisDatasource = __decorate([
     customElement({
         name: 'grid-pro-genesis-datasource',

package/dist/esm/grid-pro.js

@@ -12,7 +12,7 @@ import debounce from 'lodash.debounce';
 import { GridProCell } from './cell';
 import { DateEditor, MultiselectEditor, NumberEditor, SelectEditor, StringEditor, } from './cell-editors';
 import { ActionRenderer, ActionsMenuRenderer, BooleanRenderer, EditableRenderer, IconRenderer, SelectRenderer, StatusPillRenderer, } from './cell-renderers';
-import { GridProColumn } from './column';
+import { GridProColumn, resolveVisibleColumnFields } from './column';
 import { GridProClientSideDatasource, GridProServerSideDatasource } from './datasource';
 import { baseDatasourceEventNames } from './datasource/base.types';
 import { agThemeFontFaceMap, defaultAgGridFontFace } from './external';
@@ -84,6 +84,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         this.disposed = false;
         this.debouncedSaveColumnState = debounce(this.saveColumnState.bind(this), DEBOUNCE_TIME);
         this.debouncedSaveFilterModel = debounce(this.cacheFilterConfig.bind(this), DEBOUNCE_TIME);
+        // Coalesces bursts of column-visibility events (e.g. a "hide all" tool-panel toggle fires one
+        // per column) into a single datasource notification + reload.
+        this.debouncedNotifyDatasourceVisibleColumns = debounce(this.notifyDatasourceVisibleColumns.bind(this), DEBOUNCE_TIME);
         // Genesis-specific attrs
         this.autoCellRendererByType = false;
         this.onlyTemplateColDefs = false;
@@ -922,10 +925,30 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             this.querySelector('grid-pro-client-side-datasource') ||
             this.querySelector('grid-pro-server-side-datasource'));
     }
+    /**
+     * Reports the currently visible columns to the datasource. The datasource decides what to do with
+     * them (e.g. narrowing the server request); the grid stays agnostic of that behaviour.
+     * @internal
+     */
+    notifyDatasourceVisibleColumns() {
+        var _a, _b, _c, _d;
+        const datasource = this.gridProDatasource;
+        if (!datasource)
+            return;
+        const visibleFields = resolveVisibleColumnFields((_b = (_a = this.columnApi) === null || _a === void 0 ? void 0 : _a.getAllDisplayedColumns) === null || _b === void 0 ? void 0 : _b.call(_a), (_d = (_c = this.gridApi) === null || _c === void 0 ? void 0 : _c.getColumnDefs) === null || _d === void 0 ? void 0 : _d.call(_c));
+        // Skip empty results so we never overwrite a known visible set with nothing (e.g. when the
+        // column API/defs aren't populated yet during early lifecycle).
+        if (!visibleFields.length)
+            return;
+        datasource.setVisibleColumns(visibleFields);
+    }
     set gridOptions(options) {
         if (!this.applyingDatasourceGridOptions && options) {
             this.userProvidedGridOptions = Object.assign({}, options);
         }
+        // Column move/resize/pin/sort don't change which fields are visible, so they only need the
+        // column-state/autosize bookkeeping below; visibility notification is wired separately (via
+        // onColumnVisible/onDisplayedColumnsChanged) so it isn't tied to unrelated grid interactions.
         const gridOnChangeCallback = () => {
             if (this.disposed || !this.isConnected)
                 return;
@@ -933,6 +956,11 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             this.debouncedColumnAutosize();
             this.invalidateColumnWidthCache();
         };
+        const notifyVisibilityChanged = () => {
+            if (this.disposed || !this.isConnected)
+                return;
+            this.debouncedNotifyDatasourceVisibleColumns();
+        };
         Array.from(this.attributes).forEach((attribute) => {
             const attrName = this.agPropertiesMap[attribute.name];
             if (!attrName)
@@ -971,6 +999,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
                     event,
                     gridId: this.id,
                 });
+                // Seed the datasource with the initially visible columns before the load is kicked off, so
+                // a datasource that scopes its request to visible columns can narrow the first request.
+                this.notifyDatasourceVisibleColumns();
                 // Emit datasource ready event, signals that the datasource is ready to be used
                 // TODO: prevent rendering datasource slot until grid is ready
                 // so there is no need for this even and handling it in datasources
@@ -983,11 +1014,27 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             }, onFirstDataRendered: (event) => {
                 // Handle column sizing
                 this.handleColumnSizing();
+                // Safety net: by now the column API is populated, so (re)seed the datasource's visible
+                // columns in case the initial grid-ready seed ran before columns were available.
+                this.notifyDatasourceVisibleColumns();
                 // Call the original onFirstDataRendered if provided
                 if (onFirstDataRendered) {
                     onFirstDataRendered(event);
                 }
-            }, onColumnPinned: gridOnChangeCallback, onColumnResized: gridOnChangeCallback, onColumnMoved: gridOnChangeCallback, onDisplayedColumnsChanged: gridOnChangeCallback, onFilterChanged: (filterChangedEvent) => {
+            }, onColumnPinned: gridOnChangeCallback, onColumnResized: gridOnChangeCallback, onColumnMoved: gridOnChangeCallback, 
+            // Primary visibility trigger: fires per-column on show/hide, from the tool panel, header
+            // menu, or API calls alike.
+            onColumnVisible: () => {
+                gridOnChangeCallback();
+                notifyVisibilityChanged();
+            }, 
+            // Fallback for bulk tool-panel operations (e.g. "select all") that may not cleanly emit one
+            // onColumnVisible per column across entry points; debounced alongside it so a burst still
+            // collapses into a single datasource reload.
+            onDisplayedColumnsChanged: () => {
+                gridOnChangeCallback();
+                notifyVisibilityChanged();
+            }, onFilterChanged: (filterChangedEvent) => {
                 if (this.disposed || !this.isConnected)
                     return;
                 this.debouncedSaveFilterModel();

package/dist/grid-pro.api.json

@@ -14999,6 +14999,54 @@
               "isAbstract": false,
               "name": "setDisconnected"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/grid-pro!GridProBaseDatasource#setVisibleColumns:member(1)",
+              "docComment": "/**\n * Notifies the datasource of the field names of the currently visible columns.\n *\n * @remarks\n *\n * No-op by default. Datasources that support column-scoped requests override this to narrow the server query and reload data when the visible column set changes.\n *\n * @param visibleFields - Field names of the currently visible columns.\n *\n * @public\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "setVisibleColumns(visibleFields: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "void"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "visibleFields",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "setVisibleColumns"
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/grid-pro!GridProBaseDatasource#subscribeToConnection:member(1)",
@@ -20192,6 +20240,36 @@
               "isAbstract": false,
               "name": "requestChanged"
             },
+            {
+              "kind": "Property",
+              "canonicalReference": "@genesislcap/grid-pro!GridProGenesisDatasource#requestVisibleColumnsOnly:member",
+              "docComment": "/**\n * When enabled and column definitions are provided, the datasource requests data only for the columns that are currently visible. The visible set is seeded from the column config (columns not flagged with `hide`) and updated by the host grid via `setVisibleColumns`; the data is reloaded whenever that set changes.\n *\n * @remarks\n *\n * DATASERVER only.  @default false\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "requestVisibleColumnsOnly: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "boolean"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "requestVisibleColumnsOnly",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isStatic": false,
+              "isProtected": false,
+              "isAbstract": false
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/grid-pro!GridProGenesisDatasource#reset:member(1)",
@@ -20387,6 +20465,54 @@
               "isAbstract": false,
               "name": "setFilter"
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@genesislcap/grid-pro!GridProGenesisDatasource#setVisibleColumns:member(1)",
+              "docComment": "/**\n * Updates the set of visible columns and reloads the data when the set changes.\n *\n * @remarks\n *\n * Called by the host grid on column visibility changes; no-ops unless `requestVisibleColumnsOnly` is enabled. DATASERVER only; no-ops for other resource types.\n *\n * @param visibleFields - Field names of the currently visible columns.\n *\n * @public\n */\n",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "setVisibleColumns(visibleFields: "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string[]"
+                },
+                {
+                  "kind": "Content",
+                  "text": "): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "void"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 3,
+                "endIndex": 4
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [
+                {
+                  "parameterName": "visibleFields",
+                  "parameterTypeTokenRange": {
+                    "startIndex": 1,
+                    "endIndex": 2
+                  },
+                  "isOptional": false
+                }
+              ],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "setVisibleColumns"
+            },
             {
               "kind": "Property",
               "canonicalReference": "@genesislcap/grid-pro!GridProGenesisDatasource#transactionData:member",
@@ -26989,6 +27115,72 @@
             "endIndex": 2
           }
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@genesislcap/grid-pro!resolveVisibleColumnFields:function(1)",
+          "docComment": "/**\n * Resolves the field names of the currently visible columns.\n *\n * @remarks\n *\n * Prefers the grid's displayed columns (`getAllDisplayedColumns()` — already excludes hidden columns and children of collapsed groups, so no extra visibility check is needed); falls back to the current column defs (available earlier in the lifecycle than the columns), treating `hide` as not visible. Shared by the host grids to report the visible set to the datasource. Typed structurally so it works across the differing AG Grid type packages the grids depend on.\n *\n * @param displayedColumns - The grid's currently displayed columns, when available.\n *\n * @param colDefs - The current column defs, used as a fallback before the columns are populated.\n *\n * @public\n */\n",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function resolveVisibleColumnFields(displayedColumns: "
+            },
+            {
+              "kind": "Reference",
+              "text": "DisplayedColumnLike",
+              "canonicalReference": "@genesislcap/grid-pro!~DisplayedColumnLike:interface"
+            },
+            {
+              "kind": "Content",
+              "text": "[] | null | undefined"
+            },
+            {
+              "kind": "Content",
+              "text": ", colDefs: "
+            },
+            {
+              "kind": "Content",
+              "text": "readonly unknown[] | null | undefined"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "string[]"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/column/utils/grid-pro-columns.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 6,
+            "endIndex": 7
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "displayedColumns",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "isOptional": false
+            },
+            {
+              "parameterName": "colDefs",
+              "parameterTypeTokenRange": {
+                "startIndex": 4,
+                "endIndex": 5
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "resolveVisibleColumnFields"
+        },
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/grid-pro!RowCountStatusBarComponent:class",