vest-utils 0.0.1-rc → 0.0.4-dev-afe5de

package/src/{exports/__tests__ → __tests__}/bindNot.test.ts

@@ -1,4 +1,4 @@
-import bindNot from 'bindNot';
+import { bindNot } from 'vest-utils';
 
 describe('bindNot', () => {
   it('Should return return a function', () => {

package/src/{exports/__tests__ → __tests__}/cache.test.ts

@@ -1,6 +1,6 @@
 import _ from 'lodash';
 
-import cache from 'cache';
+import { cache } from 'vest-utils';
 
 describe('lib: cache', () => {
   let c: ReturnType<typeof cache>;

package/src/{exports/__tests__ → __tests__}/defaultTo.test.ts

@@ -1,4 +1,4 @@
-import defaultTo from 'defaultTo';
+import { defaultTo } from 'vest-utils';
 
 describe('defaultTo', () => {
   describe('When value is a function', () => {

package/src/__tests__/greaterThan.test.ts

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

package/src/{exports/__tests__ → __tests__}/invariant.test.ts

@@ -1,4 +1,4 @@
-import invariant from 'invariant';
+import { invariant } from 'vest-utils';
 
 describe('invariant', () => {
   it('should throw an error when condition is false', () => {

package/src/__tests__/isArray.test.ts

@@ -0,0 +1,15 @@
+import { isArray } from 'isArrayValue';
+
+describe('Tests isArray rule', () => {
+  it('Should return true for an empty array', () => {
+    expect(isArray([])).toBe(true);
+  });
+
+  it('Should return true for an array with elements', () => {
+    expect(isArray([1, 2, 3])).toBe(true);
+  });
+
+  it('Should return false a string', () => {
+    expect(isArray('1')).toBe(false);
+  });
+});

package/src/__tests__/isNull.test.ts

@@ -0,0 +1,25 @@
+import { isNull } from 'isNull';
+
+describe('Tests isNull rule', () => {
+  it('Should return true for `null` value', () => {
+    expect(isNull(null)).toBe(true);
+  });
+
+  it.each([
+    undefined,
+    NaN,
+    false,
+    true,
+    Object,
+    Array(0),
+    '',
+    ' ',
+    0,
+    1,
+    '0',
+    '1',
+    Function.prototype,
+  ])('Should return false for %s value', v => {
+    expect(isNull(v)).toBe(false);
+  });
+});

package/src/__tests__/isNumeric.test.ts

@@ -0,0 +1,26 @@
+import { isNumeric } from 'isNumeric';
+
+const NUMERICS = ['-10', '0', 0xff, '0xFF', '8e5', '3.1415', +10, '0144'];
+
+const NON_NUMERICS = [
+  '-0x42',
+  '7.2acdgs',
+  '',
+  {},
+  NaN,
+  null,
+  true,
+  Infinity,
+  undefined,
+];
+
+describe('Tests isNumeric rule', () => {
+  it('Should return true for numeric values', () => {
+    NUMERICS.forEach(value => expect(isNumeric(value)).toBe(true));
+  });
+
+  it('Should return false for non numeric values', () => {
+    // @ts-expect-error - testing bad usage
+    NON_NUMERICS.forEach(value => expect(isNumeric(value)).toBe(false));
+  });
+});

package/src/__tests__/isUndefined.test.ts

@@ -0,0 +1,26 @@
+import { isUndefined } from 'isUndefined';
+
+describe('Tests isUndefined rule', () => {
+  it('Should return true for `undefined` value', () => {
+    expect(isUndefined(undefined)).toBe(true);
+    expect(isUndefined()).toBe(true);
+  });
+
+  it.each([
+    null,
+    NaN,
+    false,
+    true,
+    Object,
+    Array(0),
+    '',
+    ' ',
+    0,
+    1,
+    '0',
+    '1',
+    () => undefined,
+  ])('Should return false for %s value', v => {
+    expect(isUndefined(v)).toBe(false);
+  });
+});

package/src/__tests__/lengthEquals.test.ts

@@ -0,0 +1,56 @@
+import faker from 'faker';
+
+import { lengthEquals } from 'lengthEquals';
+
+describe('Tests lengthEquals rule', () => {
+  const length = faker.datatype.number();
+  const word = faker.random.word();
+  const boolean = faker.datatype.boolean();
+
+  describe('First argument is array or string', () => {
+    describe('When first argument is equal to a given value', () => {
+      it('Should return true for an array equal to length', () => {
+        expect(lengthEquals(new Array(length), length)).toBe(true);
+      });
+
+      it('Should return true for a string equal to word length', () => {
+        expect(lengthEquals(word, word.length)).toBe(true);
+      });
+    });
+
+    describe('When first argument is shorter', () => {
+      it('Should return false for an array shorter than length', () => {
+        expect(lengthEquals(new Array(length), length + 1)).toBe(false);
+      });
+
+      it('Should return false for a string shorter than word length', () => {
+        expect(lengthEquals(word, word.length + 1)).toBe(false);
+      });
+    });
+
+    describe('When first argument is longer', () => {
+      it('Should return false for an array longer than length', () => {
+        expect(lengthEquals(new Array(length), length - 1)).toBe(false);
+      });
+
+      it('Should return false for a string longer than word length', () => {
+        expect(lengthEquals(word, word.length - 1)).toBe(false);
+      });
+    });
+  });
+
+  describe("First argument isn't array or string", () => {
+    it('Should throw error', () => {
+      // @ts-expect-error - testing wrong input
+      expect(() => lengthEquals(undefined, 0)).toThrow(TypeError);
+    });
+
+    it('Should return false for number argument', () => {
+      expect(lengthEquals(length, 0)).toBe(false);
+    });
+
+    it('Should return false for boolean argument', () => {
+      expect(lengthEquals(boolean, 0)).toBe(false);
+    });
+  });
+});

package/src/__tests__/longerThan.test.ts

@@ -0,0 +1,56 @@
+import faker from 'faker';
+
+import { longerThan } from 'longerThan';
+
+describe('Tests longerThan rule', () => {
+  const length = faker.datatype.number();
+  const word = faker.random.word();
+  const boolean = faker.datatype.boolean();
+
+  describe('First argument is array or string', () => {
+    describe('When first argument is longer', () => {
+      it('Should return true for an array longer than length', () => {
+        expect(longerThan(new Array(length), length - 1)).toBe(true);
+      });
+
+      it('Should return true for a string longer than word length', () => {
+        expect(longerThan(word, word.length - 1)).toBe(true);
+      });
+    });
+
+    describe('When first argument is shorter', () => {
+      it('Should return false for an array shorter than length', () => {
+        expect(longerThan(new Array(length), length + 1)).toBe(false);
+      });
+
+      it('Should return false for a string shorter than word length', () => {
+        expect(longerThan(word, word.length + 1)).toBe(false);
+      });
+    });
+
+    describe('When first argument is equal to a given value', () => {
+      it('Should return false for an array equal to length', () => {
+        expect(longerThan(new Array(length), length)).toBe(false);
+      });
+
+      it('Should return false for a string equal to word length', () => {
+        expect(longerThan(word, word.length)).toBe(false);
+      });
+    });
+  });
+
+  describe("First argument isn't array or string", () => {
+    it('Should throw error', () => {
+      // @ts-expect-error - testing wrong input
+      expect(() => longerThan(undefined, 0)).toThrow(TypeError);
+    });
+
+    it('Should return false for number argument', () => {
+      expect(longerThan(length, 0)).toBe(false);
+    });
+
+    it('Should return false for boolean argument', () => {
+      expect(longerThan(boolean, 0)).toBe(false);
+    });
+  });
+});

package/src/{exports/__tests__ → __tests__}/mapFirst.test.ts

@@ -1,4 +1,4 @@
-import mapFirst from 'mapFirst';
+import { mapFirst } from 'vest-utils';
 
 describe('mapFirst', () => {
   it('should return the broken out result', () => {

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/{exports/__tests__ → __tests__}/optionalFunctionValue.test.ts

@@ -1,4 +1,4 @@
-import optionalFunctionValue from 'optionalFunctionValue';
+import { optionalFunctionValue } from 'vest-utils';
 
 describe('optionalFunctionValue', () => {
   describe('When not a function', () => {

package/src/{exports/__tests__ → __tests__}/partition.test.ts

@@ -1,4 +1,4 @@
-import partition from 'partition';
+import { partition } from 'vest-utils';
 
 describe('partition', () => {
   it('Should correctly partition array', () => {

package/src/{exports/__tests__ → __tests__}/throwError.test.ts

@@ -1,4 +1,4 @@
-import { deferThrow } from 'throwError';
+import { deferThrow } from 'vest-utils';
 
 // @ts-ignore
 const _to = global.setTimeout;

package/src/{exports/throwError.ts → deferThrow.ts}

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

package/src/globals.d.ts

@@ -1,3 +1,3 @@
-declare var __DEV__: boolean;
-declare var __LIB_VERSION__: string;
-declare var LIBRARY_NAME: string;
+declare let __DEV__: boolean;
+declare let __LIB_VERSION__: string;
+declare let 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/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/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/{exports/isNullish.ts → isNullish.ts}

@@ -1,8 +1,7 @@
+import bindNot from 'bindNot';
 import { isNull } from 'isNull';
 import { isUndefined } from 'isUndefined';
 
-import bindNot from 'bindNot';
-
 export function isNullish(value: any): value is null | undefined {
   return isNull(value) || isUndefined(value);
 }

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/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/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/{exports/nestedArray.ts → nestedArray.ts}

@@ -1,8 +1,7 @@
-import { isArray } from 'isArrayValue';
-import { isNotNull } from 'isNull';
-
 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>;

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/{exports/optionalFunctionValue.ts → optionalFunctionValue.ts}

@@ -1,4 +1,4 @@
-import isFunction from './isFunction';
+import isFunction from 'isFunction';
 
 export default function optionalFunctionValue<T>(
   value: T | ((...args: any[]) => T),

package/src/vest-utils.ts

@@ -0,0 +1,32 @@
+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 partition } from 'partition';
+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 genId } from 'genId';
+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';