arr-helper-functions/dist/index.js

Misc. functions for finding elements in arrays, sorting, and more

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  ArraySorter: () => ArraySorter,
  FastArraySearcher: () => FastArraySearcher,
  SortingFunction: () => SortingFunction,
  areInAnyArray: () => areInAnyArray,
  areInArray: () => areInArray,
  areInSameArray: () => areInSameArray,
  distinctValues: () => distinctValues,
  filterFalsyValues: () => filterFalsyValues,
  getBestSortingFunction: () => getBestSortingFunction,
  getFirstAndLastElement: () => getFirstAndLastElement,
  isEmpty: () => isEmpty,
  isInAnyArray: () => isInAnyArray,
  isInArray: () => isInArray,
  isNotEmpty: () => isNotEmpty,
  isNotInArray: () => isNotInArray,
  sortArray: () => sortArray
});
module.exports = __toCommonJS(src_exports);

// src/modules/conditions.ts
function not(condition) {
  return condition === false;
}

// src/modules/find.ts
function isInArray(element, array) {
  return array.includes(element);
}
function isNotInArray(element, array) {
  return not(isInArray(element, array));
}
function areInArray(elements, array) {
  return elements.every((d) => isInArray(d, array));
}
function isInAnyArray(element, arrays) {
  return arrays.some((array) => isInArray(element, array));
}
function areInAnyArray(items, arrays) {
  return items.every((item) => isInAnyArray(item, arrays));
}
function areInSameArray(items, arrays) {
  return arrays.some((array) => areInArray(items, array));
}

// src/modules/conversion.ts
function arrayOfObjectsToObject(array, indexGetter, valueGetter) {
  function getIndex(d) {
    if (typeof indexGetter === "string") {
      return d[indexGetter];
    }
    const indexValue = indexGetter(d);
    if (typeof indexValue !== "string") {
      throw new Error("A string should be returned for indexing");
    } else {
      return indexValue;
    }
  }
  function getValue(d) {
    if (valueGetter == null) {
      return d;
    }
    if (typeof valueGetter === "string") {
      return d[valueGetter];
    }
    return valueGetter(d);
  }
  return array.reduce((agg, item) => {
    agg[getIndex(item)] = getValue(item);
    return agg;
  }, {});
}

// src/modules/fastFind.ts
var FastArraySearcher = class {
  /**
   * Creates an instance of FastArraySearcher.
   * @param {ArrayOfObjects} arrayToSearch Array to search
   * @param {(string | IndexerFunction)} options.indexGetter Property or item to use as index. Must resolve to a string
   * @param {(string | AccessorFunction)} [options.valueGetter] Property or item to use as value (will be returned if found)
   * @param {boolean} [options.keepOriginal=false] Whether to keeo original array reference inside
   * @memberof FastArraySearcher
   */
  constructor(arrayToSearch, options) {
    this.originalArray = options.keepOriginal ? arrayToSearch : [];
    this.searchObject = arrayOfObjectsToObject(
      arrayToSearch,
      options.indexGetter,
      options.valueGetter
    );
  }
  /**
   * Finds element in array
   *
   * @param {string} element The element to search for
   * @return {(any|undefined)} The found item, if found
   * @memberof FastArraySearcher
   */
  find(element) {
    return this.searchObject[element];
  }
};

// src/modules/unique.ts
function distinctValues(array, property) {
  let arrayToFindDistinctOf = array;
  if (property != null) {
    const mapper = typeof property === "function" ? property : (d) => d[property];
    arrayToFindDistinctOf = array.map(mapper);
  }
  return [...new Set(arrayToFindDistinctOf)];
}

// src/modules/filter.ts
function filterFalsyValues(array, includeZeros = false) {
  const falsyValues = [false, null, void 0];
  function conditionChecker(d) {
    if (falsyValues.includes(d)) {
      return false;
    }
    return includeZeros ? d !== 0 : true;
  }
  return array.filter(conditionChecker);
}

// src/modules/sort.ts
var import_array_types_counter = require("array-types-counter");
var SortingFunction = class {
  /**
   * Creates an instance of SortingFunction.
   * @param {('number' | 'string')} sortType
   * @param {(CompareFn<string> | CompareFn<number>)} sortFunc
   * @memberof SortingFunction
   */
  constructor(sortType, sortFunc) {
    this.sortType = sortType;
    this.sortFunc = sortFunc;
  }
};
function getBestSortingFunction(array) {
  var _a;
  const typesCount = (0, import_array_types_counter.countArrayTypes)(array);
  function numberSort(a, b) {
    return a - b;
  }
  if (((_a = typesCount[0]) == null ? void 0 : _a.type) === "number") {
    return new SortingFunction("number", numberSort);
  }
  return new SortingFunction("string", Intl.Collator().compare);
}
var ArraySorter = class {
  /**
   * Creates an instance of ArraySorter.
   * @param {any[]} array
   * @memberof ArraySorter
   */
  constructor(array) {
    this.arrayToSort = array;
  }
  /**
   * Sorts array
   *
   * @return {any[])}
   * @memberof ArraySorter
   */
  sort() {
    const { sortType, sortFunc } = getBestSortingFunction(this.arrayToSort);
    if (sortType === "string") {
      const arrCopy2 = [...this.arrayToSort];
      const sortingFunc2 = sortFunc;
      return arrCopy2.sort(sortingFunc2);
    }
    const arrCopy = [...this.arrayToSort];
    const sortingFunc = sortFunc;
    return arrCopy.sort(sortingFunc);
  }
};
function sortArray(array) {
  const sorter = new ArraySorter(array);
  return sorter.sort();
}
function getFirstAndLastElement(array) {
  return [array[0], array[array.length - 1]];
}

// src/modules/content.ts
function isEmpty(array) {
  return array.length === 0;
}
function isNotEmpty(array) {
  return not(isEmpty(array));
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ArraySorter,
  FastArraySearcher,
  SortingFunction,
  areInAnyArray,
  areInArray,
  areInSameArray,
  distinctValues,
  filterFalsyValues,
  getBestSortingFunction,
  getFirstAndLastElement,
  isEmpty,
  isInAnyArray,
  isInArray,
  isNotEmpty,
  isNotInArray,
  sortArray
});