@adaptabletools/adaptable 24.0.0-canary.8 → 24.0.0

package/src/setupDevTools.js

@@ -3,6 +3,9 @@ import { ADAPTABLE_VERSION } from './EnvVars';
 import { resolveVisibleSettingsPanelNavigationGroups } from './Utilities/Helpers/SettingsPanelHelper';
 import { isTransientReduxAction } from './Redux/Store/isTransientReduxAction';
 import { isPivotLayout } from './Utilities/Helpers/Layouts/LayoutHelper';
+import { formatColumnInspectorPinning, formatColumnInspectorSizing, } from './View/Layout/Utilities/columnLayoutHelpers';
+import { getVariableColor } from './Utilities/Helpers/StyleHelper';
+import { isSummaryColorLabel, parseSummaryLabelValueString, } from './View/Wizard/SummaryColorTag';
 import { debug } from '@infinite-table/infinite-react';
 import { colorSchemeDark, colorSchemeLight, themeQuartz } from 'ag-grid-enterprise';
 import { warnOnce } from './agGrid/AdaptableLogger';
@@ -192,6 +195,25 @@ function ensureDevToolsReady() {
         postStateChangeMessage(adaptableId, { api: registration.api });
     }
 }
+function handleGetColumnInfoMessage(payload) {
+    const adaptableId = payload?.adaptableId;
+    if (!adaptableId) {
+        console.warn('Adaptable DevTools: get-column-info message missing adaptableId');
+        return;
+    }
+    try {
+        const registration = resolveRegistration(adaptableId);
+        const columnInfo = buildColumnDetail(adaptableId, registration, payload.columnId);
+        window.postMessage(buildMessageForExtension({
+            type: 'column-info',
+            adaptableId,
+            columnInfo,
+        }));
+    }
+    catch (error) {
+        console.warn(error.message);
+    }
+}
 function handleOpenSettingsPanelMessage(payload) {
     const { adaptableId, moduleName } = payload ?? {};
     if (!adaptableId) {
@@ -495,6 +517,189 @@ function buildColumns(api) {
         isActionColumn: action.has(column.columnId),
     }));
 }
+const COLUMN_INFO_MODULES = [
+    'Alert',
+    'CalculatedColumn',
+    'CustomSort',
+    'FormatColumn',
+    'FlashingCell',
+    'PlusMinus',
+    'Shortcut',
+    'StyledColumn',
+];
+function isElement(value) {
+    return Boolean(value && typeof value === 'object' && 'props' in value);
+}
+function collectTagParts(node, into) {
+    if (node == null || typeof node === 'boolean') {
+        return;
+    }
+    if (typeof node === 'string' || typeof node === 'number') {
+        const text = String(node).trim();
+        if (text) {
+            into.texts.push(text);
+        }
+        return;
+    }
+    if (Array.isArray(node)) {
+        node.forEach((child) => collectTagParts(child, into));
+        return;
+    }
+    if (!isElement(node)) {
+        return;
+    }
+    const color = node.props?.color;
+    if (typeof color === 'string' && color && node.props?.children == null) {
+        into.color = getVariableColor(color);
+        return;
+    }
+    collectTagParts(node.props?.children, into);
+}
+function valueToTag(value, variant, italic) {
+    if (typeof value === 'string' || typeof value === 'number') {
+        const text = String(value).trim();
+        if (!text) {
+            return undefined;
+        }
+        const parsed = parseSummaryLabelValueString(text);
+        if (parsed && isSummaryColorLabel(parsed.label)) {
+            return { text: parsed.label, color: getVariableColor(parsed.value), variant, italic };
+        }
+        return { text, variant, italic };
+    }
+    const parts = { texts: [] };
+    collectTagParts(value, parts);
+    if (!parts.texts.length && !parts.color) {
+        return undefined;
+    }
+    return { text: parts.texts.join(' '), color: parts.color, variant, italic };
+}
+function viewItemLabel(item) {
+    if (typeof item.label === 'string' && item.label.trim()) {
+        return item.label.trim();
+    }
+    return item.name ?? '';
+}
+function serializeViewItems(items) {
+    const rows = [];
+    for (const item of items) {
+        const variant = item.tagVariant === 'default' ? undefined : item.tagVariant;
+        const italic = item.tagClassName?.includes('italic') ? true : undefined;
+        const tags = (item.values ?? [])
+            .map((value) => valueToTag(value, variant, italic))
+            .filter((tag) => tag != null);
+        if (!tags.length) {
+            continue;
+        }
+        rows.push({ label: viewItemLabel(item), tags });
+    }
+    return rows;
+}
+function summaryRow(key, value) {
+    if (value == null || value === '' || value === false) {
+        return undefined;
+    }
+    return { key, value: String(value) };
+}
+function yesNo(value) {
+    return value ? 'Yes' : 'No';
+}
+function buildColumnDetail(adaptableId, registration, columnId) {
+    const api = registration.api;
+    const columns = api.columnApi.getColumns();
+    const options = columns.map((column) => ({
+        id: column.columnId,
+        friendlyName: column.friendlyName,
+    }));
+    if (!columns.length) {
+        return { columnId: '', columns: [], summary: [], scopedObjects: [] };
+    }
+    const resolvedId = columnId || columns[0].columnId;
+    const column = api.columnApi.getColumnWithColumnId(resolvedId);
+    if (!column) {
+        throw new Error(`Adaptable DevTools: unknown column "${resolvedId}" on "${adaptableId}". Columns: ${options
+            .map((option) => `"${option.id}"`)
+            .join(', ')}.`);
+    }
+    const layout = api.layoutApi.getCurrentLayout();
+    const visible = new Set(api.columnApi.getVisibleColumns().map((entry) => entry.columnId));
+    const resolveDefaultWidth = (id) => registration.instance?.getDefaultColumnWidthForCol(id) ?? 0;
+    const columnFilter = api.filterApi.columnFilterApi.getColumnFilterForColumn(column.columnId);
+    const filterText = columnFilter
+        ? api.filterApi.columnFilterApi.columnFilterToString(columnFilter)
+        : '';
+    const summary = [
+        summaryRow('Column Id', column.columnId),
+        summaryRow('Header', column.friendlyName),
+        summaryRow('Data Type', column.dataType),
+        summaryRow('Column Types', column.columnTypes?.join(', ')),
+        summaryRow('Primary Key Column', column.isPrimaryKey ? 'Yes' : undefined),
+        summaryRow('Calculated Column', column.isCalculatedColumn ? 'Yes' : undefined),
+        summaryRow('Free Text Column', column.isFreeTextColumn ? 'Yes' : undefined),
+        summaryRow('Action Column', column.isActionColumn ? 'Yes' : undefined),
+        summaryRow('Sparkline Column', column.isSparkline ? 'Yes' : undefined),
+        summaryRow('Column Group', column.columnGroup?.friendlyName),
+        { key: 'Visible', value: yesNo(visible.has(column.columnId)) },
+        { key: 'Pinning', value: formatColumnInspectorPinning(layout, column.columnId) },
+        {
+            key: 'Width',
+            value: (() => {
+                const explicit = formatColumnInspectorSizing(column.columnId, layout.ColumnSizing?.[column.columnId], resolveDefaultWidth);
+                return explicit === 'Default' ? String(resolveDefaultWidth(column.columnId)) : explicit;
+            })(),
+        },
+        {
+            key: 'Sorting',
+            value: (layout.ColumnSorts ?? []).find((sort) => sort.ColumnId === column.columnId)?.SortOrder ??
+                'None',
+        },
+        summaryRow('Row Grouped', column.groupable ? yesNo(column.isGrouped) : undefined),
+        { key: 'Groupable', value: yesNo(column.groupable) },
+        { key: 'Aggregatable', value: yesNo(column.aggregatable) },
+        summaryRow('Aggregation Function', column.aggregatable ? column.aggregationFunction : undefined),
+        { key: 'Filterable', value: yesNo(column.filterable) },
+        summaryRow('Column Filter', column.filterable ? filterText : undefined),
+        { key: 'Hideable', value: yesNo(column.hideable) },
+        { key: 'Editable', value: yesNo(!column.readOnly) },
+        { key: 'Moveable', value: yesNo(column.moveable) },
+        { key: 'Pivotable', value: yesNo(column.pivotable) },
+        { key: 'Queryable', value: yesNo(column.queryable) },
+        { key: 'Exportable', value: yesNo(column.exportable) },
+        { key: 'Sortable', value: yesNo(column.sortable) },
+    ].filter((row) => row != null);
+    const moduleService = api.internalApi.getModuleService();
+    const scopedObjects = [];
+    for (const moduleName of COLUMN_INFO_MODULES) {
+        const module = moduleService.getModuleById(moduleName);
+        if (!module?.isModuleVisible() || !module.toViewAll) {
+            continue;
+        }
+        if (module.moduleInfo.ModuleName === 'CalculatedColumn' && !column.isCalculatedColumn) {
+            continue;
+        }
+        const itemsInScope = module.toViewAll().filter((item) => {
+            if ('Scope' in item.abObject) {
+                return api.columnScopeApi.isColumnInScope(column, item.abObject.Scope);
+            }
+            if ('ColumnId' in item.abObject) {
+                return item.abObject.ColumnId === column.columnId;
+            }
+            return false;
+        });
+        for (const item of itemsInScope) {
+            const rows = serializeViewItems(item.items);
+            if (rows.length) {
+                scopedObjects.push({ module: module.moduleInfo.FriendlyName, rows });
+            }
+        }
+    }
+    return {
+        columnId: column.columnId,
+        columns: options,
+        summary,
+        scopedObjects,
+    };
+}
 function buildGridInfo(adaptableId, api) {
     const { licenseKey, userName, primaryKey } = buildInstanceSummary(api);
     const currentLayout = api.layoutApi.getCurrentLayout();
@@ -557,6 +762,7 @@ Omit adaptableId when one instance is mounted.
   getState(id?, section?)                -> full AdapTable State, or one section such as 'Layout' or 'FormatColumn'
   getPersistentState(id?)                -> the user state AdapTable persists; pass it to the MCP check_state / migrate_state tools
   getColumns(id?)                        -> [{ id, friendlyName, dataType, visible, ... }]; { id, dataType } is the MCP "columns" input
+  getColumnInfo(id?, columnId?)          -> read-only Column Info: summary and Settings Panel tags for objects scoped to that column
   getLogs(id?, { level?, channel?, limit? }) -> recent AdapTable log messages, buffered without localStorage.debug
   getRecentActions(id?, limit?)          -> recent state-changing actions
   restoreState(id, state)                -> Promise; restores a snapshot from getState()/getPersistentState()
@@ -600,6 +806,11 @@ function createDevToolsGlobal() {
             const { api } = resolveRegistration(adaptableId);
             return serializeForPostMessage(buildColumns(api));
         },
+        getColumnInfo(adaptableId, columnId) {
+            const registration = resolveRegistration(adaptableId);
+            const id = adaptableId ?? registration.api.optionsApi.getAdaptableId();
+            return serializeForPostMessage(buildColumnDetail(id, registration, columnId));
+        },
         getGridInfo(adaptableId) {
             const registration = resolveRegistration(adaptableId);
             const id = adaptableId ?? registration.api.optionsApi.getAdaptableId();
@@ -693,6 +904,7 @@ export function listenForDevTools(adaptableInstance) {
             const handlers = {
                 'restore-state': handleRestoreStateMessage,
                 'open-settings-panel': handleOpenSettingsPanelMessage,
+                'get-column-info': handleGetColumnInfoMessage,
                 'load-variant': handleLoadVariantMessage,
                 'theme-var-change': handleThemeVarChangeMessage,
                 'apply-theme': handleApplyThemeMessage,
@@ -812,6 +1024,17 @@ function buildMessageForExtension(params) {
             },
         };
     }
+    if (type === 'column-info') {
+        return {
+            ...messageBase,
+            url,
+            type,
+            payload: {
+                adaptableId,
+                columnInfo: payload?.columnInfo,
+            },
+        };
+    }
     if (type === 'state-change') {
         return {
             ...messageBase,

package/src/types.d.ts

@@ -3,8 +3,6 @@ export type { ExpressionCategory, OfficialExpressionCategory, ExpressionReturnTy
 export { isAST_Function, getExpressionArgColumnId, EXPRESSION_CATEGORIES, EXPRESSION_RETURN_TYPES, } from "../vendor/aql/index.js";
 export type { AdaptableLogger } from './../src/agGrid/AdaptableLogger';
 export type { AgGridConfig } from './AdaptableInterfaces/IAdaptable';
-export type { AdaptableConfig } from './View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableConfig';
-export type { AdaptableNoCodeWizardOptions, IAdaptableNoCodeWizard, } from './AdaptableInterfaces/AdaptableNoCodeWizard';
 export type { ScalarFunctionName, AggregationCallableName as AggregatedScalarFunctionName, } from "../vendor/aql/index.js";
 export type { AdaptableOptions } from './AdaptableOptions/AdaptableOptions';
 export { AdaptablePlugin } from './AdaptableOptions/AdaptablePlugin';