Port common features from collections and math tgui

Port of tgstation/tgstation#57889
Notable: tests not included

tgui/packages/common/collections.js → tgui/packages/common/collections.ts

@@ -171,6 +171,23 @@ export const sortBy = (...iterateeFns) => array => {
   return mappedArray;
 };
 
+/**
+ * Creates an array of elements, sorted in ascending order by the results
+ * of running each element in a collection thru each iteratee.
+ *
+ * Iteratees are called with one argument (value).
+ *
+ * @returns {any[]}
+ */
+export const sort = sortBy();
+
+/**
+ * Returns a range of numbers from start to end, exclusively.
+ * For example, range(0, 5) will return [0, 1, 2, 3, 4].
+ */
+export const range = (start: number, end: number): number[] =>
+  new Array(end - start).fill(null).map((_, index) => index + start);
+
 /**
  * A fast implementation of reduce.
  */
@@ -203,14 +220,17 @@ export const reduce = (reducerFn, initialValue) => array => {
  * is determined by the order they occur in the array. The iteratee is
  * invoked with one argument: value.
  */
-export const uniqBy = iterateeFn => array => {
+/* eslint-disable indent */
+export const uniqBy = <T extends unknown>(
+  iterateeFn?: (value: T) => unknown
+) => (array: T[]) => {
   const { length } = array;
   const result = [];
   const seen = iterateeFn ? [] : result;
   let index = -1;
   outer:
   while (++index < length) {
-    let value = array[index];
+    let value: T | 0 = array[index];
     const computed = iterateeFn ? iterateeFn(value) : value;
     value = value !== 0 ? value : 0;
     if (computed === computed) {
@@ -234,15 +254,30 @@ export const uniqBy = iterateeFn => array => {
   }
   return result;
 };
+/**
+ * Creates a duplicate-free version of an array, using SameValueZero for
+ * equality comparisons, in which only the first occurrence of each element
+ * is kept. The order of result values is determined by the order they occur
+ * in the array.
+ *
+ * It accepts iteratee which is invoked for each element in array to generate
+ * the criterion by which uniqueness is computed. The order of result values
+ * is determined by the order they occur in the array. The iteratee is
+ * invoked with one argument: value.
+ */
+export const uniq = uniqBy();
+/* eslint-enable indent */
+
+type Zip<T extends unknown[][]> = {
+  [I in keyof T]: T[I] extends (infer U)[] ? U : never;
+}[];
 
 /**
  * Creates an array of grouped elements, the first of which contains
  * the first elements of the given arrays, the second of which contains
  * the second elements of the given arrays, and so on.
- *
- * @returns {any[]}
  */
-export const zip = (...arrays) => {
+export const zip = <T extends unknown[][]>(...arrays: T): Zip<T> => {
   if (arrays.length === 0) {
     return;
   }

tgui/packages/common/math.js → tgui/packages/common/math.ts

@@ -45,7 +45,7 @@ export const round = (value, precision) => {
   m = Math.pow(10, precision);
   value *= m;
   // sign of the number
-  sgn = (value > 0) | -(value < 0);
+  sgn = +(value > 0) | -(value < 0);
   // isHalf = value % 1 === 0.5 * sgn;
   isHalf = Math.abs(value % 1) >= 0.4999999999854481;
   f = Math.floor(value);