vest-utils 0.1.1 → 1.0.0-dev-9c596e

package/src/__tests__/cache.test.ts

@@ -1,113 +0,0 @@
-import _ from 'lodash';
-
-import { cache } from 'vest-utils';
-
-describe('lib: cache', () => {
-  let c: ReturnType<typeof cache>;
-
-  beforeEach(() => {
-    c = cache();
-  });
-  it('should return a function', () => {
-    expect(typeof cache()).toBe('function');
-  });
-
-  it('Should create a new function on each call', () => {
-    expect(cache()).not.toBe(cache());
-  });
-
-  describe('on cache miss', () => {
-    it('Should call passed cache action function and return its value', () => {
-      const cacheAction = jest.fn(() => ({}));
-      const res = c([{}], cacheAction);
-      expect(cacheAction).toHaveBeenCalledTimes(1);
-      expect(res).toBe(cacheAction.mock.results[0].value);
-    });
-  });
-
-  describe('On cache hit', () => {
-    it('Should return cached result', () => {
-      const cacheAction = jest.fn(() => {
-        Math.random();
-      });
-      const depsArray = [true, false, {}];
-      const res1 = c(depsArray, cacheAction);
-      expect(res1).toBe(cacheAction.mock.results[0].value);
-      const res2 = c(depsArray, cacheAction);
-      expect(res2).toBe(res1);
-    });
-
-    it('Should return without calling the cache action', () => {
-      const cacheAction = jest.fn();
-      const depsArray = [Math.random()];
-      c(depsArray, cacheAction);
-      expect(cacheAction).toHaveBeenCalledTimes(1);
-      c(depsArray, cacheAction);
-      expect(cacheAction).toHaveBeenCalledTimes(1);
-    });
-
-    it('Should limit cache results to `maxSize`', () => {
-      const cacheSize = _.random(5, 10);
-      const callCount = _.random(cacheSize, cacheSize + 10);
-      const diff = callCount - cacheSize;
-      /**
-       * Doing a nested check to combat the auto cleanup of the cache.
-       * Otherwise, each access to the cache would purge the oldest results
-       * and we wouldn't get an accurate read - so instantiating a new cache
-       * for each index is a good workaround.
-       */
-      Array.from({ length: callCount }, (_, i) => {
-        const c = cache(/*maxSize*/ cacheSize);
-        const results = Array.from({ length: callCount }, (_, j) =>
-          c([j], Math.random)
-        );
-
-        if (i < diff) {
-          // Here we generate a fresh `null` result
-          expect(c([i], () => null)).toBeNull();
-        } else {
-          // Here we retrieve an existing result
-          expect(c([i], () => null)).toBe(results[i]);
-        }
-      });
-    });
-  });
-  it('Should take into account the deps array in its entirety', () => {
-    const deps = Array.from({ length: 100 }, () =>
-      _.sample([{}, false, Math.random(), true, () => null])
-    );
-    const c = cache();
-    const res = c([...deps], Math.random);
-    expect(c([...deps], () => undefined)).toBe(res);
-    const sliced = deps.slice(0, -1);
-    expect(c(sliced, () => null)).toBeNull();
-  });
-
-  describe('cache.get', () => {
-    describe('On cache miss', () => {
-      it('Should return null', () => {
-        expect(c.get([1, 2, 3])).toBeNull();
-        c([1, 2, 3], Math.random);
-        expect(c.get([1, 2, '3'])).toBeNull();
-      });
-    });
-
-    describe('On cache hit', () => {
-      it('Should return cached key and item from cache storage', () => {
-        const res = c([1, 2, 3], Math.random);
-        expect(c.get([1, 2, 3])?.[0]).toEqual([1, 2, 3]);
-        expect(c.get([1, 2, 3])?.[1]).toEqual(res);
-      });
-    });
-  });
-
-  describe('cache.invalidate', () => {
-    it('Should remove cached item from cache storage by its dependcies', () => {
-      const deps = [1, 2, 3];
-      c(deps, Math.random);
-      expect(c.get(deps)).not.toBeNull();
-      c.invalidate(deps);
-      expect(c.get(deps)).toBeNull();
-    });
-  });
-});

package/src/__tests__/defaultTo.test.ts

@@ -1,50 +0,0 @@
-import { defaultTo } from 'vest-utils';
-
-describe('defaultTo', () => {
-  describe('When value is a function', () => {
-    it('Should call the function', () => {
-      const value = jest.fn(() => 'return value');
-
-      expect(defaultTo(value, 'fallback value')).toBe('return value');
-      expect(value).toHaveBeenCalled();
-    });
-    describe('When value is nullish', () => {
-      it('Should return fallback value', () => {
-        expect(defaultTo(null, 'fallback value')).toBe('fallback value');
-        expect(defaultTo(undefined, 'fallback value')).toBe('fallback value');
-      });
-    });
-
-    describe('When value is not nullish', () => {
-      it('Should use value', () => {
-        expect(defaultTo('value', 'fallback value')).toBe('value');
-      });
-    });
-  });
-
-  describe('When value is not a function', () => {
-    describe('When the value is nullish', () => {
-      it('Should return fallback value', () => {
-        expect(defaultTo(null, 'fallback value')).toBe('fallback value');
-        expect(defaultTo(undefined, 'fallback value')).toBe('fallback value');
-      });
-    });
-    describe('When the value is not nullish', () => {
-      it.each([0, false, true, 1, [], {}, NaN])(
-        'Should return the same value',
-        value => {
-          expect(defaultTo(value, 'fallback value')).toBe(value);
-        }
-      );
-    });
-  });
-
-  describe('When the fallback value is a function', () => {
-    it('Should call the function and return its return value', () => {
-      const fallbackValue = jest.fn(() => 'fallback value');
-
-      expect(defaultTo(null, fallbackValue)).toBe('fallback value');
-      expect(fallbackValue).toHaveBeenCalled();
-    });
-  });
-});

package/src/__tests__/deferThrow.test.ts

@@ -1,24 +0,0 @@
-import { deferThrow } from 'vest-utils';
-
-// @ts-ignore
-const _to = global.setTimeout;
-describe('deferThrow', () => {
-  beforeEach(() => {
-    // @ts-ignore
-    global.setTimeout = jest.fn();
-  });
-
-  afterEach(() => {
-    global.setTimeout = _to;
-  });
-  it('Should start a timer', () => {
-    deferThrow();
-    expect(global.setTimeout).toHaveBeenCalled();
-  });
-
-  it('Should throw a timed out error with the provided message', () => {
-    deferThrow('message');
-    const timeoutCB = global.setTimeout.mock.calls[0][0];
-    expect(() => timeoutCB()).toThrow('message');
-  });
-});

package/src/__tests__/greaterThan.test.ts

@@ -1,59 +0,0 @@
-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/__tests__/invariant.test.ts

@@ -1,45 +0,0 @@
-import { invariant } from 'vest-utils';
-
-describe('invariant', () => {
-  it('should throw an error when condition is false', () => {
-    expect(() => {
-      invariant(false, 'message');
-    }).toThrow(Error);
-  });
-
-  it("Should throw an error with the message if it's a string", () => {
-    expect(() => {
-      invariant(false, 'message');
-    }).toThrow('message');
-  });
-
-  it('should contintue when condition is true', () => {
-    expect(() => {
-      invariant(true, 'message');
-    }).not.toThrow();
-  });
-
-  describe('When passed message is a string object', () => {
-    it('should throw the value of the string object', () => {
-      expect(() => {
-        invariant(false, new String('message'));
-      }).toThrow('message');
-    });
-  });
-
-  describe('Shen passed message is a function', () => {
-    it('should throw the value of the function', () => {
-      expect(() => {
-        invariant(false, () => 'message');
-      }).toThrow('message');
-    });
-  });
-
-  describe('When message is falsy', () => {
-    it('should throw an error with the message', () => {
-      expect(() => {
-        invariant(false, '');
-      }).toThrow('');
-    });
-  });
-});

package/src/__tests__/isArray.test.ts

@@ -1,15 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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/__tests__/mapFirst.test.ts

@@ -1,29 +0,0 @@
-import { mapFirst } from 'vest-utils';
-
-describe('mapFirst', () => {
-  it('should return the broken out result', () => {
-    const result = mapFirst([1, 2, 3], (value, breakout) => {
-      breakout(value === 3, { pass: true });
-    });
-
-    expect(result).toEqual({ pass: true });
-  });
-
-  it('Should respect the breakout conditional', () => {
-    const result = mapFirst([1, 2, 3], (_, breakout) => {
-      breakout(false, 0);
-      breakout(false, 0);
-      breakout(true, 1);
-    });
-
-    expect(result).toBe(1);
-  });
-
-  describe('When not broken out', () => {
-    it('Should return undefined', () => {
-      const result = mapFirst([1, 2, 3], () => {});
-
-      expect(result).toBeUndefined();
-    });
-  });
-});

package/src/__tests__/numberEquals.test.ts

@@ -1,59 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,28 +0,0 @@
-import seq, { genSeq } 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;
-    }, {});
-  });
-
-  describe('genSeq', () => {
-    it('Creates a namespaced sequence', () => {
-      const seq = genSeq('test');
-      expect(seq()).toBe('test_0');
-      expect(seq()).toBe('test_1');
-      expect(seq()).toBe('test_2');
-
-      const seq2 = genSeq('test2');
-      expect(seq2()).toBe('test2_0');
-      expect(seq2()).toBe('test2_1');
-      expect(seq2()).toBe('test2_2');
-
-      expect(seq()).toBe('test_3');
-    });
-  });
-});

package/src/asArray.ts

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

package/src/assign.ts

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

package/src/bindNot.ts

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