From 51602ffa0f45404731ed18ded72f761a782dbd8e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thea=20Sch=C3=B6bl?= <dev@theaninova.de>
Date: Tue, 7 Nov 2023 18:00:17 +0100
Subject: [PATCH] feat: pipeline improvements

---
 packages/collection-utils/package.json        | 18 +++-------
 .../src/{chunk.ts => chunk.js}                | 11 +++---
 .../src/{difference.ts => difference.js}      |  7 +++-
 .../collection-utils/src/{get.ts => get.js}   | 24 ++++++++-----
 .../src/{group-by.ts => group-by.js}          | 29 ++++++++++-----
 .../src/{index.ts => index.js}                |  0
 .../src/{key-by.ts => key-by.js}              | 15 ++++----
 ...{map-async-limit.ts => map-async-limit.js} | 18 +++++-----
 .../src/{map-values.ts => map-values.js}      | 12 ++++---
 .../collection-utils/src/{min.ts => min.js}   | 10 ++++--
 .../collection-utils/src/{omit.ts => omit.js} |  9 +++--
 .../src/{partition.ts => partition.js}        | 17 ++++-----
 .../collection-utils/src/{pick.ts => pick.js} | 23 +++++++-----
 .../src/{shuffle.ts => shuffle.js}            |  5 ++-
 .../src/{string-sort.ts => string-sort.js}    | 12 +++++--
 .../collection-utils/src/{sum.ts => sum.js}   | 15 ++++----
 .../src/{tree-group.ts => tree-group.js}      | 18 +++++-----
 packages/collection-utils/src/types.d.ts      |  7 ++++
 .../collection-utils/src/{uniq.ts => uniq.js} |  8 +++--
 .../collection-utils/src/{zip.ts => zip.js}   |  7 +++-
 .../test/{chunk.spec.ts => chunk.spec.js}     |  0
 ...{difference.spec.ts => difference.spec.js} |  0
 .../test/{get.spec.ts => get.spec.js}         |  0
 .../{group-by.spec.ts => group-by.spec.js}    |  0
 .../test/{key-by.spec.ts => key-by.spec.js}   |  0
 ...{map-values.spec.ts => map-values.spec.js} |  0
 .../test/{min.spec.ts => min.spec.js}         |  0
 .../test/{omit.spec.ts => omit.spec.js}       |  0
 .../{partition.spec.ts => partition.spec.js}  |  0
 .../test/{pick.spec.ts => pick.spec.js}       |  0
 .../test/{shuffle.spec.ts => shuffle.spec.js} |  0
 ...tring-sort.spec.ts => string-sort.spec.js} |  0
 .../test/{sum.spec.ts => sum.spec.js}         |  0
 ...{tree-group.spec.ts => tree-group.spec.js} | 36 ++++++++++---------
 .../test/{uniq.spec.ts => uniq.spec.js}       |  0
 .../test/{zip.spec.ts => zip.spec.js}         |  0
 packages/core/package.json                    |  9 -----
 pnpm-lock.yaml                                |  3 --
 38 files changed, 183 insertions(+), 130 deletions(-)
 rename packages/collection-utils/src/{chunk.ts => chunk.js} (79%)
 rename packages/collection-utils/src/{difference.ts => difference.js} (83%)
 rename packages/collection-utils/src/{get.ts => get.js} (67%)
 rename packages/collection-utils/src/{group-by.ts => group-by.js} (58%)
 rename packages/collection-utils/src/{index.ts => index.js} (100%)
 rename packages/collection-utils/src/{key-by.ts => key-by.js} (66%)
 rename packages/collection-utils/src/{map-async-limit.ts => map-async-limit.js} (74%)
 rename packages/collection-utils/src/{map-values.ts => map-values.js} (75%)
 rename packages/collection-utils/src/{min.ts => min.js} (70%)
 rename packages/collection-utils/src/{omit.ts => omit.js} (81%)
 rename packages/collection-utils/src/{partition.ts => partition.js} (70%)
 rename packages/collection-utils/src/{pick.ts => pick.js} (66%)
 rename packages/collection-utils/src/{shuffle.ts => shuffle.js} (90%)
 rename packages/collection-utils/src/{string-sort.ts => string-sort.js} (78%)
 rename packages/collection-utils/src/{sum.ts => sum.js} (66%)
 rename packages/collection-utils/src/{tree-group.ts => tree-group.js} (79%)
 create mode 100644 packages/collection-utils/src/types.d.ts
 rename packages/collection-utils/src/{uniq.ts => uniq.js} (80%)
 rename packages/collection-utils/src/{zip.ts => zip.js} (85%)
 rename packages/collection-utils/test/{chunk.spec.ts => chunk.spec.js} (100%)
 rename packages/collection-utils/test/{difference.spec.ts => difference.spec.js} (100%)
 rename packages/collection-utils/test/{get.spec.ts => get.spec.js} (100%)
 rename packages/collection-utils/test/{group-by.spec.ts => group-by.spec.js} (100%)
 rename packages/collection-utils/test/{key-by.spec.ts => key-by.spec.js} (100%)
 rename packages/collection-utils/test/{map-values.spec.ts => map-values.spec.js} (100%)
 rename packages/collection-utils/test/{min.spec.ts => min.spec.js} (100%)
 rename packages/collection-utils/test/{omit.spec.ts => omit.spec.js} (100%)
 rename packages/collection-utils/test/{partition.spec.ts => partition.spec.js} (100%)
 rename packages/collection-utils/test/{pick.spec.ts => pick.spec.js} (100%)
 rename packages/collection-utils/test/{shuffle.spec.ts => shuffle.spec.js} (100%)
 rename packages/collection-utils/test/{string-sort.spec.ts => string-sort.spec.js} (100%)
 rename packages/collection-utils/test/{sum.spec.ts => sum.spec.js} (100%)
 rename packages/collection-utils/test/{tree-group.spec.ts => tree-group.spec.js} (74%)
 rename packages/collection-utils/test/{uniq.spec.ts => uniq.spec.js} (100%)
 rename packages/collection-utils/test/{zip.spec.ts => zip.spec.js} (100%)

diff --git a/packages/collection-utils/package.json b/packages/collection-utils/package.json
index f8fc6b8c..0049a342 100644
--- a/packages/collection-utils/package.json
+++ b/packages/collection-utils/package.json
@@ -3,19 +3,19 @@
   "version": "3.0.0",
   "type": "module",
   "license": "GPL-3.0-only",
-  "main": "lib/index.js",
+  "main": "src/index.js",
+  "types": "src/types.d.ts",
   "files": [
     "lib",
     "README.md",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsup-node --dts",
     "docs": "typedoc --json ./docs/docs.json --options ../../typedoc.base.json src/index.ts",
     "format": "prettier . -c --ignore-path ../../.gitignore",
     "format:fix": "prettier --write . --ignore-path ../../.gitignore",
-    "lint": "eslint --ext .ts src/",
-    "lint:fix": "eslint --fix --ext .ts src/",
+    "lint": "tsc --noEmit && eslint --ext .js src/",
+    "lint:fix": "eslint --fix --ext .js src/",
     "test": "c8 mocha"
   },
   "devDependencies": {
@@ -30,19 +30,9 @@
     "mocha": "10.2.0",
     "mocha-junit-reporter": "2.2.0",
     "ts-node": "10.9.1",
-    "tsup": "7.2.0",
     "typedoc": "0.24.8",
     "typescript": "5.1.6"
   },
-  "tsup": {
-    "entry": [
-      "src/index.ts"
-    ],
-    "sourcemap": true,
-    "clean": true,
-    "format": "esm",
-    "outDir": "lib"
-  },
   "prettier": "@openstapps/prettier-config",
   "eslintConfig": {
     "extends": [
diff --git a/packages/collection-utils/src/chunk.ts b/packages/collection-utils/src/chunk.js
similarity index 79%
rename from packages/collection-utils/src/chunk.ts
rename to packages/collection-utils/src/chunk.js
index 4d5422c5..ab1d8fce 100644
--- a/packages/collection-utils/src/chunk.ts
+++ b/packages/collection-utils/src/chunk.js
@@ -15,12 +15,15 @@
 
 /**
  * Chunk array into smaller arrays of a specified size.
- * @param array The array to chunk.
- * @param chunkSize The size of each chunk.
+ * @template T
+ * @param array {T[]} The array to chunk.
+ * @param [chunkSize] {number} The size of each chunk.
+ * @returns {T[][]}
  */
-export function chunk<T>(array: T[], chunkSize = 1): T[][] {
+export function chunk(array, chunkSize = 1) {
   const arrayCopy = [...array];
-  const out: T[][] = [];
+  /** @type {T[][]} */
+  const out = [];
   if (chunkSize <= 0) return out;
   while (arrayCopy.length > 0) out.push(arrayCopy.splice(0, chunkSize));
   return out;
diff --git a/packages/collection-utils/src/difference.ts b/packages/collection-utils/src/difference.js
similarity index 83%
rename from packages/collection-utils/src/difference.ts
rename to packages/collection-utils/src/difference.js
index 62839057..a704b9a3 100644
--- a/packages/collection-utils/src/difference.ts
+++ b/packages/collection-utils/src/difference.js
@@ -15,8 +15,13 @@
 
 /**
  * Returns the difference between two arrays.
+ * @template T
+ * @param a {T[]}
+ * @param b {T[]}
+ * @param transform {(item: T) => unknown}
+ * @returns {T[]}
  */
-export function differenceBy<T>(a: T[], b: T[], transform: (item: T) => unknown) {
+export function differenceBy(a, b, transform) {
   const disallowed = new Set(b.map(transform));
 
   return a.filter(item => !disallowed.has(transform(item)));
diff --git a/packages/collection-utils/src/get.ts b/packages/collection-utils/src/get.js
similarity index 67%
rename from packages/collection-utils/src/get.ts
rename to packages/collection-utils/src/get.js
index 78f20749..48f6e550 100644
--- a/packages/collection-utils/src/get.ts
+++ b/packages/collection-utils/src/get.js
@@ -17,14 +17,20 @@
  * 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.
+ *
+ * @template {unknown} U
+ * @param object {object}
+ * @param path {string}
+ * @returns {U}
  */
-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;
+export function get(object, path) {
+  return /** @type {U} */ (
+    path
+      .split('.')
+      .reduce(
+        (accumulator, current) =>
+          accumulator?.hasOwnProperty(current) ? /** @type {any} */ (accumulator)[current] : undefined,
+        object,
+      )
+  );
 }
diff --git a/packages/collection-utils/src/group-by.ts b/packages/collection-utils/src/group-by.js
similarity index 58%
rename from packages/collection-utils/src/group-by.ts
rename to packages/collection-utils/src/group-by.js
index 6723f7db..c7d63952 100644
--- a/packages/collection-utils/src/group-by.ts
+++ b/packages/collection-utils/src/group-by.js
@@ -15,31 +15,42 @@
 
 /**
  * Group an array by a function
+ * @template T
+ * @param collection {T[]}
+ * @param group {(item: T) => string | undefined}
+ * @returns {Record<string, T[]>}
  */
-export function groupBy<T>(collection: T[], group: (item: T) => string | undefined): Record<string, T[]> {
-  return collection.reduce((accumulator: Record<string, T[]>, item) => {
+export function groupBy(collection, group) {
+  return collection.reduce((accumulator, item) => {
     const key = group(item) ?? '';
     accumulator[key] = accumulator[key] ?? [];
     accumulator[key].push(item);
     return accumulator;
-  }, {});
+  }, /** @type {Record<string, T[]>} */ ({}));
 }
 
 /**
  * Group an array by a function (returns a Map, whose keys keep order info of items entry)
+ * @template T
+ * @param collection {T[]}
+ * @param group {(item: T) => string | undefined}
+ * @returns {Map<string, T[]>}
  */
-export function groupByStable<T>(collection: T[], group: (item: T) => string | undefined): Map<string, T[]> {
-  return collection.reduce((accumulator: Map<string, T[]>, item) => {
+export function groupByStable(collection, group) {
+  return collection.reduce((accumulator, item) => {
     const key = group(item) ?? '';
     accumulator.set(key, accumulator.get(key) ?? []);
     accumulator.get(key)?.push(item);
     return accumulator;
-  }, new Map<string, T[]>());
+  }, /** @type {Map<string, T[]>} */ new Map());
 }
 
 /**
- *
+ * @template {object} T
+ * @param collection {T[]}
+ * @param property {keyof T}
+ * @returns {Record<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);
+export function groupByProperty(collection, property) {
+  return groupBy(collection, item => item[property]);
 }
diff --git a/packages/collection-utils/src/index.ts b/packages/collection-utils/src/index.js
similarity index 100%
rename from packages/collection-utils/src/index.ts
rename to packages/collection-utils/src/index.js
diff --git a/packages/collection-utils/src/key-by.ts b/packages/collection-utils/src/key-by.js
similarity index 66%
rename from packages/collection-utils/src/key-by.ts
rename to packages/collection-utils/src/key-by.js
index e7f3a544..4ca74bce 100644
--- a/packages/collection-utils/src/key-by.ts
+++ b/packages/collection-utils/src/key-by.js
@@ -14,14 +14,17 @@
  */
 
 /**
- * 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).
+ * Create an object composed of keys generated from the results of running each element of collection through iteratee.
+ * The corresponding value of each key is the last element responsible for generating the key.
+ * The iteratee is invoked with one argument: (value).
+ * @template T
+ * @param collection {T[]}
+ * @param key {(item: T) => string | number}
+ * @returns {Record<string, T>}
  */
-export function keyBy<T>(collection: T[], key: (item: T) => string | number): Record<string, T> {
+export function keyBy(collection, key) {
   return collection.reduce((accumulator, item) => {
     accumulator[key(item)] = item;
     return accumulator;
-  }, {} as Record<string | number, T>);
+  }, /** @type {Record<string, T>} */ ({}));
 }
diff --git a/packages/collection-utils/src/map-async-limit.ts b/packages/collection-utils/src/map-async-limit.js
similarity index 74%
rename from packages/collection-utils/src/map-async-limit.ts
rename to packages/collection-utils/src/map-async-limit.js
index 10a949ac..ef50db1c 100644
--- a/packages/collection-utils/src/map-async-limit.ts
+++ b/packages/collection-utils/src/map-async-limit.js
@@ -19,19 +19,19 @@
  * Note: JavaScript is not multithreaded.
  * This will not let you run tasks in parallel, use it only to limit how many network requests should be
  * running at once.
- * @param items the items to iterate through
- * @param task the task to be run
- * @param limit the maximum number of tasks that should be run asynchronously
+ * @template T
+ * @template U
+ * @param items {T[]} the items to iterate through
+ * @param task {(item: T, index: number) => Promise<U>} the task to be run
+ * @param [limit] {number} the maximum number of tasks that should be run asynchronously
+ * @returns {Promise<U[]>}
  */
-export async function mapAsyncLimit<T, U = void>(
-  items: T[],
-  task: (item: T, index: number) => Promise<U>,
-  limit = 5,
-): Promise<U[]> {
+export async function mapAsyncLimit(items, task, limit = 5) {
   return Promise.all(
     Array.from({length: limit}).map(async () => {
       let i = 0;
-      const results: U[] = [];
+      /** @type {U[]} */
+      const results = [];
       for (let item = items.shift(); item !== undefined; item = items.shift()) {
         results.push(await task(item, i));
         i++;
diff --git a/packages/collection-utils/src/map-values.ts b/packages/collection-utils/src/map-values.js
similarity index 75%
rename from packages/collection-utils/src/map-values.ts
rename to packages/collection-utils/src/map-values.js
index 3b36d107..00c72279 100644
--- a/packages/collection-utils/src/map-values.ts
+++ b/packages/collection-utils/src/map-values.js
@@ -15,12 +15,14 @@
 
 /**
  * Maps the values of an object to a new object
+ * @template {object} T
+ * @template U
+ * @param object {T}
+ * @param transform {(value: T[keyof T], key: keyof T) => U}
+ * @returns {{[key in keyof T]: U}}
  */
-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};
+export function mapValues(object, transform) {
+  const result = /** @type {{[key in keyof T]: U}} */ ({});
 
   for (const key in object) {
     if (object.hasOwnProperty(key)) {
diff --git a/packages/collection-utils/src/min.ts b/packages/collection-utils/src/min.js
similarity index 70%
rename from packages/collection-utils/src/min.ts
rename to packages/collection-utils/src/min.js
index 2a99e971..e8eb9d40 100644
--- a/packages/collection-utils/src/min.ts
+++ b/packages/collection-utils/src/min.js
@@ -15,9 +15,13 @@
 
 /**
  * Returns the minimum value of a collection.
+ * @template T
+ * @param array {T[]}
+ * @param transform {(item: T) => number | undefined}
+ * @returns {T}
  */
-export function minBy<T>(array: T[], transform: (item: T) => number | undefined): T {
+export function minBy(array, transform) {
   const transforms = array.map(transform);
-  const min = Math.min(...(transforms.filter(it => !!it) as number[]));
-  return array.find((_, i) => transforms[i] === min) as T;
+  const min = Math.min(.../** @type {number[]} */ (transforms.filter(it => !!it)));
+  return /** @type {T} */ (array.find((_, i) => transforms[i] === min));
 }
diff --git a/packages/collection-utils/src/omit.ts b/packages/collection-utils/src/omit.js
similarity index 81%
rename from packages/collection-utils/src/omit.ts
rename to packages/collection-utils/src/omit.js
index dd15b66f..7384b6ac 100644
--- a/packages/collection-utils/src/omit.ts
+++ b/packages/collection-utils/src/omit.js
@@ -15,9 +15,14 @@
 
 /**
  * Returns a new object without the specified keys.
+ * @template {object} T
+ * @template {keyof T} U
+ * @param object {T}
+ * @param keys {U[]}
+ * @returns {Omit<T, U>}
  */
-export function omit<T extends object, U extends keyof T>(object: T, ...keys: U[]): Omit<T, U> {
+export function omit(object, ...keys) {
   const out = {...object};
   for (const key of keys) delete out[key];
-  return out as Exclude<T, U>;
+  return out;
 }
diff --git a/packages/collection-utils/src/partition.ts b/packages/collection-utils/src/partition.js
similarity index 70%
rename from packages/collection-utils/src/partition.ts
rename to packages/collection-utils/src/partition.js
index 27ccfb62..5e902933 100644
--- a/packages/collection-utils/src/partition.ts
+++ b/packages/collection-utils/src/partition.js
@@ -16,13 +16,14 @@
 /**
  * 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.
+ * @template T
+ * @param array {T[]}
+ * @param transform {(item: T) => boolean}
+ * @returns {[T[], T[]]}
  */
-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;
-    },
-    [[], []],
-  );
+export function partition(array, transform) {
+  return array.reduce((accumulator, item) => {
+    accumulator[transform(item) ? 0 : 1].push(item);
+    return accumulator;
+  }, /** @type {[T[], T[]]} */ ([[], []]));
 }
diff --git a/packages/collection-utils/src/pick.ts b/packages/collection-utils/src/pick.js
similarity index 66%
rename from packages/collection-utils/src/pick.ts
rename to packages/collection-utils/src/pick.js
index 9405a37b..84ade235 100644
--- a/packages/collection-utils/src/pick.ts
+++ b/packages/collection-utils/src/pick.js
@@ -15,27 +15,34 @@
 
 /**
  * Pick a set of properties from an object
+ * @template {object} T
+ * @template {keyof T} U
+ * @param object {T}
+ * @param keys {U[]}
+ * @returns {Pick<T, U>}
  */
-export function pick<T extends object, U extends keyof T>(object: T, keys: U[]): Pick<T, U> {
+export function pick(object, keys) {
   return keys.reduce((accumulator, key) => {
     if (object.hasOwnProperty(key)) {
       accumulator[key] = object[key];
     }
     return accumulator;
-  }, {} as Pick<T, U>);
+  }, /** @type {Pick<T, U>} */ ({}));
 }
 
 /**
  * Pick a set of properties from an object using a predicate function
+ * @template {object} T
+ * @template {keyof T} U
+ * @param object {T}
+ * @param predicate {(value: T[U], key: U) => boolean}
+ * @returns {Pick<T, U>}
  */
-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) => {
+export function pickBy(object, predicate) {
+  return /** @type {U[]} */ (Object.keys(object)).reduce((accumulator, key) => {
     if (predicate(object[key], key)) {
       accumulator[key] = object[key];
     }
     return accumulator;
-  }, {} as Pick<T, U>);
+  }, /** @type {Pick<T, U>} */ ({}));
 }
diff --git a/packages/collection-utils/src/shuffle.ts b/packages/collection-utils/src/shuffle.js
similarity index 90%
rename from packages/collection-utils/src/shuffle.ts
rename to packages/collection-utils/src/shuffle.js
index 1c053c85..9e8f2f13 100644
--- a/packages/collection-utils/src/shuffle.ts
+++ b/packages/collection-utils/src/shuffle.js
@@ -15,8 +15,11 @@
 
 /**
  * Shuffles an array
+ * @template T
+ * @param array {T[]}
+ * @returns {T[]}
  */
-export function shuffle<T>(array: T[]): T[] {
+export function shuffle(array) {
   const copy = [...array];
   const out = [];
 
diff --git a/packages/collection-utils/src/string-sort.ts b/packages/collection-utils/src/string-sort.js
similarity index 78%
rename from packages/collection-utils/src/string-sort.ts
rename to packages/collection-utils/src/string-sort.js
index b7a2b24d..0ea6c110 100644
--- a/packages/collection-utils/src/string-sort.ts
+++ b/packages/collection-utils/src/string-sort.js
@@ -15,8 +15,11 @@
 
 /**
  * sort function for two strings
+ * @param [a] {string}
+ * @param [b] {string}
+ * @returns {number}
  */
-export function stringSort(a = '', b = ''): number {
+export function stringSort(a = '', b = '') {
   if (a < b) return -1;
   if (a > b) return 1;
   return 0;
@@ -24,9 +27,12 @@ export function stringSort(a = '', b = ''): number {
 
 /**
  * sort function for two strings that allows for a custom transform
+ * @template T
+ * @param map {(item: T) => string | undefined}
+ * @returns {(a: T, b: T) => number}
  */
-export function stringSortBy<T>(map: (item: T) => string | undefined): (a: T, b: T) => number {
-  return (a: T, b: T): number => {
+export function stringSortBy(map) {
+  return (a, b) => {
     const aValue = map(a) || '';
     const bValue = map(b) || '';
     if (aValue < bValue) return -1;
diff --git a/packages/collection-utils/src/sum.ts b/packages/collection-utils/src/sum.js
similarity index 66%
rename from packages/collection-utils/src/sum.ts
rename to packages/collection-utils/src/sum.js
index a92a796c..8c7e9420 100644
--- a/packages/collection-utils/src/sum.ts
+++ b/packages/collection-utils/src/sum.js
@@ -15,17 +15,20 @@
 
 /**
  * Sum an an array
+ * @template {object} T
+ * @param collection {T[]}
+ * @param transform {(value: T) => number | undefined}
+ * @returns {number}
  */
-export function sumBy<T extends object>(
-  collection: T[],
-  transform: (value: T) => number | undefined,
-): number {
+export function sumBy(collection, transform) {
   return collection.reduce((accumulator, item) => accumulator + (transform(item) || 0), 0);
 }
 
 /**
  * Sum an array of numbers
+ * @param collection {Array<number | undefined>}
+ * @returns {number}
  */
-export function sum(collection: Array<number | undefined>): number {
-  return collection.reduce<number>((accumulator, item) => accumulator + (item || 0), 0);
+export function sum(collection) {
+  return /** @type {number[]} */ (collection).reduce((accumulator, item) => accumulator + (item ?? 0), 0);
 }
diff --git a/packages/collection-utils/src/tree-group.ts b/packages/collection-utils/src/tree-group.js
similarity index 79%
rename from packages/collection-utils/src/tree-group.ts
rename to packages/collection-utils/src/tree-group.js
index 171644b9..8745ca69 100644
--- a/packages/collection-utils/src/tree-group.ts
+++ b/packages/collection-utils/src/tree-group.js
@@ -13,17 +13,15 @@
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
 
-export type Tree<T> = {
-  [key: string]: Tree<T>;
-} & {
-  _?: T[] | undefined;
-};
-
 /**
- *
+ * @template T
+ * @param items {T[]}
+ * @param transform {(item: T) => string[]}
+ * @returns {import('./types.js').Tree<T>}
  */
-export function treeGroupBy<T>(items: T[], transform: (item: T) => string[]): Tree<T> {
-  const tree: Tree<T> = {};
+export function treeGroupBy(items, transform) {
+  /** @type {import('./types.js').Tree<T>} */
+  const tree = {};
 
   for (const item of items) {
     let currentTree = tree;
@@ -34,7 +32,7 @@ export function treeGroupBy<T>(items: T[], transform: (item: T) => string[]): Tr
     }
     // eslint-disable-next-line unicorn/no-array-for-each
     keys.forEach((key, i) => {
-      currentTree = currentTree[key] = (currentTree[key] ?? {}) as Tree<T>;
+      currentTree = currentTree[key] = currentTree[key] ?? {};
       if (i === keys.length - 1) {
         currentTree._ = currentTree._ ?? [];
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
diff --git a/packages/collection-utils/src/types.d.ts b/packages/collection-utils/src/types.d.ts
new file mode 100644
index 00000000..65362ca4
--- /dev/null
+++ b/packages/collection-utils/src/types.d.ts
@@ -0,0 +1,7 @@
+export * from './index.js';
+
+export type Tree<T> = {
+  [key: string]: Tree<T>;
+} & {
+  _?: T[] | undefined;
+};
diff --git a/packages/collection-utils/src/uniq.ts b/packages/collection-utils/src/uniq.js
similarity index 80%
rename from packages/collection-utils/src/uniq.ts
rename to packages/collection-utils/src/uniq.js
index 933c07e7..9ac6700f 100644
--- a/packages/collection-utils/src/uniq.ts
+++ b/packages/collection-utils/src/uniq.js
@@ -15,12 +15,16 @@
 
 /**
  * Filter out duplicates from an array.
+ * @template T
+ * @param array {T[]}
+ * @param transform {(item: T) => string | number}
+ * @returns {T[]}
  */
-export function uniqBy<T>(array: T[], transform: (item: T) => string | number): T[] {
+export function uniqBy(array, transform) {
   return Object.values(
     array.reduce((accumulator, current) => {
       accumulator[transform(current)] = current;
       return accumulator;
-    }, {} as Record<string | number, T>),
+    }, /** @type {Record<string, T>} */ ({})),
   );
 }
diff --git a/packages/collection-utils/src/zip.ts b/packages/collection-utils/src/zip.js
similarity index 85%
rename from packages/collection-utils/src/zip.ts
rename to packages/collection-utils/src/zip.js
index f17e89f1..7c2e28dd 100644
--- a/packages/collection-utils/src/zip.ts
+++ b/packages/collection-utils/src/zip.js
@@ -15,7 +15,12 @@
 
 /**
  * Zip two arrays together.
+ * @template T
+ * @template U
+ * @param a {T[]}
+ * @param b {U[]}
+ * @returns {[T, U][]}
  */
-export function zip<T, U>(a: T[], b: U[]): [T, U][] {
+export function zip(a, b) {
   return a.map((_, i) => [a[i], b[i]]);
 }
diff --git a/packages/collection-utils/test/chunk.spec.ts b/packages/collection-utils/test/chunk.spec.js
similarity index 100%
rename from packages/collection-utils/test/chunk.spec.ts
rename to packages/collection-utils/test/chunk.spec.js
diff --git a/packages/collection-utils/test/difference.spec.ts b/packages/collection-utils/test/difference.spec.js
similarity index 100%
rename from packages/collection-utils/test/difference.spec.ts
rename to packages/collection-utils/test/difference.spec.js
diff --git a/packages/collection-utils/test/get.spec.ts b/packages/collection-utils/test/get.spec.js
similarity index 100%
rename from packages/collection-utils/test/get.spec.ts
rename to packages/collection-utils/test/get.spec.js
diff --git a/packages/collection-utils/test/group-by.spec.ts b/packages/collection-utils/test/group-by.spec.js
similarity index 100%
rename from packages/collection-utils/test/group-by.spec.ts
rename to packages/collection-utils/test/group-by.spec.js
diff --git a/packages/collection-utils/test/key-by.spec.ts b/packages/collection-utils/test/key-by.spec.js
similarity index 100%
rename from packages/collection-utils/test/key-by.spec.ts
rename to packages/collection-utils/test/key-by.spec.js
diff --git a/packages/collection-utils/test/map-values.spec.ts b/packages/collection-utils/test/map-values.spec.js
similarity index 100%
rename from packages/collection-utils/test/map-values.spec.ts
rename to packages/collection-utils/test/map-values.spec.js
diff --git a/packages/collection-utils/test/min.spec.ts b/packages/collection-utils/test/min.spec.js
similarity index 100%
rename from packages/collection-utils/test/min.spec.ts
rename to packages/collection-utils/test/min.spec.js
diff --git a/packages/collection-utils/test/omit.spec.ts b/packages/collection-utils/test/omit.spec.js
similarity index 100%
rename from packages/collection-utils/test/omit.spec.ts
rename to packages/collection-utils/test/omit.spec.js
diff --git a/packages/collection-utils/test/partition.spec.ts b/packages/collection-utils/test/partition.spec.js
similarity index 100%
rename from packages/collection-utils/test/partition.spec.ts
rename to packages/collection-utils/test/partition.spec.js
diff --git a/packages/collection-utils/test/pick.spec.ts b/packages/collection-utils/test/pick.spec.js
similarity index 100%
rename from packages/collection-utils/test/pick.spec.ts
rename to packages/collection-utils/test/pick.spec.js
diff --git a/packages/collection-utils/test/shuffle.spec.ts b/packages/collection-utils/test/shuffle.spec.js
similarity index 100%
rename from packages/collection-utils/test/shuffle.spec.ts
rename to packages/collection-utils/test/shuffle.spec.js
diff --git a/packages/collection-utils/test/string-sort.spec.ts b/packages/collection-utils/test/string-sort.spec.js
similarity index 100%
rename from packages/collection-utils/test/string-sort.spec.ts
rename to packages/collection-utils/test/string-sort.spec.js
diff --git a/packages/collection-utils/test/sum.spec.ts b/packages/collection-utils/test/sum.spec.js
similarity index 100%
rename from packages/collection-utils/test/sum.spec.ts
rename to packages/collection-utils/test/sum.spec.js
diff --git a/packages/collection-utils/test/tree-group.spec.ts b/packages/collection-utils/test/tree-group.spec.js
similarity index 74%
rename from packages/collection-utils/test/tree-group.spec.ts
rename to packages/collection-utils/test/tree-group.spec.js
index d2f71f65..7de4c61b 100644
--- a/packages/collection-utils/test/tree-group.spec.ts
+++ b/packages/collection-utils/test/tree-group.spec.js
@@ -12,17 +12,17 @@
  *  You should have received a copy of the GNU General Public License along with
  *  this program. If not, see <https://www.gnu.org/licenses/>.
  */
+import {treeGroupBy} from '../src/index.js';
 import {expect} from 'chai';
-import {Tree, treeGroupBy} from '../src/index.js';
-
-interface TestItem {
-  id: number;
-  path?: string[];
-}
 
+/**
+ * @typedef {{id: number; path?: string[]}} TestItem
+ * @typedef {import('../src/types.js').Tree<TestItem>} TestItemTree
+ */
 describe('tree-group', function () {
   it('should create a tree', function () {
-    const items: Array<TestItem> = [
+    /** @type {TestItem[]} */
+    const items = [
       {
         id: 1,
         path: ['a', 'b', 'c'],
@@ -35,20 +35,22 @@ describe('tree-group', function () {
 
     const tree = treeGroupBy(items, item => item.path ?? []);
 
-    const expectedTree: Tree<TestItem> = {
-      a: {
+    /** @type {TestItemTree} */
+    const expectedTree = {
+      a: /** @type {TestItemTree} */ ({
         b: {
           c: {_: [items[0]]},
           d: {_: [items[1]]},
-        } as Tree<TestItem>,
-      } as Tree<TestItem>,
-    } as Tree<TestItem>;
+        },
+      }),
+    };
 
     expect(tree).to.deep.equal(expectedTree);
   });
 
   it('should also sort empty paths', () => {
-    const items: Array<TestItem> = [
+    /** @type {TestItem[]} */
+    const items = [
       {
         id: 1,
         path: ['a', 'b', 'c'],
@@ -60,14 +62,14 @@ describe('tree-group', function () {
 
     const tree = treeGroupBy(items, item => item.path ?? []);
 
-    const expectedTree: Tree<TestItem> = {
+    const expectedTree = /** @type {TestItemTree} */ ({
       a: {
         b: {
           c: {_: [items[0]]},
-        } as Tree<TestItem>,
-      } as Tree<TestItem>,
+        },
+      },
       _: [items[1]],
-    } as Tree<TestItem>;
+    });
 
     expect(tree).to.deep.equal(expectedTree);
   });
diff --git a/packages/collection-utils/test/uniq.spec.ts b/packages/collection-utils/test/uniq.spec.js
similarity index 100%
rename from packages/collection-utils/test/uniq.spec.ts
rename to packages/collection-utils/test/uniq.spec.js
diff --git a/packages/collection-utils/test/zip.spec.ts b/packages/collection-utils/test/zip.spec.js
similarity index 100%
rename from packages/collection-utils/test/zip.spec.ts
rename to packages/collection-utils/test/zip.spec.js
diff --git a/packages/core/package.json b/packages/core/package.json
index 3a0ded9a..016664e6 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -74,15 +74,6 @@
     "typedoc": "0.24.8",
     "typescript": "5.1.6"
   },
-  "tsup": {
-    "entry": [
-      "src/index.ts"
-    ],
-    "sourcemap": true,
-    "clean": true,
-    "format": "esm",
-    "outDir": "lib"
-  },
   "prettier": "@openstapps/prettier-config",
   "eslintConfig": {
     "extends": [
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 75561015..0f87e9df 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1625,9 +1625,6 @@ importers:
       ts-node:
         specifier: 10.9.1
         version: 10.9.1(@types/node@18.15.3)(typescript@5.1.6)
-      tsup:
-        specifier: 7.2.0
-        version: 7.2.0(ts-node@10.9.1)(typescript@5.1.6)
       typedoc:
         specifier: 0.24.8
         version: 0.24.8(typescript@5.1.6)