@adaptabletools/adaptable 23.1.0-canary.2 → 24.0.0-canary.0

package/src/View/NamedQuery/Wizard/NamedQueryExpressionWizardSection.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { AdaptableApi } from '../../../Api/AdaptableApi';
-import { NamedQuery } from '../../../types';
+import { NamedQuery } from '../../../AdaptableState/NamedQueryState';
 export interface NamedQueryExpressionWizardSectionProps {
     onChange: (data: NamedQuery) => void;
 }

package/src/View/NamedQuery/Wizard/NamedQueryExpressionWizardSection.js

@@ -1,27 +1,65 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from 'react';
-import { ExpressionEditor } from '../../../components/ExpressionEditor';
-import { Tag } from '../../../components/Tag';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { ExpressionEditor, ExpressionUseCaseCard } from '../../../components/aql/ExpressionEditor';
+import { ExpressionTag } from '../../../components/Tag';
+import { getNamedQueryReturnType } from '../../../AdaptableState/NamedQueryState';
 import { NamedQueryModuleId } from '../../../Utilities/Constants/ModuleConstants';
 import { useOnePageAdaptableWizardContext } from '../../Wizard/OnePageAdaptableWizard';
 import { Box } from '../../../components/Flex';
+import { inferNamedQueryReturnType, runtimeMatchesNamedQueryReturnType, suggestNamedQueryReturnTypeFromExpression, } from '../../../Utilities/Helpers/NamedQueryHelper';
 export const isValidNamedQueryExpression = (data, api) => {
-    if (!data.BooleanExpression) {
-        return 'An expression is required';
+    if (!data.Expression) {
+        return 'An Expression is required';
     }
-    const valid = api.expressionApi.isValidBooleanExpression(data.BooleanExpression, NamedQueryModuleId);
+    const returnType = getNamedQueryReturnType(data);
+    if (returnType === 'boolean') {
+        const valid = api.expressionApi.isValidScalarExpression(data.Expression, NamedQueryModuleId);
+        if (!valid) {
+            if (api.expressionApi.isValidValueExpression(data.Expression, NamedQueryModuleId)) {
+                return 'The Expression is valid but does not return a boolean value. Change the Result Type to match the Expression.';
+            }
+            return 'The query is not a valid Boolean expression.';
+        }
+        return true;
+    }
+    const valid = api.expressionApi.isValidValueExpression(data.Expression, NamedQueryModuleId);
     if (!valid) {
-        return 'The query is not a valid Boolean expression.';
+        return 'The query is not a valid Expression.';
+    }
+    try {
+        const previewRow = api.gridApi.getFirstRowNode();
+        const result = api.internalApi
+            .getQueryLanguageService()
+            .evaluateScalarExpression(data.Expression, NamedQueryModuleId, previewRow);
+        if (!runtimeMatchesNamedQueryReturnType(result, returnType)) {
+            const inferred = inferNamedQueryReturnType(result);
+            return `Expression evaluates to ${inferred}, but Result Type is ${returnType}.`;
+        }
+    }
+    catch (error) {
+        return `Expression could not be evaluated: ${error}`;
     }
-    return valid;
+    return true;
 };
 export const renderNamedQueryExpressionSummary = (data, api) => {
-    return (_jsxs(Box, { className: "twa:text-2", children: ["Expression: ", _jsx(Tag, { children: api.internalApi.getAdaptableQueryExpressionText(data) })] }));
+    return (_jsxs(Box, { className: "twa:text-2", children: ["Expression:", ' ', _jsx(ExpressionTag, { children: api.internalApi.getAdaptableQueryExpressionText(data) })] }));
 };
 export const NamedQueryExpressionWizardSection = (props) => {
     const { data, moduleInfo, api } = useOnePageAdaptableWizardContext();
     const initialData = useMemo(() => api.internalApi.getQueryPreviewData(), []);
-    return (_jsx(ExpressionEditor, { allowSaveNamedQuery: false, showQueryBuilder: true, type: 'boolean', module: moduleInfo.ModuleName, value: data.BooleanExpression, onChange: (BooleanExpression) => {
-            props.onChange({ ...data, BooleanExpression });
-        }, initialData: initialData, columns: api.columnApi.internalApi.getQueryableColumnsForUIEditor(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api }));
+    const returnType = getNamedQueryReturnType(data);
+    const isBooleanQuery = returnType === 'boolean';
+    const [inferHint, setInferHint] = useState(null);
+    const examplesKind = isBooleanQuery ? 'boolean' : 'standard';
+    return (_jsxs(ExpressionUseCaseCard, { title: "Named Query Expression", description: _jsx(_Fragment, { children: "Create a reusable Expression that can be referenced in other Expressions via QUERY keyword" }), examplesKind: examplesKind, children: [_jsx(ExpressionEditor, { allowSaveNamedQuery: false, showQueryBuilder: true, queryBuilderTabLabel: "Query Builder (Boolean only)", isFullExpression: !isBooleanQuery, type: 'scalar', module: moduleInfo.ModuleName, className: "twa:pl-0", value: data.Expression, onChange: (Expression) => {
+                    const inferred = Expression
+                        ? suggestNamedQueryReturnTypeFromExpression(api, Expression)
+                        : undefined;
+                    if (inferred && inferred !== returnType) {
+                        setInferHint(`Result Type updated to ${inferred} to match the Expression`);
+                        props.onChange({ ...data, Expression, ReturnType: inferred });
+                        return;
+                    }
+                    props.onChange({ ...data, Expression });
+                }, initialData: initialData, columns: api.columnApi.internalApi.getQueryableColumnsForUIEditor(), fields: api.expressionApi.internalApi.getAvailableFields(), namedQueries: api.namedQueryApi.getNamedQueries(), api: api, suppressTypeInfoCard: true, examplesKind: examplesKind }), inferHint ? (_jsx(Box, { "data-name": "named-query-infer-hint", className: "twa:text-2 twa:opacity-70 twa:px-2 twa:pb-1", children: inferHint })) : null] }));
 };

package/src/View/NamedQuery/Wizard/NamedQuerySettingsWizardSection.js

@@ -1,9 +1,14 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from 'react';
 import { useOnePageAdaptableWizardContext, SummaryText } from '../../Wizard/OnePageAdaptableWizard';
 import { Tag } from '../../../components/Tag';
+import { getNamedQueryReturnType, } from '../../../AdaptableState/NamedQueryState';
 import { Box, Flex } from '../../../components/Flex';
 import { Card } from '../../../components/Card';
 import Input from '../../../components/Input';
+import { SingleSelect } from '../../../components/Select';
+import SimpleButton from '../../../components/SimpleButton';
+import { RETURN_TYPE_OPTIONS, suggestNamedQueryReturnTypeFromExpression, } from '../../../Utilities/Helpers/NamedQueryHelper';
 export const isValidNamedQuerySettings = (data, api) => {
     const validationResult = api.namedQueryApi.isValidNamedQuery(data);
     const ErrorMessage = !validationResult.valid ? validationResult.message : null;
@@ -13,15 +18,35 @@ export const isValidNamedQuerySettings = (data, api) => {
     return ErrorMessage;
 };
 export const renderNamedQuerySettingsSummary = (data) => {
-    return (_jsxs(SummaryText, { children: ["Name ", _jsx(Tag, { children: data.Name || 'Not specified' })] }));
+    return (_jsxs(_Fragment, { children: [_jsxs(SummaryText, { children: ["Name ", _jsx(Tag, { children: data.Name || 'Not specified' })] }), _jsxs(SummaryText, { children: ["Result Type ", _jsx(Tag, { children: getNamedQueryReturnType(data) })] }), _jsxs(SummaryText, { children: ["Description ", _jsx(Tag, { children: data.Description || 'Not specified' })] })] }));
 };
 export const NamedQuerySettingsWizardSection = (props) => {
-    const { data } = useOnePageAdaptableWizardContext();
+    const { data, api } = useOnePageAdaptableWizardContext();
+    const returnType = getNamedQueryReturnType(data);
+    const [inferHint, setInferHint] = useState(null);
     const handleNameChange = (event) => {
         props.onChange({
             ...data,
             Name: event.target.value,
         });
     };
-    return (_jsx(Box, { "data-name": "named-query-settings", children: _jsx(Flex, { flexDirection: "column", className: "twa:gap-3 twa:p-3", children: _jsxs(Card, { shadow: false, children: [_jsxs(Card.Title, { children: [_jsx(Box, { className: "twa:font-medium", children: "Name" }), _jsx(Box, { className: "twa:text-xs twa:opacity-70 twa:font-normal twa:max-w-[520px]", children: "Provide a unique name for the Named Query" })] }), _jsx(Card.Body, { className: "twa:p-1", children: _jsx(Input, { "data-name": "query-name", value: data.Name ?? '', autoFocus: true, className: "twa:max-w-[300px] twa:w-full", type: "text", placeholder: "Enter name for Named Query", onChange: handleNameChange }) })] }) }) }));
+    const handleDescriptionChange = (event) => {
+        const value = event.target.value;
+        props.onChange({
+            ...data,
+            Description: value || undefined,
+        });
+    };
+    return (_jsx(Box, { "data-name": "named-query-settings", children: _jsxs(Flex, { flexDirection: "column", className: "twa:gap-3 twa:p-3", children: [_jsxs(Card, { shadow: false, children: [_jsxs(Card.Title, { children: [_jsx(Box, { className: "twa:font-medium", children: "Name" }), _jsx(Box, { className: "twa:text-xs twa:opacity-70 twa:font-normal twa:max-w-[520px]", children: "Provide a unique name for the Named Query" })] }), _jsx(Card.Body, { className: "twa:p-1", children: _jsx(Input, { "data-name": "query-name", value: data.Name ?? '', autoFocus: true, className: "twa:max-w-[300px] twa:w-full", type: "text", placeholder: "Enter name for Named Query", onChange: handleNameChange }) })] }), _jsxs(Card, { shadow: false, children: [_jsxs(Card.Title, { children: [_jsx(Box, { className: "twa:font-medium", children: "Description" }), _jsx(Box, { className: "twa:text-xs twa:opacity-70 twa:font-normal twa:max-w-[520px]", children: "Short explanation shown when picking this Named Query in the Expression Editor" })] }), _jsx(Card.Body, { className: "twa:p-1", children: _jsx(Input, { "data-name": "query-description", value: data.Description ?? '', className: "twa:max-w-[520px] twa:w-full", type: "text", placeholder: "Enter description (optional)", onChange: handleDescriptionChange }) })] }), _jsxs(Card, { shadow: false, children: [_jsxs(Card.Title, { children: [_jsx(Box, { className: "twa:font-medium", children: "Result Type" }), _jsx(Box, { className: "twa:text-xs twa:opacity-70 twa:font-normal twa:max-w-[520px]", children: "The data type this Named Query returns" })] }), _jsxs(Card.Body, { className: "twa:p-1 twa:gap-1", children: [_jsxs(Flex, { alignItems: "center", className: "twa:gap-2", children: [_jsx(SingleSelect, { "data-name": "named-query-return-type", placeholder: "Select Result Type", items: RETURN_TYPE_OPTIONS, value: returnType, onValueChange: (value) => {
+                                                setInferHint(null);
+                                                props.onChange({ ...data, ReturnType: value });
+                                            }, className: "twa:max-w-[300px]" }), _jsx(SimpleButton, { variant: "outlined", icon: "refresh", tooltip: "Evaluate the Expression and set the Result Type from the result", disabled: !data.Expression, onClick: () => {
+                                                const inferred = suggestNamedQueryReturnTypeFromExpression(api, data.Expression);
+                                                if (!inferred) {
+                                                    setInferHint('Could not detect the type from the current expression.');
+                                                    return;
+                                                }
+                                                setInferHint(`Detected as ${inferred}`);
+                                                props.onChange({ ...data, ReturnType: inferred });
+                                            }, children: "Detect from Expression" })] }), inferHint ? _jsx(Box, { className: "twa:text-2 twa:opacity-70", children: inferHint }) : null] })] })] }) }));
 };

package/src/View/NamedQuery/Wizard/NamedQueryWizard.js

@@ -16,6 +16,8 @@ export function NamedQueryWizard(props) {
             ? cloneObject(props.data)
             : ObjectFactory.CreateEmptyNamedQuery(value);
     });
+    const defaultCurrentSectionName = props.defaultCurrentSectionName ??
+        props.popupParams?.config?.defaultCurrentSectionName;
     const dispatch = useDispatch();
     const handleFinish = () => {
         if (props.data) {
@@ -26,7 +28,7 @@ export function NamedQueryWizard(props) {
         }
         props.onFinishWizard(namedQuery);
     };
-    return (_jsx(OnePageAdaptableWizard, { defaultCurrentSectionName: props.defaultCurrentSectionName, onFinish: handleFinish, sections: [
+    return (_jsx(OnePageAdaptableWizard, { defaultCurrentSectionName: defaultCurrentSectionName, onFinish: handleFinish, sections: [
             {
                 title: 'Expression',
                 details: "Build the Named Query's Expression",
@@ -35,8 +37,8 @@ export function NamedQueryWizard(props) {
                 render: () => _jsx(NamedQueryExpressionWizardSection, { onChange: setNamedQuery }),
             },
             {
-                title: 'Query Name',
-                details: 'Specify a unique Name for the Named Query',
+                title: 'Settings',
+                details: 'Specify Named Query Properties',
                 renderSummary: renderNamedQuerySettingsSummary,
                 isValid: isValidNamedQuerySettings,
                 render: () => _jsx(NamedQuerySettingsWizardSection, { onChange: setNamedQuery }),

package/src/View/Note/NotePopup.js

@@ -1,14 +1,17 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import * as React from 'react';
 import { useSelector } from 'react-redux';
 import { DataSource, InfiniteTableGrid } from '../../components/InfiniteTable';
 import { GetAllNotesSelector } from '../../Redux/ActionsReducers/NoteRedux';
 import { useAdaptable } from '../AdaptableContext';
+import { getColorByMessageType } from '../../Utilities/Helpers/UIHelper';
+import { SingleSelect } from '../../components/Select';
 import { AdaptableButtonComponent } from '../Components/AdaptableButton';
 import { PopupPanel } from '../Components/Popups/AdaptablePopup/PopupPanel';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import FormatHelper from '../../Utilities/Helpers/DisplayFormatHelper';
 import { ACCESS_LEVEL_READ_ONLY } from '../../Utilities/Constants/GeneralConstants';
+const NOTE_TYPES = ['Info', 'Warning', 'Error', 'Success'];
 const tableDOMProps = {
     style: {
         height: '100%',
@@ -56,10 +59,50 @@ export const NotePopup = (props) => {
                 defaultEditable: !isReadOnlyModule,
                 defaultFlex: 3,
             },
-            timestamp: {
-                field: 'Timestamp',
+            noteType: {
+                field: 'NoteType',
+                header: 'Type',
+                defaultWidth: 130,
+                render: (params) => {
+                    const noteType = params.data.NoteType ?? 'Info';
+                    const withDot = (type) => (_jsxs("span", { style: { display: 'inline-flex', alignItems: 'center', gap: 6 }, children: [_jsx("span", { style: {
+                                    width: 8,
+                                    height: 8,
+                                    borderRadius: '50%',
+                                    background: getColorByMessageType(type),
+                                    flex: '0 0 auto',
+                                } }), type] }));
+                    if (isReadOnlyModule) {
+                        return withDot(noteType);
+                    }
+                    return (_jsx(SingleSelect, { size: "small", className: "twa:w-full", value: noteType, onValueChange: (value) => {
+                            const note = adaptable.api.noteApi.getNoteByUuid(params.data.Uuid);
+                            if (note) {
+                                adaptable.api.noteApi.setNoteType(note, value);
+                            }
+                        }, renderValue: (item) => withDot(item.value), items: NOTE_TYPES.map((type) => ({
+                            value: type,
+                            label: withDot(type),
+                            ariaLabel: type,
+                        })) }));
+                },
+            },
+            createdAt: {
+                field: 'CreatedAt',
+                header: 'Created',
+                valueGetter: (params) => {
+                    return params.data.CreatedAt == null
+                        ? ''
+                        : formatDate(params.data.CreatedAt, adaptable.api.noteApi.internalApi.getNotesDateFormat());
+                },
+            },
+            updatedAt: {
+                field: 'UpdatedAt',
+                header: 'Last Updated',
                 valueGetter: (params) => {
-                    return formatDate(params.data.Timestamp, adaptable.api.noteApi.internalApi.getNotesDateFormat());
+                    return params.data.UpdatedAt == null
+                        ? ''
+                        : formatDate(params.data.UpdatedAt, adaptable.api.noteApi.internalApi.getNotesDateFormat());
                 },
             },
             delete: {

package/src/View/Note/NoteStatusPanel.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+/**
+ * Status Bar panel for Notes. Shows the number of Notes; clicking opens the Settings Panel
+ * on the Notes page.
+ */
+export declare const NoteStatusPanel: () => React.JSX.Element;

package/src/View/Note/NoteStatusPanel.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { useSelector } from 'react-redux';
+import { useAdaptable } from '../AdaptableContext';
+import { StatusBarPanel } from '../StatusBar/StatusBarPanel';
+import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
+import { GetAllNotesSelector } from '../../Redux/ActionsReducers/NoteRedux';
+export const NoteStatusPanel = () => {
+    const adaptableApi = useAdaptable().api;
+    const module = adaptableApi.internalApi
+        .getModuleService()
+        .getModuleById(ModuleConstants.NoteModuleId);
+    const noteCount = useSelector((state) => GetAllNotesSelector(state.Note).length);
+    const text = noteCount === 1 ? '1 Note' : `${noteCount} Notes`;
+    const handleAction = React.useCallback(() => adaptableApi.settingsPanelApi.openSettingsPanel('Note'), []);
+    return (_jsx(StatusBarPanel, { tooltip: module.moduleInfo.FriendlyName, "data-name": module.moduleInfo.ModuleName, onAction: handleAction, icon: module.moduleInfo.Glyph, content: text }));
+};

package/src/View/Note/NoteViewPanel.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { ViewPanelProps } from '../Components/SharedProps/ViewPanelProps';
+/**
+ * Dashboard Toolbar / Tool Panel for Notes. Shows the number of Notes in a neutral count box
+ * (sized to match the Alert toolbar) that, when clicked, opens Notes in the resolved panel
+ * (Grid Settings / adaptableId / explicit title).
+ */
+export declare const NoteViewPanelControl: React.FunctionComponent<ViewPanelProps>;

package/src/View/Note/NoteViewPanel.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSelector } from 'react-redux';
+import { cn } from '../../lib/utils';
+import { Flex } from '../../components/Flex';
+import { GetAllNotesSelector } from '../../Redux/ActionsReducers/NoteRedux';
+import SimpleButton from '../../components/SimpleButton';
+import { getOpenModuleInPanelLabel } from '../../Utilities/Helpers/SettingsPanelHelper';
+export const NoteViewPanelControl = (props) => {
+    const noteCount = useSelector((state) => GetAllNotesSelector(state.Note).length);
+    const isToolbar = props.viewType === 'Toolbar';
+    const elementType = isToolbar ? 'DashboardToolbar' : 'ToolPanel';
+    const label = noteCount === 1 ? '1 Note' : `${noteCount} Notes`;
+    const openNotesLabel = getOpenModuleInPanelLabel('Notes', props.api.optionsApi.getSettingsPanelOptions().title);
+    return (_jsx(Flex, { alignItems: "center", className: cn(`ab-${elementType}__Note__wrap twa:gap-1`, {
+            'twa:min-w-[120px]': isToolbar,
+            'twa:flex-1': !isToolbar,
+        }), children: _jsx(SimpleButton, { variant: "text", tone: "none", tooltip: openNotesLabel, "aria-label": openNotesLabel, onClick: () => props.api.settingsPanelApi.openSettingsPanel('Note'), className: `ab-${elementType}__Note__text twa:flex-1 twa:justify-center twa:rounded-standard text-2 twa:min-h-input twa:bg-foreground/5`, children: label }) }));
+};

package/src/View/ObjectItemViews/Alert/getAlertBehaviourViewItems.d.ts

@@ -0,0 +1,3 @@
+import { AdaptableApi } from '../../../types';
+import { AdaptableObjectItemView } from '../../../Strategy/Interface/IModule';
+export declare const getAlertBehaviourViewItems: (api: AdaptableApi) => AdaptableObjectItemView;

package/src/View/ObjectItemViews/Alert/getAlertPreviewViewItems.d.ts

@@ -0,0 +1,4 @@
+import { AdaptableApi } from '../../../types';
+import { AlertDefinition } from '../../../AdaptableState/AlertState';
+import { AdaptableObjectItemView } from '../../../Strategy/Interface/IModule';
+export declare const getAlertPreviewViewItems: (alert: AlertDefinition, api: AdaptableApi) => AdaptableObjectItemView;

package/src/View/ObjectItemViews/CustomSort/getCustomSortColumnViewItems.d.ts

@@ -0,0 +1,6 @@
+import { AdaptableApi, CustomSort } from '../../../../types';
+export declare const getCustomSortColumnViewItems: (customSort: CustomSort, api: AdaptableApi) => {
+    name: string;
+    values: string[];
+    tagVariant: "accent";
+};

package/src/View/ObjectItemViews/CustomSort/getCustomSortColumnViewItems.js

@@ -0,0 +1,7 @@
+export const getCustomSortColumnViewItems = (customSort, api) => {
+    return {
+        name: 'Column',
+        values: [api.columnApi.getFriendlyNameForColumnId(customSort.ColumnId)],
+        tagVariant: 'accent',
+    };
+};

package/src/View/ObjectItemViews/Export/formatScheduledReportSummary.js

@@ -0,0 +1,6 @@
+import UIHelper from '../../../Utilities/Helpers/UIHelper';
+export function formatScheduledReportSummary(reportSchedule) {
+    const scheduleText = UIHelper.getScheduleDescription(reportSchedule.Schedule);
+    const suspendedSuffix = reportSchedule.IsSuspended ? ' (Suspended)' : '';
+    return `${reportSchedule.ReportFormat} → ${reportSchedule.ExportDestination}: ${scheduleText}${suspendedSuffix}`;
+}

package/src/View/ObjectItemViews/Export/getExportColumnsViewItems.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import { AdaptableObjectItemView } from '../../../Strategy/Interface/IModule';
+import { AdaptableApi, Report } from '../../../../types';
+export declare const getExportColumnsViewItems: (report: Report, api: AdaptableApi) => AdaptableObjectItemView;
+export declare const renderExportColumnsView: (report: Report, api: AdaptableApi) => React.ReactNode;

package/src/View/ObjectItemViews/Export/getExportColumnsViewItems.js

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { TagList } from '../../../components/Tag/Tag';
+import { reportColumnTagsUseAccentVariant } from '../../../components/Tag/columnScopeTagHelpers';
+export const getExportColumnsViewItems = (report, api) => {
+    return {
+        name: 'Columns',
+        values: [...api.exportApi.internalApi.getReportColumnScopeShortDescription(report)],
+        tagVariant: reportColumnTagsUseAccentVariant(report) ? 'accent' : undefined,
+    };
+};
+export const renderExportColumnsView = (report, api) => {
+    const { values } = getExportColumnsViewItems(report, api);
+    if (!values?.length) {
+        return null;
+    }
+    return React.createElement(TagList, {
+        tags: values,
+        variant: reportColumnTagsUseAccentVariant(report) ? 'accent' : undefined,
+    });
+};

package/src/View/ObjectItemViews/Export/getExportRowsViewItems.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExpressionPreview } from '../../../components/aql/ExpressionEditor/ExpressionPreview';
+import { ExpressionTag, Tag } from '../../../components/Tag';
+export const getExportRowsViewItems = (report, api) => {
+    if (report.ReportRowScope === 'ExpressionRows') {
+        return {
+            name: 'Rows',
+            view: (_jsx(ExpressionTag, { children: _jsx(ExpressionPreview, { expression: report.Expression }) })),
+        };
+    }
+    return {
+        name: 'Rows',
+        view: (_jsx(Tag, { children: api.exportApi.internalApi.getReportExpressionDescription(report, api.columnApi.getColumns()) })),
+    };
+};
+export const renderExportRowsView = (report, api) => {
+    return getExportRowsViewItems(report, api).view;
+};

package/src/View/ObjectItemViews/FlashingCell/getFlashingCellStyleViewItems.d.ts

@@ -0,0 +1,2 @@
+import { AdaptableObjectItemView } from '../../../Strategy/Interface/IModule';
+export declare const getFlashingCellStyleViewItems: () => AdaptableObjectItemView;

package/src/View/ObjectItemViews/FlashingCell/getFlashingTargetViewItems.d.ts

@@ -0,0 +1,5 @@
+import { FlashingCellDefinition } from '../../../types';
+export declare const getFlashingTargetViewItems: (flashingCell: FlashingCellDefinition) => {
+    name: string;
+    values: import("../../../types").FlashTargetTypes[];
+};

package/src/View/ObjectItemViews/Layout/columnsSummaryHelpers.d.ts

@@ -0,0 +1,48 @@
+import { AdaptableApi, Layout, TableLayout } from '../../../types';
+export declare const TABLE_COLUMNS_SETTINGS_PANEL_LABELS: {
+    visibility: string;
+    pinning: string;
+    sizing: string;
+    sorting: string;
+};
+export declare const TABLE_COLUMNS_WIZARD_SUBSECTION_LABELS: {
+    visibility: string;
+    pinning: string;
+    sizing: string;
+    sorting: string;
+};
+export type TableColumnsSummaryLabels = {
+    readonly visibility: string;
+    readonly pinning: string;
+    readonly sizing: string;
+    readonly sorting: string;
+};
+export type TableColumnsSummaryGroup = {
+    label: string;
+    values: string[];
+    emptyLabel: string;
+};
+export declare function getTableColumnsVisibilitySummaryValues(layout: TableLayout, api: AdaptableApi): string[];
+export declare function getTableColumnsPinningSummaryValues(layout: Layout, api: AdaptableApi): string[];
+export declare function getTableColumnsSizingSummaryValues(layout: Layout, api: AdaptableApi): string[];
+export declare function getTableColumnsSortingSummaryValues(layout: Layout, api: AdaptableApi): string[];
+/** Matches legacy Layout settings panel behaviour (`layoutViewOptions.maxColumnsToDisplay`). */
+export declare const DEFAULT_LAYOUT_VIEW_MAX_COLUMNS = 10;
+/**
+ * Collapse a long column list for compact views (e.g. Layout settings panel).
+ * Keeps all items when the overflow is only 1 column; otherwise shows `+N more`.
+ */
+export declare function truncateColumnSummaryValues(values: string[], maxToDisplay?: number): string[];
+export declare function getTableColumnsSummaryGroups(layout: TableLayout, api: AdaptableApi, labels?: TableColumnsSummaryLabels): TableColumnsSummaryGroup[];
+export declare function getLayoutTableColumnsViewItems(layout: Layout, api: AdaptableApi, options?: {
+    maxColumnsToDisplay?: number;
+}): {
+    name: string;
+    values: string[];
+    tagVariant: "accent";
+}[];
+export declare function getLayoutPivotSortingViewItem(layout: Layout, api: AdaptableApi): {
+    name: string;
+    values: string[];
+    tagVariant: "accent";
+};

package/src/View/ObjectItemViews/Layout/columnsSummaryHelpers.js

@@ -0,0 +1,161 @@
+export const TABLE_COLUMNS_SETTINGS_PANEL_LABELS = {
+    visibility: 'Columns',
+    pinning: 'Pinning',
+    sizing: 'Sizing',
+    sorting: 'Sorting',
+};
+export const TABLE_COLUMNS_WIZARD_SUBSECTION_LABELS = {
+    visibility: 'Visibility and Order',
+    pinning: 'Pinning',
+    sizing: 'Sizing',
+    sorting: 'Sorting',
+};
+function resolveDefaultColumnWidth(api) {
+    return (columnId) => api.internalApi.getAdaptableInstance().getDefaultColumnWidthForCol(columnId);
+}
+function hasExplicitLayoutSizing(columnId, sizing, resolveDefaultWidth) {
+    if (!sizing) {
+        return false;
+    }
+    if (sizing.Flex != null) {
+        return true;
+    }
+    if (sizing.MinWidth != null || sizing.MaxWidth != null) {
+        return true;
+    }
+    if (sizing.Width != null) {
+        return sizing.Width !== resolveDefaultWidth(columnId);
+    }
+    return false;
+}
+function getLayoutExplicitSizedColumnIds(layout, resolveDefaultWidth) {
+    const sizing = layout.ColumnSizing ?? {};
+    return Object.keys(sizing).filter((columnId) => hasExplicitLayoutSizing(columnId, sizing[columnId], resolveDefaultWidth));
+}
+function formatExplicitColumnSizingBrief(columnId, sizing, resolveDefaultWidth) {
+    if (!hasExplicitLayoutSizing(columnId, sizing, resolveDefaultWidth)) {
+        return '';
+    }
+    const parts = [];
+    if (sizing?.Flex != null) {
+        parts.push(`flex ${sizing.Flex}`);
+    }
+    else if (sizing?.Width != null && sizing.Width !== resolveDefaultWidth(columnId)) {
+        parts.push(String(sizing.Width));
+    }
+    if (sizing?.MinWidth != null) {
+        parts.push(`min ${sizing.MinWidth}`);
+    }
+    if (sizing?.MaxWidth != null) {
+        parts.push(`max ${sizing.MaxWidth}`);
+    }
+    return parts.join(', ');
+}
+function getLayoutTableColumnIds(layout, api) {
+    return (layout.TableColumns ?? [])
+        .filter((columnId) => !api.columnApi.isAutoRowGroupColumn(columnId))
+        .filter((columnId) => !api.columnApi.isPivotResultColumn(columnId))
+        .filter((columnId) => !api.columnApi.isSelectionColumn(columnId));
+}
+function getLayoutPinnedColumnIds(layout, side) {
+    const pinning = layout.ColumnPinning ?? {};
+    return Object.entries(pinning)
+        .filter(([, pin]) => pin === side)
+        .map(([columnId]) => columnId);
+}
+export function getTableColumnsVisibilitySummaryValues(layout, api) {
+    return getLayoutTableColumnIds(layout, api).map((columnId) => {
+        const name = api.columnApi.getFriendlyNameForColumnId(columnId, layout);
+        const customHeader = layout.ColumnHeaders?.[columnId]?.trim();
+        if (customHeader) {
+            return `${name} (header: ${customHeader})`;
+        }
+        return name;
+    });
+}
+export function getTableColumnsPinningSummaryValues(layout, api) {
+    const leftPinned = getLayoutPinnedColumnIds(layout, 'left');
+    const rightPinned = getLayoutPinnedColumnIds(layout, 'right');
+    return [
+        ...leftPinned.map((columnId) => `${api.columnApi.getFriendlyNameForColumnId(columnId, layout)} (left)`),
+        ...rightPinned.map((columnId) => `${api.columnApi.getFriendlyNameForColumnId(columnId, layout)} (right)`),
+    ];
+}
+export function getTableColumnsSizingSummaryValues(layout, api) {
+    const resolveDefaultWidth = resolveDefaultColumnWidth(api);
+    return getLayoutExplicitSizedColumnIds(layout, resolveDefaultWidth).map((columnId) => {
+        const name = api.columnApi.getFriendlyNameForColumnId(columnId, layout);
+        const sizingBrief = formatExplicitColumnSizingBrief(columnId, layout.ColumnSizing?.[columnId], resolveDefaultWidth);
+        return `${name} (${sizingBrief})`;
+    });
+}
+export function getTableColumnsSortingSummaryValues(layout, api) {
+    return (layout.ColumnSorts ?? []).map((sort) => `[${api.columnApi.getFriendlyNameForColumnId(sort.ColumnId, layout)}: ${sort.SortOrder}]`);
+}
+export const DEFAULT_LAYOUT_VIEW_MAX_COLUMNS = 10;
+export function truncateColumnSummaryValues(values, maxToDisplay = DEFAULT_LAYOUT_VIEW_MAX_COLUMNS) {
+    if (maxToDisplay <= 0 || values.length <= maxToDisplay + 1) {
+        return values;
+    }
+    const extra = values.length - maxToDisplay;
+    return [...values.slice(0, maxToDisplay), `+${extra} more`];
+}
+export function getTableColumnsSummaryGroups(layout, api, labels = TABLE_COLUMNS_SETTINGS_PANEL_LABELS) {
+    return [
+        {
+            label: labels.visibility,
+            values: getTableColumnsVisibilitySummaryValues(layout, api),
+            emptyLabel: 'No columns in this Layout',
+        },
+        {
+            label: labels.pinning,
+            values: getTableColumnsPinningSummaryValues(layout, api),
+            emptyLabel: 'No columns pinned in this Layout',
+        },
+        {
+            label: labels.sizing,
+            values: getTableColumnsSizingSummaryValues(layout, api),
+            emptyLabel: 'All columns use default sizing in this Layout',
+        },
+        {
+            label: labels.sorting,
+            values: getTableColumnsSortingSummaryValues(layout, api),
+            emptyLabel: 'No column sorts in this Layout',
+        },
+    ];
+}
+export function getLayoutTableColumnsViewItems(layout, api, options) {
+    const maxColumnsToDisplay = options?.maxColumnsToDisplay ?? DEFAULT_LAYOUT_VIEW_MAX_COLUMNS;
+    const optionalRowLabels = new Set([
+        TABLE_COLUMNS_SETTINGS_PANEL_LABELS.pinning,
+        TABLE_COLUMNS_SETTINGS_PANEL_LABELS.sizing,
+        TABLE_COLUMNS_SETTINGS_PANEL_LABELS.sorting,
+    ]);
+    return getTableColumnsSummaryGroups(layout, api).flatMap(({ label, values, emptyLabel }) => {
+        if (optionalRowLabels.has(label) && !values.length) {
+            return [];
+        }
+        const resolvedValues = values.length ? values : [emptyLabel];
+        const displayValues = label === TABLE_COLUMNS_SETTINGS_PANEL_LABELS.visibility
+            ? truncateColumnSummaryValues(resolvedValues, maxColumnsToDisplay)
+            : resolvedValues;
+        return [
+            {
+                name: label,
+                values: displayValues,
+                tagVariant: 'accent',
+            },
+        ];
+    });
+}
+export function getLayoutPivotSortingViewItem(layout, api) {
+    const values = getTableColumnsSortingSummaryValues(layout, api);
+    if (!values.length) {
+        return null;
+    }
+    return {
+        name: 'Sorting',
+        values,
+        tagVariant: 'accent',
+    };
+}

package/src/View/ObjectItemViews/Layout/getLayoutFilterViewItems.d.ts

@@ -0,0 +1,12 @@
+import { AdaptableApi, Layout } from '../../../../types';
+import { ColumnFilter } from '../../../types';
+/**
+ * Human-readable one-line preview for a column filter (layout wizard, module
+ * summaries). Uses `QlPredicate` labelling — never the retired QlFilter path.
+ */
+export declare const getColumnFilterExpressionPreview: (columnFilter: ColumnFilter, api: AdaptableApi) => string | null;
+export declare const getFilterPreview: (columnFilter: ColumnFilter, api: AdaptableApi) => string;
+export declare const getLayoutFilterViewItems: (layout: Layout, api: AdaptableApi) => {
+    name: string;
+    values: string[];
+};