vest-utils 1.5.0 → 2.0.1

package/src/__tests__/toNumber.test.ts

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

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

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

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

@@ -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,52 @@
+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;
+};

package/src/cache.ts

@@ -0,0 +1,68 @@
+import { lengthEquals } from './lengthEquals';
+import { longerThan } from './longerThan';
+import { DynamicValue, Nullable } from './utilityTypes';
+import { dynamicValue } from './vest-utils';
+
+/**
+ * Creates a cache function
+ */
+export default function createCache<T = unknown>(maxSize = 1): CacheApi<T> {
+  const cacheStorage: Array<[unknown[], T]> = [];
+
+  const cache = (deps: unknown[], cacheAction: DynamicValue<T>): T => {
+    const cacheHit = cache.get(deps);
+    // cache hit is not null
+    if (cacheHit) return cacheHit[1];
+
+    const result = dynamicValue(cacheAction);
+    cacheStorage.unshift([deps.concat(), result]);
+
+    trimToSize();
+
+    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[]): Nullable<[unknown[], T]> =>
+    cacheStorage[findIndex(deps)] || null;
+
+  // sets a value to the cache by its dependencies, updating if a hit is found.
+  cache.set = (deps: unknown[], value: T): void => {
+    const index = findIndex(deps);
+    if (index > -1) {
+      cacheStorage[index] = [deps, value];
+    } else {
+      cacheStorage.unshift([deps, value]);
+    }
+    trimToSize();
+  };
+
+  return cache;
+
+  function trimToSize() {
+    if (longerThan(cacheStorage, maxSize)) {
+      cacheStorage.length = maxSize;
+    }
+  }
+
+  function findIndex(deps: unknown[]): number {
+    return cacheStorage.findIndex(
+      ([cachedDeps]) =>
+        lengthEquals(deps, cachedDeps.length) &&
+        deps.every((dep, i) => dep === cachedDeps[i]),
+    );
+  }
+}
+
+export type CacheApi<T = unknown> = {
+  (deps: unknown[], cacheAction: DynamicValue<T>): T;
+  get(deps: unknown[]): Nullable<[unknown[], T]>;
+  set(deps: unknown[], value: T): void;
+  invalidate(item: any): void;
+};

package/src/callEach.ts

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

package/src/defaultTo.ts

@@ -0,0 +1,9 @@
+import dynamicValue from './dynamicValue';
+import { DynamicValue, Nullish } from './utilityTypes';
+
+export default function defaultTo<T>(
+  value: DynamicValue<Nullish<T>>,
+  defaultValue: DynamicValue<T>,
+): T {
+  return dynamicValue(value) ?? dynamicValue(defaultValue);
+}

package/src/deferThrow.ts

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

package/src/dynamicValue.ts

@@ -0,0 +1,9 @@
+import isFunction from './isFunction';
+import { DynamicValue } from './utilityTypes';
+
+export default function dynamicValue<T>(
+  value: DynamicValue<T>,
+  ...args: unknown[]
+): T {
+  return isFunction(value) ? value(...args) : value;
+}

package/src/either.ts

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

package/src/exports/__tests__/minifyObject.security.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { expandObject } from '../minifyObject';
+
+describe('minifyObject Security', () => {
+  describe('Prototype Pollution', () => {
+    it('Should not allow pollution via "__proto__" key', () => {
+      const maliciousPayload = '{"__proto__":{"polluted":true}}';
+      const parsed = JSON.parse(maliciousPayload);
+
+      // Simulate expansion (minifyObject's expandObject handles the reconstruction)
+      // We pass an empty map as we are testing raw key assignment
+      const expanded = expandObject(parsed, {});
+
+      // @ts-ignore
+      expect({}.polluted).toBeUndefined();
+      expect(expanded.polluted).toBeUndefined();
+      // @ts-ignore
+      expect(expanded.__proto__).not.toEqual({ polluted: true });
+    });
+
+    it('Should not allow pollution via "constructor" key', () => {
+      const maliciousPayload =
+        '{"constructor":{"prototype":{"polluted":true}}}';
+      const parsed = JSON.parse(maliciousPayload);
+
+      const expanded = expandObject(parsed, {});
+
+      // @ts-ignore
+      expect({}.polluted).toBeUndefined();
+      expect(expanded.constructor?.prototype?.polluted).toBeUndefined();
+    });
+
+    it('Should not allow pollution via "prototype" key', () => {
+      const maliciousPayload = '{"prototype":{"polluted":true}}';
+      const parsed = JSON.parse(maliciousPayload);
+
+      expandObject(parsed, {});
+
+      // @ts-ignore
+      expect({}.polluted).toBeUndefined();
+    });
+  });
+
+  describe('Sanity: Unprotected JSON.parse behavior', () => {
+    it('Should preserve "__proto__" as a plain key when using standard JSON.parse', () => {
+      const json = '{"__proto__":{"polluted":true}}';
+      const parsed = JSON.parse(json);
+
+      // This confirms that the environment allows parsing this key
+      // which justifies the need for our protections.
+      expect(Object.prototype.hasOwnProperty.call(parsed, '__proto__')).toBe(
+        true,
+      );
+      expect(parsed.__proto__).toEqual({ polluted: true });
+    });
+
+    it('Should preserve "constructor" as a plain key when using standard JSON.parse', () => {
+      const json = '{"constructor":{"prototype":{"polluted":true}}}';
+      const parsed = JSON.parse(json);
+
+      expect(parsed).toHaveProperty('constructor');
+      expect(parsed.constructor).toEqual({ prototype: { polluted: true } });
+    });
+  });
+});

package/src/exports/__tests__/minifyObject.test.ts

@@ -0,0 +1,281 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { expandObject, minifyObject } from '../minifyObject';
+
+describe('minifyObject', () => {
+  it('should be a function', () => {
+    expect(typeof minifyObject).toBe('function');
+  });
+
+  it('should return an array', () => {
+    expect(Array.isArray(minifyObject({}))).toBe(true);
+  });
+
+  it('should return an array with two items', () => {
+    expect(minifyObject({})).toHaveLength(2);
+  });
+
+  it('should return an array with two items, the first being an object', () => {
+    expect(typeof minifyObject({})[0]).toBe('object');
+  });
+
+  it('should return an array with two items, the second being an object', () => {
+    expect(typeof minifyObject({})[1]).toBe('object');
+  });
+
+  it('Should return a minified object', () => {
+    // we can't really test this because the minified object is random
+    // but we can test that the object is minified
+    // by checking that it is smaller than the original
+
+    const obj = {
+      lorem: 'ipsum',
+      dolor: 'sit',
+      amet: 'consectetur',
+      adipiscing: 'elit',
+      sed: [
+        'lorem',
+        'ipsum',
+        'dolor',
+        'sit',
+        'amet',
+        'consectetur',
+        'adipiscing',
+        'elit',
+      ],
+      sed2: [
+        'lorem',
+        'ipsum',
+        'dolor',
+        'sit',
+        'amet',
+        'consectetur',
+        'adipiscing',
+        'elit',
+      ],
+    };
+
+    const [minified] = minifyObject(obj);
+    expect(JSON.stringify(minified).length).toBeLessThan(
+      JSON.stringify(obj).length,
+    );
+  });
+
+  it('Should return a minified object with a reverse map', () => {
+    // check that all the keys in the reverse map are in the minified object
+    // either as a key or a value
+    const obj = {
+      lorem: 'ipsum',
+      dolor: 'sit',
+      amet: 'consectetur',
+      adipiscing: 'elit',
+    };
+
+    const [minified, reverseMap] = minifyObject(obj);
+
+    for (const key in reverseMap) {
+      expect(minified[key] || Object.values(minified).includes(key)).toBe(true);
+    }
+  });
+
+  describe('When a key only appears once', () => {
+    it('Should remain in place', () => {
+      const obj = {
+        lorem: 'ipsum',
+        dolor: false,
+        amet: true,
+        adipiscing: 1,
+      };
+
+      const [minified] = minifyObject(obj);
+      expect(minified).toEqual(obj);
+    });
+
+    it('Should not appear in the mapping', () => {
+      const obj = {
+        lorem: 'ipsum',
+        dolor: false,
+        amet: true,
+        adipiscing: 1,
+      };
+
+      const [, reverseMap] = minifyObject(obj);
+      expect(reverseMap).toEqual({});
+    });
+  });
+
+  it('Should omit nullish values', () => {
+    const obj = {
+      lorem: 'ipsum',
+      dolor: null,
+      amet: undefined,
+      adipiscing: '',
+    };
+
+    const [minified] = minifyObject(obj);
+    expect(minified).toEqual({ lorem: 'ipsum', adipiscing: '' });
+  });
+
+  it('Should omit functions', () => {
+    const obj = {
+      lorem: 'ipsum',
+      dolor: () => {},
+      amet() {},
+      adipiscing: '',
+    };
+
+    const [minified] = minifyObject(obj);
+    expect(minified).toEqual({ lorem: 'ipsum', adipiscing: '' });
+  });
+
+  it('Should omit symbols', () => {
+    const obj = {
+      lorem: 'ipsum',
+      dolor: Symbol('dolor'),
+      amet: Symbol('amet'),
+      adipiscing: '',
+    };
+
+    const [minified] = minifyObject(obj);
+    expect(minified).toEqual({ lorem: 'ipsum', adipiscing: '' });
+  });
+
+  it('Should give the most occuring values or keys the first keys', () => {
+    const obj = {
+      consectetur: ['consectetur'],
+      amet: ['amet', 'amet'],
+      sit: ['sit', 'sit', 'sit'],
+      dolor: ['dolor', 'dolor', 'dolor', 'dolor'],
+      ipsum: ['ipsum', 'ipsum', 'ipsum', 'ipsum', 'ipsum'],
+      lorem: ['lorem', 'lorem', 'lorem', 'lorem', 'lorem', 'lorem'],
+    };
+
+    const [_m, map] = minifyObject(obj);
+
+    expect(map).toEqual({
+      0: 'lorem',
+      1: 'ipsum',
+      2: 'dolor',
+      3: 'sit',
+      4: 'amet',
+      5: 'consectetur',
+    });
+  });
+
+  it('Should only minify values that are longer than the next key', () => {
+    const obj = {
+      a: 1,
+      b: 2,
+      c: 3,
+      lorem: 'lorem',
+    };
+    expect(minifyObject(obj)).toEqual([
+      {
+        a: 1,
+        b: 2,
+        c: 3,
+        0: '0',
+      },
+      { 0: 'lorem' },
+    ]);
+  });
+
+  describe('replacer function', () => {
+    it('Should be a function receiving the value and key being iterated', () => {
+      const replacer = vi.fn((value: any, _key: string) => value);
+      const obj = {
+        lorem: 'hi!',
+        a: 1,
+      };
+      minifyObject(obj, replacer);
+
+      expect(replacer.mock.calls[0]).toEqual(['hi!', 'lorem']);
+      expect(replacer.mock.calls[1]).toEqual([1, 'a']);
+    });
+
+    it('Should replace the object value when a different value is being returned', () => {
+      const obj = {
+        lorem: 'hi!',
+        a: 1,
+      };
+
+      expect(minifyObject(obj, v => v + 1)).toEqual([
+        {
+          a: 2,
+          lorem: 'hi!1',
+        },
+        {},
+      ]);
+    });
+
+    it('Should omit values when returning undefined', () => {
+      const obj = {
+        lorem: 'hi!',
+        a: 1,
+      };
+
+      expect(
+        minifyObject(obj, (v, k) => (k === 'lorem' ? undefined : v)),
+      ).toEqual([
+        {
+          a: 1,
+        },
+        {},
+      ]);
+    });
+  });
+
+  describe('Auto removal of empty objects', () => {
+    it('Should remove empty objects', () => {
+      expect(
+        minifyObject({
+          a: 1,
+          data: {},
+        }),
+      ).toEqual([{ a: 1 }, {}]);
+    });
+
+    it('Should remove empty arrays', () => {
+      expect(
+        minifyObject({
+          a: 1,
+          data: [],
+        }),
+      ).toEqual([{ a: 1 }, {}]);
+    });
+  });
+});
+
+describe('expandObject', () => {
+  it('should be a function', () => {
+    expect(typeof expandObject).toBe('function');
+  });
+  it('should take the output of minifyObject and return a clone original object', () => {
+    const obj = {
+      lorem: 'ipsum',
+      dolor: ['lorem', 'ipsum'],
+      amet: {
+        lorem: 'ipsum',
+        dolor: ['sit', 'amet'],
+      },
+      adipiscing: 'elit',
+      number: 1,
+      boolean: true,
+      someValues: [
+        'lorem',
+        'ipsum',
+        'dolor',
+        'sit',
+        'amet',
+        {
+          lorem: 'ipsum',
+          dolor: ['sit', 'amet'],
+        },
+      ],
+    };
+
+    const [minified, reverseMap] = minifyObject(obj);
+
+    expect(expandObject(minified, reverseMap)).toEqual(obj);
+  });
+});