Add several more util functions and tests (#4106)

src/common/hotbar-types.ts

@@ -20,7 +20,7 @@
  */
 
 import * as uuid from "uuid";
-import type { Tuple } from "./utils";
+import { tuple, Tuple } from "./utils";
 
 export interface HotbarItem {
   entity: {
@@ -46,7 +46,7 @@ export const defaultHotbarCells = 12; // Number is chosen to easy hit any item w
 export function getEmptyHotbar(name: string, id: string = uuid.v4()): Hotbar {
   return {
     id,
-    items: Array(defaultHotbarCells).fill(null) as Tuple<HotbarItem | null, typeof defaultHotbarCells>,
+    items: tuple.filled(defaultHotbarCells, null),
     name,
   };
 }

src/common/utils/__tests__/tuple.test.ts

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import { tuple } from "../../utils";
+
+describe("tuple tests", () => {
+  describe("zip()", () => {
+    it("should yield 0 times and return 1 tuple of empty arrays when given empty array", () => {
+      expect(tuple.zip([]).next()).toEqual({
+        done: true,
+        value: [[]],
+      });
+    });
+
+    it("should yield 1 times and return 2 tuple of empty arrays when given one element array tuples", () => {
+      const i = tuple.zip([1], [2]);
+
+      expect(i.next()).toEqual({
+        done: false,
+        value: [1, 2]
+      });
+      expect(i.next()).toEqual({
+        done: true,
+        value: [[], []],
+      });
+    });
+
+    it("should yield 1 times and return 2 tuple of partial arrays when given one element array tuples", () => {
+      const i = tuple.zip([1], [2, 3]);
+
+      expect(i.next()).toEqual({
+        done: false,
+        value: [1, 2]
+      });
+      expect(i.next()).toEqual({
+        done: true,
+        value: [[], [3]],
+      });
+    });
+  });
+});

src/common/utils/array.ts

@@ -19,26 +19,11 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-export type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
-type _TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>;
-
 /**
- *
- * @param sources The source arrays
- * @yields A tuple of the next element from each of the sources
- * @returns The tuple of all the sources as soon as at least one of the sources is exausted
+ * A inference typed version of `Array(length).fill(value)`
+ * @param length The number of entries
+ * @param value The value of each of the indices
  */
-export function* zipStrict<T, N extends number>(...sources: Tuple<T[], N>): Iterator<Tuple<T, N>, Tuple<T[], N>> {
-  const maxSafeLength = sources.reduce((prev, cur) => Math.min(prev, cur.length), Number.POSITIVE_INFINITY);
-
-  if (!isFinite(maxSafeLength)) {
-    // There are no sources, thus just return
-    return [] as Tuple<T[], N>;
-  }
-
-  for (let i = 0; i < maxSafeLength; i += 1) {
-    yield sources.map(source => source[i]) as Tuple<T, N>;
-  }
-
-  return sources.map(source => source.slice(maxSafeLength)) as Tuple<T[], N>;
+export function filled<T>(length: number, value: T): T[] {
+  return Array(length).fill(value);
 }

src/common/utils/index.ts

@@ -61,5 +61,10 @@ export * from "./convertCpu";
 
 import * as iter from "./iter";
 import * as array from "./array";
+import * as tuple from "./tuple";
 
-export { iter, array };
+export {
+  iter,
+  array,
+  tuple,
+};

src/common/utils/tuple.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import { array } from "../utils";
+
+/**
+ * A strict N-tuple of type T
+ */
+export type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
+type _TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+
+/**
+ * Iterates over `sources` yielding full tuples until one of the tuple arrays
+ * is empty. Then it returns a tuple with the rest of each of tuples
+ * @param sources The source arrays
+ * @yields A tuple of the next element from each of the sources
+ * @returns The tuple of all the sources as soon as at least one of the sources is exausted
+ */
+export function* zip<T, N extends number>(...sources: Tuple<T[], N>): Iterator<Tuple<T, N>, Tuple<T[], N>> {
+  const maxSafeLength = Math.min(...sources.map(source => source.length));
+
+  for (let i = 0; i < maxSafeLength; i += 1) {
+    yield sources.map(source => source[i]) as Tuple<T, N>;
+  }
+
+  return sources.map(source => source.slice(maxSafeLength)) as Tuple<T[], N>;
+}
+
+/**
+ * Returns a `length` tuple filled with copies of `value`
+ * @param length The size of the tuple
+ * @param value The value for each of the tuple entries
+ */
+export function filled<T, L extends number>(length: L, value: T): Tuple<T, L> {
+  return array.filled(length, value) as Tuple<T, L>;
+}