vest-utils 1.4.0 → 1.5.0

package/src/__tests__/isUnsafeKey.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import isUnsafeKey from '../isUnsafeKey';
-
-describe('isUnsafeKey', () => {
-  it('should return true for __proto__', () => {
-    expect(isUnsafeKey('__proto__')).toBe(true);
-  });
-
-  it('should return true for constructor', () => {
-    expect(isUnsafeKey('constructor')).toBe(true);
-  });
-
-  it('should return true for prototype', () => {
-    expect(isUnsafeKey('prototype')).toBe(true);
-  });
-
-  it('should return false for other keys', () => {
-    expect(isUnsafeKey('someKey')).toBe(false);
-    expect(isUnsafeKey('toString')).toBe(false);
-    expect(isUnsafeKey('valueOf')).toBe(false);
-  });
-});

package/src/__tests__/lengthEquals.test.ts

@@ -1,58 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { lengthEquals } from '../lengthEquals';
-import { describe, it, expect } from 'vitest';
-
-describe('Tests lengthEquals rule', () => {
-  const length = 10;
-  const word = faker.lorem.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', () => {
-      // @ts-expect-error - testing wrong input
-      expect(lengthEquals(100, 0)).toBe(false);
-    });
-
-    it('Should return false for boolean argument', () => {
-      // @ts-expect-error - testing wrong input
-      expect(lengthEquals(boolean, 0)).toBe(false);
-    });
-  });
-});

package/src/__tests__/longerThan.test.ts

@@ -1,58 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { longerThan } from '../longerThan';
-import { describe, it, expect } from 'vitest';
-
-describe('Tests longerThan rule', () => {
-  const length = 10;
-  const word = faker.lorem.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', () => {
-      // @ts-expect-error - testing wrong input
-      expect(longerThan(length, 0)).toBe(false);
-    });
-
-    it('Should return false for boolean argument', () => {
-      // @ts-expect-error - testing wrong input
-      expect(longerThan(boolean, 0)).toBe(false);
-    });
-  });
-});

package/src/__tests__/mapFirst.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-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__/nonnullish.test.ts

@@ -1,25 +0,0 @@
-import { nonnullish } from '../nonnullish';
-import { describe, it, expect } from 'vitest';
-
-describe('nonnullish', () => {
-  it('should return the value if it is not null or undefined', () => {
-    const value = 'hello';
-    expect(nonnullish(value)).toBe(value);
-  });
-
-  it('should throw an error if the value is null', () => {
-    const value = null;
-    expect(() => nonnullish(value)).toThrow();
-  });
-
-  it('should throw an error if the value is undefined', () => {
-    const value = undefined;
-    expect(() => nonnullish(value)).toThrow();
-  });
-
-  it('should throw a custom error message if provided', () => {
-    const value = null;
-    const errorMessage = 'Value must be defined';
-    expect(() => nonnullish(value, errorMessage)).toThrow(errorMessage);
-  });
-});

package/src/__tests__/noop.test.ts

@@ -1,12 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { noop } from '../noop';
-
-describe('noop', () => {
-  it('should be a function', () => {
-    expect(typeof noop).toBe('function');
-  });
-
-  it('should return undefined', () => {
-    expect(noop()).toBeUndefined();
-  });
-});

package/src/__tests__/numberEquals.test.ts

@@ -1,67 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { numberEquals } from '../numberEquals';
-import { describe, it, expect, beforeEach } from 'vitest';
-
-describe('Tests numberEquals rule', () => {
-  describe('Arguments are numbers', () => {
-    let arg0: number;
-    beforeEach(() => {
-      arg0 = faker.number.int();
-    });
-
-    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', () => {
-    let arg0: string;
-
-    beforeEach(() => {
-      arg0 = faker.number.int().toString();
-    });
-
-    describe('When first argument is larger', () => {
-      it('Should return false', () => {
-        expect(numberEquals(`${arg0}`, `${Number(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('100', '100')).toBe(true);
-      });
-    });
-  });
-
-  describe('Arguments are non numeric', () => {
-    [faker.lorem.word(), `${faker.number.int()}`.split(''), {}].forEach(
-      element => {
-        it('Should return false', () => {
-          // @ts-expect-error - testing invalid input
-          expect(numberEquals(element, 0)).toBe(false);
-        });
-      },
-    );
-  });
-});

package/src/__tests__/optionalFunctionValue.test.ts

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

package/src/__tests__/seq.test.ts

@@ -1,29 +0,0 @@
-import seq, { genSeq } from '../seq';
-import { describe, it, expect } from 'vitest';
-
-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/__tests__/text.test.ts

@@ -1,41 +0,0 @@
-import { text } from '../text';
-import { describe, it, expect } from 'vitest';
-
-describe('text', () => {
-  describe('named substitutions (object)', () => {
-    describe('When all substitutions exist', () => {
-      it('Should replace delimited placeholders', () => {
-        expect(text('this {t} an example', { t: 'was' })).toBe(
-          'this was an example',
-        );
-        expect(text('this {t1} {t2} example', { t1: 'was', t2: 'one' })).toBe(
-          'this was one example',
-        );
-      });
-    });
-
-    describe('When a placeholder repeats', () => {
-      it('Should use the same substitution multiple times', () => {
-        expect(text('{n} {n} {n}', { n: 1 })).toBe('1 1 1');
-      });
-    });
-
-    describe('When a substitution is missing', () => {
-      it('Should keep the placeholder', () => {
-        expect(text('{no}', { yes: 'yes' })).toBe('{no}');
-      });
-    });
-  });
-
-  describe('Positional substitutions', () => {
-    it('should use substitutions one by one', () => {
-      expect(text('{n} {n} {x} {y}', 1, 2, 3, 4)).toBe('1 2 3 4');
-    });
-
-    describe('When there are not enough substitutions', () => {
-      it('Should default to the placeholder', () => {
-        expect(text('{n} {n} {x} {y}', 1, 2)).toBe('1 2 {x} {y}');
-      });
-    });
-  });
-});

package/src/__tests__/tinyState.test.ts

@@ -1,68 +0,0 @@
-import { createTinyState } from '../tinyState';
-import { describe, it, expect } from 'vitest';
-
-describe('tinyTest', () => {
-  it('Should be a function', () => {
-    expect(typeof createTinyState).toBe('function');
-  });
-
-  it('Should return a function', () => {
-    expect(typeof createTinyState(1)).toBe('function');
-  });
-
-  it('Should return a function that returns an array', () => {
-    expect(Array.isArray(createTinyState(1)())).toBe(true);
-  });
-
-  it('Should return a function that returns an array with three items', () => {
-    expect(createTinyState(1)()).toHaveLength(3);
-  });
-
-  it('Should return a function that returns an array with three items, the first being the initial value', () => {
-    expect(createTinyState('initial_value')()[0]).toBe('initial_value');
-
-    const initialValue = {};
-    expect(createTinyState(initialValue)()[0]).toBe(initialValue);
-  });
-
-  it('Should return a function that returns an array with three items, the second being a function', () => {
-    expect(typeof createTinyState(1)()[1]).toBe('function');
-  });
-
-  it('Should return a function that returns an array with three items, the third being a function', () => {
-    expect(typeof createTinyState(1)()[2]).toBe('function');
-  });
-
-  it('Updates the value when the second item is called', () => {
-    const testState = createTinyState('initial_value');
-
-    {
-      const [, setValue] = testState();
-      setValue('new_value');
-    }
-
-    {
-      const [value] = testState();
-      expect(value).toBe('new_value');
-    }
-  });
-
-  it('resets the value when the third item is called', () => {
-    const testState = createTinyState('initial_value');
-
-    {
-      const [, setValue] = testState();
-      setValue('new_value');
-    }
-
-    {
-      const [, , resetValue] = testState();
-      resetValue();
-    }
-
-    {
-      const [value] = testState();
-      expect(value).toBe('initial_value');
-    }
-  });
-});

package/src/__tests__/toNumber.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { isFailure, isSuccess, unwrap } from '../Result';
-import { toNumber } from '../toNumber';
-
-describe('toNumber', () => {
-  describe('Successful conversions', () => {
-    it.each([
-      [1, 1],
-      [0, 0],
-      [-1, -1],
-      [1.5, 1.5],
-      ['1', 1],
-      ['0', 0],
-      ['-1', -1],
-      ['1.5', 1.5],
-      [true, 1],
-      [false, 0],
-      [null, 0],
-      ['', 0],
-      ['   ', 0],
-      [[], 0],
-      [[1], 1],
-    ])('should convert %s to %s', (input, expected) => {
-      const result = toNumber(input);
-      expect(isSuccess(result)).toBe(true);
-      expect(unwrap(result)).toBe(expected);
-    });
-  });
-
-  describe('Failed conversions', () => {
-    it.each([undefined, 'abc', '1a', {}, [1, 2], NaN])(
-      'should fail to convert %s',
-      input => {
-        expect(isFailure(toNumber(input))).toBe(true);
-      },
-    );
-  });
-});

package/src/__tests__/vest-utils.test.ts

@@ -1,13 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as vestUtils from '../vest-utils';
-
-describe('vest-utils exports', () => {
-  it('should export expected utilities', () => {
-    expect(vestUtils.noop).toBeDefined();
-    expect(vestUtils.isFunction).toBeDefined();
-    expect(vestUtils.withResolvers).toBeDefined();
-    // Verify a few others to ensure the file is processed
-    expect(vestUtils.defaultTo).toBeDefined();
-    expect(vestUtils.assign).toBeDefined();
-  });
-});

package/src/__tests__/withCatch.test.ts

@@ -1,17 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { withCatch } from '../withCatch';
-
-describe('withCatch', () => {
-  it('should return the result of the callback if it succeeds', () => {
-    const fn = withCatch(() => 'success');
-    expect(fn()).toBe('success');
-  });
-
-  it('should return the error if the callback throws', () => {
-    const error = new Error('failure');
-    const fn = withCatch(() => {
-      throw error;
-    });
-    expect(fn()).toBe(error);
-  });
-});

package/src/__tests__/withResolvers.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { withResolvers } from '../withResolvers';
-
-describe('withResolvers', () => {
-  const originalWithResolvers = Promise.withResolvers;
-
-  afterEach(() => {
-    // Restore the original implementation
-    if (originalWithResolvers) {
-      Promise.withResolvers = originalWithResolvers;
-    } else {
-      // @ts-ignore
-      delete Promise.withResolvers;
-    }
-  });
-
-  it('should return a promise, resolve, and reject', () => {
-    const { promise, resolve, reject } = withResolvers();
-    expect(promise).toBeInstanceOf(Promise);
-    expect(typeof resolve).toBe('function');
-    expect(typeof reject).toBe('function');
-  });
-
-  it('should resolve the promise', async () => {
-    const { promise, resolve } = withResolvers<string>();
-    resolve('success');
-    await expect(promise).resolves.toBe('success');
-  });
-
-  it('should reject the promise', async () => {
-    const { promise, reject } = withResolvers<string>();
-    const error = new Error('fail');
-    reject(error);
-    await expect(promise).rejects.toBe(error);
-  });
-
-  it('should use the polyfill if Promise.withResolvers is not defined', async () => {
-    // @ts-ignore
-    Promise.withResolvers = undefined;
-
-    const { promise, resolve } = withResolvers<string>();
-    resolve('polyfill');
-    await expect(promise).resolves.toBe('polyfill');
-  });
-});

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);
-}

package/src/bus.ts

@@ -1,52 +0,0 @@
-import type { CB } from './utilityTypes';
-
-const EVENT_WILDCARD = '*';
-type TEventsWildcard = typeof EVENT_WILDCARD;
-
-export function createBus<
-  TEvents extends Record<string, any> = Record<string, any>,
->(): BusType<TEvents> {
-  const listeners = {} as Record<keyof TEvents | TEventsWildcard, CB[]>;
-
-  return {
-    emit(event: keyof TEvents | TEventsWildcard, payload?: any) {
-      getListeners(event)
-        .concat(getListeners(EVENT_WILDCARD))
-        .forEach(handler => {
-          handler(payload);
-        });
-    },
-
-    on(event: keyof TEvents | TEventsWildcard, handler: CB): OnReturn {
-      listeners[event] = getListeners(event).concat(handler);
-
-      return {
-        off() {
-          listeners[event] = getListeners(event).filter(h => h !== handler);
-        },
-      };
-    },
-  };
-
-  function getListeners(event: keyof TEvents | TEventsWildcard): CB[] {
-    return listeners[event] || [];
-  }
-}
-
-type OnReturn = { off: CB<void> };
-
-export type BusType<TEvents extends Record<string, any>> = {
-  on<T extends keyof TEvents>(
-    event: T,
-    handler: (payload: TEvents[T]) => void,
-  ): OnReturn;
-  on(event: TEventsWildcard, handler: (payload: any) => void): OnReturn;
-
-  emit<T extends keyof TEvents>(
-    event: T,
-    ...args: TEvents[T] extends void
-      ? [payload?: TEvents[T]]
-      : [payload: TEvents[T]]
-  ): void;
-  emit(event: TEventsWildcard, payload?: any): void;
-};