@bemoje/array 1.0.0 → 1.0.2

package/index.mjs

@@ -0,0 +1,354 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => {
+  return __defProp(target, 'name', { value, configurable: true });
+};
+
+// src/lib/arrSum.ts
+function arrSum(array) {
+  return array.reduce((acc, cur) => {
+    return acc + cur;
+  }, 0);
+}
+__name(arrSum, 'arrSum');
+
+// src/lib/arrAverage.ts
+function arrAverage(array) {
+  if (!array.length) {
+    throw new Error('Cannot take an average of zero values.');
+  }
+  return arrSum(array) / array.length;
+}
+__name(arrAverage, 'arrAverage');
+
+// src/lib/arrEachToString.ts
+function arrEachToString(array) {
+  return array.map((element) => {
+    return `${element}`;
+  });
+}
+__name(arrEachToString, 'arrEachToString');
+
+// src/lib/arrFindIndicesOf.ts
+function arrFindIndicesOf(input, predicate) {
+  const result = [];
+  for (let i = 0; i < input.length; i++) {
+    if (predicate(input[i])) {
+      result.push(i);
+    }
+  }
+  return result;
+}
+__name(arrFindIndicesOf, 'arrFindIndicesOf');
+
+// src/lib/arrGetOrDefault.ts
+function arrGetOrDefault(array, index, factory) {
+  const value = array[index];
+  if (value !== void 0 || Object.hasOwn(array, index)) {
+    return value;
+  }
+  return (array[index] = factory(index));
+}
+__name(arrGetOrDefault, 'arrGetOrDefault');
+
+// src/lib/arrHasDuplicates.ts
+function arrHasDuplicates(arr) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of arr) {
+    if (seen.has(e)) {
+      return true;
+    }
+    seen.add(e);
+  }
+  return false;
+}
+__name(arrHasDuplicates, 'arrHasDuplicates');
+
+// src/lib/arrIndicesOf.ts
+function arrIndicesOf(input, element) {
+  const result = [];
+  for (let i = 0; i < input.length; i++) {
+    if (element === input[i]) {
+      result.push(i);
+    }
+  }
+  return result;
+}
+__name(arrIndicesOf, 'arrIndicesOf');
+
+// src/lib/arrLast.ts
+function arrLast(array) {
+  if (!array.length) {
+    throw new Error('Cannot get last element of empty array.');
+  }
+  return array[array.length - 1];
+}
+__name(arrLast, 'arrLast');
+
+// src/lib/arrMapMutable.ts
+function arrMapMutable(input, f) {
+  for (let i = 0; i < input.length; i++) {
+    input[i] = f(input[i], i, input);
+  }
+  return input;
+}
+__name(arrMapMutable, 'arrMapMutable');
+
+// src/lib/arrObjectsUniqueKeys.ts
+function arrObjectsUniqueKeys(objects) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const o of objects) {
+    for (const key of Object.keys(o)) {
+      keys.add(key);
+    }
+  }
+  return Array.from(keys);
+}
+__name(arrObjectsUniqueKeys, 'arrObjectsUniqueKeys');
+
+// src/lib/arrObjectsToTable.ts
+function arrObjectsToTable(objects, options = {}) {
+  const headers = options?.headers?.slice() || arrObjectsUniqueKeys(objects);
+  const table = [headers];
+  for (const o of objects) {
+    const row = headers.map((header) => {
+      const value = o[header];
+      return value !== void 0 ? value : options.emptyCell;
+    });
+    table.push(row);
+  }
+  return table;
+}
+__name(arrObjectsToTable, 'arrObjectsToTable');
+
+// src/lib/arrRemove.ts
+function arrRemove(arr, elementToRemove) {
+  return arr.filter((element) => {
+    return element !== elementToRemove;
+  });
+}
+__name(arrRemove, 'arrRemove');
+
+// src/lib/arrRemoveDuplicates.ts
+function arrRemoveDuplicates(array) {
+  return Array.from(new Set(array));
+}
+__name(arrRemoveDuplicates, 'arrRemoveDuplicates');
+
+// src/lib/arrRemoveMutable.ts
+function arrRemoveMutable(arr, elementToRemove) {
+  let index = arr.indexOf(elementToRemove);
+  while (index !== -1) {
+    arr.splice(index, 1);
+    index = arr.indexOf(elementToRemove);
+  }
+}
+__name(arrRemoveMutable, 'arrRemoveMutable');
+
+// src/lib/arrSwap.ts
+function arrSwap(input, from, to) {
+  if (from === to) {
+    return input;
+  }
+  [input[from], input[to]] = [input[to], input[from]];
+  return input;
+}
+__name(arrSwap, 'arrSwap');
+
+// src/lib/arrShuffle.ts
+function arrShuffle(input) {
+  if (input.length <= 1) {
+    return input;
+  }
+  const original = input.slice();
+  let equal = true;
+  while (equal) {
+    for (let i = 0; i < input.length; i++) {
+      const newIndex = Math.floor(Math.random() * input.length);
+      arrSwap(input, i, newIndex);
+    }
+    equal = input.join(',') === original.join(',');
+  }
+  return input;
+}
+__name(arrShuffle, 'arrShuffle');
+
+// src/lib/arrSortNumeric.ts
+function arrSortNumeric(input) {
+  return input.sort((a, b) => {
+    if (a < b) {
+      return -1;
+    }
+    if (a > b) {
+      return 1;
+    }
+    return 0;
+  });
+}
+__name(arrSortNumeric, 'arrSortNumeric');
+
+// src/lib/arrSortedInsertionIndex.ts
+function arrSortedInsertionIndex(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      it++;
+      first = it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+__name(arrSortedInsertionIndex, 'arrSortedInsertionIndex');
+
+// src/lib/arrTableAssertRowsSameLength.ts
+function arrTableAssertRowsSameLength(rows, headers) {
+  const numHeaders = (headers || rows[0]).length;
+  for (const row of rows) {
+    if (row.length !== numHeaders) {
+      throw new Error(`Expected ${numHeaders} columns, got ${row.length}`);
+    }
+  }
+}
+__name(arrTableAssertRowsSameLength, 'arrTableAssertRowsSameLength');
+
+// src/lib/arrTableEachToString.ts
+function arrTableEachToString(table) {
+  return table.map(arrEachToString);
+}
+__name(arrTableEachToString, 'arrTableEachToString');
+
+// src/lib/arrTableIterateAsObjects.ts
+function* arrTableIterateAsObjects(rows, headers, ignoreHeaders = /* @__PURE__ */ new Set()) {
+  if (!headers.length) {
+    throw new Error('No headers provided');
+  }
+  ignoreHeaders.forEach((h) => {
+    if (!headers.includes(h)) {
+      throw new Error(`Header "${h}" not found in headers: ${headers}`);
+    }
+  });
+  if (new Set(headers).size === ignoreHeaders.size) {
+    throw new Error('All headers are ignored');
+  }
+  for (let r = 0; r < rows.length; r++) {
+    if (rows[r].length !== headers.length) {
+      throw new Error(`Row ${r} has ${rows[r].length} columns, but expected ${headers.length}`);
+    }
+    const o = {};
+    for (let c = 0; c < headers.length; c++) {
+      if (ignoreHeaders.has(headers[c])) {
+        continue;
+      }
+      o[headers[c]] = rows[r][c];
+    }
+    yield o;
+  }
+}
+__name(arrTableIterateAsObjects, 'arrTableIterateAsObjects');
+
+// src/lib/arrTableRemoveColumns.ts
+function arrTableRemoveColumns(table, ...removeColumnNames) {
+  if (!removeColumnNames.length || !table.length) {
+    return table;
+  }
+  const set = new Set(
+    removeColumnNames
+      .map((col) => {
+        return arrIndicesOf(table[0], col);
+      })
+      .flat(),
+  );
+  return table.map((row) => {
+    return row.filter((_, i) => {
+      return !set.has(i);
+    });
+  });
+}
+__name(arrTableRemoveColumns, 'arrTableRemoveColumns');
+
+// src/lib/arrTableToCsv.ts
+function arrTableToCsv(input, delimiter = ';', replaceLinebreakWith = '<br>') {
+  return input
+    .map((row) => {
+      return row
+        .map((item) => {
+          return String(item).replace(new RegExp(';', 'g'), '').replace(/\r*\n/g, replaceLinebreakWith);
+        })
+        .join(delimiter);
+    })
+    .join('\n');
+}
+__name(arrTableToCsv, 'arrTableToCsv');
+
+// src/lib/arrTableToObjects.ts
+function arrTableToObjects(rows, headers, ignoreKeys) {
+  if (headers) {
+    if (!rows.length) {
+      return [];
+    }
+  } else {
+    if (rows.length <= 1) {
+      return [];
+    }
+    headers = rows[0].map((header) => {
+      return header === null || header === void 0 ? '' : String(header);
+    });
+    rows = rows.slice(1);
+  }
+  const _headers = headers;
+  return rows.map((row) => {
+    const o = {};
+    for (let i = 0; i < _headers.length; i++) {
+      const header = _headers[i];
+      if (ignoreKeys && ignoreKeys.has(header)) {
+        continue;
+      }
+      o[header] = row[i];
+    }
+    return o;
+  });
+}
+__name(arrTableToObjects, 'arrTableToObjects');
+
+// src/lib/arrayToString.ts
+function arrayToString(array) {
+  return `[${array
+    .map((item) => {
+      return item == null ? String(item) : Array.isArray(item) ? arrayToString(item) : item.toString();
+    })
+    .join(',')}]`;
+}
+__name(arrayToString, 'arrayToString');
+
+export {
+  arrAverage,
+  arrEachToString,
+  arrFindIndicesOf,
+  arrGetOrDefault,
+  arrHasDuplicates,
+  arrIndicesOf,
+  arrLast,
+  arrMapMutable,
+  arrObjectsToTable,
+  arrObjectsUniqueKeys,
+  arrRemove,
+  arrRemoveDuplicates,
+  arrRemoveMutable,
+  arrShuffle,
+  arrSortNumeric,
+  arrSortedInsertionIndex,
+  arrSum,
+  arrSwap,
+  arrTableAssertRowsSameLength,
+  arrTableEachToString,
+  arrTableIterateAsObjects,
+  arrTableRemoveColumns,
+  arrTableToCsv,
+  arrTableToObjects,
+  arrayToString,
+};

package/package.json

@@ -1,35 +1,32 @@
 {
   "name": "@bemoje/array",
-  "version": "1.0.0",
-  "packageManager": "yarn@4.3.1",
+  "version": "1.0.2",
+  "description": "Array utils",
   "type": "module",
   "sideEffects": false,
-  "module": "src/index.ts",
+  "keywords": [
+    "array"
+  ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.mjs"
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "default": "./index.mjs"
     }
   },
-  "files": [
-    "dist/"
-  ],
+  "dependencies": {},
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "node esbuild.mjs"
-  },
   "license": "MIT",
   "author": {
-    "name": "Benjamin Moller Jensen",
+    "name": "Benjamin Møller Jensen",
     "email": "bemoje@bemoje.net",
     "url": "https://github.com/bemoje/"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/bemoje/mono.git",
+    "url": "git+https://github.com/bemoje/mono.git",
     "directory": "libs/array"
   }
 }

package/README.md

@@ -1,3 +0,0 @@
-# @mono/array
-
-Array manipulation and table processing utilities.

package/dist/arrAverage.d.ts

@@ -1,12 +0,0 @@
-/**
- * Calculates the average of an array of numbers.
- * @returns The average of all numbers in the array.
- * @throws an error if the input array is empty.
- * @param array The array of numbers.
- * @example ```ts
- * const numbers = [1, 2, 3, 4, 5];
- * arrAverage(numbers);
- * //=> 3
- * ```
- */
-export declare function arrAverage(array: number[]): number;

package/dist/arrEachToString.d.ts

@@ -1,12 +0,0 @@
-/**
- * Coerce each element of an array to string.
- * @template T - The type of elements in the input array.
- * @returns A new array where each element is the string representation of the corresponding element in the input array.
- * @param array The array to iterate over.
- * @example ```ts
- * const numbers = [1, 2, 3];
- * arrEachToString(numbers);
- * //=> ['1', '2', '3']
- * ```
- */
-export declare function arrEachToString<T>(array: T[]): string[];

package/dist/arrFindIndicesOf.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns an array of indices where the predicate function returns true for the corresponding element in the input array.
- * @param input - The array to search.
- * @param predicate - The function to test each element of the array.
- * @returns An array of indices where the predicate function returns true.
- */
-export declare function arrFindIndicesOf<T>(input: Array<T>, predicate: (value: T) => boolean): number[];

package/dist/arrGetOrDefault.d.ts

@@ -1,4 +0,0 @@
-/**
- * Get array element at index or create it using factory function if it doesn't exist.
- */
-export declare function arrGetOrDefault<V>(array: V[], index: number, factory: (index: number) => V): V;

package/dist/arrHasDuplicates.d.ts

@@ -1,7 +0,0 @@
-/**
- * Checks if an array has any duplicate elements.
- * @param arr - The array to check for duplicates.
- * @returns A boolean indicating whether the array has duplicates.
- * @typeParam T - The type of elements in the array.
- */
-export declare function arrHasDuplicates<T>(arr: T[]): boolean;

package/dist/arrIndicesOf.d.ts

@@ -1,14 +0,0 @@
-/**
- * Returns all indexes at which an element is found.
- * @param input The array to search
- * @template T - The type of elements in the input array.
- * @returns An array of indices where the specified element can be found.
- * @param element The element to find
- * @example ```ts
- *  const inputArray = [1, 2, 3, 2, 4, 2, 5];
- *  const elementToFind = 2;
- *  arrIndicesOf(inputArray, elementToFind);
- *  //=> [1, 3, 5]
- *  ```
- */
-export declare function arrIndicesOf<T>(input: Array<T>, element: T): number[];

package/dist/arrLast.d.ts

@@ -1,12 +0,0 @@
-/**
- * Returns the last element of an array.
- * Throws an error if the array is empty.
- * @template T The type of elements in the array.
- * @param array The array to get the last element from.
- * @returns The last element of the array.
- * @throws If the array is empty.
- * @example const numbers = [1, 2, 3, 4, 5];
- * const lastNumber = arrLast(numbers);
- * //=> 5
- */
-export declare function arrLast<T>(array: T[]): T;

package/dist/arrMapMutable.d.ts

@@ -1,12 +0,0 @@
-/**
- * This function takes an array and a callback function as arguments. It applies the callback function to each element of the array, mutating the original array in the process.
- * @template T The type of elements in the input array.
- * @param input The array to be mapped over.
- * @param f The callback function to be applied to each element of the array. This function takes three arguments: the current element, its index, and the original array.
- * @returns The original array, mutated by the callback function.
- * @example ```ts
- * arrMapMutable([1, 2, 3], (value: number) => value * 2);
- * //=> [2, 4, 6]
- * ```
- */
-export declare function arrMapMutable<T>(input: Array<T>, f: (value: T, index: number, array: T[]) => T): Array<T>;

package/dist/arrObjectsToTable.d.ts

@@ -1,22 +0,0 @@
-/**
- * Convert an array of objects to a two-dimensional table.
- * @param objects The array of objects to convert to a table.
- * @template T - The type of the values in the objects.
- * @param options.headers An optional array of strings specifying the headers (property names) to use. If not provided, the function will use all unique keys found in the objects.
- * @param options.emptyCell An optional value to use for empty cells. If not provided, the function will use `undefined`.
- * @returns A 2D array (table) where each row represents an object and each column represents a property of the object.
- * @param options The options for converting the objects to a table.
- * @example ```ts
- * arrObjectsToTable(
- *   [
- *     { a: 1, b: 2 },
- *     { a: 3, b: 4, c: 5 },
- *   ],
- *   { emptyCell:1 },
- * ) //=> [ [ 'a', 'b', 'c' ], [ 1, 2,1 ], [ 3, 4, 5 ] ]
- * ```
- */
-export declare function arrObjectsToTable<T, E>(objects: Record<string, T | undefined>[], options?: {
-    headers?: string[];
-    emptyCell?: E;
-}): Array<Array<string | T | E>>;

package/dist/arrObjectsUniqueKeys.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns an array of all unique object keys found in an array of objects.
- * @template T - The type of values in the input objects.
- * @returns An array of unique keys present in the input objects.
- * @param objects The array of objects.
- * @example ```ts
- * const objects = [
- *   { name: 'John', age: 25 },
- *   { name: 'Jane', gender: 'female' },
- *   { name: 'Bob', age: 30, gender: 'male' },
- * ];
- * arrObjectsUniqueKeys(objects);
- * //=> ['name', 'age', 'gender']
- * ```
- */
-export declare function arrObjectsUniqueKeys<T>(objects: Record<string, T>[]): string[];

package/dist/arrRemove.d.ts

@@ -1,4 +0,0 @@
-/**
- * Remove a given element from a copy of a given array and return the resulting array.
- */
-export declare function arrRemove<T>(arr: T[], elementToRemove: T): T[];

package/dist/arrRemoveDuplicates.d.ts

@@ -1,13 +0,0 @@
-/**
- * Remove duplicates from an array
- * @remarks This function uses the JavaScript Set object to remove duplicate values from an array.
- * @typeparam T - The type of elements in the array.
- * @returns The new array with duplicates removed.
- * @param array The array from which to remove duplicates.
- * @example ```ts
- * const array = [1, 2, 2, 3, 4, 4, 5];
- * arrRemoveDuplicates(array);
- * //=> [1, 2, 3, 4, 5]
- * ```
- */
-export declare function arrRemoveDuplicates<T>(array: T[]): T[];

package/dist/arrRemoveMutable.d.ts

@@ -1,4 +0,0 @@
-/**
- * Remove elements in-place from an array.
- */
-export declare function arrRemoveMutable<T>(arr: T[], elementToRemove: T): void;

package/dist/arrShuffle.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shuffle items in an array in-place. Guarantees changes.
- * @remarks This function does not guarantee that the order of the elements will be different after shuffling.
- * @typeparam T - The type of the elements in the input array.
- * @returns The same array, but shuffled.
- * @param input The array to shuffle.
- * @example ```ts
- * const input = [1, 2, 3, 4, 5];
- * arrShuffle(input);
- * //=> [3, 1, 5, 2, 4]
- * ```
- */
-export declare function arrShuffle<T>(input: Array<T>): Array<T>;

package/dist/arrSortNumeric.d.ts

@@ -1,14 +0,0 @@
-/**
- * Sorts an array of numbers, bigints, or booleans in ascending order.
- * @returns The sorted array.
- * @remarks This function uses the JavaScript `Array.prototype.sort()` method, which sorts elements in place.
- * Therefore, the original array will be modified.
- * @throws If any element in the input array is not a number, bigint, or boolean.
- * @param input The array to be sorted.
- * @example ```ts
- * const input = [5, 2n, true, 10, false];
- * arrSortNumeric(input);
- * //=> [false, true, 2n, 5, 10]
- * ```
- */
-export declare function arrSortNumeric(input: Array<number | bigint | boolean>): Array<number | bigint | boolean>;

package/dist/arrSortedInsertionIndex.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns an index in the sorted array where the specified value could be inserted while maintaining the sorted order of the array.
- * If the element is already in the array, returns the index after the last instance of the element.
- * @param array - The sorted array to search.
- * @param value - The value to locate in the array.
- * @param comparator - A function that defines the sort order. If omitted, the array elements are converted to strings, then sorted according to each character's Unicode code point value.
- * @returns The index at which the value could be inserted into array to maintain the array's sorted order.
- * @example ```ts
- * const array = [1, 2, 3, 5, 6];
- * const value = 4;
- * const comparator = (a, b) => a - b;
- * const index = arrSortedLowerBound(array, value, comparator);
- * console.log(index); // Output: 3
- * ```
- */
-export declare function arrSortedInsertionIndex<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;

package/dist/arrSum.d.ts

@@ -1,11 +0,0 @@
-/**
- * Calculates the sum of an array of numbers.
- * @returns The sum of all numbers in the array.
- * @param array The array of numbers to sum.
- * @example ```ts
- * const numbers = [1, 2, 3, 4, 5];
- * arrSum(numbers);
- * //=> 15
- * ```
- */
-export declare function arrSum(array: number[]): number;

package/dist/arrSwap.d.ts

@@ -1,14 +0,0 @@
-/**
- * Swaps two elements in an array. This function takes an input array and swaps the elements at the specified indices.
- * @param to The index of the element to swap to.
- * @param from The index of the element to swap from.
- * @template T - The type of elements in the array.
- * @returns The modified array with swapped elements.
- * @throws Will throw an error if 'from' or 'to' is not a valid index in the array.
- * @param input The input array.
- * @example ```ts
- * const arr = [1, 2, 3, 4, 5]
- * arrSwap(arr, 1, 3) //=> [1, 4, 3, 2, 5]
- * ```
- */
-export declare function arrSwap<T>(input: Array<T>, from: number, to: number): Array<T>;

package/dist/arrTableAssertRowsSameLength.d.ts

@@ -1,25 +0,0 @@
-/**
- * Asserts that all rows in a 2D array have the same length.
- * @param - Optional array of headers to compare the row length against.
- * @throws If any row in the array has a different length than the others.
- * @param headers Optional. An array of headers. If provided, each row must have the same length as this array.
- * @typeparam T - The type of elements in the rows.
- * @param rows The 2D array to check.
- * @example ```ts
- *  const rows = [
- *    [1, 2, 3],
- *    [4, 5, 6],
- *    [7, 8, 9],
- *  ];
- *  arrTableAssertRowsSameLength(rows);
- *  //=> undefined
- *  const rowsWithDifferentLength = [
- *    [1, 2, 3],
- *    [4, 5],
- *    [7, 8, 9],
- *  ];
- *  arrTableAssertRowsSameLength(rowsWithDifferentLength);
- *  //=> Error: Expected 3 columns, got 2
- *  ```
- */
-export declare function arrTableAssertRowsSameLength<T>(rows: T[][], headers?: string[]): void;

package/dist/arrTableEachToString.d.ts

@@ -1,12 +0,0 @@
-/**
- * Coerce each value of a 2D array table to string.
- * @template T - The type of the elements in the input array.
- * @returns The converted 2D array where each element is a string.
- * @param table The 2D array to convert.
- * @example ```ts
- * const input: number[][] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
- * arrTableEachToString(input);
- * //=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]
- * ```
- */
-export declare function arrTableEachToString<T>(table: T[][]): string[][];