vest-utils 0.0.2-rc → 0.0.2

package/src/__tests__/numberEquals.test.ts

@@ -0,0 +1,59 @@
+import { random, datatype } from 'faker';
+
+import { numberEquals } from 'numberEquals';
+
+describe('Tests numberEquals rule', () => {
+  let arg0;
+
+  describe('Arguments are numbers', () => {
+    beforeEach(() => {
+      arg0 = datatype.number();
+    });
+
+    describe('When first argument is larger', () => {
+      it('Should return false', () => {
+        expect(numberEquals(arg0, arg0 - 1)).toBe(false);
+      });
+    });
+
+    describe('When first argument is smaller', () => {
+      it('Should return false', () => {
+        expect(numberEquals(arg0, arg0 + 1)).toBe(false);
+      });
+    });
+
+    describe('When values are equal', () => {
+      it('Should return true', () => {
+        expect(numberEquals(arg0, arg0)).toBe(true);
+      });
+    });
+  });
+
+  describe('Arguments are numeric strings', () => {
+    describe('When first argument is larger', () => {
+      it('Should return false', () => {
+        expect(numberEquals(`${arg0}`, `${arg0 - 1}`)).toBe(false);
+      });
+    });
+
+    describe('When first argument is smaller', () => {
+      it('Should return false', () => {
+        expect(numberEquals(`${arg0}`, `${arg0 + 1}`)).toBe(false);
+      });
+    });
+
+    describe('When values are equal', () => {
+      it('Should return true', () => {
+        expect(numberEquals(arg0, arg0)).toBe(true);
+      });
+    });
+  });
+
+  describe('Arguments are non numeric', () => {
+    [random.word(), `${datatype.number()}`.split(''), {}].forEach(element => {
+      it('Should return false', () => {
+        expect(numberEquals(element, 0)).toBe(false);
+      });
+    });
+  });
+});

package/src/__tests__/optionalFunctionValue.test.ts

@@ -0,0 +1,27 @@
+import { optionalFunctionValue } from 'vest-utils';
+
+describe('optionalFunctionValue', () => {
+  describe('When not a function', () => {
+    it.each([0, undefined, false, true, 1, [], {}, null, NaN])(
+      'Should return the same value',
+      value => {
+        expect(optionalFunctionValue(value)).toBe(value);
+      }
+    );
+  });
+
+  describe('When value is a function', () => {
+    it('Should call the function and return its return value', () => {
+      const value = jest.fn(() => 'return value');
+
+      expect(optionalFunctionValue(value)).toBe('return value');
+      expect(value).toHaveBeenCalled();
+    });
+    it('Should run with arguments arry', () => {
+      const value = jest.fn((...args) => args.join('|'));
+      const args = [1, 2, 3, 4];
+      expect(optionalFunctionValue(value, ...args)).toBe('1|2|3|4');
+      expect(value).toHaveBeenCalledWith(...args);
+    });
+  });
+});

package/src/__tests__/seq.test.ts

@@ -0,0 +1,12 @@
+import seq from 'seq';
+
+describe('lib:seq', () => {
+  it('Should return a new id on each run', () => {
+    Array.from({ length: 100 }, () => seq()).reduce((existing, seq) => {
+      expect(existing).not.toHaveProperty(seq.toString());
+      Object.assign(existing, { [seq]: true });
+      expect(existing).toHaveProperty(seq.toString());
+      return existing;
+    }, {});
+  });
+});

package/src/asArray.ts

@@ -0,0 +1,3 @@
+export default function asArray<T>(possibleArg: T | T[]): T[] {
+  return ([] as T[]).concat(possibleArg);
+}

package/src/assign.ts

@@ -0,0 +1 @@
+export default Object.assign;

package/src/bindNot.ts

@@ -0,0 +1,3 @@
+export default function bindNot<T extends (...args: any[]) => unknown>(fn: T) {
+  return (...args: Parameters<T>): boolean => !fn(...args);
+}

package/src/bus.ts

@@ -0,0 +1,32 @@
+import { CB } from 'utilityTypes';
+
+export function createBus(): {
+  on: (event: string, handler: CB) => OnReturn;
+  emit: (event: string, ...args: any[]) => void;
+} {
+  const listeners: Record<string, CB[]> = {};
+
+  return {
+    emit(event: string, data: any) {
+      listener(event).forEach(handler => {
+        handler(data);
+      });
+    },
+
+    on(event: string, handler: CB): OnReturn {
+      listeners[event] = listener(event).concat(handler);
+
+      return {
+        off() {
+          listeners[event] = listener(event).filter(h => h !== handler);
+        },
+      };
+    },
+  };
+
+  function listener(event: string): CB[] {
+    return listeners[event] || [];
+  }
+}
+
+type OnReturn = { off: () => void };

package/src/cache.ts

@@ -0,0 +1,49 @@
+import { lengthEquals } from 'lengthEquals';
+import { longerThan } from 'longerThan';
+
+/**
+ * Creates a cache function
+ */
+export default function createCache(maxSize = 1): {
+  <T>(deps: unknown[], cacheAction: (...args: unknown[]) => T): T;
+  get(deps: unknown[]): any;
+  invalidate(item: any): void;
+} {
+  const cacheStorage: Array<[unknown[], any]> = [];
+
+  const cache = <T>(
+    deps: unknown[],
+    cacheAction: (...args: unknown[]) => T
+  ): T => {
+    const cacheHit = cache.get(deps);
+    // cache hit is not null
+    if (cacheHit) return cacheHit[1];
+
+    const result = cacheAction();
+    cacheStorage.unshift([deps.concat(), result]);
+
+    if (longerThan(cacheStorage, maxSize)) cacheStorage.length = maxSize;
+
+    return result;
+  };
+
+  // invalidate an item in the cache by its dependencies
+  cache.invalidate = (deps: any[]): void => {
+    const index = findIndex(deps);
+    if (index > -1) cacheStorage.splice(index, 1);
+  };
+
+  // Retrieves an item from the cache.
+  cache.get = (deps: unknown[]): [unknown[], any] | null =>
+    cacheStorage[findIndex(deps)] || null;
+
+  return cache;
+
+  function findIndex(deps: unknown[]): number {
+    return cacheStorage.findIndex(
+      ([cachedDeps]) =>
+        lengthEquals(deps, cachedDeps.length) &&
+        deps.every((dep, i) => dep === cachedDeps[i])
+    );
+  }
+}

package/src/callEach.ts

@@ -0,0 +1,5 @@
+import { CB } from 'utilityTypes';
+
+export default function callEach(arr: CB[]): void {
+  return arr.forEach(fn => fn());
+}

package/src/defaultTo.ts

@@ -0,0 +1,8 @@
+import optionalFunctionValue from 'optionalFunctionValue';
+
+export default function defaultTo<T>(
+  value: T | ((...args: any[]) => T),
+  defaultValue: T | (() => T)
+): T {
+  return optionalFunctionValue(value) ?? optionalFunctionValue(defaultValue);
+}

package/src/deferThrow.ts

@@ -0,0 +1,5 @@
+export default function deferThrow(message?: string): void {
+  setTimeout(() => {
+    throw new Error(message);
+  }, 0);
+}

package/src/either.ts

@@ -0,0 +1,3 @@
+export default function either(a: unknown, b: unknown): boolean {
+  return !!a !== !!b;
+}

package/src/globals.d.ts

@@ -0,0 +1,3 @@
+declare const __DEV__: boolean;
+declare const __LIB_VERSION__: string;
+declare const LIBRARY_NAME: string;

package/src/greaterThan.ts

@@ -0,0 +1,8 @@
+import { isNumeric } from 'isNumeric';
+
+export function greaterThan(
+  value: number | string,
+  gt: number | string
+): boolean {
+  return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+}

package/src/hasOwnProperty.ts

@@ -0,0 +1,9 @@
+/**
+ * A safe hasOwnProperty access
+ */
+export default function hasOwnProperty<T>(
+  obj: T,
+  key: string | number | symbol
+): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}

package/src/invariant.ts

@@ -0,0 +1,24 @@
+import optionalFunctionValue from 'optionalFunctionValue';
+import { Stringable } from 'utilityTypes';
+
+export default function invariant(
+  condition: any,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  message?: String | Stringable
+): asserts condition {
+  if (condition) {
+    return;
+  }
+
+  // If message is a string object (rather than string literal)
+  // Throw the value directly as a string
+  // Alternatively, throw an error with the message
+  throw message instanceof String
+    ? message.valueOf()
+    : new Error(message ? optionalFunctionValue(message) : message);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function StringObject(value?: Stringable): String {
+  return new String(optionalFunctionValue(value));
+}

package/src/isArrayValue.ts

@@ -0,0 +1,11 @@
+import bindNot from 'bindNot';
+
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+
+export function isArray(value: unknown): value is Array<unknown> {
+  return Boolean(Array.isArray(value));
+}
+
+export const isNotArray = bindNot(isArray);

package/src/isBooleanValue.ts

@@ -0,0 +1,3 @@
+export default function isBoolean(value: unknown): value is boolean {
+  return !!value === value;
+}

package/src/isEmpty.ts

@@ -0,0 +1,17 @@
+import bindNot from 'bindNot';
+import hasOwnProperty from 'hasOwnProperty';
+import { lengthEquals } from 'lengthEquals';
+
+export function isEmpty(value: unknown): boolean {
+  if (!value) {
+    return true;
+  } else if (hasOwnProperty(value, 'length')) {
+    return lengthEquals(value as string | unknown[], 0);
+  } else if (typeof value === 'object') {
+    return lengthEquals(Object.keys(value as Record<string, unknown>), 0);
+  }
+
+  return false;
+}
+
+export const isNotEmpty = bindNot(isEmpty);

package/src/isFunction.ts

@@ -0,0 +1,5 @@
+export default function isFunction(
+  value: unknown
+): value is (...args: unknown[]) => unknown {
+  return typeof value === 'function';
+}

package/src/isNull.ts

@@ -0,0 +1,7 @@
+import bindNot from 'bindNot';
+
+export function isNull(value: unknown): value is null {
+  return value === null;
+}
+
+export const isNotNull = bindNot(isNull);

package/src/isNullish.ts

@@ -0,0 +1,9 @@
+import bindNot from 'bindNot';
+import { isNull } from 'isNull';
+import { isUndefined } from 'isUndefined';
+
+export function isNullish(value: any): value is null | undefined {
+  return isNull(value) || isUndefined(value);
+}
+
+export const isNotNullish = bindNot(isNullish);

package/src/isNumeric.ts

@@ -0,0 +1,11 @@
+import bindNot from 'bindNot';
+
+export function isNumeric(value: string | number): boolean {
+  const str = String(value);
+  const num = Number(value);
+  const result =
+    !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
+  return Boolean(result);
+}
+
+export const isNotNumeric = bindNot(isNumeric);

package/src/isPositive.ts

@@ -0,0 +1,5 @@
+import { greaterThan } from 'greaterThan';
+
+export function isPositive(value: number | string): boolean {
+  return greaterThan(value, 0);
+}

package/src/isPromise.ts

@@ -0,0 +1,5 @@
+import isFunction from 'isFunction';
+
+export default function isPromise(value: any): value is Promise<unknown> {
+  return value && isFunction(value.then);
+}

package/src/isStringValue.ts

@@ -0,0 +1,3 @@
+export default function isStringValue(v: unknown): v is string {
+  return String(v) === v;
+}

package/src/isUndefined.ts

@@ -0,0 +1,7 @@
+import bindNot from 'bindNot';
+
+export function isUndefined(value?: unknown): value is undefined {
+  return value === undefined;
+}
+
+export const isNotUndefined = bindNot(isUndefined);

package/src/last.ts

@@ -0,0 +1,7 @@
+import asArray from 'asArray';
+
+export default function last<T>(values: T | T[]): T {
+  const valuesArray = asArray(values);
+
+  return valuesArray[valuesArray.length - 1];
+}

package/src/lengthEquals.ts

@@ -0,0 +1,11 @@
+import bindNot from 'bindNot';
+import { numberEquals } from 'numberEquals';
+
+export function lengthEquals(
+  value: string | unknown[],
+  arg1: string | number
+): boolean {
+  return numberEquals(value.length, arg1);
+}
+
+export const lengthNotEquals = bindNot(lengthEquals);

package/src/longerThan.ts

@@ -0,0 +1,8 @@
+import { greaterThan } from 'greaterThan';
+
+export function longerThan(
+  value: string | unknown[],
+  arg1: string | number
+): boolean {
+  return greaterThan(value.length, arg1);
+}

package/src/mapFirst.ts

@@ -0,0 +1,25 @@
+export default function mapFirst<T>(
+  array: T[],
+  callback: (
+    item: T,
+    breakout: (conditional: boolean, value: unknown) => void,
+    index: number
+  ) => unknown
+): any {
+  let broke = false;
+  let breakoutValue = null;
+  for (let i = 0; i < array.length; i++) {
+    callback(array[i], breakout, i);
+
+    if (broke) {
+      return breakoutValue;
+    }
+  }
+
+  function breakout(conditional: boolean, value: unknown) {
+    if (conditional) {
+      broke = true;
+      breakoutValue = value;
+    }
+  }
+}

package/src/nestedArray.ts

@@ -0,0 +1,69 @@
+import asArray from 'asArray';
+import defaultTo from 'defaultTo';
+import { isArray } from 'isArrayValue';
+import { isNotNull } from 'isNull';
+import last from 'last';
+
+export type NestedArray<T> = Array<NestedArray<T> | T>;
+
+// This is kind of a map/filter in one function.
+// Normally, behaves like a nested-array map,
+// but returning `null` will drop the element from the array
+export function transform<T>(
+  array: NestedArray<T>,
+  cb: (value: T) => NestedArray<T> | T | null
+): NestedArray<T> {
+  const res = [];
+  for (const v of array) {
+    if (isArray(v)) {
+      res.push(transform(v, cb));
+    } else {
+      const output = cb(v);
+
+      if (isNotNull(output)) {
+        res.push(output);
+      }
+    }
+  }
+  return res as NestedArray<T>;
+}
+
+export function valueAtPath<T>(
+  array: NestedArray<T>,
+  path: number[]
+): T | NestedArray<T> {
+  return getCurrent(array, path)[last(path)];
+}
+
+export function setValueAtPath<T>(
+  array: NestedArray<T>,
+  path: number[],
+  value: NestedArray<T> | T
+): NestedArray<T> {
+  const current = getCurrent(array, path);
+
+  current[last(path)] = value;
+  return array;
+}
+
+export function flatten<T>(values: NestedArray<T> | T): T[] {
+  return asArray(values).reduce((acc, value) => {
+    if (isArray(value)) {
+      return (acc as NestedArray<T>).concat(flatten(value));
+    }
+
+    return asArray(acc).concat(value);
+  }, [] as T[]) as T[];
+}
+
+export function getCurrent<T>(
+  array: NestedArray<T>,
+  path: number[]
+): NestedArray<T> {
+  let current: NestedArray<T> = array;
+  for (const p of path.slice(0, -1)) {
+    current[p] = defaultTo(current[p], []);
+    current = current[p] as NestedArray<T>;
+  }
+  return current;
+}

package/src/numberEquals.ts

@@ -0,0 +1,11 @@
+import bindNot from 'bindNot';
+import { isNumeric } from 'isNumeric';
+
+export function numberEquals(
+  value: string | number,
+  eq: string | number
+): boolean {
+  return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+}
+
+export const numberNotEquals = bindNot(numberEquals);

package/src/optionalFunctionValue.ts

@@ -0,0 +1,8 @@
+import isFunction from 'isFunction';
+
+export default function optionalFunctionValue<T>(
+  value: T | ((...args: any[]) => T),
+  ...args: unknown[]
+): T {
+  return isFunction(value) ? value(...args) : value;
+}

package/src/seq.ts

@@ -0,0 +1,10 @@
+/**
+ * @returns a unique numeric id.
+ */
+
+const seq: () => string = (
+  (n: number) => (): string =>
+    `${n++}`
+)(0);
+
+export default seq;

package/src/utilityTypes.ts

@@ -0,0 +1,9 @@
+export type DropFirst<T extends unknown[]> = T extends [unknown, ...infer U]
+  ? U
+  : never;
+
+export type Stringable = string | ((...args: any[]) => string);
+
+export type CB = (...args: any[]) => any;
+
+export type ValueOf<T> = T[keyof T];

package/src/vest-utils.ts

@@ -0,0 +1,31 @@
+export { default as cache } from 'cache';
+export { isNullish, isNotNullish } from 'isNullish';
+export * as nestedArray from 'nestedArray';
+export { default as asArray } from 'asArray';
+export { default as callEach } from 'callEach';
+export { default as hasOwnProperty } from 'hasOwnProperty';
+export { default as isPromise } from 'isPromise';
+export { default as optionalFunctionValue } from 'optionalFunctionValue';
+export { default as assign } from 'assign';
+export { default as defaultTo } from 'defaultTo';
+export { default as invariant, StringObject } from 'invariant';
+export { default as isStringValue } from 'isStringValue';
+export { default as bindNot } from 'bindNot';
+export { default as either } from 'either';
+export { default as isBoolean } from 'isBooleanValue';
+export { default as last } from 'last';
+export { default as deferThrow } from 'deferThrow';
+export * as bus from 'bus';
+export { default as seq } from 'seq';
+export { default as isFunction } from 'isFunction';
+export { default as mapFirst } from 'mapFirst';
+export { greaterThan } from 'greaterThan';
+export { longerThan } from 'longerThan';
+export { isNumeric, isNotNumeric } from 'isNumeric';
+export { lengthEquals, lengthNotEquals } from 'lengthEquals';
+export { numberEquals, numberNotEquals } from 'numberEquals';
+export { isNull, isNotNull } from 'isNull';
+export { isUndefined, isNotUndefined } from 'isUndefined';
+export { isArray, isNotArray } from 'isArrayValue';
+export { isEmpty, isNotEmpty } from 'isEmpty';
+export { isPositive } from 'isPositive';

package/tsconfig.json

@@ -1,6 +1,8 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "noEmit": true
+    "declarationMap": true,
+    "declarationDir": "./types",
+    "outDir": "./dist"
   }
 }