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

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LAYOUT_VIEW_MAX_COLUMNS = exports.TABLE_COLUMNS_WIZARD_SUBSECTION_LABELS = exports.TABLE_COLUMNS_SETTINGS_PANEL_LABELS = void 0;
+exports.getTableColumnsVisibilitySummaryValues = getTableColumnsVisibilitySummaryValues;
+exports.getTableColumnsPinningSummaryValues = getTableColumnsPinningSummaryValues;
+exports.getTableColumnsSizingSummaryValues = getTableColumnsSizingSummaryValues;
+exports.getTableColumnsSortingSummaryValues = getTableColumnsSortingSummaryValues;
+exports.truncateColumnSummaryValues = truncateColumnSummaryValues;
+exports.getTableColumnsSummaryGroups = getTableColumnsSummaryGroups;
+exports.getLayoutTableColumnsViewItems = getLayoutTableColumnsViewItems;
+exports.getLayoutPivotSortingViewItem = getLayoutPivotSortingViewItem;
+exports.TABLE_COLUMNS_SETTINGS_PANEL_LABELS = {
+    visibility: 'Columns',
+    pinning: 'Pinning',
+    sizing: 'Sizing',
+    sorting: 'Sorting',
+};
+exports.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);
+}
+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;
+    });
+}
+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)`),
+    ];
+}
+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})`;
+    });
+}
+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`). */
+exports.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`.
+ */
+function truncateColumnSummaryValues(values, maxToDisplay = exports.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`];
+}
+function getTableColumnsSummaryGroups(layout, api, labels = exports.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',
+        },
+    ];
+}
+function getLayoutTableColumnsViewItems(layout, api, options) {
+    const maxColumnsToDisplay = options?.maxColumnsToDisplay ?? exports.DEFAULT_LAYOUT_VIEW_MAX_COLUMNS;
+    const optionalRowLabels = new Set([
+        exports.TABLE_COLUMNS_SETTINGS_PANEL_LABELS.pinning,
+        exports.TABLE_COLUMNS_SETTINGS_PANEL_LABELS.sizing,
+        exports.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 === exports.TABLE_COLUMNS_SETTINGS_PANEL_LABELS.visibility
+            ? truncateColumnSummaryValues(resolvedValues, maxColumnsToDisplay)
+            : resolvedValues;
+        return [
+            {
+                name: label,
+                values: displayValues,
+                tagVariant: 'column',
+            },
+        ];
+    });
+}
+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

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

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,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROW_GROUP_BEHAVIOR_DESCRIPTIONS = exports.ROW_GROUP_BEHAVIOR_LABELS = exports.ROW_GROUP_DISPLAY_TYPE_DESCRIPTIONS = exports.ROW_GROUP_DISPLAY_TYPE_LABELS = void 0;
+exports.getRowGroupDisplayTypeLabel = getRowGroupDisplayTypeLabel;
+exports.getRowGroupDisplayTypeDescription = getRowGroupDisplayTypeDescription;
+exports.getRowGroupBehaviorLabel = getRowGroupBehaviorLabel;
+exports.getRowGroupBehaviorDescription = getRowGroupBehaviorDescription;
+exports.getTableRowGroupSummaryValues = getTableRowGroupSummaryValues;
+exports.getLayoutTableRowGroupViewItems = getLayoutTableRowGroupViewItems;
+exports.getPivotRowGroupSummaryValues = getPivotRowGroupSummaryValues;
+exports.getLayoutPivotRowGroupViewItems = getLayoutPivotRowGroupViewItems;
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const rowGroupSummaryTags_1 = require("../../../View/Wizard/rowGroupSummaryTags");
+exports.ROW_GROUP_DISPLAY_TYPE_LABELS = {
+    single: 'Single Column',
+    multi: 'Multiple Columns',
+    groupRows: 'Full Width Group Rows',
+};
+exports.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)',
+};
+exports.ROW_GROUP_BEHAVIOR_LABELS = {
+    'always-collapsed': 'All Collapsed',
+    'always-expanded': 'All Expanded',
+    expanded: 'Mostly Expanded',
+    collapsed: 'Mostly Collapsed',
+};
+exports.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',
+};
+function getRowGroupDisplayTypeLabel(layout) {
+    const displayType = layout.RowGroupDisplayType ?? 'single';
+    return exports.ROW_GROUP_DISPLAY_TYPE_LABELS[displayType];
+}
+function getRowGroupDisplayTypeDescription(layout) {
+    const displayType = layout.RowGroupDisplayType ?? 'single';
+    return exports.ROW_GROUP_DISPLAY_TYPE_DESCRIPTIONS[displayType];
+}
+function getRowGroupBehaviorLabel(layout) {
+    const behavior = layout.RowGroupValues?.RowGroupDefaultBehavior ?? 'always-collapsed';
+    return exports.ROW_GROUP_BEHAVIOR_LABELS[behavior];
+}
+function getRowGroupBehaviorDescription(layout) {
+    const behavior = layout.RowGroupValues?.RowGroupDefaultBehavior ?? 'always-collapsed';
+    return exports.ROW_GROUP_BEHAVIOR_DESCRIPTIONS[behavior];
+}
+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;
+}
+function getLayoutTableRowGroupViewItems(layout, api) {
+    return [
+        {
+            name: 'Row Groups',
+            view: () => React.createElement(rowGroupSummaryTags_1.TableRowGroupSummaryView, { layout, api }),
+        },
+    ];
+}
+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;
+}
+function getLayoutPivotRowGroupViewItems(layout, api) {
+    return [
+        {
+            name: 'Row Groups',
+            view: () => React.createElement(rowGroupSummaryTags_1.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

@@ -13,18 +13,5 @@ exports.QUICK_SEARCH_DEFAULT_FORE_COLOR = (0, UIHelper_1.getSwatchColorVar)(1);
 exports.QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR = (0, UIHelper_1.getSwatchColorVar)(20); // orange
 // theme
 // consts for Themes
-exports.SYSTEM_THEMES = [
-    {
-        Name: GeneralConstants_1.LIGHT_THEME,
-        Description: 'Light Theme',
-    },
-    {
-        Name: GeneralConstants_1.DARK_THEME,
-        Description: 'Dark Theme',
-    },
-    {
-        Name: GeneralConstants_1.OS_THEME,
-        Description: 'OS Theme',
-    },
-];
+exports.SYSTEM_THEMES = [GeneralConstants_1.LIGHT_THEME, GeneralConstants_1.DARK_THEME, GeneralConstants_1.OS_THEME];
 exports.THEME_DEFAULT_CURRENT_THEME = GeneralConstants_1.LIGHT_THEME;

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregatedBooleanExpressionFunctionNames = exports.aggregatedBooleanExpressionFunctions = void 0;
-const tslib_1 = require("tslib");
-const parseInt_1 = tslib_1.__importDefault(require("../utils/parseInt"));
+const NumberExtensions_1 = require("../Extensions/NumberExtensions");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const aggregatedScalarExpressionFunctions_1 = require("./aggregatedScalarExpressionFunctions");
@@ -189,6 +188,6 @@ const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
         b: 1000000000,
     };
     // numeric value
-    return (0, parseInt_1.default)(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
+    return (0, NumberExtensions_1.parseIntFn)(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
 };
 exports.aggregatedBooleanExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedBooleanExpressionFunctions);

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
 const operators_1 = require("rxjs/operators");
-const toNumber_1 = tslib_1.__importDefault(require("../utils/toNumber"));
+const NumberExtensions_1 = require("../Extensions/NumberExtensions");
 const evaluator_1 = require("../../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
@@ -120,7 +120,7 @@ const getNumericValue = (input, returnRawValue) => {
     if (typeof input === 'number') {
         return input;
     }
-    const numericValue = (0, toNumber_1.default)(input);
+    const numericValue = (0, NumberExtensions_1.toNumber)(input);
     if (returnRawValue === true) {
         return numericValue;
     }

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.observableExpressionFunctionNames = exports.observableExpressionFunctions = void 0;
-const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const parseInt_1 = tslib_1.__importDefault(require("../utils/parseInt"));
+const NumberExtensions_1 = require("../Extensions/NumberExtensions");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
@@ -239,7 +238,7 @@ exports.observableExpressionFunctions = {
             const unit = matchingResult?.[2]?.toLowerCase();
             let duration;
             if (value && unit && durationUnitRatios[unit]) {
-                duration = (0, parseInt_1.default)(value) * durationUnitRatios[unit];
+                duration = (0, NumberExtensions_1.parseIntFn)(value) * durationUnitRatios[unit];
             }
             if (!duration) {
                 throw new ExpressionEvaluationError_1.ExpressionEvaluationError('TIMEFRAME', `timeframe expression is invalid`);

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = exports.getDateComparatorForGridCell = exports.getNumericComparatorForGridCell = exports.getGenericComparatorForGridCell = void 0;
+exports.ArrayExtensions = exports.isArray = exports.getDateComparatorForGridCell = exports.getNumericComparatorForGridCell = exports.getGenericComparatorForGridCell = void 0;
 exports.GetLength = GetLength;
 exports.CorrectLength = CorrectLength;
 exports.NotCorrectLength = NotCorrectLength;
@@ -37,6 +37,10 @@ exports.createCommaSeparatedString = createCommaSeparatedString;
 exports.SumArray = SumArray;
 exports.reorderArray = reorderArray;
 exports.sortArrayWithOrder = sortArrayWithOrder;
+exports.chunk = chunk;
+exports.flatten = flatten;
+exports.flattenDeep = flattenDeep;
+exports.uniq = uniq;
 const Enums_1 = require("../../AdaptableState/Common/Enums");
 function GetLength(arrayToCheck) {
     return IsNotNull(arrayToCheck) ? arrayToCheck.length : 0;
@@ -410,6 +414,50 @@ 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.
+ */
+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.
+ */
+function flatten(array) {
+    return array.flat();
+}
+/**
+ * Recursively flattens array.
+ * Drop-in replacement for lodash/flattenDeep.
+ */
+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.
+ */
+function uniq(array) {
+    return [...new Set(array)];
+}
+/**
+ * Checks if `value` is classified as an Array object.
+ * Drop-in replacement for lodash/isArray.
+ */
+exports.isArray = Array.isArray;
 exports.ArrayExtensions = {
     GetLength,
     CorrectLength,
@@ -447,5 +495,10 @@ exports.ArrayExtensions = {
     SumArray,
     reorderArray,
     sortArrayWithOrder,
+    chunk,
+    flatten,
+    flattenDeep,
+    uniq,
+    isArray: exports.isArray,
 };
 exports.default = exports.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;

package/src/Utilities/Extensions/NumberExtensions.js

@@ -6,6 +6,10 @@ exports.wrapInParentheses = wrapInParentheses;
 exports.timesBy100 = timesBy100;
 exports.divideBy100 = divideBy100;
 exports.avoidJavascriptPrecisionIssues = avoidJavascriptPrecisionIssues;
+exports.clamp = clamp;
+exports.roundNumber = roundNumber;
+exports.toNumber = toNumber;
+exports.parseIntFn = parseIntFn;
 function abbreviateNumber(numberToAbbreviate) {
     let str = '';
     if (numberToAbbreviate >= 1000000000) {
@@ -85,11 +89,85 @@ function avoidJavascriptPrecisionIssues(value) {
     }
     return newValue;
 }
+/**
+ * Clamps `number` within the inclusive `lower` and `upper` bounds.
+ * Drop-in replacement for lodash/clamp.
+ */
+function clamp(value, lower, upper) {
+    return Math.min(Math.max(value, lower), upper);
+}
+function roundNumber(numberToRound, decimalPlaces) {
+    switch (decimalPlaces) {
+        case 1:
+            return Math.round(numberToRound * 10) / 10;
+        case 2:
+            return Math.round(numberToRound * 100) / 100;
+        case 3:
+            return Math.round(numberToRound * 1000) / 1000;
+        case 4:
+            return Math.round(numberToRound * 10000) / 10000;
+        case 5:
+            return Math.round(numberToRound * 100000) / 100000;
+        case 6:
+            return Math.round(numberToRound * 1000000) / 1000000;
+    }
+}
+const _reTrimStart = /^\s+/;
+const _reTrimEnd = /\s+$/;
+const _reIsBinary = /^0b[01]+$/i;
+const _reIsOctal = /^0o[0-7]+$/i;
+const _reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+/**
+ * Converts value to a number.
+ * Drop-in replacement for lodash/toNumber.
+ */
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'symbol') {
+        return NaN;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (value == null) {
+        return value === undefined ? NaN : 0;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.replace(_reTrimStart, '').replace(_reTrimEnd, '');
+        if (_reIsBinary.test(trimmed)) {
+            return globalThis.parseInt(trimmed.slice(2), 2);
+        }
+        if (_reIsOctal.test(trimmed)) {
+            return globalThis.parseInt(trimmed.slice(2), 8);
+        }
+        if (_reIsBadHex.test(trimmed)) {
+            return NaN;
+        }
+        return +trimmed;
+    }
+    const other = typeof value.valueOf === 'function' ? value.valueOf() : value;
+    return +other;
+}
+/**
+ * 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.
+ */
+function parseIntFn(string, radix) {
+    const str = typeof string === 'string' ? string.trim() : String(string);
+    return globalThis.parseInt(str, radix || 10);
+}
 exports.NumberExtensions = {
     abbreviateNumber,
     wrapInParentheses,
     timesBy100,
     divideBy100,
     avoidJavascriptPrecisionIssues,
+    clamp,
+    roundNumber,
+    toNumber,
+    parseIntFn,
 };
 exports.default = exports.NumberExtensions;