@exabytellc/utils/dist/list/_list.js

EB react utils to make everything a little easier!

import { handleTryCatch } from "../_helpers/handleError";
import { isArr, isEmpty, isFunc, isObj } from "../types";

/* eslint-disable no-unused-vars */
export function arrClean(array, predicate = (_index, value) => isEmpty(value)) {
  return handleTryCatch({
    n: "arrClean",
    c: !isArr(array) || !isFunc(predicate),
    p: { array, predicate },
    e: () => {
      const cleanedArray = [];
      for (let i = 0; i < array.length; i++) {
        if (!predicate(i, array[i])) {
          cleanedArray.push(array[i]);
        }
      }
      return cleanedArray;
    }
  });
}
export function arrCountIf(array, predicate = (_key, _value) => false) {
  return handleTryCatch({
    n: "arrCountIf",
    c: !isArr(array) || !isFunc(predicate),
    p: { array, predicate },
    e: () => {

      let count = 0;
      for (let i = 0; i < array.length; i++) {
        if (predicate(i, array[i])) {
          count++;
        }
      }
      return count;
    }
  });
}
export function arrUnique(array, removeEmpty = false) {
  return handleTryCatch({
    n: "arrUnique",
    c: !isArr(array),
    p: { array },
    e: () => {
      const uniqueArray = [];
      for (const value of array) {
        if (!uniqueArray.includes(value)) {
          uniqueArray.push(value);
        }
      }
      if (removeEmpty) {
        return arrClean(uniqueArray);
      }
      return uniqueArray;
    }
  });
}
export function flattenObj(object, separator = "/", parentKey = null) {
  return handleTryCatch({
    n: "flattenObj",
    c: !isObj(object),
    p: { object },
    e: () => {
      const flattenedObject = {};
      for (const key in object) {
        const value = { ...object[key] };
        if (isObj(value)) {
          const nestedKeys = flattenObj(value, separator, key);
          for (const nestedKey in nestedKeys) {
            flattenedObject[`${key}${separator}${nestedKey}`] = nestedKeys[nestedKey];
          }
        } else {
          const flattenedKey = parentKey ? `${parentKey}${separator}${key}` : key;
          flattenedObject[flattenedKey] = value;
        }
      }
      return flattenedObject;
    }
  });
}
export function forEach(data, initialValue, callback = (_key, _value, _accumulator) => undefined) {
  return handleTryCatch({
    n: "forEach",
    c: !isArr(data) && !isObj(data) || !isFunc(callback),
    p: { data, callback },
    e: () => {
      let accumulator = initialValue;
      for (const key in data) {
        if (Object.prototype.hasOwnProperty.call(data, key)) {
          accumulator = callback(key, data[key], accumulator);
        }
      }
      return accumulator;
    }
  });
}
export function mapToArray(data, callback = (_index, _value, _sourceArray) => undefined) {
  return handleTryCatch({
    n: "mapToArray",
    c: !isArr(data) && !isObj(data) || !isFunc(callback),
    p: { data, callback },
    e: () => {
      const resultArray = [];
      for (const key in data) {
        if (Object.prototype.hasOwnProperty.call(data, key)) {
          const value = callback(key, data[key], data);
          if (value !== undefined) {
            resultArray.push(value);
          }
        }
      }
      return resultArray;
    }
  });
}
export function mapToObject(data, callback = (_index, _value, _sourceObject) => undefined) {
  return handleTryCatch({
    n: "mapToObject",
    c: !isArr(data) && !isObj(data) || !isFunc(callback),
    p: { data, callback },
    e: () => {
      const resultObject = {};
      for (const key in data) {
        if (Object.prototype.hasOwnProperty.call(data, key)) {
          const value = callback(key, data[key], data);
          if (isObj(value)) {
            Object.assign(resultObject, value);
          }
        }
      }
      return resultObject;
    }
  });
}