@adaptabletools/adaptable 18.0.0-canary.12 → 18.0.0-canary.13

package/src/View/Layout/Wizard/sections/RowSummarySection.js

@@ -0,0 +1,140 @@
+import * as React from 'react';
+import { Box, Flex } from 'rebass';
+import FormLayout, { FormRow } from '../../../../components/FormLayout';
+import Panel from '../../../../components/Panel';
+import { Select } from '../../../../components/Select';
+import SimpleButton from '../../../../components/SimpleButton';
+import { Tabs } from '../../../../components/Tabs';
+import { Tag } from '../../../../components/Tag';
+import { mapColumnDataTypeToExpressionFunctionType } from '../../../../Utilities/adaptableQlUtils';
+import { LayoutModuleId } from '../../../../Utilities/Constants/ModuleConstants';
+import { summarySupportedExpressions } from '../../../../Utilities/Services/SummaryService';
+import { sortWithOrderArray } from '../../../../Utilities/sortWithOrder';
+import { useAdaptable } from '../../../AdaptableContext';
+import { ValueSelector } from '../../../Components/ValueSelector';
+import { useOnePageAdaptableWizardContext } from '../../../Wizard/OnePageAdaptableWizard';
+import { columnFilter } from './Utilities';
+const getAvailableExpressionsForColumnType = (columnType, availableScalarExpressions) => {
+    const inputType = mapColumnDataTypeToExpressionFunctionType(columnType);
+    return Object.entries(availableScalarExpressions !== null && availableScalarExpressions !== void 0 ? availableScalarExpressions : {})
+        .map(([expression, expressionDef]) => {
+        var _a, _b;
+        let firstArg = null;
+        if (!summarySupportedExpressions.includes(expression)) {
+            return null;
+        }
+        if (Array.isArray((_a = expressionDef === null || expressionDef === void 0 ? void 0 : expressionDef.inputs) === null || _a === void 0 ? void 0 : _a[0])) {
+            // @ts-ignore
+            firstArg = (_b = expressionDef.inputs.find((input) => input.includes(inputType))) === null || _b === void 0 ? void 0 : _b[0];
+        }
+        else {
+            firstArg = expressionDef.inputs[0];
+        }
+        if (inputType === firstArg) {
+            return expression;
+        }
+        else {
+            return null;
+        }
+    })
+        .filter(Boolean);
+};
+export const RowGroupingSectionSummary = () => {
+    var _a;
+    const adaptable = useAdaptable();
+    const { data: layout } = useOnePageAdaptableWizardContext();
+    return (React.createElement(Box, null, ((_a = layout.RowGroupedColumns) === null || _a === void 0 ? void 0 : _a.length) ? (layout.RowGroupedColumns.map((columnId) => (React.createElement(Tag, { mr: 1, key: columnId }, adaptable.api.columnApi.getFriendlyNameForColumnId(columnId))))) : (React.createElement(Tag, null, "No Row Grouping"))));
+};
+const RowSummaryEditor = ({ rowSummary, onChange, availableScalarExpressions, onDelete, }) => {
+    const { data: layout } = useOnePageAdaptableWizardContext();
+    const adaptable = useAdaptable();
+    const columns = React.useMemo(() => {
+        const colIds = adaptable.api.columnApi
+            .getColumns()
+            .filter((column) => {
+            var _a, _b;
+            if (!['Number', 'String'].includes(column.dataType))
+                return false;
+            return (_b = (_a = layout.Columns) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, column.columnId);
+        })
+            .map((c) => c.columnId);
+        return sortWithOrderArray(colIds, Object.keys(rowSummary.ColumnsMap), {
+            sortUnorderedItems: false,
+        }).map((colId) => adaptable.api.columnApi.getColumnWithColumnId(colId));
+    }, [rowSummary.ColumnsMap]);
+    return (React.createElement(Panel, { header: React.createElement(Flex, { style: { width: '100%' } },
+            React.createElement(Flex, { flex: 1, alignItems: "center" }, "Row Summary"),
+            React.createElement(SimpleButton, { icon: "delete", onClick: () => {
+                    onDelete();
+                } })), p: 2 },
+        React.createElement(FormLayout, null,
+            React.createElement(FormRow, { label: "Position" },
+                React.createElement(Select, { options: [
+                        {
+                            label: 'Top',
+                            value: 'Top',
+                        },
+                        {
+                            label: 'Bottom',
+                            value: 'Bottom',
+                        },
+                    ], value: rowSummary.Position, onChange: (position) => {
+                        onChange(Object.assign(Object.assign({}, rowSummary), { Position: position }));
+                    } }))),
+        React.createElement(Flex, { flexDirection: 'column', mt: 2, mb: 1 },
+            React.createElement(Flex, { alignItems: "center", flex: 1, mb: 2 }, "Column Aggregations"),
+            React.createElement(Panel, { bodyProps: { maxHeight: '100%' }, style: { height: 360 } },
+                React.createElement(ValueSelector, { style: { maxHeight: '100%' }, showFilterInput: true, filter: columnFilter, toIdentifier: (column) => column.columnId, toLabel: (option) => { var _a; return (_a = option.friendlyName) !== null && _a !== void 0 ? _a : option.columnId; }, options: columns, xSelectedLabel: () => {
+                        return 'Active Aggregations:';
+                    }, toListLabel: (column) => {
+                        var _a, _b;
+                        const label = (_a = column.friendlyName) !== null && _a !== void 0 ? _a : column.columnId;
+                        if (!(column.columnId in ((_b = rowSummary.ColumnsMap) !== null && _b !== void 0 ? _b : {}))) {
+                            return label;
+                        }
+                        const expressionOptions = getAvailableExpressionsForColumnType(column.dataType, availableScalarExpressions).map((expression) => ({
+                            label: expression,
+                            value: expression,
+                        }));
+                        const expression = rowSummary.ColumnsMap[column.columnId];
+                        return (React.createElement(Flex, null,
+                            React.createElement(Flex, { mr: 2, alignItems: 'center' }, label),
+                            React.createElement(Select, { value: expression, options: expressionOptions, onChange: (expression) => {
+                                    onChange(Object.assign(Object.assign({}, rowSummary), { ColumnsMap: Object.assign(Object.assign({}, rowSummary.ColumnsMap), { [column.columnId]: expression }) }));
+                                } })));
+                    }, value: Object.keys(rowSummary.ColumnsMap), onChange: (colIds) => {
+                        const newColumnsMap = {};
+                        colIds.forEach((colId) => {
+                            var _a;
+                            newColumnsMap[colId] = (_a = rowSummary.ColumnsMap[colId]) !== null && _a !== void 0 ? _a : null;
+                        });
+                        onChange(Object.assign(Object.assign({}, rowSummary), { ColumnsMap: newColumnsMap }));
+                    } })))));
+};
+export const RowSummarySection = (props) => {
+    const adaptable = useAdaptable();
+    const { data: layout } = useOnePageAdaptableWizardContext();
+    const availableScalarExpressions = React.useMemo(() => {
+        return adaptable.api.internalApi
+            .getQueryLanguageService()
+            .getModuleExpressionFunctionsMap(LayoutModuleId).aggregatedScalarFunctions;
+    }, []);
+    return (React.createElement(Tabs, { style: { height: '100%' } },
+        React.createElement(Tabs.Tab, null, "Row Summaries"),
+        React.createElement(Tabs.Content, null,
+            React.createElement("div", null,
+                React.createElement(Flex, { mb: 1 },
+                    React.createElement(Flex, { flex: 1 }),
+                    React.createElement(SimpleButton, { icon: "plus" }, "Add Row Summary")),
+                layout.RowSummaries.map((rowSummary, index) => {
+                    return (React.createElement(RowSummaryEditor, { key: index, onDelete: () => {
+                            const newSummaries = [...layout.RowSummaries];
+                            newSummaries.splice(index, 1);
+                            props.onChange(Object.assign(Object.assign({}, layout), { RowSummaries: newSummaries }));
+                        }, availableScalarExpressions: availableScalarExpressions, rowSummary: rowSummary, onChange: (rowSummary) => {
+                            const newSummaries = [...layout.RowSummaries];
+                            newSummaries[index] = rowSummary;
+                            props.onChange(Object.assign(Object.assign({}, layout), { RowSummaries: newSummaries }));
+                        } }));
+                })))));
+};

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

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const NotePopup: React.FunctionComponent;

package/src/View/{Notes/NotesPopup.js → Note/NotePopup.js}

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { useSelector } from 'react-redux';
 import { DataSource, InfiniteTable } from '../../components/InfiniteTable';
-import { GetAllNotesSelector } from '../../Redux/ActionsReducers/NotesRedux';
+import { GetAllNotesSelector } from '../../Redux/ActionsReducers/NoteRedux';
 import { useAdaptable } from '../AdaptableContext';
 import { AdaptableButtonComponent } from '../Components/AdaptableButton';
 import { PopupPanel } from '../Components/Popups/AdaptablePopup/PopupPanel';
@@ -12,10 +12,10 @@ const tableDOMProps = {
         // minHeight: 600,
     },
 };
-export const NotesPopup = (props) => {
+export const NotePopup = (props) => {
     const adaptable = useAdaptable();
     const primaryKeyHeader = adaptable.api.columnApi.getFriendlyNameForColumnId(adaptable.api.columnApi.getPrimaryKeyColumn().columnId);
-    const allNotes = useSelector((state) => GetAllNotesSelector(state.Notes));
+    const allNotes = useSelector((state) => GetAllNotesSelector(state.Note));
     const columnsMap = React.useMemo(() => {
         const columns = {
             primaryKey: {

package/src/agGrid/AdaptableAgGrid.js

@@ -59,12 +59,12 @@ import { ColumnInfoModule } from '../Strategy/ColumnInfoModule';
 import { SettingsPanelModule } from '../Strategy/SettingsPanelModule';
 import { StatusBarModule } from '../Strategy/StatusBarModule';
 import { ChartingModule } from '../Strategy/ChartingModule';
-import { NotesModule } from '../Strategy/NotesModule';
+import { NoteModule } from '../Strategy/NoteModule';
 import { StyledColumnModule } from '../Strategy/StyledColumnModule';
 import { Fdc3Module } from '../Strategy/Fdc3Module';
 import { GridFilterModule } from '../Strategy/GridFilterModule';
 import { NamedQueryModule } from '../Strategy/NamedQueryModule';
-import { CommentsModule } from '../Strategy/CommentsModule';
+import { CommentModule } from '../Strategy/CommentModule';
 import { AdaptableNumberEditor, ReactAdaptableNumberEditor } from './editors/AdaptableNumberEditor';
 import { AdaptableDateEditor, ReactAdaptableDateEditor } from './editors/AdaptableDateEditor';
 import { Helper } from '../Utilities/Helpers/Helper';
@@ -1581,7 +1581,7 @@ export class AdaptableAgGrid {
         modules.set(ModuleConstants.ChartingModuleId, new ChartingModule(this.api));
         modules.set(ModuleConstants.ColumnFilterModuleId, new ColumnFilterModule(this.api));
         modules.set(ModuleConstants.ColumnInfoModuleId, new ColumnInfoModule(this.api));
-        modules.set(ModuleConstants.CommentsModuleId, new CommentsModule(this.api));
+        modules.set(ModuleConstants.CommentModuleId, new CommentModule(this.api));
         modules.set(ModuleConstants.CustomSortModuleId, new CustomSortModule(this.api));
         modules.set(ModuleConstants.DashboardModuleId, new DashboardModule(this.api));
         modules.set(ModuleConstants.DataChangeHistoryModuleId, new DataChangeHistoryModule(this.api));
@@ -1596,7 +1596,7 @@ export class AdaptableAgGrid {
         modules.set(ModuleConstants.GridInfoModuleId, new GridInfoModule(this.api));
         modules.set(ModuleConstants.LayoutModuleId, new LayoutModule(this.api));
         modules.set(ModuleConstants.NamedQueryModuleId, new NamedQueryModule(this.api));
-        modules.set(ModuleConstants.NotesModuleId, new NotesModule(this.api));
+        modules.set(ModuleConstants.NoteModuleId, new NoteModule(this.api));
         modules.set(ModuleConstants.PlusMinusModuleId, new PlusMinusModule(this.api));
         modules.set(ModuleConstants.QuickSearchModuleId, new QuickSearchModule(this.api));
         modules.set(ModuleConstants.ScheduleModuleId, new ScheduleModule(this.api));

package/src/agGrid/AgGridAdapter.d.ts

@@ -60,4 +60,5 @@ export declare class AgGridAdapter {
      * Mutates the colDefs to ensure that each column has a colId
      */
     assignColumnIdsToColDefs(colDefs?: (ColDef | ColGroupDef)[]): void;
+    getDefaultColumnDefinition(): GridOptions['defaultColDef'];
 }

package/src/agGrid/AgGridAdapter.js

@@ -577,4 +577,9 @@ export class AgGridAdapter {
         };
         colDefs.forEach((colDef) => assignColId(colDef));
     }
+    getDefaultColumnDefinition() {
+        var _a, _b;
+        // for early init phase, gridApi might not be ready yet
+        return (_b = (_a = this.getAgGridApi(true)) === null || _a === void 0 ? void 0 : _a.getGridOption('defaultColDef')) !== null && _b !== void 0 ? _b : {};
+    }
 }

package/src/agGrid/AgGridColumnAdapter.js

@@ -603,7 +603,7 @@ export class AgGridColumnAdapter {
                     : undefined;
     }
     getNoteCellClassName(gridCell, params) {
-        if (!this.adaptableApi.internalApi.getModuleService().isModuleAvailable('Notes')) {
+        if (!this.adaptableApi.internalApi.getModuleService().isModuleAvailable('Note')) {
             return;
         }
         if (!this.adaptableApi.noteApi.internalApi.areNotesAvailable()) {
@@ -613,14 +613,14 @@ export class AgGridColumnAdapter {
             PrimaryKeyValue: gridCell.primaryKeyValue,
             ColumnId: gridCell.column.columnId,
         };
-        const cellNotes = this.adaptableApi.noteApi.getCellNotes(cellPosition);
+        const cellNotes = this.adaptableApi.noteApi.getNotesForCell(cellPosition);
         if (!(cellNotes === null || cellNotes === void 0 ? void 0 : cellNotes.length)) {
             return undefined;
         }
         return 'ab-Cell-Note';
     }
     getCommentCellClassName(gridCell, params) {
-        if (!this.adaptableApi.internalApi.getModuleService().isModuleAvailable('Comments')) {
+        if (!this.adaptableApi.internalApi.getModuleService().isModuleAvailable('Comment')) {
             return;
         }
         if (!this.adaptableApi.commentApi.internalApi.areCommentsAvailable()) {

package/src/agGrid/defaultAdaptableOptions.js

@@ -170,13 +170,6 @@ const DefaultAdaptableOptions = {
     menuOptions: {
         customColumnMenu: undefined,
         customContextMenu: undefined,
-        showAdaptableContextMenu: true,
-        showAdaptableColumnMenu: true,
-        showUngroupColumnMenuItem: true,
-        columnMenuOrder: ['aggrid', 'adaptable', 'user'],
-        contextMenuOrder: ['aggrid', 'adaptable', 'user'],
-        columnMenuItems: undefined,
-        contextMenuItems: undefined,
     },
     columnFilterOptions: {
         quickFilterOptions: {

package/src/components/ExpressionEditor/QueryBuilder/QueryPredicateBuilder.js

@@ -2,6 +2,7 @@ import React from 'react';
 import { Draggable, Droppable } from 'react-beautiful-dnd';
 import { Box, Flex } from 'rebass';
 import { isQlLogicalOperator } from '../../../parser/src/predicate';
+import { mapColumnDataTypeToExpressionFunctionType } from '../../../Utilities/adaptableQlUtils';
 import { booleanExpressionFunctions } from '../../../Utilities/ExpressionFunctions/booleanExpressionFunctions';
 import { useAdaptable } from '../../../View/AdaptableContext';
 import DropdownButton from '../../DropdownButton';
@@ -9,7 +10,7 @@ import ErrorBox from '../../ErrorBox';
 import { Icon } from '../../icons';
 import SimpleButton from '../../SimpleButton';
 import { CombinatorSelector, ExpressionSelector, PrimiteValueInput, PrimitiveColumnSelector, PrimitiveMultiValueInput, } from './QueryBuilderInputs';
-import { getOperatorMatchingInputs as getFunctionMatchingInputTypes, mapColumnDataTypeToExpressionFunctionType, } from './utils';
+import { getOperatorMatchingInputs as getFunctionMatchingInputTypes } from './utils';
 const ITEM_HEIGHT = 40;
 const BASE_CLASS_NAME = 'ab-QueryBuilder-predicate-editor';
 const Handle = (props) => (React.createElement(Flex, Object.assign({ className: `${BASE_CLASS_NAME}__handle`, height: ITEM_HEIGHT, alignItems: "center", mr: 1 }, props),

package/src/components/ExpressionEditor/QueryBuilder/utils.d.ts

@@ -2,7 +2,6 @@ import { QlPredicate, QlPredicateError } from '../../../parser/src/predicate';
 import { ExpressionFunctionInputType } from '../../../parser/src/types';
 import { AdaptableColumnDataType, BooleanFunctionName } from '../../../types';
 export declare const reorder: (predicate: QlPredicate, from: string, to: string) => any;
-export declare const mapColumnDataTypeToExpressionFunctionType: (dataType: AdaptableColumnDataType) => ExpressionFunctionInputType;
 export declare const mapExpressionFunctionTypeToColumnDataType: (type: ExpressionFunctionInputType) => AdaptableColumnDataType;
 export declare const getOperatorMatchingInputs: (columnType: ExpressionFunctionInputType, inputs: ExpressionFunctionInputType[] | Array<ExpressionFunctionInputType>[]) => ExpressionFunctionInputType[];
 export declare const getFunctionsForColumnType: (dataType: AdaptableColumnDataType, availableBooleanFunctions: BooleanFunctionName[]) => BooleanFunctionName[];

package/src/components/ExpressionEditor/QueryBuilder/utils.js

@@ -1,3 +1,4 @@
+import { mapColumnDataTypeToExpressionFunctionType } from '../../../Utilities/adaptableQlUtils';
 import { isQlLogicalOperator } from '../../../parser/src/predicate';
 import { booleanExpressionFunctions } from '../../../Utilities/ExpressionFunctions/booleanExpressionFunctions';
 import { deepClone } from '../../../Utilities/Extensions/ObjectExtensions';
@@ -26,20 +27,6 @@ export const reorder = (predicate, from, to) => {
     parent.args.splice(parseInt(toPath[toPath.length - 1]), 0, itemToMove);
     return predicateCopy;
 };
-export const mapColumnDataTypeToExpressionFunctionType = (dataType) => {
-    if (dataType === 'Number') {
-        return 'number';
-    }
-    if (dataType === 'Boolean') {
-        return 'boolean';
-    }
-    if (dataType === 'String') {
-        return 'text';
-    }
-    if (dataType === 'Date') {
-        return 'date';
-    }
-};
 export const mapExpressionFunctionTypeToColumnDataType = (type) => {
     if (type === 'number') {
         return 'Number';

package/src/components/icons/note.js

@@ -1,4 +1,4 @@
 import * as React from 'react';
 import DefaultIcon from './DefaultIcon';
-export default (props) => (React.createElement(DefaultIcon, Object.assign({}, props, { viewBox: "0 -960 960 960" }),
-    React.createElement("path", { d: "M440-240h80v-120h120v-80H520v-120h-80v120H320v80h120v120ZM240-80q-33 0-56.5-23.5T160-160v-640q0-33 23.5-56.5T240-880h320l240 240v480q0 33-23.5 56.5T720-80H240Zm280-520v-200H240v640h480v-440H520ZM240-800v200-200 640-640Z" })));
+export default (props) => (React.createElement(DefaultIcon, Object.assign({}, props),
+    React.createElement("path", { d: "M20 2H4c-1.1 0-1.99.9-1.99 2L2 22l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zM8 14H6v-2h2v2zm0-3H6V9h2v2zm0-3H6V6h2v2zm7 6h-5v-2h5v2zm3-3h-8V9h8v2zm0-3h-8V6h8v2z" })));

package/src/env.js

@@ -1,5 +1,5 @@
 export default {
     INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1711034314862 || Date.now(),
-    VERSION: "18.0.0-canary.12" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1711118620968 || Date.now(),
+    VERSION: "18.0.0-canary.13" || '--current-version--',
 };

package/src/metamodel/adaptable.metamodel.d.ts

@@ -382,11 +382,19 @@ export declare const ADAPTABLE_METAMODEL: {
             kind: string;
             desc: string;
             isOpt: boolean;
+            ref?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
             isOpt?: undefined;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            ref: string;
         })[];
     };
     AdaptableComparerFunction: {
@@ -1973,6 +1981,24 @@ export declare const ADAPTABLE_METAMODEL: {
             isOpt: boolean;
         }[];
     };
+    CommentThread: {
+        name: string;
+        kind: string;
+        desc: string;
+        props: ({
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt?: undefined;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt: boolean;
+            ref: string;
+        })[];
+    };
     CompatibleContext: {
         name: string;
         kind: string;
@@ -2894,10 +2920,18 @@ export declare const ADAPTABLE_METAMODEL: {
             kind: string;
             desc: string;
             isOpt: boolean;
+            ref?: undefined;
+        } | {
+            name: string;
+            kind: string;
+            desc: string;
+            isOpt?: undefined;
+            ref?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
+            ref: string;
             isOpt?: undefined;
         })[];
     };
@@ -3915,21 +3949,12 @@ export declare const ADAPTABLE_METAMODEL: {
         name: string;
         kind: string;
         desc: string;
-        props: ({
-            name: string;
-            kind: string;
-            desc: string;
-            isOpt: boolean;
-            gridInfo?: undefined;
-            defVal?: undefined;
-        } | {
+        props: {
             name: string;
             kind: string;
             desc: string;
             isOpt: boolean;
-            gridInfo: string;
-            defVal: string;
-        })[];
+        }[];
     };
     MenuOrderContext: {
         name: string;