fix: build

packages/collection-utils/src/chunk.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Chunk array into smaller arrays of a specified size.
+ *
+ * @param array The array to chunk.
+ * @param chunkSize The size of each chunk.
+ */
+export function chunk<T>(array: T[], chunkSize = 1): T[][] {
+  const arrayCopy = [...array];
+  const out: T[][] = [];
+  if (chunkSize <= 0) return out;
+  while (arrayCopy.length > 0) out.push(arrayCopy.splice(0, chunkSize));
+  return out;
+}

packages/collection-utils/src/difference.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Returns the difference between two arrays.
+ */
+export function differenceBy<T>(a: T[], b: T[], transform: (item: T) => unknown) {
+  const disallowed = new Set(b.map(transform));
+
+  return a.filter(item => !disallowed.has(transform(item)));
+}

packages/collection-utils/src/get.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Gets a value from a nested object.
+ * The path must be key names separated by dots.
+ * If the path doesn't exist, undefined is returned.
+ */
+export function get<U = unknown>(object: object, path: string): U {
+  return path.split('.').reduce(
+    (accumulator, current) =>
+      accumulator?.hasOwnProperty(current)
+        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (accumulator as any)[current]
+        : undefined,
+    object,
+  ) as unknown as U;
+}

packages/collection-utils/src/group-by.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Group an array by a function
+ */
+export function groupBy<T>(collection: T[], group: (item: T) => string | undefined): Record<string, T[]> {
+  return collection.reduce((accumulator: Record<string, T[]>, item) => {
+    const key = group(item) ?? '';
+    accumulator[key] = accumulator[key] ?? [];
+    accumulator[key].push(item);
+    return accumulator;
+  }, {});
+}
+
+/**
+ * Group an array by a function (returns a Map, whose keys keep order info of items entry)
+ */
+export function groupByStable<T>(collection: T[], group: (item: T) => string | undefined): Map<string, T[]> {
+  return collection.reduce((accumulator: Map<string, T[]>, item) => {
+    const key = group(item) ?? '';
+    accumulator.set(key, accumulator.get(key) ?? []);
+    accumulator.get(key)?.push(item);
+    return accumulator;
+  }, new Map<string, T[]>());
+}
+
+/**
+ *
+ */
+export function groupByProperty<T extends object>(collection: T[], property: keyof T): Record<string, T[]> {
+  return groupBy(collection, item => item[property] as unknown as string);
+}

packages/collection-utils/src/key-by.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Create an object composed of keys generated from the results of running
+ * each element of collection thru iteratee. The corresponding value of
+ * each key is the last element responsible for generating the key. The
+ * iteratee is invoked with one argument: (value).
+ */
+export function keyBy<T>(collection: T[], key: (item: T) => string | number): Record<string, T> {
+  return collection.reduce((accumulator, item) => {
+    accumulator[key(item)] = item;
+    return accumulator;
+  }, {} as Record<string | number, T>);
+}

packages/collection-utils/src/map-values.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Maps the values of an object to a new object
+ */
+export function mapValues<T extends object, U>(
+  object: T,
+  transform: (value: T[keyof T], key: keyof T) => U,
+): {[key in keyof T]: U} {
+  const result = {} as {[key in keyof T]: U};
+
+  for (const key in object) {
+    if (object.hasOwnProperty(key)) {
+      result[key] = transform(object[key], key);
+    }
+  }
+
+  return result;
+}

packages/collection-utils/src/min.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Returns the minimum value of a collection.
+ */
+export function minBy<T>(array: T[], transform: (item: T) => number | undefined): T {
+  const transforms = array.map(transform);
+  const min = Math.min(...(transforms.filter(it => !!it) as number[]));
+  return array.find((_, i) => transforms[i] === min) as T;
+}

packages/collection-utils/src/omit.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Returns a new object without the specified keys.
+ */
+export function omit<T extends object, U extends keyof T>(object: T, ...keys: U[]): Omit<T, U> {
+  const out = {...object};
+  for (const key of keys) delete out[key];
+  return out as Exclude<T, U>;
+}

packages/collection-utils/src/partition.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Partitions a list into two lists. One with the elements that satisfy a predicate,
+ * and one with the elements that don't satisfy the predicate.
+ */
+export function partition<T>(array: T[], transform: (item: T) => boolean): [T[], T[]] {
+  return array.reduce<[T[], T[]]>(
+    (accumulator, item) => {
+      accumulator[transform(item) ? 0 : 1].push(item);
+      return accumulator;
+    },
+    [[], []],
+  );
+}

packages/collection-utils/src/pick.ts

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Pick a set of properties from an object
+ */
+export function pick<T extends object, U extends keyof T>(object: T, keys: U[]): Pick<T, U> {
+  return keys.reduce((accumulator, key) => {
+    if (object.hasOwnProperty(key)) {
+      accumulator[key] = object[key];
+    }
+    return accumulator;
+  }, {} as Pick<T, U>);
+}
+
+/**
+ * Pick a set of properties from an object using a predicate function
+ */
+export function pickBy<T extends object, U extends keyof T>(
+  object: T,
+  predicate: (value: T[U], key: U) => boolean,
+): Pick<T, U> {
+  return (Object.keys(object) as U[]).reduce((accumulator, key) => {
+    if (predicate(object[key], key)) {
+      accumulator[key] = object[key];
+    }
+    return accumulator;
+  }, {} as Pick<T, U>);
+}

packages/collection-utils/src/shuffle.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Shuffles an array
+ */
+export function shuffle<T>(array: T[]): T[] {
+  const copy = [...array];
+  const out = [];
+
+  while (copy.length > 0) {
+    out.push(copy.splice(Math.floor(Math.random() * copy.length), 1)[0]);
+  }
+
+  return out;
+}

packages/collection-utils/src/string-sort.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * sort function for two strings
+ */
+export function stringSort(a = '', b = ''): number {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+
+/**
+ * sort function for two strings that allows for a custom transform
+ */
+export function stringSortBy<T>(map: (item: T) => string | undefined): (a: T, b: T) => number {
+  return (a: T, b: T): number => {
+    const aValue = map(a) || '';
+    const bValue = map(b) || '';
+    if (aValue < bValue) return -1;
+    if (aValue > bValue) return 1;
+    return 0;
+  };
+}

packages/collection-utils/src/sum.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Sum an an array
+ */
+export function sumBy<T extends object>(
+  collection: T[],
+  transform: (value: T) => number | undefined,
+): number {
+  return collection.reduce((accumulator, item) => accumulator + (transform(item) || 0), 0);
+}
+
+/**
+ * Sum an array of numbers
+ */
+export function sum(collection: Array<number | undefined>): number {
+  return collection.reduce<number>((accumulator, item) => accumulator + (item || 0), 0);
+}

packages/collection-utils/src/tree-group.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export type Tree<T> = {
+  [key: string]: Tree<T>;
+} & {
+  _?: T[] | undefined;
+};
+
+/**
+ *
+ */
+export function treeGroupBy<T>(items: T[], transform: (item: T) => string[]): Tree<T> {
+  const tree: Tree<T> = {};
+
+  for (const item of items) {
+    let currentTree = tree;
+    const keys = transform(item);
+    if (keys.length === 0) {
+      currentTree._ = currentTree._ || [];
+      currentTree._.push(item);
+    }
+    // eslint-disable-next-line unicorn/no-array-for-each
+    keys.forEach((key, i) => {
+      currentTree = currentTree[key] = (currentTree[key] ?? {}) as Tree<T>;
+      if (i === keys.length - 1) {
+        currentTree._ = currentTree._ ?? [];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        currentTree._.push(item);
+      }
+    });
+  }
+
+  return tree;
+}

packages/collection-utils/src/uniq.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2022 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Filter out duplicates from an array.
+ */
+export function uniqBy<T>(array: T[], transform: (item: T) => string | number): T[] {
+  return Object.values(
+    array.reduce((accumulator, current) => {
+      accumulator[transform(current)] = current;
+      return accumulator;
+    }, {} as Record<string | number, T>),
+  );
+}

packages/collection-utils/src/zip.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2022 StApps
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the Free
+ *  Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ *  more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Zip two arrays together.
+ */
+export function zip<T, U>(a: T[], b: U[]): [T, U][] {
+  return a.map((_, i) => [a[i], b[i]]);
+}