@adaptabletools/adaptable-cjs 23.0.4 → 23.0.5-canary.0

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -7,9 +7,8 @@ const NumberExtensions_1 = require("../Extensions/NumberExtensions");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const TypeExtensions_1 = require("../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;
 exports.observableExpressionFunctions = {
     WHERE: {
         handler(args, context) {
@@ -43,13 +42,7 @@ exports.observableExpressionFunctions = {
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
                 case 'NONE': {
-                    return dataChangeLog$.pipe(
-                    // wait for the given time
-                    (0, operators_1.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)
-                    (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
+                    return dataChangeLog$.pipe((0, operators_1.debounceTime)(timeframeParameter.value), (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
                 }
             }
         },
@@ -83,15 +76,7 @@ exports.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
-                    (0, operators_1.startWith)(getDataChangedInfoStub(context)), 
-                    // wait for the given time
-                    (0, operators_1.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)
-                    (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
+                    return dataChangeLog$.pipe((0, operators_1.startWith)(getDataChangedInfoStub(context)), (0, operators_1.debounceTime)(timeframeParameter.value), (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
                 }
             }
         },
@@ -225,14 +210,12 @@ exports.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();
@@ -243,7 +226,6 @@ exports.observableExpressionFunctions = {
             if (!duration) {
                 throw new ExpressionEvaluationError_1.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',
@@ -263,26 +245,22 @@ exports.observableExpressionFunctions = {
     },
 };
 exports.observableExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.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)) {
@@ -313,13 +291,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((0, operators_1.withLatestFrom)(timeframeChange$), (0, operators_1.filter)(([_, changeCountWithinTimeframe]) => {
         return targetCount === changeCountWithinTimeframe;
     }), (0, operators_1.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((0, operators_1.withLatestFrom)(timeframeChange$), (0, operators_1.filter)(([changeLog, values]) => {
         return values.length > 1
@@ -329,7 +305,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((0, operators_1.withLatestFrom)(timeframeChange$), (0, operators_1.filter)(([changeLog, values]) => {
         return values.length > 1
@@ -339,17 +314,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 (0, rxjs_1.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--;
             }
@@ -357,19 +327,14 @@ const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
         return movingTimeWindow$.pipe((0, operators_1.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 (0, rxjs_1.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) => {
@@ -377,7 +342,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);
             }
@@ -385,32 +349,25 @@ const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
         return slidingTimeframe$.pipe((0, operators_1.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 (0, rxjs_1.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((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.oldValue));
-                // mark the double insertion, we will have to pop 2 elements
                 doubleInsertionsMap.set(dataChangeLog, true);
             }
             values.push((0, expressionFunctionUtils_1.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);
             }
@@ -418,20 +375,15 @@ const getTrailingGridValueChange$ = (source$, trailingPeriod) => {
         return slidingTimeframe$.pipe((0, operators_1.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 (0, rxjs_1.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((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.oldValue));
-                // mark the double insertion, we will have to pop 2 elements
                 doubleInsertionsMap.set(dataChangeLog, true);
             }
             rowValues.push((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.newValue));
@@ -440,7 +392,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);
             }
@@ -449,20 +400,10 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
         return slidingTimeframe$.pipe((0, operators_1.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$:
-    (0, operators_1.mergeMap)((dataChangeLog) => {
-        // 1. it will emit the payload immediately...
-        const enter$ = (0, rxjs_1.of)(dataChangeLog).pipe(
-        // ...and execute the provided onPushHandler() callback
-        (0, operators_1.tap)((dataChangeLog) => onTimeframeEnter(dataChangeLog)));
-        // 2. and after a given 'timeWindowSize' delay it will re-emit the payload...
-        const exit$ = (0, rxjs_1.of)(dataChangeLog).pipe((0, operators_1.delay)(timeframeDuration), 
-        // ...and execute the provided onPopHandler() callback
-        (0, operators_1.tap)((dataChangeLog) => onTimeframeExit(dataChangeLog)));
+    return source$.pipe((0, operators_1.mergeMap)((dataChangeLog) => {
+        const enter$ = (0, rxjs_1.of)(dataChangeLog).pipe((0, operators_1.tap)((dataChangeLog) => onTimeframeEnter(dataChangeLog)));
+        const exit$ = (0, rxjs_1.of)(dataChangeLog).pipe((0, operators_1.delay)(timeframeDuration), (0, operators_1.tap)((dataChangeLog) => onTimeframeExit(dataChangeLog)));
         return (0, rxjs_1.of)(enter$, exit$).pipe((0, operators_1.mergeAll)());
     }));
 };
@@ -483,15 +424,12 @@ const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, co
         throw new ExpressionEvaluationError_1.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',
@@ -499,7 +437,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: [],
@@ -507,15 +444,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
-        (0, operators_1.startWith)(rowDataChangeInfoStub), 
-        // wait for the given time
-        (0, operators_1.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)
-        (0, operators_1.takeUntil)(gridChangeLog$.pipe((0, operators_1.count)())));
+        return gridChangeLog$.pipe((0, operators_1.startWith)(rowDataChangeInfoStub), (0, operators_1.debounceTime)(timeframeParameter.value), (0, operators_1.takeUntil)(gridChangeLog$.pipe((0, operators_1.count)())));
     }
     const timeframeChange$ = getTrailingGridCountChange$(gridChangeLog$, timeframeParameter.value, countValue);
     return getDataChangeCount$(gridChangeLog$, timeframeChange$, countValue);

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -66,15 +66,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

@@ -22,8 +22,6 @@ const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/String
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 const src_1 = require("../../parser/src");
 const evaluator_1 = require("../../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;
@@ -64,11 +62,9 @@ exports.scalarExpressionFunctions = {
             if (!column.queryable) {
                 throw new ExpressionEvaluationError_1.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());
                 }
             }
@@ -107,11 +103,9 @@ exports.scalarExpressionFunctions = {
             if (!column.queryable) {
                 throw new ExpressionEvaluationError_1.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());
                 }
             }
@@ -133,12 +127,10 @@ exports.scalarExpressionFunctions = {
             if (!namedQuery) {
                 throw new ExpressionEvaluationError_1.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) {
@@ -146,7 +138,6 @@ exports.scalarExpressionFunctions = {
                 throw new ExpressionEvaluationError_1.ExpressionEvaluationError(`${namedQueryName}`, ` contains a circular reference: ${cycle.join('  ->  ')}`);
             }
             const queryEvaluationResult = (0, src_1.evaluate)(namedQuery.BooleanExpression, context);
-            // remove query name from callstack
             context.namedQueryCallStack?.pop();
             return queryEvaluationResult;
         },
@@ -277,7 +268,6 @@ exports.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;
@@ -292,7 +282,6 @@ exports.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);
@@ -308,7 +297,6 @@ exports.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);
@@ -367,9 +355,9 @@ exports.scalarExpressionFunctions = {
     CASE: {
         handler([expressionValueNode, whenThenListNodes, defaultValueNode], context) {
             const caseExpressionValue = expressionValueNode != undefined
-                ? // CASE matches the first WHEN statement with the provided expression value
+                ?
                     (0, expressionFunctionUtils_1.evaluateExpressionNode)(expressionValueNode, context)
-                : // otherwise it returns the first WHEN statement evaluated to TRUE
+                :
                     true;
             const matchingWhen = whenThenListNodes.find((whenThenStatement) => {
                 const whenValue = (0, expressionFunctionUtils_1.evaluateExpressionNode)(whenThenStatement.WHEN, context);
@@ -738,10 +726,8 @@ exports.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_1.ExpressionEvaluationError('ANY_CHANGE', 'accepts only a column reference or scope as an argument');
             }

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -132,7 +132,6 @@ function hasItemsOfCount(arrayToCheck, numberOfItems) {
 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]
 function areArraysEqual(arr1, arr2) {
     if (IsNullOrEmpty(arr1) && IsNotNullOrEmpty(arr2)) {
         return false;
@@ -157,29 +156,17 @@ 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
- */
 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];
@@ -187,45 +174,34 @@ function areArraysEqualWithCustomComparator(arr1, arr2, equalityFn) {
         if (matchIndex === -1) {
             return false;
         }
-        // Remove the matched element to prevent duplicate matches
         arr2Copy.splice(matchIndex, 1);
     }
     return true;
 }
 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;
@@ -238,7 +214,6 @@ function areArraysEqualWithOrderAndProperties(value, other) {
             }
         }
     };
-    // Compare properties
     if (type === '[object Array]') {
         for (let i = 0; i < valueLen; i++) {
             if (compare(value[i], other[i]) === false) {
@@ -255,7 +230,6 @@ function areArraysEqualWithOrderAndProperties(value, other) {
             }
         }
     }
-    // If nothing failed, return true
     return true;
 }
 function sortArrayWithProperty(sortOrder, values, sortProperty) {
@@ -354,7 +328,6 @@ function SumArray(array) {
 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) {
@@ -364,15 +337,7 @@ function reorderArray(array, startIndex, endIndex) {
     result.splice(endIndex, 0, removed);
     return result;
 }
-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 }) {
+function sortArrayWithOrder(array, order, { sortUnorderedItems }) {
     const itemsToIndex = array.reduce((acc, x, i) => {
         acc.set(x, i);
         return acc;
@@ -390,10 +355,8 @@ 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) {
@@ -401,24 +364,16 @@ 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.
- */
 function chunk(array, size = 1) {
     const length = array.length;
     if (!length || !(size >= 1)) {
@@ -431,32 +386,15 @@ function chunk(array, size = 1) {
     }
     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,

package/src/Utilities/Extensions/NumberExtensions.js

@@ -30,14 +30,6 @@ function wrapInParentheses(numberToWrap) {
     return ' (' + numberToWrap + ')';
 }
 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;
     }
@@ -53,12 +45,6 @@ function timesBy100(value) {
     return Number(num.join(''));
 }
 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;
     }
@@ -89,10 +75,6 @@ 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);
 }
@@ -117,10 +99,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.
- */
 function toNumber(value) {
     if (typeof value === 'number') {
         return value;
@@ -150,11 +128,6 @@ 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.
- */
 function parseIntFn(string, radix) {
     const str = typeof string === 'string' ? string.trim() : String(string);
     return globalThis.parseInt(str, radix || 10);