@adaptabletools/adaptable 23.0.4 → 23.0.5-canary.1

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -4,9 +4,8 @@ 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';
-// numeric value(digits) followed by a single 's', 'm' or 'h' letter (case insensitive)
 const TIMEFRAME_REGEX = /^(\d+)(s|m|h)$/i;
-const SYSTEM_MAX_TIMEFRAME_SIZE = 86400000; // 24h
+const SYSTEM_MAX_TIMEFRAME_SIZE = 86400000;
 export const observableExpressionFunctions = {
     WHERE: {
         handler(args, context) {
@@ -40,13 +39,7 @@ export const observableExpressionFunctions = {
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
                 case 'NONE': {
-                    return dataChangeLog$.pipe(
-                    // wait for the given time
-                    debounceTime(timeframeParameter.value), 
-                    // completing the observable (ex. alert deletion) will also fire the NONE event
-                    // takeUntil takes care of this, ignoring any emissions as soon as the source completes
-                    // (count() result is irrelevant here, the main thing is that it emits an source completion)
-                    takeUntil(dataChangeLog$.pipe(count())));
+                    return dataChangeLog$.pipe(debounceTime(timeframeParameter.value), takeUntil(dataChangeLog$.pipe(count())));
                 }
             }
         },
@@ -80,15 +73,7 @@ export const observableExpressionFunctions = {
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
                 case 'NONE': {
-                    return dataChangeLog$.pipe(
-                    // add a synthetic first value to ensure the grid is observed even when there are no changes
-                    startWith(getDataChangedInfoStub(context)), 
-                    // wait for the given time
-                    debounceTime(timeframeParameter.value), 
-                    // completing the observable (ex. alert deletion) will also fire the NONE event
-                    // takeUntil takes care of this, ignoring any emissions as soon as the source completes
-                    // (count() result is irrelevant here, the main thing is that it emits a source completion)
-                    takeUntil(dataChangeLog$.pipe(count())));
+                    return dataChangeLog$.pipe(startWith(getDataChangedInfoStub(context)), debounceTime(timeframeParameter.value), takeUntil(dataChangeLog$.pipe(count())));
                 }
             }
         },
@@ -222,14 +207,12 @@ export const observableExpressionFunctions = {
     },
     TIMEFRAME: {
         handler(args, context) {
-            // unit -> milliseconds
             const durationUnitRatios = {
                 s: 1000,
                 m: 60000,
                 h: 3600000,
             };
             const input = args[0] + '';
-            //we allow only seconds, minutes & hours durations
             const matchingResult = input.match(TIMEFRAME_REGEX);
             const value = matchingResult?.[1];
             const unit = matchingResult?.[2]?.toLowerCase();
@@ -240,7 +223,6 @@ export const observableExpressionFunctions = {
             if (!duration) {
                 throw new ExpressionEvaluationError('TIMEFRAME', `timeframe expression is invalid`);
             }
-            // check if the given duration is greater than the generally defined maxTimeframe size
             duration = getMaxTimeframeSize(duration, context);
             const result = {
                 type: 'config',
@@ -260,26 +242,22 @@ export const observableExpressionFunctions = {
     },
 };
 export const observableExpressionFunctionNames = getTypedKeys(observableExpressionFunctions);
-// return TRUE if the last(tail) element has the greatest value
 const isLastElementMaxValue = (values) => {
     const [tailValue] = values.slice(-1);
     const restValues = values.slice(0, -1);
     return restValues.every((value) => value < tailValue);
 };
-// return TRUE if the last(tail) element has the greatest value
 const isLastElementMinValue = (values) => {
     const [tailValue] = values.slice(-1);
     const restValues = values.slice(0, -1);
     return restValues.every((value) => value > tailValue);
 };
-// useful for functions which do NOT have an initial change (ex. GRID_CHANGE NONE)
 const getDataChangedInfoStub = (context) => {
     let rowNodeStub;
     if (!context.filterFn) {
         rowNodeStub = context.node ?? context.adaptableApi.gridApi.getFirstRowNode();
     }
     else {
-        // if there is a WHERE clause defined, find the first rowNode which satisfies the condition
         context.adaptableApi.internalApi.forAllRowNodesDo((rowNode) => {
             if (!rowNodeStub) {
                 if (context.filterFn(rowNode)) {
@@ -310,13 +288,11 @@ const getDataChangedInfoStub = (context) => {
         };
     }
 };
-// returns an observable which fires if the source$ emitted `targetCount` times in the given `timeframeChange$` period
 const getDataChangeCount$ = (dataChangeLog$, timeframeChange$, targetCount) => {
     return dataChangeLog$.pipe(withLatestFrom(timeframeChange$), filter(([_, changeCountWithinTimeframe]) => {
         return targetCount === changeCountWithinTimeframe;
     }), map(([source]) => source));
 };
-// returns an observable which fires if the last source$ emission had the lowest(min) value in the given `timeframeChange$` period
 const getDataChangeMin$ = (dataChangeLog$, timeframeChange$) => {
     return dataChangeLog$.pipe(withLatestFrom(timeframeChange$), filter(([changeLog, values]) => {
         return values.length > 1
@@ -326,7 +302,6 @@ const getDataChangeMin$ = (dataChangeLog$, timeframeChange$) => {
         return changeLog;
     }));
 };
-// returns an observable which fires if the last source$ emission had the highest(max) value in the given `timeframeChange$` period
 const getDataChangeMax$ = (dataChangeLog$, timeframeChange$) => {
     return dataChangeLog$.pipe(withLatestFrom(timeframeChange$), filter(([changeLog, values]) => {
         return values.length > 1
@@ -336,17 +311,12 @@ const getDataChangeMax$ = (dataChangeLog$, timeframeChange$) => {
         return changeLog;
     }));
 };
-// returns an observable which maps a dataChangeLogEntry to the number(count) of changed values in the entire grid
-// the counter is continuously up-to-date in the given timeframe
-// if the given counterLimit is reached, the counter is reset
 const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
     return defer(() => {
-        // keep the counter value in an internal intermediary state
         let counter = 0;
         const movingTimeWindow$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
             counter++;
         }, (dataChangeLog) => {
-            // counter may have been reset during the timeframe, in which case we skip the decrement
             if (counter > 0) {
                 counter--;
             }
@@ -354,19 +324,14 @@ const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
         return movingTimeWindow$.pipe(map(() => {
             const gridCounter = counter;
             if (gridCounter === counterLimit) {
-                // reset counter
                 counter = 0;
             }
             return gridCounter;
         }));
     });
 };
-// returns an observable which maps a dataChangeLogEntry to the number(count) of changed values in the row of the given dataChangeLogEntry
-// the counter is continuously up-to-date in the given timeframe
-// if the given counterLimit is reached, the counter is reset
 const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
     return defer(() => {
-        // keep the counter value in an internal intermediary state (distinct per row PK)
         const counterMap = new Map();
         const getCellCounter = (dataChangeLog) => counterMap.get(dataChangeLog.primaryKeyValue) ?? 0;
         const slidingTimeframe$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
@@ -374,7 +339,6 @@ const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
             counterMap.set(dataChangeLog.primaryKeyValue, ++currentCounter);
         }, (dataChangeLog) => {
             let currentCounter = getCellCounter(dataChangeLog);
-            // counter may have been reset during the timeframe, in which case we skip the decrement
             if (currentCounter > 0) {
                 counterMap.set(dataChangeLog.primaryKeyValue, --currentCounter);
             }
@@ -382,32 +346,25 @@ const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
         return slidingTimeframe$.pipe(map((dataChangeLog) => {
             const cellCounter = getCellCounter(dataChangeLog);
             if (cellCounter === counterLimit) {
-                // reset counter
                 counterMap.set(dataChangeLog.primaryKeyValue, 0);
             }
             return cellCounter;
         }));
     });
 };
-// returns an observable which maps a dataChangeLogEntry to the array of changed values in the entire grid
-// the changed values array is continuously up-to-date in the given timeframe
 const getTrailingGridValueChange$ = (source$, trailingPeriod) => {
     return defer(() => {
-        // keep the changed values in an internal intermediary state
         let values = [];
         const doubleInsertionsMap = new WeakMap();
         const slidingTimeframe$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
             if (!values.length) {
-                // values is empty, so we evaluate both old & new node values
                 values.push(getNumericValue(dataChangeLog.oldValue));
-                // mark the double insertion, we will have to pop 2 elements
                 doubleInsertionsMap.set(dataChangeLog, true);
             }
             values.push(getNumericValue(dataChangeLog.newValue));
         }, (dataChangeLog) => {
             values.shift();
             if (doubleInsertionsMap.get(dataChangeLog)) {
-                // the current change inserted both old and new values, so we have to extract 2 elements
                 values.shift();
                 doubleInsertionsMap.delete(dataChangeLog);
             }
@@ -415,20 +372,15 @@ const getTrailingGridValueChange$ = (source$, trailingPeriod) => {
         return slidingTimeframe$.pipe(map(() => values));
     });
 };
-// returns an observable which maps a dataChangeLogEntry to the array of changed values in the row of the given dataChangeLogEntry
-// the changed values array is continuously up-to-date in the given timeframe
 const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
     return defer(() => {
-        // keep the changed values in an internal intermediary state (distinct per row PK)
         const rowValuesMap = new Map();
         const doubleInsertionsMap = new WeakMap();
         const getRowValues = (dataChangeLog) => rowValuesMap.get(dataChangeLog.primaryKeyValue) ?? [];
         const slidingTimeframe$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
             let rowValues = getRowValues(dataChangeLog);
             if (!rowValues.length) {
-                // values is empty, so we evaluate both old & new node values
                 rowValues.push(getNumericValue(dataChangeLog.oldValue));
-                // mark the double insertion, we will have to pop 2 elements
                 doubleInsertionsMap.set(dataChangeLog, true);
             }
             rowValues.push(getNumericValue(dataChangeLog.newValue));
@@ -437,7 +389,6 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
             let rowValues = getRowValues(dataChangeLog);
             rowValues.shift();
             if (doubleInsertionsMap.get(dataChangeLog)) {
-                // the current change inserted both old and new values, so we have to extract 2 elements
                 rowValues.shift();
                 doubleInsertionsMap.delete(dataChangeLog);
             }
@@ -446,20 +397,10 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
         return slidingTimeframe$.pipe(map((dataChangeLog) => getRowValues(dataChangeLog)));
     });
 };
-// return an observable which will emit when the source$ event enters, respectively exits the timeframe
-// it also executes the provided onEnter/onExit handlers
 const getSlidingTimeframe$ = (source$, timeframeDuration, onTimeframeEnter, onTimeframeExit) => {
-    return source$.pipe(
-    // create intermediary observable which, for each emission from source$:
-    mergeMap((dataChangeLog) => {
-        // 1. it will emit the payload immediately...
-        const enter$ = of(dataChangeLog).pipe(
-        // ...and execute the provided onPushHandler() callback
-        tap((dataChangeLog) => onTimeframeEnter(dataChangeLog)));
-        // 2. and after a given 'timeWindowSize' delay it will re-emit the payload...
-        const exit$ = of(dataChangeLog).pipe(delay(timeframeDuration), 
-        // ...and execute the provided onPopHandler() callback
-        tap((dataChangeLog) => onTimeframeExit(dataChangeLog)));
+    return source$.pipe(mergeMap((dataChangeLog) => {
+        const enter$ = of(dataChangeLog).pipe(tap((dataChangeLog) => onTimeframeEnter(dataChangeLog)));
+        const exit$ = of(dataChangeLog).pipe(delay(timeframeDuration), tap((dataChangeLog) => onTimeframeExit(dataChangeLog)));
         return of(enter$, exit$).pipe(mergeAll());
     }));
 };
@@ -480,15 +421,12 @@ const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, co
         throw new ExpressionEvaluationError(consumingFunction, 'requires a TIMEFRAME parameter when observing for no changes');
     }
     if (countValue == null && timeframeParameter == null) {
-        // default - return all new rows
         return gridChangeLog$;
     }
     if (countValue == null) {
-        // default count value of 1
         countValue = 1;
     }
     if (timeframeParameter == null) {
-        // default time parameter of max
         timeframeParameter = {
             name: 'TIMEFRAME',
             type: 'config',
@@ -496,7 +434,6 @@ const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, co
         };
     }
     if (countValue === 0) {
-        // handle special case when observing NO changes
         const rowDataChangeInfoStub = {
             rowTrigger: consumingFunction === 'ROW_ADDED' ? 'Add' : 'Delete',
             rowNodes: [],
@@ -504,15 +441,7 @@ const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, co
             changedAt: Date.now(),
             ...context.adaptableApi.internalApi.buildBaseContext(),
         };
-        return gridChangeLog$.pipe(
-        // add a synthetic first value to ensure the grid is observed even when there are no changes
-        startWith(rowDataChangeInfoStub), 
-        // wait for the given time
-        debounceTime(timeframeParameter.value), 
-        // completing the observable (ex. alert deletion) will also fire the NONE event
-        // takeUntil takes care of this, ignoring any emissions as soon as the source completes
-        // (count() result is irrelevant here, the main thing is that it emits a source completion)
-        takeUntil(gridChangeLog$.pipe(count())));
+        return gridChangeLog$.pipe(startWith(rowDataChangeInfoStub), debounceTime(timeframeParameter.value), takeUntil(gridChangeLog$.pipe(count())));
     }
     const timeframeChange$ = getTrailingGridCountChange$(gridChangeLog$, timeframeParameter.value, countValue);
     return getDataChangeCount$(gridChangeLog$, timeframeChange$, countValue);

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -63,15 +63,6 @@ function initReducers(reducers) {
         }
     return result;
 }
-/**
- *
- * This fn mutates the reducerResults array!!!
- *
- * @param data data item
- * @param reducers an array of reducers
- * @param reducerResults the results on which to operate
- *
- */
 function computeReducersFor(data, reducers, reducerResults, dataIndex) {
     if (!reducers || !Object.keys(reducers).length) {
         return;

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -18,8 +18,6 @@ import StringExtensions from '../Extensions/StringExtensions';
 import { getTypedKeys } from '../Extensions/TypeExtensions';
 import { evaluate } from '../../parser/src';
 import { evaluateNode } from '../../parser/src/evaluator';
-// useful for unary operators which expect a list of arguments
-// we extract the provided array elements into a list
 const flattenArguments = (values) => {
     if (!Array.isArray(values)) {
         return values;
@@ -60,11 +58,9 @@ export const scalarExpressionFunctions = {
             if (!column.queryable) {
                 throw new ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
             }
-            // see #derived_pivot_cell_style
             if (context.pivotResultColumn) {
                 const baseColumnId = context.pivotResultColumn.getColDef()?.pivotValueColumn?.getColId();
                 if (baseColumnId === columnId) {
-                    // we evaluate the pivot result column instead of the base column
                     return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, context.pivotResultColumn.getColId());
                 }
             }
@@ -103,11 +99,9 @@ export const scalarExpressionFunctions = {
             if (!column.queryable) {
                 throw new ExpressionEvaluationError('$SCOPE', `Column name "${scopeColumnId}" is not queryable`);
             }
-            // see #derived_pivot_cell_style
             if (context.pivotResultColumn) {
                 const baseColumnId = context.pivotResultColumn.getColDef()?.pivotValueColumn?.getColId();
                 if (baseColumnId === scopeColumnId) {
-                    // we evaluate the pivot result column instead of the base column
                     return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, context.pivotResultColumn.getColId());
                 }
             }
@@ -129,12 +123,10 @@ export const scalarExpressionFunctions = {
             if (!namedQuery) {
                 throw new ExpressionEvaluationError('QUERY', `Named Query with name ${namedQueryName} not found!`);
             }
-            // add query to call stack
             if (!context.namedQueryCallStack) {
                 context.namedQueryCallStack = [];
             }
             context.namedQueryCallStack.push(namedQueryName);
-            //check if this Named Query is not already evaluated, in which case this would lead to an infinite evaluation cycle
             const firstIndex = context.namedQueryCallStack.indexOf(namedQueryName);
             const lastIndex = context.namedQueryCallStack.lastIndexOf(namedQueryName);
             if (firstIndex !== lastIndex) {
@@ -142,7 +134,6 @@ export const scalarExpressionFunctions = {
                 throw new ExpressionEvaluationError(`${namedQueryName}`, ` contains a circular reference: ${cycle.join('  ->  ')}`);
             }
             const queryEvaluationResult = evaluate(namedQuery.BooleanExpression, context);
-            // remove query name from callstack
             context.namedQueryCallStack?.pop();
             return queryEvaluationResult;
         },
@@ -273,7 +264,6 @@ export const scalarExpressionFunctions = {
         handler(args) {
             const sanitizedArguments = sanitizeArguments(flattenArguments(args));
             if (args.length && !sanitizedArguments.length) {
-                // expression is syntactically valid, but operates with incompatible values
                 return;
             }
             return sanitizedArguments.reduce((a, b) => a + b) / sanitizedArguments.length;
@@ -288,7 +278,6 @@ export const scalarExpressionFunctions = {
         handler(args) {
             const sanitizedArguments = sanitizeArguments(args, true);
             if (args.length && !sanitizedArguments.length) {
-                // expression is syntactically valid, but operates with incompatible values
                 return;
             }
             return sanitizedArguments.reduce((a, b) => a + b);
@@ -304,7 +293,6 @@ export const scalarExpressionFunctions = {
         handler(args) {
             const sanitizedArguments = sanitizeArguments(args);
             if (args.length && !sanitizedArguments.length) {
-                // expression is syntactically valid, but operates with incompatible values
                 return;
             }
             return sanitizedArguments.reduce((a, b) => a - b);
@@ -363,9 +351,9 @@ export const scalarExpressionFunctions = {
     CASE: {
         handler([expressionValueNode, whenThenListNodes, defaultValueNode], context) {
             const caseExpressionValue = expressionValueNode != undefined
-                ? // CASE matches the first WHEN statement with the provided expression value
+                ?
                     evaluateExpressionNode(expressionValueNode, context)
-                : // otherwise it returns the first WHEN statement evaluated to TRUE
+                :
                     true;
             const matchingWhen = whenThenListNodes.find((whenThenStatement) => {
                 const whenValue = evaluateExpressionNode(whenThenStatement.WHEN, context);
@@ -734,10 +722,8 @@ export const scalarExpressionFunctions = {
             }
             const columnArg = args[0];
             if (!columnArg) {
-                // if no column is provided, we check if any value has changed
                 return context.dataChangedEvent.oldValue !== context.dataChangedEvent.newValue;
             }
-            // only COL argument is supported
             if (columnArg.type !== 'COL' && columnArg.type !== '$SCOPE') {
                 throw new ExpressionEvaluationError('ANY_CHANGE', 'accepts only a column reference or scope as an argument');
             }

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -89,7 +89,6 @@ export function hasItemsOfCount(arrayToCheck, numberOfItems) {
 export function moveArray(array, from, to) {
     array.splice(to, 0, array.splice(from, 1)[0]);
 }
-//This deliberately only checks contents equality and not positional so [1, 2, 3]== [1, 3, 2]
 export function areArraysEqual(arr1, arr2) {
     if (IsNullOrEmpty(arr1) && IsNotNullOrEmpty(arr2)) {
         return false;
@@ -114,29 +113,17 @@ export function areArraysEqualWithOrder(arr1, arr2) {
     }
     return arr1.every((x, index) => arr2.indexOf(x) == index);
 }
-/**
- * Checks if two arrays contain the same elements (order-independent).
- *
- * @param arr1 First array to compare
- * @param arr2 Second array to compare
- * @param equalityFn Optional function to determine if two elements are equal
- * @returns True if arrays contain the same elements, false otherwise
- */
 export function areArraysEqualWithCustomComparator(arr1, arr2, equalityFn) {
-    // Handle null/undefined cases
     if (!arr1 && !arr2) {
         return true;
     }
     if (!arr1 || !arr2) {
         return false;
     }
-    // Check length
     if (arr1.length !== arr2.length) {
         return false;
     }
-    // Use default equality comparison if no custom function provided
     const compareElements = equalityFn || ((a, b) => a === b);
-    // For each element in arr1, find a matching element in arr2
     const arr2Copy = [...arr2];
     for (let i = 0; i < arr1.length; i++) {
         const element = arr1[i];
@@ -144,45 +131,34 @@ export function areArraysEqualWithCustomComparator(arr1, arr2, equalityFn) {
         if (matchIndex === -1) {
             return false;
         }
-        // Remove the matched element to prevent duplicate matches
         arr2Copy.splice(matchIndex, 1);
     }
     return true;
 }
 export function areArraysEqualWithOrderAndProperties(value, other) {
     const type = Object.prototype.toString.call(value);
-    // If the two objects are not the same type, return false
     if (type !== Object.prototype.toString.call(other)) {
         return false;
     }
-    // If items are not an object or array, return false
     if (['[object Array]', '[object Object]'].indexOf(type) < 0) {
         return false;
     }
-    // Compare the length of the length of the two items
     const valueLen = type === '[object Array]' ? value.length : Object.keys(value).length;
     const otherLen = type === '[object Array]' ? other.length : Object.keys(other).length;
     if (valueLen !== otherLen) {
         return false;
     }
-    // Compare two items
     const compare = function (item1, item2) {
-        // Get the object type
         const itemType = Object.prototype.toString.call(item1);
-        // If an object or array, compare recursively
         if (['[object Array]', '[object Object]'].indexOf(itemType) >= 0) {
             if (!areArraysEqualWithOrderAndProperties(item1, item2)) {
                 return false;
             }
         }
-        // Otherwise, do a simple comparison
         else {
-            // If the two items are not the same type, return false
             if (itemType !== Object.prototype.toString.call(item2)) {
                 return false;
             }
-            // Else if it's a function, convert to a string and compare
-            // Otherwise, just compare
             if (itemType === '[object Function]') {
                 if (item1.toString() !== item2.toString()) {
                     return false;
@@ -195,7 +171,6 @@ export function areArraysEqualWithOrderAndProperties(value, other) {
             }
         }
     };
-    // Compare properties
     if (type === '[object Array]') {
         for (let i = 0; i < valueLen; i++) {
             if (compare(value[i], other[i]) === false) {
@@ -212,7 +187,6 @@ export function areArraysEqualWithOrderAndProperties(value, other) {
             }
         }
     }
-    // If nothing failed, return true
     return true;
 }
 export function sortArrayWithProperty(sortOrder, values, sortProperty) {
@@ -308,7 +282,6 @@ export function SumArray(array) {
 export function reorderArray(array, startIndex, endIndex) {
     const result = [...array];
     if (startIndex > array.length - 1) {
-        // not much that we can do if the dragged item is out of bounds...
         return result;
     }
     if (endIndex > array.length - 1) {
@@ -318,15 +291,7 @@ export function reorderArray(array, startIndex, endIndex) {
     result.splice(endIndex, 0, removed);
     return result;
 }
-export function sortArrayWithOrder(array, order, 
-/**
- *
- * The array can contain items which are not listed in the order array.
- * So sortUnorderedItems decides whether to leave these items untouched
- * in the current order in which they are in the array (sortUnorderedItems: false)
- * or to sort them using normal comparison rules
- */
-{ sortUnorderedItems }) {
+export function sortArrayWithOrder(array, order, { sortUnorderedItems }) {
     const itemsToIndex = array.reduce((acc, x, i) => {
         acc.set(x, i);
         return acc;
@@ -344,10 +309,8 @@ export function sortArrayWithOrder(array, order,
         const indexInOrderSecondElement = orderContainsSecondElement
             ? orderItemsToIndex.get(valueB)
             : -1;
-        //if none of the element are in the order list we just return normal compare
         if (!orderContainsFirstElement && !orderContainsSecondElement) {
             if (!sortUnorderedItems) {
-                // keep the original order
                 return itemsToIndex.get(valueA) - itemsToIndex.get(valueB);
             }
             if (valueA == valueB) {
@@ -355,24 +318,16 @@ export function sortArrayWithOrder(array, order,
             }
             return valueA < valueB ? -1 : 1;
         }
-        //if first item not in the list make sure we put it after the second item
         if (!orderContainsFirstElement) {
             return 1;
         }
-        //if second item not in the list make sure we put it after the first item
         if (!orderContainsSecondElement) {
             return -1;
         }
-        //return the comparison from the list if the two items are in the list
         return indexInOrderOfFirstElement - indexInOrderSecondElement;
     }
     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)) {
@@ -385,32 +340,15 @@ export function chunk(array, size = 1) {
     }
     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,

package/src/Utilities/Extensions/NumberExtensions.js

@@ -18,14 +18,6 @@ export function wrapInParentheses(numberToWrap) {
     return ' (' + numberToWrap + ')';
 }
 export function timesBy100(value) {
-    // the simple solution does not work
-    // return value * 100;
-    // needed because 0.12676 * 100 = 12.676000000000002
-    // but we dont want that to happen
-    // this solution does not handle  -0 correctly
-    // also 1267.6 * 100 is 126759.99999999999
-    // which is not what we want
-    // return parseFloat((value * 100).toFixed(12));
     if (isNaN(value) || !value) {
         return value;
     }
@@ -41,12 +33,6 @@ export function timesBy100(value) {
     return Number(num.join(''));
 }
 export function divideBy100(value) {
-    // the simple solution does not work
-    // return value / 100;
-    // needed because 4012.3456/100 = 40.123456000000004
-    // but we dont want that to happen
-    // this solution does not handle  -0 correctly
-    // return parseFloat((value / 100).toFixed(12));
     if (isNaN(value) || !value) {
         return value;
     }
@@ -77,10 +63,6 @@ export function avoidJavascriptPrecisionIssues(value) {
     }
     return newValue;
 }
-/**
- * Clamps `number` within the inclusive `lower` and `upper` bounds.
- * Drop-in replacement for lodash/clamp.
- */
 export function clamp(value, lower, upper) {
     return Math.min(Math.max(value, lower), upper);
 }
@@ -105,10 +87,6 @@ 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.
- */
 export function toNumber(value) {
     if (typeof value === 'number') {
         return value;
@@ -138,11 +116,6 @@ export function toNumber(value) {
     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.
- */
 export function parseIntFn(string, radix) {
     const str = typeof string === 'string' ? string.trim() : String(string);
     return globalThis.parseInt(str, radix || 10);