vest-utils 1.5.0 → 2.0.1

package/src/exports/minifyObject.ts

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

package/src/exports/standardSchemaSpec.ts

@@ -0,0 +1,70 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (
+      value: unknown,
+    ) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema['~standard']['types']
+  >['input'];
+
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema['~standard']['types']
+  >['output'];
+}

package/src/freezeAssign.ts

@@ -0,0 +1,5 @@
+import assign from './assign';
+
+export function freezeAssign<T extends object>(...args: Partial<T>[]): T {
+  return Object.freeze(assign(...(args as [Partial<T>])));
+}

package/src/globals.d.ts

@@ -0,0 +1,3 @@
+declare const __DEV__: boolean;
+declare const __LIB_VERSION__: string;
+declare const 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/hasOwnProperty.ts

@@ -0,0 +1,9 @@
+/**
+ * A safe hasOwnProperty access
+ */
+export default function hasOwnProperty<T>(
+  obj: T,
+  key: string | number | symbol,
+): key is keyof T {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}

package/src/invariant.ts

@@ -0,0 +1,19 @@
+import dynamicValue from './dynamicValue';
+import type { Stringable } from './utilityTypes';
+
+export default function invariant(
+  condition: any,
+
+  message?: String | Stringable,
+): asserts condition {
+  if (condition) {
+    return;
+  }
+
+  // If message is a string object (rather than string literal)
+  // Throw the value directly as a string
+  // Alternatively, throw an error with the message
+  throw message instanceof String
+    ? message.valueOf()
+    : new Error(message ? dynamicValue(message) : message);
+}

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,18 @@
+import bindNot from './bindNot';
+import hasOwnProperty from './hasOwnProperty';
+import { lengthEquals } from './lengthEquals';
+import { isObject } from './valueIsObject';
+
+export function isEmpty(value: unknown): boolean {
+  if (!value) {
+    return true;
+  } else if (hasOwnProperty(value, 'length')) {
+    return lengthEquals(value as string | unknown[], 0);
+  } else if (isObject(value)) {
+    return lengthEquals(Object.keys(value as Record<string, unknown>), 0);
+  }
+
+  return false;
+}
+
+export const isNotEmpty = bindNot(isEmpty);

package/src/isEmptySet.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks if a given set is empty.
+ * @param value value to check
+ */
+export function isEmptySet(value: Set<unknown>): boolean {
+  return value.size === 0;
+}
+
+/**
+ * Checks if a given set is NOT empty.
+ * @param value value to check
+ */
+export function isNotEmptySet(value: Set<unknown>): boolean {
+  return value.size > 0;
+}

package/src/isFunction.ts

@@ -0,0 +1,5 @@
+export default function isFunction(
+  value: unknown,
+): value is (...args: unknown[]) => unknown {
+  return typeof value === 'function';
+}

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/isNullish.ts

@@ -0,0 +1,10 @@
+import bindNot from './bindNot';
+import { isNull } from './isNull';
+import { isUndefined } from './isUndefined';
+import { Nullish } from './utilityTypes';
+
+export function isNullish(value: any): value is Nullish {
+  return isNull(value) || isUndefined(value);
+}
+
+export const isNotNullish = bindNot(isNullish);

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/isPromise.ts

@@ -0,0 +1,5 @@
+import isFunction from './isFunction';
+
+export default function isPromise(value: any): value is Promise<unknown> {
+  return !!value && isFunction(value.then);
+}

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/isUnsafeKey.ts

@@ -0,0 +1,3 @@
+export default function isUnsafeKey(key: string): boolean {
+  return key === '__proto__' || key === 'constructor' || key === 'prototype';
+}

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/mapFirst.ts

@@ -0,0 +1,25 @@
+export default function mapFirst<T>(
+  array: T[],
+  callback: (
+    item: T,
+    breakout: (conditional: boolean, value: unknown) => void,
+    index: number,
+  ) => unknown,
+): any {
+  let broke = false;
+  let breakoutValue = null;
+  for (let i = 0; i < array.length; i++) {
+    callback(array[i], breakout, i);
+
+    if (broke) {
+      return breakoutValue;
+    }
+  }
+
+  function breakout(conditional: boolean, value: unknown) {
+    if (conditional) {
+      broke = true;
+      breakoutValue = value;
+    }
+  }
+}

package/src/nonnullish.ts

@@ -0,0 +1,9 @@
+import invariant from './invariant';
+import { isNullish } from './isNullish';
+import { Nullish } from './utilityTypes';
+
+export function nonnullish<T>(value: Nullish<T>, error?: string): T {
+  invariant(!isNullish(value), error);
+
+  return value;
+}

package/src/noop.ts

@@ -0,0 +1 @@
+export function noop() {}

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/seq.ts

@@ -0,0 +1,16 @@
+/**
+ * @returns a unique numeric id.
+ */
+
+import { CB } from './utilityTypes';
+
+const seq = genSeq();
+
+export default seq;
+
+export function genSeq(namespace?: string): CB<string> {
+  return (
+    (n: number) => () =>
+      `${namespace ? namespace + '_' : ''}${n++}`
+  )(0);
+}

package/src/text.ts

@@ -0,0 +1,20 @@
+import { isEmpty } from './isEmpty';
+import { isObject } from './valueIsObject';
+
+const regexp = /{([^}]*)}/g;
+
+export function text(str: string, ...substitutions: Array<unknown>): string {
+  const first = substitutions[0];
+
+  if (isObject(first)) {
+    return str.replace(regexp, (placeholder, key: string) => {
+      return `${first[key] ?? placeholder}`;
+    });
+  }
+
+  const subs = [...substitutions];
+
+  return str.replace(regexp, placeholder => {
+    return `${isEmpty(subs) ? placeholder : subs.shift()}`;
+  });
+}

package/src/tinyState.ts

@@ -0,0 +1,28 @@
+import dynamicValue from './dynamicValue';
+import { DynamicValue } from './utilityTypes';
+
+export function createTinyState<S>(
+  initialValue: SetValueInput<S>,
+): TinyState<S> {
+  let value: S;
+
+  resetValue();
+
+  return () => [value, setValue, resetValue];
+
+  function setValue(nextValue: SetValueInput<S>) {
+    value = dynamicValue(nextValue, value);
+  }
+
+  function resetValue() {
+    setValue(dynamicValue(initialValue));
+  }
+}
+
+export type TinyState<S> = () => [
+  value: S,
+  setValue: (next: SetValueInput<S>) => void,
+  resetValue: () => void,
+];
+
+type SetValueInput<S> = DynamicValue<S, [prev: S]>;

package/src/toNumber.ts

@@ -0,0 +1,11 @@
+import { makeResult, Result } from './Result';
+
+export function toNumber(value: any): Result<number, string> {
+  const num = Number(value);
+
+  if (Number.isNaN(num)) {
+    return makeResult.Err(`Value "${value}" is not a number`);
+  }
+
+  return makeResult.Ok(num);
+}

package/src/utilityTypes.ts

@@ -0,0 +1,25 @@
+export type DropFirst<T extends unknown[]> = T extends [unknown, ...infer U]
+  ? U
+  : never;
+
+export type Stringable = string | CB<string>;
+
+export type CB<T = any, Args extends TArgs = TArgs> = (...args: Args) => T;
+
+export type ValueOf<T> = T[keyof T];
+
+export type Nullish<T = void> = Nullable<T> | Maybe<T>;
+
+export type Nullable<T> = T | null;
+
+export type Maybe<T> = T | undefined;
+
+export type OneOrMoreOf<T> = T | T[];
+
+export type DynamicValue<T, Args extends TArgs = TArgs> = T | CB<T, Args>;
+
+export type BlankValue = Maybe<''>;
+
+type TArgs = any[];
+
+export type Predicate<T = any> = boolean | ((value: T) => boolean);

package/src/valueIsObject.ts

@@ -0,0 +1,5 @@
+import { isNullish } from './isNullish';
+
+export function isObject(v: any): v is Record<any, any> {
+  return typeof v === 'object' && !isNullish(v);
+}