general utilities for reuse

utils.tsx

export const { info, log, warn, error, table } = console;

export function keys(src = {}) {
  return Object.keys(src);
}

export function isArr(src = []) {
  return Array.isArray(src);
}

export function values(src = {}) {
  return Object.values(src);
}

export function entries(src = {}) {
  return Object.entries(src);
}

export function expPass(src = true) {
  return src === true;
}

export function expFail(src = false) {
  return src === false;
}

export function verify(src = '') {
  return usable(src) && !empty(src);
}

export function isInt(src = 0) {
  return !isNaN(Number(parseInt(src)));
}

export function toArr(src = '') {
  return Array.from(src);
}

export function unique(src = {}) {
  return isArr(src) ? [...new Set(src)] : src;
}

export function isObj(src = {}) {
  return typeof src == 'object' && !isArr(src);
}

export function isSet(src = new Set()) {
  return typeof isObj(src) && src instanceof Set;
}

export function isMap(src = new Map()) {
  return typeof isObj(src) && src instanceof Map;
}

export function reduce(fn) {
  return (src = [], x0 = []) => src.reduce(fn, x0);
}

export function isStr(src = '') {
  return typeof src == 'string' && src instanceof String;
}

export function usable(src = null) {
  return ![null, undefined, 'Invalid Date'].includes(src);
}

export function sort(src = []) {
  return src.sort((x, y) => `${x}`.localeCompare(`${y}`));
}

export function pipe(...fns) {
  return (x0 = []) => reduce((acc, fn) => fn(acc))(fns, x0);
}

export function empty(src = '') {
  src = !isNaN(src) ? `${src}` : src;
  return 0 == (src?.length || src?.size || keys(src)?.length);
}

export function repeat(src = [], n = 1, x0 = []) {
  return reduce(acc => [...acc, src])(toArr({ length: n }), x0);
}

export function flow(...fns) {
  return (x0 = []) => reverse(reduce((acc, fn) => fn(acc))(fns, x0));
}

export function reverse(src = [], x0 = []) {
  return reduce((acc, _, i) => [...acc, src[src.length - i - 1]])(src, x0);
}

export function map(fn) {
  return (src = [], x0 = []) => reduce((acc, x) => [...acc, fn(x)])(src, x0);
}

export function grab(key = '') {
  return (src = [], x0 = []) => reduce((acc, x) => [...acc, x[key]])(src, x0);
}

export function scan(fn) {
  return (src = [], x0 = []) => reduce((acc, x) => [...acc, fn(acc, x)])(src, x0);
}

export function all(fn) {
  return (src = [], x0 = true) => reduce((acc, x) => verify(acc) && fn(x))(src, x0);
}

export function chunk(fn) {
  return (src = [], x0 = [[], []]) =>
    reduce(([x = [], y = []], z = '') => (expPass(fn(x)) ? [...x, z] : [...y, z]))(src, x0);
}

export function none(fn) {
  return (src = [], x0 = false) => reduce((acc, x) => verify(acc) && expFail(fn(x)))(src, x0);
}

export function filter(fn) {
  return (src = [], x0 = []) => reduce((acc, x) => (expPass(fn(x)) ? [...acc, x] : acc))(src, x0);
}

export function drop(fn) {
  return (src = [], x0 = []) => reduce((acc, x) => (expFail(fn(x)) ? [...acc, x] : acc))(src, x0);
}

export function some(fn) {
  return (src = [], x0 = []) => reduce((acc, x) => (expFail(fn(x)) ? [...acc, x] : acc))(src, x0);
}

export function find(fn) {
  return (src = [], x0 = []) => reduce((acc, x) => (verify(acc) && expPass(fn(x)) ? [...acc, x] : acc))(src, x0);
}

export const Util = {
  all,
  map,
  log,
  warn,
  info,
  keys,
  none,
  pipe,
  find,
  flow,
  grab,
  drop,
  scan,
  some,
  sort,
  error,
  chunk,
  empty,
  isArr,
  isStr,
  isObj,
  isSet,
  isMap,
  isInt,
  table,
  unique,
  usable,
  verify,
  filter,
  reduce,
  repeat,
  values,
  reverse,
  entries,
  expFail,
  expPass
};

export const __MOCKS = values({
  falsy_int: 0,
  truthy_tin: 1,
  empty_str: '',
  empty_obj: {},
  empty_arr: [],
  filled_int: 123,
  truthy_txt: true,
  falsey_txt: false,
  invalid_bad: null,
  filled_str: 'abc',
  empty_map: new Map(),
  empty_set: new Set(),
  invalid_und: undefined,
  filled_obj: { prop: [9, 'z'] },
  filled_map: new Map([['a', 1]]),
  filled_set: new Set([5, 10, 15]),
  filled_arr: ['arr', { key: 'value' }],
  invalid_now: new Date('Invalid Date'),
  filled_date: new Date().toISOString()
});

export const Mock = pipe(filter(usable), some(empty), unique, sort)(reduce((acc, x) => [...acc, x])(__MOCKS, []));

info(Mock);

export default Mock;