@adaptabletools/adaptable 23.0.0-canary.1 → 23.0.0-canary.10

package/src/Strategy/Utilities/Export/getExportRowsViewItems.d.ts

@@ -4,3 +4,4 @@ export declare const getExportRowsViewItems: (report: Report, api: AdaptableApi)
     name: string;
     view: React.JSX.Element;
 };
+export declare const renderExportRowsView: (report: Report, api: AdaptableApi) => React.ReactNode;

package/src/Strategy/Utilities/Export/getExportRowsViewItems.js

@@ -14,3 +14,6 @@ export const getExportRowsViewItems = (report, api) => {
         view: _jsx(Tag, { children: element }),
     };
 };
+export const renderExportRowsView = (report, api) => {
+    return getExportRowsViewItems(report, api).view;
+};

package/src/Strategy/Utilities/Layout/aggregationSummaryHelpers.d.ts

@@ -0,0 +1,11 @@
+import { AdaptableApi, PivotLayout, TableLayout } from '../../../types';
+export declare function getTableAggregationSummaryValues(layout: TableLayout, api: AdaptableApi): string[];
+export declare function getPivotAggregationSummaryValues(layout: PivotLayout, api: AdaptableApi): string[];
+export declare function getLayoutTableAggregationViewItems(layout: TableLayout, api: AdaptableApi): {
+    name: string;
+    values: string[];
+}[];
+export declare function getLayoutPivotAggregationViewItems(layout: PivotLayout, api: AdaptableApi): {
+    name: string;
+    values: string[];
+}[];

package/src/Strategy/Utilities/Layout/aggregationSummaryHelpers.js

@@ -0,0 +1,105 @@
+import { WEIGHTED_AVERAGE_AGG_FN_NAME } from '../../../AdaptableState/Common/AggregationColumns';
+const IGNORED_AGG_COLUMN_IDS = new Set(['Source', 'Uuid', 'AdaptableVersion']);
+const GRAND_TOTAL_ROW_LABELS = {
+    off: 'None',
+    top: 'Top',
+    bottom: 'Bottom',
+    pinnedTop: 'Pinned Top',
+    pinnedBottom: 'Pinned Bottom',
+};
+const PIVOT_LAYOUT_TOTAL_LABELS = {
+    off: 'None',
+    before: 'Before',
+    after: 'After',
+};
+function getGrandTotalRowKey(layout) {
+    const value = layout.GrandTotalRow;
+    if (value == null || value === false) {
+        return 'off';
+    }
+    return value;
+}
+function getGrandTotalRowLabel(layout) {
+    return GRAND_TOTAL_ROW_LABELS[getGrandTotalRowKey(layout)];
+}
+function getPivotLayoutTotalKey(value) {
+    if (value == null || value === false) {
+        return 'off';
+    }
+    if (value === 'before') {
+        return 'before';
+    }
+    if (value === 'after') {
+        return 'after';
+    }
+    return 'off';
+}
+function getPivotLayoutTotalLabel(value) {
+    return PIVOT_LAYOUT_TOTAL_LABELS[getPivotLayoutTotalKey(value)];
+}
+function formatAggregationTag(columnId, aggFn, columnIdToFriendlyName) {
+    if (IGNORED_AGG_COLUMN_IDS.has(columnId)) {
+        return null;
+    }
+    let aggFnName = '';
+    if (typeof aggFn === 'string') {
+        aggFnName = aggFn;
+    }
+    else if (typeof aggFn === 'object' && aggFn?.type === 'weightedAverage') {
+        aggFnName = WEIGHTED_AVERAGE_AGG_FN_NAME;
+    }
+    if (!aggFnName) {
+        return null;
+    }
+    return `${aggFnName}(${columnIdToFriendlyName(columnId)})`;
+}
+export function getTableAggregationSummaryValues(layout, api) {
+    const columnIdToFriendlyName = (columnId) => api.columnApi.getFriendlyNameForColumnId(columnId);
+    const values = (layout.TableAggregationColumns || [])
+        .map(({ ColumnId, AggFunc }) => formatAggregationTag(ColumnId, AggFunc, columnIdToFriendlyName))
+        .filter((value) => Boolean(value));
+    if (getGrandTotalRowKey(layout) !== 'off') {
+        values.push(`Grand Total Row: ${getGrandTotalRowLabel(layout)}`);
+    }
+    return values;
+}
+export function getPivotAggregationSummaryValues(layout, api) {
+    const columnIdToFriendlyName = (columnId) => api.columnApi.getFriendlyNameForColumnId(columnId);
+    const values = (layout.PivotAggregationColumns || [])
+        .map(({ ColumnId, AggFunc }) => formatAggregationTag(ColumnId, AggFunc, columnIdToFriendlyName))
+        .filter((value) => Boolean(value));
+    if (getGrandTotalRowKey(layout) !== 'off') {
+        values.push(`Grand Total Row: ${getGrandTotalRowLabel(layout)}`);
+    }
+    if (getPivotLayoutTotalKey(layout.PivotGrandTotal) !== 'off') {
+        values.push(`Pivot Grand Total: ${getPivotLayoutTotalLabel(layout.PivotGrandTotal)}`);
+    }
+    if (getPivotLayoutTotalKey(layout.PivotColumnTotal) !== 'off') {
+        values.push(`Pivot Column Total: ${getPivotLayoutTotalLabel(layout.PivotColumnTotal)}`);
+    }
+    return values;
+}
+export function getLayoutTableAggregationViewItems(layout, api) {
+    const values = getTableAggregationSummaryValues(layout, api);
+    if (!values.length) {
+        return [];
+    }
+    return [
+        {
+            name: 'Aggregations',
+            values,
+        },
+    ];
+}
+export function getLayoutPivotAggregationViewItems(layout, api) {
+    const values = getPivotAggregationSummaryValues(layout, api);
+    if (!values.length) {
+        return [];
+    }
+    return [
+        {
+            name: 'Aggregations',
+            values,
+        },
+    ];
+}

package/src/Strategy/Utilities/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: "column";
+}[];
+export declare function getLayoutPivotSortingViewItem(layout: Layout, api: AdaptableApi): {
+    name: string;
+    values: string[];
+    tagVariant: "column";
+};

package/src/Strategy/Utilities/Layout/columnsSummaryHelpers.js

@@ -0,0 +1,166 @@
+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}]`);
+}
+/** Matches legacy Layout settings panel behaviour (`layoutViewOptions.maxColumnsToDisplay`). */
+export 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 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: 'column',
+            },
+        ];
+    });
+}
+export function getLayoutPivotSortingViewItem(layout, api) {
+    const values = getTableColumnsSortingSummaryValues(layout, api);
+    if (!values.length) {
+        return null;
+    }
+    return {
+        name: 'Sorting',
+        values,
+        tagVariant: 'column',
+    };
+}

package/src/Strategy/Utilities/Layout/getLayoutSortViewItems.d.ts

@@ -2,4 +2,5 @@ import { AdaptableApi, Layout } from '../../../types';
 export declare const getLayoutSortViewItems: (layout: Layout, api: AdaptableApi) => {
     name: string;
     values: string[];
+    tagVariant: "column";
 };

package/src/Strategy/Utilities/Layout/getLayoutSortViewItems.js

@@ -5,5 +5,6 @@ export const getLayoutSortViewItems = (layout, api) => {
     return {
         name: 'Sort',
         values: (layout.ColumnSorts ?? []).map((customSort) => `[${columnIdToFriendlyName(customSort.ColumnId)}: ${customSort.SortOrder}]`),
+        tagVariant: 'column',
     };
 };

package/src/Strategy/Utilities/Layout/rowGroupSummaryHelpers.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { AdaptableApi, Layout, TableLayout } from '../../../types';
+export declare const ROW_GROUP_DISPLAY_TYPE_LABELS: Record<NonNullable<TableLayout['RowGroupDisplayType']>, string>;
+export declare const ROW_GROUP_DISPLAY_TYPE_DESCRIPTIONS: Record<NonNullable<TableLayout['RowGroupDisplayType']>, string>;
+export declare const ROW_GROUP_BEHAVIOR_LABELS: Record<TableLayout['RowGroupValues']['RowGroupDefaultBehavior'], string>;
+export declare const ROW_GROUP_BEHAVIOR_DESCRIPTIONS: Record<TableLayout['RowGroupValues']['RowGroupDefaultBehavior'], string>;
+export declare function getRowGroupDisplayTypeLabel(layout: Layout): string;
+export declare function getRowGroupDisplayTypeDescription(layout: Layout): string;
+export declare function getRowGroupBehaviorLabel(layout: Layout): string;
+export declare function getRowGroupBehaviorDescription(layout: Layout): string;
+export declare function getTableRowGroupSummaryValues(layout: Layout, api: AdaptableApi): string[];
+export declare function getLayoutTableRowGroupViewItems(layout: Layout, api: AdaptableApi): {
+    name: string;
+    view: () => React.FunctionComponentElement<{
+        layout: Layout;
+        api: AdaptableApi;
+    }>;
+}[];
+export declare function getPivotRowGroupSummaryValues(layout: Layout, api: AdaptableApi): string[];
+export declare function getLayoutPivotRowGroupViewItems(layout: Layout, api: AdaptableApi): {
+    name: string;
+    view: () => React.FunctionComponentElement<{
+        layout: Layout;
+        api: AdaptableApi;
+    }>;
+}[];

package/src/Strategy/Utilities/Layout/rowGroupSummaryHelpers.js

@@ -0,0 +1,85 @@
+import * as React from 'react';
+import { PivotRowGroupSummaryView, TableRowGroupSummaryView, } from '../../../View/Wizard/rowGroupSummaryTags';
+export const ROW_GROUP_DISPLAY_TYPE_LABELS = {
+    single: 'Single Column',
+    multi: 'Multiple Columns',
+    groupRows: 'Full Width Group Rows',
+};
+export const ROW_GROUP_DISPLAY_TYPE_DESCRIPTIONS = {
+    single: 'All Row Grouped Columns display in one hierarchical Column',
+    multi: 'Each Row Grouped Column displays in its own, separate, Column',
+    groupRows: 'Row groups display as full-width rows (no group column and no aggregations)',
+};
+export const ROW_GROUP_BEHAVIOR_LABELS = {
+    'always-collapsed': 'All Collapsed',
+    'always-expanded': 'All Expanded',
+    expanded: 'Mostly Expanded',
+    collapsed: 'Mostly Collapsed',
+};
+export const ROW_GROUP_BEHAVIOR_DESCRIPTIONS = {
+    'always-collapsed': 'All Grouped Rows are always collapsed',
+    'always-expanded': 'All Grouped Rows are always expanded',
+    expanded: 'All Grouped Rows expanded, other than those collapsed when Layout last displayed',
+    collapsed: 'All Grouped Rows collapsed, other than those expanded when Layout last displayed',
+};
+export function getRowGroupDisplayTypeLabel(layout) {
+    const displayType = layout.RowGroupDisplayType ?? 'single';
+    return ROW_GROUP_DISPLAY_TYPE_LABELS[displayType];
+}
+export function getRowGroupDisplayTypeDescription(layout) {
+    const displayType = layout.RowGroupDisplayType ?? 'single';
+    return ROW_GROUP_DISPLAY_TYPE_DESCRIPTIONS[displayType];
+}
+export function getRowGroupBehaviorLabel(layout) {
+    const behavior = layout.RowGroupValues?.RowGroupDefaultBehavior ?? 'always-collapsed';
+    return ROW_GROUP_BEHAVIOR_LABELS[behavior];
+}
+export function getRowGroupBehaviorDescription(layout) {
+    const behavior = layout.RowGroupValues?.RowGroupDefaultBehavior ?? 'always-collapsed';
+    return ROW_GROUP_BEHAVIOR_DESCRIPTIONS[behavior];
+}
+export function getTableRowGroupSummaryValues(layout, api) {
+    const columnIdToFriendlyName = (columnId) => api.columnApi.getFriendlyNameForColumnId(columnId);
+    const values = [];
+    if (!layout.RowGroupedColumns?.length) {
+        values.push('No Row Grouped Columns');
+    }
+    else {
+        layout.RowGroupedColumns.forEach((colId) => {
+            values.push(columnIdToFriendlyName(colId));
+        });
+    }
+    values.push(`Display Type: ${getRowGroupDisplayTypeLabel(layout)}`);
+    values.push(`Behaviour: ${getRowGroupBehaviorLabel(layout)}`);
+    return values;
+}
+export function getLayoutTableRowGroupViewItems(layout, api) {
+    return [
+        {
+            name: 'Row Groups',
+            view: () => React.createElement(TableRowGroupSummaryView, { layout, api }),
+        },
+    ];
+}
+export function getPivotRowGroupSummaryValues(layout, api) {
+    const columnIdToFriendlyName = (columnId) => api.columnApi.getFriendlyNameForColumnId(columnId);
+    const values = [];
+    if (!layout.PivotGroupedColumns?.length) {
+        values.push('No Row Grouped Columns');
+    }
+    else {
+        layout.PivotGroupedColumns.forEach((colId) => {
+            values.push(columnIdToFriendlyName(colId));
+        });
+    }
+    values.push(`Behaviour: ${getRowGroupBehaviorLabel(layout)}`);
+    return values;
+}
+export function getLayoutPivotRowGroupViewItems(layout, api) {
+    return [
+        {
+            name: 'Row Groups',
+            view: () => React.createElement(PivotRowGroupSummaryView, { layout, api }),
+        },
+    ];
+}

package/src/Utilities/Constants/ReduxConstants.d.ts

@@ -1,9 +1,9 @@
 import { SummaryOperation } from '../../AdaptableState/Common/Enums';
-import { AdaptableTheme } from '../../AdaptableState/ThemeState';
+import { SystemThemeEntry } from '../../AdaptableState/ThemeState';
 export declare const CELL_SUMMARY_DEFAULT_OPERATION: SummaryOperation | string;
 export declare const QUICK_SEARCH_DEFAULT_TEXT_BACK_COLOR: string;
 export declare const QUICK_SEARCH_DEFAULT_CELL_BACK_COLOR: string;
 export declare const QUICK_SEARCH_DEFAULT_FORE_COLOR: string;
 export declare const QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR: string;
-export declare const SYSTEM_THEMES: AdaptableTheme[];
+export declare const SYSTEM_THEMES: SystemThemeEntry[];
 export declare const THEME_DEFAULT_CURRENT_THEME: string;

package/src/Utilities/Constants/ReduxConstants.js

@@ -10,18 +10,5 @@ export const QUICK_SEARCH_DEFAULT_FORE_COLOR = getSwatchColorVar(1); // black
 export const QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR = getSwatchColorVar(20); // orange
 // theme
 // consts for Themes
-export const SYSTEM_THEMES = [
-    {
-        Name: LIGHT_THEME,
-        Description: 'Light Theme',
-    },
-    {
-        Name: DARK_THEME,
-        Description: 'Dark Theme',
-    },
-    {
-        Name: OS_THEME,
-        Description: 'OS Theme',
-    },
-];
+export const SYSTEM_THEMES = [LIGHT_THEME, DARK_THEME, OS_THEME];
 export const THEME_DEFAULT_CURRENT_THEME = LIGHT_THEME;

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -1,4 +1,4 @@
-import parseInt from '../utils/parseInt';
+import { parseIntFn as parseInt } from '../Extensions/NumberExtensions';
 import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
 import { handleColumnFunction, handleWhereFunction, } from './expressionFunctionUtils';
 import { aggregatedScalarExpressionFunctions, } from './aggregatedScalarExpressionFunctions';

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -1,7 +1,7 @@
 import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
 import StringExtensions from '../Extensions/StringExtensions';
 import { filter } from 'rxjs/operators';
-import toNumber from '../utils/toNumber';
+import { toNumber } from '../Extensions/NumberExtensions';
 import { evaluateNode } from '../../parser/src/evaluator';
 // string functions may be case (in)sensitive, see internalApi.isTextComparisonCaseSensitive()
 // if case is insensitive, we convert ALL involved strings to lower case

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -1,6 +1,6 @@
 import { defer, of } from 'rxjs';
 import { count, debounceTime, delay, filter, map, mergeAll, mergeMap, startWith, takeUntil, tap, withLatestFrom, } from 'rxjs/operators';
-import parseInt from '../utils/parseInt';
+import { parseIntFn as parseInt } from '../Extensions/NumberExtensions';
 import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
 import { extractColumnParameter, extractParameter, getDataChangeLog$, getGridChangeLog$, getNumericValue, handleColumnFunction, handleWhereFunction, validateColumnType, } from './expressionFunctionUtils';
 import { getTypedKeys } from '../Extensions/TypeExtensions';

package/src/Utilities/Extensions/ArrayExtensions.d.ts

@@ -58,6 +58,33 @@ export declare function sortArrayWithOrder<T>(array: T[], order: T[],
 { sortUnorderedItems }: {
     sortUnorderedItems: boolean;
 }): T[];
+/**
+ * Creates an array of elements split into groups the length of `size`.
+ * If `array` can't be split evenly, the final chunk will be the remaining elements.
+ * Drop-in replacement for lodash/chunk.
+ */
+export declare function chunk<T>(array: T[], size?: number): T[][];
+/**
+ * Flattens array a single level deep.
+ * Drop-in replacement for lodash/flatten.
+ */
+export declare function flatten<T>(array: (T | T[])[]): T[];
+/**
+ * Recursively flattens array.
+ * Drop-in replacement for lodash/flattenDeep.
+ */
+export declare function flattenDeep<T>(array: any[]): T[];
+/**
+ * Creates a duplicate-free version of an array, using SameValueZero for equality
+ * comparisons, in which only the first occurrence of each element is kept.
+ * Drop-in replacement for lodash/uniq.
+ */
+export declare function uniq<T>(array: T[]): T[];
+/**
+ * Checks if `value` is classified as an Array object.
+ * Drop-in replacement for lodash/isArray.
+ */
+export declare const isArray: (value: any) => value is any[];
 export declare const ArrayExtensions: {
     GetLength: typeof GetLength;
     CorrectLength: typeof CorrectLength;
@@ -95,5 +122,10 @@ export declare const ArrayExtensions: {
     SumArray: typeof SumArray;
     reorderArray: typeof reorderArray;
     sortArrayWithOrder: typeof sortArrayWithOrder;
+    chunk: typeof chunk;
+    flatten: typeof flatten;
+    flattenDeep: typeof flattenDeep;
+    uniq: typeof uniq;
+    isArray: (value: any) => value is any[];
 };
 export default ArrayExtensions;

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -368,6 +368,50 @@ export function sortArrayWithOrder(array, order,
     }
     return [].concat(array).sort(compareItemsOfCustomSort);
 }
+/**
+ * Creates an array of elements split into groups the length of `size`.
+ * If `array` can't be split evenly, the final chunk will be the remaining elements.
+ * Drop-in replacement for lodash/chunk.
+ */
+export function chunk(array, size = 1) {
+    const length = array.length;
+    if (!length || !(size >= 1)) {
+        return [];
+    }
+    const chunkSize = Math.floor(size);
+    const result = [];
+    for (let i = 0; i < length; i += chunkSize) {
+        result.push(array.slice(i, i + chunkSize));
+    }
+    return result;
+}
+/**
+ * Flattens array a single level deep.
+ * Drop-in replacement for lodash/flatten.
+ */
+export function flatten(array) {
+    return array.flat();
+}
+/**
+ * Recursively flattens array.
+ * Drop-in replacement for lodash/flattenDeep.
+ */
+export function flattenDeep(array) {
+    return array.flat(Infinity);
+}
+/**
+ * Creates a duplicate-free version of an array, using SameValueZero for equality
+ * comparisons, in which only the first occurrence of each element is kept.
+ * Drop-in replacement for lodash/uniq.
+ */
+export function uniq(array) {
+    return [...new Set(array)];
+}
+/**
+ * Checks if `value` is classified as an Array object.
+ * Drop-in replacement for lodash/isArray.
+ */
+export const isArray = Array.isArray;
 export const ArrayExtensions = {
     GetLength,
     CorrectLength,
@@ -405,5 +449,10 @@ export const ArrayExtensions = {
     SumArray,
     reorderArray,
     sortArrayWithOrder,
+    chunk,
+    flatten,
+    flattenDeep,
+    uniq,
+    isArray,
 };
 export default ArrayExtensions;

package/src/Utilities/Extensions/NumberExtensions.d.ts

@@ -3,11 +3,32 @@ export declare function wrapInParentheses(numberToWrap: number): string;
 export declare function timesBy100(value: any): any;
 export declare function divideBy100(value: any): any;
 export declare function avoidJavascriptPrecisionIssues(value: number): number;
+/**
+ * Clamps `number` within the inclusive `lower` and `upper` bounds.
+ * Drop-in replacement for lodash/clamp.
+ */
+export declare function clamp(value: number, lower: number, upper: number): number;
+export declare function roundNumber(numberToRound: any, decimalPlaces: number): number;
+/**
+ * Converts value to a number.
+ * Drop-in replacement for lodash/toNumber.
+ */
+export declare function toNumber(value: any): number;
+/**
+ * Converts string to an integer of the specified radix.
+ * If radix is undefined or 0, a radix of 10 is used (unlike native parseInt which auto-detects).
+ * Drop-in replacement for lodash/parseInt.
+ */
+export declare function parseIntFn(string: string, radix?: number): number;
 export declare const NumberExtensions: {
     abbreviateNumber: typeof abbreviateNumber;
     wrapInParentheses: typeof wrapInParentheses;
     timesBy100: typeof timesBy100;
     divideBy100: typeof divideBy100;
     avoidJavascriptPrecisionIssues: typeof avoidJavascriptPrecisionIssues;
+    clamp: typeof clamp;
+    roundNumber: typeof roundNumber;
+    toNumber: typeof toNumber;
+    parseIntFn: typeof parseIntFn;
 };
 export default NumberExtensions;