@bemoje/array 0.3.3 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,442 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/arrAverage.ts
+var arrAverage_exports = {};
+__export(arrAverage_exports, {
+  arrAverage: () => arrAverage
+});
+
+// src/arrSum.ts
+var arrSum_exports = {};
+__export(arrSum_exports, {
+  arrSum: () => arrSum
+});
+function arrSum(array) {
+  return array.reduce((acc, cur) => acc + cur, 0);
+}
+__name(arrSum, "arrSum");
+
+// src/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/arrEachToString.ts
+var arrEachToString_exports = {};
+__export(arrEachToString_exports, {
+  arrEachToString: () => arrEachToString
+});
+function arrEachToString(array) {
+  return array.map((element) => "" + element);
+}
+__name(arrEachToString, "arrEachToString");
+
+// src/arrFindIndicesOf.ts
+var arrFindIndicesOf_exports = {};
+__export(arrFindIndicesOf_exports, {
+  arrFindIndicesOf: () => arrFindIndicesOf
+});
+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/arrGetOrDefault.ts
+var arrGetOrDefault_exports = {};
+__export(arrGetOrDefault_exports, {
+  arrGetOrDefault: () => arrGetOrDefault
+});
+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/arrHasDuplicates.ts
+var arrHasDuplicates_exports = {};
+__export(arrHasDuplicates_exports, {
+  arrHasDuplicates: () => arrHasDuplicates
+});
+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/arrIndicesOf.ts
+var arrIndicesOf_exports = {};
+__export(arrIndicesOf_exports, {
+  arrIndicesOf: () => arrIndicesOf
+});
+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/arrLast.ts
+var arrLast_exports = {};
+__export(arrLast_exports, {
+  arrLast: () => arrLast
+});
+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/arrMapMutable.ts
+var arrMapMutable_exports = {};
+__export(arrMapMutable_exports, {
+  arrMapMutable: () => arrMapMutable
+});
+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/arrObjectsToTable.ts
+var arrObjectsToTable_exports = {};
+__export(arrObjectsToTable_exports, {
+  arrObjectsToTable: () => arrObjectsToTable
+});
+
+// src/arrObjectsUniqueKeys.ts
+var arrObjectsUniqueKeys_exports = {};
+__export(arrObjectsUniqueKeys_exports, {
+  arrObjectsUniqueKeys: () => arrObjectsUniqueKeys
+});
+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/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/arrRemove.ts
+var arrRemove_exports = {};
+__export(arrRemove_exports, {
+  arrRemove: () => arrRemove
+});
+function arrRemove(arr, elementToRemove) {
+  return arr.filter((element) => element !== elementToRemove);
+}
+__name(arrRemove, "arrRemove");
+
+// src/arrRemoveDuplicates.ts
+var arrRemoveDuplicates_exports = {};
+__export(arrRemoveDuplicates_exports, {
+  arrRemoveDuplicates: () => arrRemoveDuplicates
+});
+function arrRemoveDuplicates(array) {
+  return Array.from(new Set(array));
+}
+__name(arrRemoveDuplicates, "arrRemoveDuplicates");
+
+// src/arrRemoveMutable.ts
+var arrRemoveMutable_exports = {};
+__export(arrRemoveMutable_exports, {
+  arrRemoveMutable: () => arrRemoveMutable
+});
+function arrRemoveMutable(arr, elementToRemove) {
+  let index = arr.indexOf(elementToRemove);
+  while (index !== -1) {
+    arr.splice(index, 1);
+    index = arr.indexOf(elementToRemove);
+  }
+}
+__name(arrRemoveMutable, "arrRemoveMutable");
+
+// src/arrShuffle.ts
+var arrShuffle_exports = {};
+__export(arrShuffle_exports, {
+  arrShuffle: () => arrShuffle
+});
+
+// src/arrSwap.ts
+var arrSwap_exports = {};
+__export(arrSwap_exports, {
+  arrSwap: () => arrSwap
+});
+function arrSwap(input, from, to) {
+  if (from === to) return input;
+  [input[from], input[to]] = [input[to], input[from]];
+  return input;
+}
+__name(arrSwap, "arrSwap");
+
+// src/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/arrSortNumeric.ts
+var arrSortNumeric_exports = {};
+__export(arrSortNumeric_exports, {
+  arrSortNumeric: () => arrSortNumeric
+});
+function arrSortNumeric(input) {
+  return input.sort((a, b) => {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  });
+}
+__name(arrSortNumeric, "arrSortNumeric");
+
+// src/arrSortedInsertionIndex.ts
+var arrSortedInsertionIndex_exports = {};
+__export(arrSortedInsertionIndex_exports, {
+  arrSortedInsertionIndex: () => arrSortedInsertionIndex
+});
+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) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+__name(arrSortedInsertionIndex, "arrSortedInsertionIndex");
+
+// src/arrTableAssertRowsSameLength.ts
+var arrTableAssertRowsSameLength_exports = {};
+__export(arrTableAssertRowsSameLength_exports, {
+  arrTableAssertRowsSameLength: () => arrTableAssertRowsSameLength
+});
+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/arrTableEachToString.ts
+var arrTableEachToString_exports = {};
+__export(arrTableEachToString_exports, {
+  arrTableEachToString: () => arrTableEachToString
+});
+function arrTableEachToString(table) {
+  return table.map(arrEachToString);
+}
+__name(arrTableEachToString, "arrTableEachToString");
+
+// src/arrTableIterateAsObjects.ts
+var arrTableIterateAsObjects_exports = {};
+__export(arrTableIterateAsObjects_exports, {
+  arrTableIterateAsObjects: () => arrTableIterateAsObjects
+});
+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/arrTableRemoveColumns.ts
+var arrTableRemoveColumns_exports = {};
+__export(arrTableRemoveColumns_exports, {
+  arrTableRemoveColumns: () => arrTableRemoveColumns
+});
+function arrTableRemoveColumns(table, ...removeColumnNames) {
+  if (!removeColumnNames.length || !table.length) return table;
+  const set = new Set(removeColumnNames.map((col) => arrIndicesOf(table[0], col)).flat());
+  return table.map((row) => row.filter((_, i) => !set.has(i)));
+}
+__name(arrTableRemoveColumns, "arrTableRemoveColumns");
+
+// src/arrTableToCsv.ts
+var arrTableToCsv_exports = {};
+__export(arrTableToCsv_exports, {
+  arrTableToCsv: () => arrTableToCsv
+});
+function arrTableToCsv(input, delimiter = ";", replaceLinebreakWith = "<br>") {
+  return input.map((row) => {
+    return row.map((item) => String(item).replace(new RegExp(";", "g"), "").replace(/\r*\n/g, replaceLinebreakWith)).join(delimiter);
+  }).join("\n");
+}
+__name(arrTableToCsv, "arrTableToCsv");
+
+// src/arrTableToObjects.ts
+var arrTableToObjects_exports = {};
+__export(arrTableToObjects_exports, {
+  arrTableToObjects: () => arrTableToObjects
+});
+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/arrayToString.ts
+var arrayToString_exports = {};
+__export(arrayToString_exports, {
+  arrayToString: () => arrayToString
+});
+function arrayToString(array) {
+  return `[${array.map((item) => {
+    return item == null ? String(item) : Array.isArray(item) ? arrayToString(item) : item.toString();
+  }).join(",")}]`;
+}
+__name(arrayToString, "arrayToString");
+
+// src/index.ts
+var src_default = {
+  ...arrAverage_exports,
+  //
+  ...arrEachToString_exports,
+  ...arrFindIndicesOf_exports,
+  ...arrGetOrDefault_exports,
+  ...arrHasDuplicates_exports,
+  ...arrIndicesOf_exports,
+  ...arrLast_exports,
+  ...arrMapMutable_exports,
+  ...arrObjectsToTable_exports,
+  ...arrObjectsUniqueKeys_exports,
+  ...arrRemove_exports,
+  ...arrRemoveDuplicates_exports,
+  ...arrRemoveMutable_exports,
+  ...arrShuffle_exports,
+  ...arrSortNumeric_exports,
+  ...arrSortedInsertionIndex_exports,
+  ...arrSum_exports,
+  ...arrSwap_exports,
+  ...arrTableAssertRowsSameLength_exports,
+  ...arrTableEachToString_exports,
+  ...arrTableIterateAsObjects_exports,
+  ...arrTableRemoveColumns_exports,
+  ...arrTableToCsv_exports,
+  ...arrTableToObjects_exports,
+  ...arrayToString_exports
+};
+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,
+  src_default as default
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/arrAverage.ts", "../src/arrSum.ts", "../src/arrEachToString.ts", "../src/arrFindIndicesOf.ts", "../src/arrGetOrDefault.ts", "../src/arrHasDuplicates.ts", "../src/arrIndicesOf.ts", "../src/arrLast.ts", "../src/arrMapMutable.ts", "../src/arrObjectsToTable.ts", "../src/arrObjectsUniqueKeys.ts", "../src/arrRemove.ts", "../src/arrRemoveDuplicates.ts", "../src/arrRemoveMutable.ts", "../src/arrShuffle.ts", "../src/arrSwap.ts", "../src/arrSortNumeric.ts", "../src/arrSortedInsertionIndex.ts", "../src/arrTableAssertRowsSameLength.ts", "../src/arrTableEachToString.ts", "../src/arrTableIterateAsObjects.ts", "../src/arrTableRemoveColumns.ts", "../src/arrTableToCsv.ts", "../src/arrTableToObjects.ts", "../src/arrayToString.ts", "../src/index.ts"],
+  "sourcesContent": ["import { arrSum } from './arrSum'\n\n/**\n * Calculates the average of an array of numbers.\n * @returns The average of all numbers in the array.\n * @throws an error if the input array is empty.\n * @param array The array of numbers.\n * @example ```ts\n * const numbers = [1, 2, 3, 4, 5];\n * arrAverage(numbers);\n * //=> 3\n * ```\n */\nexport function arrAverage(array: number[]): number {\n  if (!array.length) throw new Error('Cannot take an average of zero values.')\n  return arrSum(array) / array.length\n}\n", "/**\n * Calculates the sum of an array of numbers.\n * @returns The sum of all numbers in the array.\n * @param array The array of numbers to sum.\n * @example ```ts\n * const numbers = [1, 2, 3, 4, 5];\n * arrSum(numbers);\n * //=> 15\n * ```\n */\nexport function arrSum(array: number[]): number {\n  return array.reduce((acc, cur) => acc + cur, 0)\n}\n", "/**\n * Coerce each element of an array to string.\n * @template T - The type of elements in the input array.\n * @returns A new array where each element is the string representation of the corresponding element in the input array.\n * @param array The array to iterate over.\n * @example ```ts\n * const numbers = [1, 2, 3];\n * arrEachToString(numbers);\n * //=> ['1', '2', '3']\n * ```\n */\nexport function arrEachToString<T>(array: T[]): string[] {\n  return array.map((element) => '' + element)\n}\n", "/**\n * Returns an array of indices where the predicate function returns true for the corresponding element in the input array.\n * @param input - The array to search.\n * @param predicate - The function to test each element of the array.\n * @returns An array of indices where the predicate function returns true.\n */\nexport function arrFindIndicesOf<T>(input: Array<T>, predicate: (value: T) => boolean): number[] {\n  const result: number[] = []\n  for (let i = 0; i < input.length; i++) {\n    if (predicate(input[i])) {\n      result.push(i)\n    }\n  }\n  return result\n}\n", "/**\n * Get array element at index or create it using factory function if it doesn't exist.\n */\nexport function arrGetOrDefault<V>(array: V[], index: number, factory: (index: number) => V): V {\n  const value = array[index]\n  if (value !== undefined || Object.hasOwn(array, index)) return value\n  return (array[index] = factory(index))\n}\n", "/**\n * Checks if an array has any duplicate elements.\n * @param arr - The array to check for duplicates.\n * @returns A boolean indicating whether the array has duplicates.\n * @typeParam T - The type of elements in the array.\n */\nexport function arrHasDuplicates<T>(arr: T[]): boolean {\n  const seen = new Set<T>()\n  for (const e of arr) {\n    if (seen.has(e)) return true\n    seen.add(e)\n  }\n  return false\n}\n", "/**\n * Returns all indexes at which an element is found.\n * @param input The array to search\n * @template T - The type of elements in the input array.\n * @returns An array of indices where the specified element can be found.\n * @param element The element to find\n * @example ```ts\n *  const inputArray = [1, 2, 3, 2, 4, 2, 5];\n *  const elementToFind = 2;\n *  arrIndicesOf(inputArray, elementToFind);\n *  //=> [1, 3, 5]\n *  ```\n */\nexport function arrIndicesOf<T>(input: Array<T>, element: T): number[] {\n  const result: number[] = []\n  for (let i = 0; i < input.length; i++) {\n    if (element === input[i]) {\n      result.push(i)\n    }\n  }\n  return result\n}\n", "/**\n * Returns the last element of an array.\n * Throws an error if the array is empty.\n * @template T The type of elements in the array.\n * @param array The array to get the last element from.\n * @returns The last element of the array.\n * @throws If the array is empty.\n * @example const numbers = [1, 2, 3, 4, 5];\n * const lastNumber = arrLast(numbers);\n * //=> 5\n */\nexport function arrLast<T>(array: T[]): T {\n  if (!array.length) throw new Error('Cannot get last element of empty array.')\n  return array[array.length - 1]\n}\n", "/**\n * 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.\n * @template T The type of elements in the input array.\n * @param input The array to be mapped over.\n * @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.\n * @returns The original array, mutated by the callback function.\n * @example ```ts\n * arrMapMutable([1, 2, 3], (value: number) => value * 2);\n * //=> [2, 4, 6]\n * ```\n */\nexport function arrMapMutable<T>(input: Array<T>, f: (value: T, index: number, array: T[]) => T): Array<T> {\n  for (let i = 0; i < input.length; i++) {\n    input[i] = f(input[i], i, input)\n  }\n  return input\n}\n", "import { arrObjectsUniqueKeys } from './arrObjectsUniqueKeys'\n\n/**\n * Convert an array of objects to a two-dimensional table.\n * @param objects The array of objects to convert to a table.\n * @template T - The type of the values in the objects.\n * @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.\n * @param options.emptyCell An optional value to use for empty cells. If not provided, the function will use `undefined`.\n * @returns A 2D array (table) where each row represents an object and each column represents a property of the object.\n * @param options The options for converting the objects to a table.\n * @example ```ts\n * arrObjectsToTable(\n *   [\n *     { a: 1, b: 2 },\n *     { a: 3, b: 4, c: 5 },\n *   ],\n *   { emptyCell:1 },\n * ) //=> [ [ 'a', 'b', 'c' ], [ 1, 2,1 ], [ 3, 4, 5 ] ]\n * ```\n */\nexport function arrObjectsToTable<T, E>(\n  objects: Record<string, T | undefined>[],\n  options: {\n    headers?: string[]\n    emptyCell?: E\n  } = {},\n): Array<Array<string | T | E>> {\n  const headers = options?.headers?.slice() || arrObjectsUniqueKeys(objects)\n  const table: Array<Array<string | T | E>> = [headers]\n  for (const o of objects) {\n    const row = headers.map((header) => {\n      const value = o[header]\n      return value !== undefined ? value : (options.emptyCell as E)\n    })\n    table.push(row)\n  }\n  return table\n}\n", "/**\n * Returns an array of all unique object keys found in an array of objects.\n * @template T - The type of values in the input objects.\n * @returns An array of unique keys present in the input objects.\n * @param objects The array of objects.\n * @example ```ts\n * const objects = [\n *   { name: 'John', age: 25 },\n *   { name: 'Jane', gender: 'female' },\n *   { name: 'Bob', age: 30, gender: 'male' },\n * ];\n * arrObjectsUniqueKeys(objects);\n * //=> ['name', 'age', 'gender']\n * ```\n */\nexport function arrObjectsUniqueKeys<T>(objects: Record<string, T>[]): string[] {\n  const keys = new Set<string>()\n  for (const o of objects) {\n    for (const key of Object.keys(o)) {\n      keys.add(key)\n    }\n  }\n  return Array.from(keys)\n}\n", "/**\n * Remove a given element from a copy of a given array and return the resulting array.\n */\nexport function arrRemove<T>(arr: T[], elementToRemove: T): T[] {\n  return arr.filter((element) => element !== elementToRemove)\n}\n", "/**\n * Remove duplicates from an array\n * @remarks This function uses the JavaScript Set object to remove duplicate values from an array.\n * @typeparam T - The type of elements in the array.\n * @returns The new array with duplicates removed.\n * @param array The array from which to remove duplicates.\n * @example ```ts\n * const array = [1, 2, 2, 3, 4, 4, 5];\n * arrRemoveDuplicates(array);\n * //=> [1, 2, 3, 4, 5]\n * ```\n */\nexport function arrRemoveDuplicates<T>(array: T[]): T[] {\n  return Array.from(new Set(array))\n}\n", "/**\n * Remove elements in-place from an array.\n */\nexport function arrRemoveMutable<T>(arr: T[], elementToRemove: T): void {\n  let index = arr.indexOf(elementToRemove)\n  while (index !== -1) {\n    arr.splice(index, 1)\n    index = arr.indexOf(elementToRemove)\n  }\n}\n", "import { arrSwap } from './arrSwap'\n\n/**\n * Shuffle items in an array in-place. Guarantees changes.\n * @remarks This function does not guarantee that the order of the elements will be different after shuffling.\n * @typeparam T - The type of the elements in the input array.\n * @returns The same array, but shuffled.\n * @param input The array to shuffle.\n * @example ```ts\n * const input = [1, 2, 3, 4, 5];\n * arrShuffle(input);\n * //=> [3, 1, 5, 2, 4]\n * ```\n */\nexport function arrShuffle<T>(input: Array<T>): Array<T> {\n  if (input.length <= 1) return input\n  const original = input.slice()\n  let equal = true\n  while (equal) {\n    for (let i = 0; i < input.length; i++) {\n      const newIndex = Math.floor(Math.random() * input.length)\n      arrSwap(input, i, newIndex)\n    }\n    equal = input.join(',') === original.join(',')\n  }\n  return input\n}\n", "/**\n * Swaps two elements in an array. This function takes an input array and swaps the elements at the specified indices.\n * @param to The index of the element to swap to.\n * @param from The index of the element to swap from.\n * @template T - The type of elements in the array.\n * @returns The modified array with swapped elements.\n * @throws Will throw an error if 'from' or 'to' is not a valid index in the array.\n * @param input The input array.\n * @example ```ts\n * const arr = [1, 2, 3, 4, 5]\n * arrSwap(arr, 1, 3) //=> [1, 4, 3, 2, 5]\n * ```\n */\nexport function arrSwap<T>(input: Array<T>, from: number, to: number): Array<T> {\n  if (from === to) return input\n  ;[input[from], input[to]] = [input[to], input[from]]\n  return input\n}\n", "/**\n * Sorts an array of numbers, bigints, or booleans in ascending order.\n * @returns The sorted array.\n * @remarks This function uses the JavaScript `Array.prototype.sort()` method, which sorts elements in place.\n * Therefore, the original array will be modified.\n * @throws If any element in the input array is not a number, bigint, or boolean.\n * @param input The array to be sorted.\n * @example ```ts\n * const input = [5, 2n, true, 10, false];\n * arrSortNumeric(input);\n * //=> [false, true, 2n, 5, 10]\n * ```\n */\nexport function arrSortNumeric(input: Array<number | bigint | boolean>): Array<number | bigint | boolean> {\n  return input.sort((a: number | bigint | boolean, b: number | bigint | boolean) => {\n    if (a < b) return -1\n    if (a > b) return 1\n    return 0\n  })\n}\n", "/**\n * Returns an index in the sorted array where the specified value could be inserted while maintaining the sorted order of the array.\n * If the element is already in the array, returns the index after the last instance of the element.\n * @param array - The sorted array to search.\n * @param value - The value to locate in the array.\n * @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.\n * @returns The index at which the value could be inserted into array to maintain the array's sorted order.\n * @example ```ts\n * const array = [1, 2, 3, 5, 6];\n * const value = 4;\n * const comparator = (a, b) => a - b;\n * const index = arrSortedLowerBound(array, value, comparator);\n * console.log(index); // Output: 3\n * ```\n */\nexport function arrSortedInsertionIndex<T>(\n  array: readonly T[],\n  value: T,\n  comparator: (a: T, b: T) => number,\n): number {\n  let first = 0\n  let count = array.length\n  while (count > 0) {\n    const step = Math.trunc(count / 2)\n    let it = first + step\n    if (comparator(array[it]!, value) <= 0) {\n      first = ++it\n      count -= step + 1\n    } else {\n      count = step\n    }\n  }\n  return first\n}\n", "/**\n * Asserts that all rows in a 2D array have the same length.\n * @param - Optional array of headers to compare the row length against.\n * @throws If any row in the array has a different length than the others.\n * @param headers Optional. An array of headers. If provided, each row must have the same length as this array.\n * @typeparam T - The type of elements in the rows.\n * @param rows The 2D array to check.\n * @example ```ts\n *  const rows = [\n *    [1, 2, 3],\n *    [4, 5, 6],\n *    [7, 8, 9],\n *  ];\n *  arrTableAssertRowsSameLength(rows);\n *  //=> undefined\n *  const rowsWithDifferentLength = [\n *    [1, 2, 3],\n *    [4, 5],\n *    [7, 8, 9],\n *  ];\n *  arrTableAssertRowsSameLength(rowsWithDifferentLength);\n *  //=> Error: Expected 3 columns, got 2\n *  ```\n */\nexport function arrTableAssertRowsSameLength<T>(rows: T[][], headers?: string[]): void {\n  const numHeaders = (headers || rows[0]).length\n  for (const row of rows) {\n    if (row.length !== numHeaders) {\n      throw new Error(`Expected ${numHeaders} columns, got ${row.length}`)\n    }\n  }\n}\n", "import { arrEachToString } from './arrEachToString'\n\n/**\n * Coerce each value of a 2D array table to string.\n * @template T - The type of the elements in the input array.\n * @returns The converted 2D array where each element is a string.\n * @param table The 2D array to convert.\n * @example ```ts\n * const input: number[][] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];\n * arrTableEachToString(input);\n * //=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]\n * ```\n */\nexport function arrTableEachToString<T>(table: T[][]): string[][] {\n  return table.map(arrEachToString)\n}\n", "/**\n * Generator that iterates through a 2D array table, yielding objects with header keys and row values.\n */\nexport function* arrTableIterateAsObjects<T>(\n  rows: T[][],\n  headers: string[],\n  ignoreHeaders: Set<string> = new Set(),\n) {\n  if (!headers.length) {\n    throw new Error('No headers provided')\n  }\n\n  ignoreHeaders.forEach((h) => {\n    if (!headers.includes(h)) {\n      throw new Error(`Header \"${h}\" not found in headers: ${headers}`)\n    }\n  })\n\n  if (new Set(headers).size === ignoreHeaders.size) {\n    throw new Error('All headers are ignored')\n  }\n\n  for (let r = 0; r < rows.length; r++) {\n    if (rows[r].length !== headers.length) {\n      throw new Error(`Row ${r} has ${rows[r].length} columns, but expected ${headers.length}`)\n    }\n\n    const o: Record<string, T> = {}\n    for (let c = 0; c < headers.length; c++) {\n      if (ignoreHeaders.has(headers[c])) continue\n      o[headers[c]] = rows[r][c]\n    }\n    yield o\n  }\n}\n", "import { arrIndicesOf } from './arrIndicesOf'\n\n/**\n * Removes specified columns from a 2D array table.\n * @param table - The 2D array (table) from which columns will be removed. The first row of the table is assumed to contain column names.\n * @param removeColumnNames - The names of the columns to be removed. These should match the entries in the first row of the table.\n * @returns A new 2D array (table) with the specified columns removed.\n */\nexport function arrTableRemoveColumns(table: string[][], ...removeColumnNames: string[]): string[][] {\n  if (!removeColumnNames.length || !table.length) return table\n  const set = new Set(removeColumnNames.map((col) => arrIndicesOf(table[0], col)).flat())\n  return table.map((row) => row.filter((_, i) => !set.has(i)))\n}\n", "/**\n * Converts a 2D array to a CSV string.\n * @param input The input 2D array.\n * @remarks This function is useful for exporting data to CSV format.\n * @param replaceLinebreakWith The character used to replace line breaks in the CSV string. Defaults to '|'.\n * @typeparam T - The type of the elements in the input array.\n * @returns The CSV string representation of the input array.\n * @param delimiter The delimiter to use for separating values in the CSV string.\n * @example ```ts\n * const input = [\n *   ['Name', 'Age', 'Country'],\n *   ['John', '25', 'USA'],\n *   ['Alice', '30', 'Canada'],\n *   ['Bob', '35', 'UK'],\n * ];\n * arrTableToCsv(input);\n * //=> \"Name;Age;Country\\nJohn;25;USA\\nAlice;30;Canada\\nBob;35;UK\"\n * ```\n */\nexport function arrTableToCsv<T>(input: T[][], delimiter = ';', replaceLinebreakWith = '<br>'): string {\n  return input\n    .map((row) => {\n      return row\n        .map((item) => String(item).replace(new RegExp(';', 'g'), '').replace(/\\r*\\n/g, replaceLinebreakWith))\n        .join(delimiter)\n    })\n    .join('\\n')\n}\n", "/**\n * Converts a 2D array representing a table into an array of objects.\n * @param rows The 2D array representing the table.\n * @template T - The type of the elements in the rows.\n * @param headers The headers to use as keys for the objects. If not provided, the first row of the table is used as headers.\n * @returns An array of objects, where each object represents a row in the table.\n * @throws Throws an error if the headers are not provided and the table is empty or only contains one row.\n * @param headers Optional array of headers for the table.\n * @example ```ts\n * const table = [\n *   ['Name', 'Age', 'Country'],\n *   ['John', 25, 'USA'],\n *   ['Jane', 30, 'Canada'],\n * ];\n * const headers = ['Name', 'Age', 'Country'];\n * arrTableToObjects(table, headers) //=> [\n * //   { Name: 'John', Age: 25, Country: 'USA' },\n * //   { Name: 'Jane', Age: 30, Country: 'Canada' },\n * // ]\n * ```\n */\nexport function arrTableToObjects<T>(\n  rows: T[][],\n  headers?: string[],\n  ignoreKeys?: Set<string>,\n): Record<string, T>[] {\n  if (headers) {\n    if (!rows.length) return []\n  } else {\n    if (rows.length <= 1) return []\n    headers = rows[0].map((header) => {\n      return header === null || header === undefined ? '' : String(header)\n    })\n    rows = rows.slice(1)\n  }\n  const _headers = headers\n  return rows.map((row: T[]) => {\n    const o: Record<string, T> = {}\n    for (let i = 0; i < _headers.length; i++) {\n      const header = _headers[i]\n      if (ignoreKeys && ignoreKeys.has(header)) continue\n      o[header] = row[i]\n    }\n    return o\n  })\n}\n", "/**\n * Short and condensed string representation of an array, easy to read for error outputs or similar.\n */\nexport function arrayToString<T>(array: T[]): string {\n  return `[${array\n    .map((item: T) => {\n      return item == null ? String(item) : Array.isArray(item) ? arrayToString(item) : item.toString()\n    })\n    .join(',')}]`\n}\n", "export * from './arrAverage'\nexport * from './arrEachToString'\nexport * from './arrFindIndicesOf'\nexport * from './arrGetOrDefault'\nexport * from './arrHasDuplicates'\nexport * from './arrIndicesOf'\nexport * from './arrLast'\nexport * from './arrMapMutable'\nexport * from './arrObjectsToTable'\nexport * from './arrObjectsUniqueKeys'\nexport * from './arrRemove'\nexport * from './arrRemoveDuplicates'\nexport * from './arrRemoveMutable'\nexport * from './arrShuffle'\nexport * from './arrSortNumeric'\nexport * from './arrSortedInsertionIndex'\nexport * from './arrSum'\nexport * from './arrSwap'\nexport * from './arrTableAssertRowsSameLength'\nexport * from './arrTableEachToString'\nexport * from './arrTableIterateAsObjects'\nexport * from './arrTableRemoveColumns'\nexport * from './arrTableToCsv'\nexport * from './arrTableToObjects'\nexport * from './arrayToString'\n\nimport * as MODULE_01 from './arrAverage'\nimport * as MODULE_02 from './arrEachToString'\nimport * as MODULE_03 from './arrFindIndicesOf'\nimport * as MODULE_04 from './arrGetOrDefault'\nimport * as MODULE_05 from './arrHasDuplicates'\nimport * as MODULE_06 from './arrIndicesOf'\nimport * as MODULE_07 from './arrLast'\nimport * as MODULE_08 from './arrMapMutable'\nimport * as MODULE_09 from './arrObjectsToTable'\nimport * as MODULE_10 from './arrObjectsUniqueKeys'\nimport * as MODULE_11 from './arrRemove'\nimport * as MODULE_12 from './arrRemoveDuplicates'\nimport * as MODULE_13 from './arrRemoveMutable'\nimport * as MODULE_14 from './arrShuffle'\nimport * as MODULE_15 from './arrSortNumeric'\nimport * as MODULE_16 from './arrSortedInsertionIndex'\nimport * as MODULE_17 from './arrSum'\nimport * as MODULE_18 from './arrSwap'\nimport * as MODULE_19 from './arrTableAssertRowsSameLength'\nimport * as MODULE_20 from './arrTableEachToString'\nimport * as MODULE_21 from './arrTableIterateAsObjects'\nimport * as MODULE_22 from './arrTableRemoveColumns'\nimport * as MODULE_23 from './arrTableToCsv'\nimport * as MODULE_24 from './arrTableToObjects'\nimport * as MODULE_25 from './arrayToString'\n\nexport default {\n  ...MODULE_01, //\n  ...MODULE_02,\n  ...MODULE_03,\n  ...MODULE_04,\n  ...MODULE_05,\n  ...MODULE_06,\n  ...MODULE_07,\n  ...MODULE_08,\n  ...MODULE_09,\n  ...MODULE_10,\n  ...MODULE_11,\n  ...MODULE_12,\n  ...MODULE_13,\n  ...MODULE_14,\n  ...MODULE_15,\n  ...MODULE_16,\n  ...MODULE_17,\n  ...MODULE_18,\n  ...MODULE_19,\n  ...MODULE_20,\n  ...MODULE_21,\n  ...MODULE_22,\n  ...MODULE_23,\n  ...MODULE_24,\n  ...MODULE_25,\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/package.json

@@ -1,29 +1,35 @@
 {
   "name": "@bemoje/array",
-  "version": "0.3.3",
-  "type": "commonjs",
-  "main": "cjs/index.js",
-  "types": "cjs/index.d.ts",
-  "dependencies": {
-    "tslib": "latest"
+  "version": "1.0.0",
+  "packageManager": "yarn@4.3.1",
+  "type": "module",
+  "sideEffects": false,
+  "module": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node esbuild.mjs"
   },
   "license": "MIT",
-  "keywords": [],
   "author": {
-    "name": "Benjamin Møller Jensen",
+    "name": "Benjamin Moller Jensen",
     "email": "bemoje@bemoje.net",
     "url": "https://github.com/bemoje/"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bemoje/tsmono.git"
-  },
-  "funding": {
-    "type": "patreon",
-    "url": "https://www.patreon.com/user?u=40752770"
-  },
-  "bugs": {
-    "url": "https://github.com/bemoje/tsmono/issues"
-  },
-  "homepage": "https://github.com/bemoje/tsmono"
+    "url": "https://github.com/bemoje/mono.git",
+    "directory": "libs/array"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Benjamin Møller Jensen
-
-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.

package/cjs/index.d.ts

@@ -1,33 +0,0 @@
-export * from './lib/arrAverage';
-export * from './lib/arrEachToString';
-export * from './lib/arrEvery';
-export * from './lib/arrFindIndicesOf';
-export * from './lib/arrFindLast';
-export * from './lib/arrFindLastIndexOf';
-export * from './lib/arrFlatten';
-export * from './lib/arrHasDuplicates';
-export * from './lib/arrIndicesOf';
-export * from './lib/arrLast';
-export * from './lib/arrMapMutable';
-export * from './lib/arrObjectsToTable';
-export * from './lib/arrObjectsUniqueKeys';
-export * from './lib/arrRemove';
-export * from './lib/arrRemoveDuplicates';
-export * from './lib/arrRemoveMutable';
-export * from './lib/arrShallowEquals';
-export * from './lib/arrShuffle';
-export * from './lib/arrSome';
-export * from './lib/arrSortedInsertionIndex';
-export * from './lib/arrSortNumeric';
-export * from './lib/arrSum';
-export * from './lib/arrSwap';
-export * from './lib/arrTableAssertRowsSameLength';
-export * from './lib/arrTableEachToString';
-export * from './lib/arrTableRemoveColumns';
-export * from './lib/arrTableToCsv';
-export * from './lib/arrTableToObjects';
-export * from './lib/types/ArrayPredicate';
-export * from './lib/types/ArrayValueCallback';
-export * from './lib/types/ArrayVoidCallback';
-export * from './lib/types/NestedArray';
-//# sourceMappingURL=index.d.ts.map

package/cjs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/array/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,2BAA2B,CAAA;AACzC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,sBAAsB,CAAA;AACpC,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,oCAAoC,CAAA;AAClD,cAAc,4BAA4B,CAAA;AAC1C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,yBAAyB,CAAA"}

package/cjs/index.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/arrAverage"), exports);
-tslib_1.__exportStar(require("./lib/arrEachToString"), exports);
-tslib_1.__exportStar(require("./lib/arrEvery"), exports);
-tslib_1.__exportStar(require("./lib/arrFindIndicesOf"), exports);
-tslib_1.__exportStar(require("./lib/arrFindLast"), exports);
-tslib_1.__exportStar(require("./lib/arrFindLastIndexOf"), exports);
-tslib_1.__exportStar(require("./lib/arrFlatten"), exports);
-tslib_1.__exportStar(require("./lib/arrHasDuplicates"), exports);
-tslib_1.__exportStar(require("./lib/arrIndicesOf"), exports);
-tslib_1.__exportStar(require("./lib/arrLast"), exports);
-tslib_1.__exportStar(require("./lib/arrMapMutable"), exports);
-tslib_1.__exportStar(require("./lib/arrObjectsToTable"), exports);
-tslib_1.__exportStar(require("./lib/arrObjectsUniqueKeys"), exports);
-tslib_1.__exportStar(require("./lib/arrRemove"), exports);
-tslib_1.__exportStar(require("./lib/arrRemoveDuplicates"), exports);
-tslib_1.__exportStar(require("./lib/arrRemoveMutable"), exports);
-tslib_1.__exportStar(require("./lib/arrShallowEquals"), exports);
-tslib_1.__exportStar(require("./lib/arrShuffle"), exports);
-tslib_1.__exportStar(require("./lib/arrSome"), exports);
-tslib_1.__exportStar(require("./lib/arrSortedInsertionIndex"), exports);
-tslib_1.__exportStar(require("./lib/arrSortNumeric"), exports);
-tslib_1.__exportStar(require("./lib/arrSum"), exports);
-tslib_1.__exportStar(require("./lib/arrSwap"), exports);
-tslib_1.__exportStar(require("./lib/arrTableAssertRowsSameLength"), exports);
-tslib_1.__exportStar(require("./lib/arrTableEachToString"), exports);
-tslib_1.__exportStar(require("./lib/arrTableRemoveColumns"), exports);
-tslib_1.__exportStar(require("./lib/arrTableToCsv"), exports);
-tslib_1.__exportStar(require("./lib/arrTableToObjects"), exports);
-tslib_1.__exportStar(require("./lib/types/ArrayPredicate"), exports);
-tslib_1.__exportStar(require("./lib/types/ArrayValueCallback"), exports);
-tslib_1.__exportStar(require("./lib/types/ArrayVoidCallback"), exports);
-tslib_1.__exportStar(require("./lib/types/NestedArray"), exports);
-//# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/array/src/index.ts"],"names":[],"mappings":";;;AAAA,2DAAgC;AAChC,gEAAqC;AACrC,yDAA8B;AAC9B,iEAAsC;AACtC,4DAAiC;AACjC,mEAAwC;AACxC,2DAAgC;AAChC,iEAAsC;AACtC,6DAAkC;AAClC,wDAA6B;AAC7B,8DAAmC;AACnC,kEAAuC;AACvC,qEAA0C;AAC1C,0DAA+B;AAC/B,oEAAyC;AACzC,iEAAsC;AACtC,iEAAsC;AACtC,2DAAgC;AAChC,wDAA6B;AAC7B,wEAA6C;AAC7C,+DAAoC;AACpC,uDAA4B;AAC5B,wDAA6B;AAC7B,6EAAkD;AAClD,qEAA0C;AAC1C,sEAA2C;AAC3C,8DAAmC;AACnC,kEAAuC;AACvC,qEAA0C;AAC1C,yEAA8C;AAC9C,wEAA6C;AAC7C,kEAAuC"}

package/cjs/lib/arrAverage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrAverage.d.ts","sourceRoot":"","sources":["../../../../../packages/array/src/lib/arrAverage.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAGlD"}