vest-utils 1.4.0 → 1.5.0

package/src/cache.ts

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

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

package/src/defaultTo.ts

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

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

package/src/dynamicValue.ts

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

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

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

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

@@ -1,281 +0,0 @@
-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);
-  });
-});

package/src/exports/minifyObject.ts

@@ -1,198 +0,0 @@
-import isUnsafeKey from '../isUnsafeKey';
-import { isArray } from '../isArrayValue';
-import { isEmpty } from '../isEmpty';
-import isFunction from '../isFunction';
-import { isNullish } from '../isNullish';
-import isStringValue from '../isStringValue';
-import { isObject } from '../valueIsObject';
-
-// Basic key generator that generates keys like a, b, c, ... aa, ab, ac, ...
-function genMinifiedKey() {
-  const chars =
-    '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*';
-  let index = 0;
-
-  return function next(): string {
-    let code = '';
-    let x = index;
-
-    do {
-      code = code + chars[x % chars.length];
-      x = Math.floor(x / chars.length);
-    } while (x > 0);
-    index++;
-    return code;
-  };
-}
-
-export function minifyObject(
-  obj: any,
-  replacer: MinifyObjectReplacer = v => v,
-): [any, any] {
-  const countMap = new Map<any, number>();
-  countOccurrences(obj, countMap, replacer);
-  const maps = genMap(countMap);
-  const o = minifyObjectImpl(obj, maps.map, replacer);
-  // need to reverse the map so that the minified keys are the keys and the original keys are the values
-  // and turn it into an object
-
-  return [o, maps.reverseMap];
-}
-
-function genMap(countMap: Map<any, number>) {
-  const counts = [];
-
-  for (const [value, count] of countMap) {
-    if (count > 1) {
-      counts.push({ value, count });
-    }
-  }
-
-  const sorted = counts.sort((a, z) => z.count - a.count);
-
-  const getKey = genMinifiedKey();
-  return sorted.reduce(
-    (maps, { value }) => {
-      if (!shouldAddToMap(value, maps.keyLength)) {
-        return maps;
-      }
-
-      let key;
-      do {
-        key = getKey();
-      } while (countMap.has(key));
-      maps.map.set(value, key);
-      maps.reverseMap[key] = value;
-      maps.keyLength = key.length;
-      return maps;
-    },
-    {
-      map: new Map(),
-      reverseMap: {},
-      keyLength: 1,
-    } as {
-      map: Map<any, string>;
-      reverseMap: Record<string, any>;
-      keyLength: number;
-    },
-  );
-}
-
-// This avoids minification if the original key is shorter than or equals the minified key
-function shouldAddToMap(value: any, keyLength: number) {
-  return value.toString().length >= keyLength;
-}
-
-function addCount(value: any, countMap: Map<any, number>) {
-  countMap.set(value, (countMap.get(value) || 0) + 1);
-}
-
-function countOccurrences(
-  obj: any,
-  countMap: Map<any, number>,
-  replacer: MinifyObjectReplacer,
-) {
-  for (const key in obj) {
-    const value = replacer(obj[key], key);
-    if (!shouldMinify(value)) continue;
-
-    if (!Array.isArray(obj)) {
-      addCount(key, countMap);
-    }
-
-    if (isObject(value)) {
-      countOccurrences(value, countMap, replacer);
-    } else {
-      addCount(value, countMap);
-    }
-  }
-}
-
-function isNonSerializable(value: any): boolean {
-  return isNullish(value) || isFunction(value) || typeof value === 'symbol';
-}
-
-function shouldMinify(value: any): boolean {
-  if (isObject(value) && isEmpty(value)) {
-    return false;
-  }
-
-  if (isNonSerializable(value)) {
-    return false;
-  }
-
-  return true;
-}
-
-function minifyObjectImpl(
-  obj: any,
-  map: Map<any, string>,
-  replacer: MinifyObjectReplacer,
-): any {
-  const minifiedObject: any = getRootNode(obj);
-
-  for (const key in obj) {
-    const value = replacer(obj[key], key);
-    if (!shouldMinify(value)) continue;
-
-    let minifiedValue;
-    if (isObject(value)) {
-      minifiedValue = minifyObjectImpl(value, map, replacer);
-    } else {
-      minifiedValue = minifyValue(value, map);
-    }
-
-    setValue(minifiedObject, minifiedValue, minifyValue(key, map));
-  }
-
-  return minifiedObject;
-}
-
-function minifyValue(value: any, map: Map<any, string>) {
-  return map.get(value) ?? value;
-}
-
-function expandSingle(value: any, map: Record<string, any>): any {
-  if (isStringValue(value)) {
-    return map[value] ?? value;
-  }
-
-  return value;
-}
-
-export function expandObject(minifiedObj: any, map: Record<string, any>): any {
-  const expandedObject: any = getRootNode(minifiedObj);
-
-  for (const key in minifiedObj) {
-    let expandedValue;
-    const value = minifiedObj[key];
-    if (isObject(value)) {
-      expandedValue = expandObject(value, map);
-    } else {
-      expandedValue = expandSingle(value, map);
-    }
-
-    const expandedKey = expandSingle(key, map);
-    setValue(expandedObject, expandedValue, expandedKey);
-  }
-
-  return expandedObject;
-}
-
-function setValue(container: any, value: any, key: string) {
-  if (isUnsafeKey(key)) {
-    return;
-  }
-
-  if (isArray(container)) {
-    container.push(value);
-  } else {
-    container[key] = value;
-  }
-}
-
-function getRootNode(node: any) {
-  return isArray(node) ? [] : {};
-}
-
-export type MinifyObjectReplacer = (value: any, key: string) => any;