umt 2.3.0 → 2.5.0

package/module/es5/Array/groupBy.js

@@ -15,12 +15,13 @@ exports.groupBy = void 0;
  * groupBy(["apple", "banana", "carrot"], (str) => str[0]); // { 'a': ['apple'], 'b': ['banana'], 'c': ['carrot'] }
  */
 var groupBy = exports.groupBy = function groupBy(array, iteratee) {
-  return array.reduce(function (accumulator, value, index, array) {
+  var result = Object.create(null);
+  var length = array.length;
+  for (var index = 0; index < length; index++) {
+    var value = array[index];
     var key = iteratee(value, index, array);
-    if (!accumulator[key]) {
-      accumulator[key] = [];
-    }
-    accumulator[key].push(value);
-    return accumulator;
-  }, {});
+    // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+    (result[key] || (result[key] = [])).push(value);
+  }
+  return result;
 };

package/module/es5/Array/index.d.ts

@@ -20,5 +20,6 @@ export * from "./shuffle";
 export * from "./shuffle2DArray";
 export * from "./sum";
 export * from "./timSort";
+export * from "./ultraNumberSort";
 export * from "./zip";
 export * from "./zipLongest";

package/module/es5/Array/index.js

@@ -245,6 +245,17 @@ Object.keys(_timSort).forEach(function (key) {
     }
   });
 });
+var _ultraNumberSort = require("./ultraNumberSort");
+Object.keys(_ultraNumberSort).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ultraNumberSort[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _ultraNumberSort[key];
+    }
+  });
+});
 var _zip = require("./zip");
 Object.keys(_zip).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Array/quickSort.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.quickSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+var _applyInsertionSortIfNeeded = require("./sortingHelpers/applyInsertionSortIfNeeded");
+var _rangeValidator = require("./sortingHelpers/rangeValidator");
 /**
  * Finds the median value among three elements in the array
  * @param array The array containing the elements
@@ -64,25 +66,6 @@ var partition = function partition(array, low, high, compareFunction) {
   }
 };
 
-/**
- * Sorts a portion of the array using insertion sort algorithm
- * @param array Array to sort
- * @param low Starting index of the range to sort
- * @param high Ending index of the range to sort
- * @param compareFunction Function to compare elements
- */
-var insertionSort = function insertionSort(array, low, high, compareFunction) {
-  for (var index = low + 1; index <= high; index++) {
-    var key = array[index];
-    var currentIndex = index - 1;
-    while (currentIndex >= low && compareFunction(array[currentIndex], key) > 0) {
-      array[currentIndex + 1] = array[currentIndex];
-      currentIndex--;
-    }
-    array[currentIndex + 1] = key;
-  }
-};
-
 /**
  * Internal implementation of the quicksort algorithm with tail-call optimization
  * @param array Array to sort
@@ -95,8 +78,7 @@ var _sortImpl = function sortImpl(array, lowInit, highInit, compareFunction, ins
   var low = lowInit;
   var high = highInit;
   while (low < high) {
-    if (high - low < insertionSortThreshold) {
-      insertionSort(array, low, high, compareFunction);
+    if ((0, _applyInsertionSortIfNeeded.applyInsertionSortIfNeeded)(array, low, high, compareFunction, insertionSortThreshold)) {
       return;
     }
     var pivotIndex = partition(array, low, high, compareFunction);
@@ -128,9 +110,12 @@ var quickSort = exports.quickSort = function quickSort(array) {
   var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
   var insertionSortThreshold = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
-  // Only sort within valid range
-  var validStartIndex = Math.max(0, Math.min(startIndex, array.length - 1));
-  var validEndIndex = Math.max(validStartIndex, Math.min(endIndex, array.length - 1));
-  _sortImpl(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+  var _validateRange = (0, _rangeValidator.validateRange)(array, startIndex, endIndex),
+    validStartIndex = _validateRange.startIndex,
+    validEndIndex = _validateRange.endIndex,
+    shouldSort = _validateRange.shouldSort;
+  if (shouldSort) {
+    _sortImpl(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+  }
   return array;
 };

package/module/es5/Array/sortingHelpers/applyInsertionSortIfNeeded.d.ts

@@ -0,0 +1,13 @@
+import type { CompareFunction } from "$/array/compareFunction";
+/**
+ * Checks if a partition is small enough to apply insertion sort and applies it if so.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array containing the partition.
+ * @param {number} low The starting index of the partition.
+ * @param {number} high The ending index of the partition.
+ * @param {CompareFunction<T>} compareFunction The function to compare elements.
+ * @param {number} insertionSortThreshold The size threshold for switching to insertion sort.
+ * @returns {boolean} True if insertion sort was applied, false otherwise.
+ */
+export declare const applyInsertionSortIfNeeded: <T>(array: T[], low: number, high: number, compareFunction: CompareFunction<T>, insertionSortThreshold: number) => boolean;

package/module/es5/Array/sortingHelpers/applyInsertionSortIfNeeded.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyInsertionSortIfNeeded = void 0;
+var _insertionSort = require("@/Array/insertionSort");
+/**
+ * Checks if a partition is small enough to apply insertion sort and applies it if so.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array containing the partition.
+ * @param {number} low The starting index of the partition.
+ * @param {number} high The ending index of the partition.
+ * @param {CompareFunction<T>} compareFunction The function to compare elements.
+ * @param {number} insertionSortThreshold The size threshold for switching to insertion sort.
+ * @returns {boolean} True if insertion sort was applied, false otherwise.
+ */
+var applyInsertionSortIfNeeded = exports.applyInsertionSortIfNeeded = function applyInsertionSortIfNeeded(array, low, high, compareFunction, insertionSortThreshold) {
+  if (high - low + 1 <= insertionSortThreshold) {
+    (0, _insertionSort.insertionSort)(array, compareFunction, low, high);
+    return true;
+  }
+  return false;
+};

package/module/es5/Array/sortingHelpers/rangeValidator.d.ts

@@ -0,0 +1,17 @@
+export interface ValidatedSortRange {
+    startIndex: number;
+    endIndex: number;
+    shouldSort: boolean;
+}
+/**
+ * Validates and adjusts the start and end indices for an operation on an array.
+ * Ensures indices are within the bounds of the array.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array.
+ * @param {number} startIndex The desired starting index.
+ * @param {number} endIndex The desired ending index.
+ * @returns {ValidatedSortRange} An object containing the validated start index, end index,
+ *                               and a boolean indicating if the operation should proceed on the range.
+ */
+export declare const validateRange: <T>(array: T[], startIndex: number, endIndex: number) => ValidatedSortRange;

package/module/es5/Array/sortingHelpers/rangeValidator.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateRange = void 0;
+/**
+ * Validates and adjusts the start and end indices for an operation on an array.
+ * Ensures indices are within the bounds of the array.
+ *
+ * @template T The type of elements in the array.
+ * @param {T[]} array The array.
+ * @param {number} startIndex The desired starting index.
+ * @param {number} endIndex The desired ending index.
+ * @returns {ValidatedSortRange} An object containing the validated start index, end index,
+ *                               and a boolean indicating if the operation should proceed on the range.
+ */
+var validateRange = exports.validateRange = function validateRange(array, startIndex, endIndex) {
+  var length = array.length;
+  // Handle empty arrays early
+  if (length === 0) {
+    return {
+      startIndex: 0,
+      endIndex: -1,
+      shouldSort: false
+    };
+  }
+  var validatedStartIndex = Math.max(0, Math.min(startIndex, length - 1));
+  var validatedEndIndex = Math.max(validatedStartIndex, Math.min(endIndex, length - 1));
+  return {
+    startIndex: validatedStartIndex,
+    endIndex: validatedEndIndex,
+    shouldSort: validatedEndIndex >= validatedStartIndex
+  };
+};

package/module/es5/Array/timSort.js

@@ -5,27 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.timSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
+var _insertionSort = require("@/Array/insertionSort");
 var MIN_RUN = 32;
 
-/**
- * Sorts a portion of the array using insertion sort algorithm
- * @param array Array to sort
- * @param start Starting index of the range to sort
- * @param end Ending index of the range to sort
- * @param compareFunction Function to compare elements
- */
-var insertionSort = function insertionSort(array, start, end, compareFunction) {
-  for (var index = start + 1; index <= end; index++) {
-    var temporary = array[index];
-    var currentIndex = index - 1;
-    while (currentIndex >= start && compareFunction(array[currentIndex], temporary) > 0) {
-      array[currentIndex + 1] = array[currentIndex];
-      currentIndex--;
-    }
-    array[currentIndex + 1] = temporary;
-  }
-};
-
 /**
  * Merges two sorted portions of the array
  * @param array Array containing the portions to merge
@@ -100,7 +82,7 @@ var timSort = exports.timSort = function timSort(array) {
   var n = end - start + 1;
   var minRun = getMinRunLength(n);
   for (var index = start; index <= end; index += minRun) {
-    insertionSort(array, index, Math.min(index + MIN_RUN - 1, end), compareFunction);
+    (0, _insertionSort.insertionSort)(array, compareFunction, index, Math.min(index + MIN_RUN - 1, end));
   }
   for (var size = minRun; size < n; size *= 2) {
     for (var left = start; left <= end; left += 2 * size) {

package/module/es5/Array/ultraNumberSort.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ultra-fast sorting specifically optimized for number arrays
+ * @param array Array of numbers to sort
+ * @param ascending Sort in ascending order if true, descending if false
+ * @returns Sorted array
+ */
+export declare const ultraNumberSort: (array: number[], ascending?: boolean) => number[];