@vpmedia/simplify 1.74.0 → 1.76.0

package/src/util/string.test.ts

@@ -0,0 +1,64 @@
+import {
+  underscoreToCamelCase,
+  capitalize,
+  addLeadingZero,
+  getTypeFromValue,
+  getDisplayValue,
+  saveAsFile,
+} from './string.js';
+
+describe('string', () => {
+  test('addLeadingZero', () => {
+    expect(addLeadingZero(1)).toBe('01');
+    expect(addLeadingZero('1')).toBe('01');
+    expect(addLeadingZero(1, 3)).toBe('001');
+    expect(addLeadingZero('21')).toBe('21');
+    expect(addLeadingZero(21)).toBe('21');
+    expect(addLeadingZero(null)).toBe(null);
+    expect(addLeadingZero(undefined)).toBe(null);
+  });
+
+  test('capitalize', () => {
+    expect(capitalize('test')).toBe('Test');
+    expect(capitalize('TEST')).toBe('Test');
+    expect(capitalize('tEST')).toBe('Test');
+    expect(capitalize(null)).toBe(null);
+    expect(capitalize('')).toBe('');
+    expect(capitalize('   ')).toBe('   ');
+    expect(capitalize('a')).toBe('A');
+    expect(capitalize('A')).toBe('A');
+    expect(capitalize('test123')).toBe('Test123');
+  });
+
+  test('underscoreToCamelCase', () => {
+    expect(underscoreToCamelCase('test')).toBe('test');
+    expect(underscoreToCamelCase('test_variable')).toBe('testVariable');
+    expect(underscoreToCamelCase('test_variable_name')).toBe('testVariableName');
+  });
+
+  test('getTypeFromValue', () => {
+    expect(getTypeFromValue('test')).toBe('string');
+    expect(getTypeFromValue(() => null)).toBe('function');
+    expect(getTypeFromValue([])).toBe('array');
+    expect(getTypeFromValue({})).toBe('object');
+    expect(getTypeFromValue(new Date())).toBe('date');
+    expect(getTypeFromValue(null)).toBe('null');
+    expect(getTypeFromValue(true)).toBe('boolean');
+    expect(getTypeFromValue(undefined)).toBe('undefined');
+  });
+
+  test('getDisplayValue', () => {
+    expect(getDisplayValue('test')).toBe('"test"');
+    expect(getDisplayValue(() => null)).toBe('() => null');
+    expect(getDisplayValue([])).toBe('[]');
+    expect(getDisplayValue({})).toBe('{}');
+    expect(getDisplayValue(new Date())).not.toBe(null);
+    expect(getDisplayValue(null)).toBe('null');
+    expect(getDisplayValue(true)).toBe('true');
+    expect(getDisplayValue(undefined)).toBe('undefined');
+  });
+
+  test('saveAsFile', () => {
+    expect(() => saveAsFile('test.txt', 'test content')).not.toThrowError(Error);
+  });
+});

package/src/util/string.ts

@@ -0,0 +1,65 @@
+/**
+ * Add leading zeros to a value to ensure it has a minimum width.
+ */
+export const addLeadingZero = (value: number | string | null | undefined, size = 2): string | null => {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  let str = value.toString();
+  while (str.length < size) {
+    str = `0${str}`;
+  }
+  return str;
+};
+
+/**
+ * Capitalize a string.
+ */
+export const capitalize = (value: string | null | undefined): string | null => {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (!value || value.length === 0) {
+    return value;
+  }
+  const normValue = value.toLowerCase();
+  return normValue.charAt(0).toUpperCase() + normValue.slice(1);
+};
+
+/**
+ * Converts underscore case string to camel case.
+ */
+export const underscoreToCamelCase = (value: string): string =>
+  value.replaceAll(/(_\w)/gu, (m) => m[1]!.toUpperCase());
+
+/**
+ * Saves text file.
+ */
+export const saveAsFile = (filename: string, text: string): void => {
+  const element = document.createElement('a');
+  element.setAttribute('href', `data:text/plain;charset=utf-8,${encodeURIComponent(text)}`);
+  element.setAttribute('download', filename);
+  element.style.display = 'none';
+  document.body.append(element);
+  element.click();
+  element.remove();
+};
+
+/**
+ * Get type from value in human readable format.
+ */
+export const getTypeFromValue = (value: unknown): string =>
+  Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+
+/**
+ * Get value in human readable format.
+ */
+export const getDisplayValue = (value: unknown): string => {
+  if (typeof value === 'string') {
+    return `"${value}"`;
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+};

package/src/util/uuid.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { randomUUIDFallback, uuidv4 } from './uuid.js';
+
+const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+
+describe('UUID functions', () => {
+  let originalRandomUUID: typeof crypto.randomUUID;
+
+  beforeEach(() => {
+    originalRandomUUID = crypto.randomUUID;
+  });
+
+  afterEach(() => {
+    crypto.randomUUID = originalRandomUUID;
+  });
+
+  it('randomUUIDFallback generates a valid UUID v4', () => {
+    const uuid = randomUUIDFallback();
+    expect(uuid).toMatch(uuidV4Regex);
+  });
+
+  it('uuidv4 returns a valid UUID v4', () => {
+    const uuid = uuidv4();
+    expect(uuid).toMatch(uuidV4Regex);
+  });
+
+  it('uuidv4 uses crypto.randomUUID if available', () => {
+    crypto.randomUUID = vi.fn(() => 'mock-uuid' as `${string}-${string}-${string}-${string}-${string}`);
+    const uuid = uuidv4();
+    expect(uuid).toBe('mock-uuid');
+    expect(crypto.randomUUID).toHaveBeenCalled();
+  });
+
+  it('randomUUIDFallback fallback works if crypto.randomUUID not available', () => {
+    // @ts-expect-error - allow deleting non-optional property for test
+    delete crypto.randomUUID;
+    const uuid = randomUUIDFallback();
+    expect(uuid).toMatch(uuidV4Regex);
+  });
+
+  it('randomUUIDFallback does not generate duplicates', () => {
+    const uuidMap = new Map<string, boolean>();
+    const numSamples = 1000;
+    for (let i = 0; i < numSamples; i += 1) {
+      const uuid = randomUUIDFallback();
+      if (uuidMap.has(uuid)) {
+        throw new Error('Duplicate UUIDv4 found');
+      }
+      uuidMap.set(uuid, true);
+    }
+    expect(uuidMap.size).toBe(numSamples);
+  });
+});

package/src/util/uuid.ts

@@ -0,0 +1,31 @@
+/**
+ * Convert a byte (0–255) to a 2-character hex string.
+ */
+export const byteToHex = (byte: number): string => (byte >>> 4).toString(16) + (byte & 0b1111).toString(16);
+
+/**
+ * UUIDv4 fallback generator (RFC 4122 compliant).
+ */
+export const randomUUIDFallback = (): string => {
+  const bytes: number[] | Uint8Array = crypto.getRandomValues
+    ? crypto.getRandomValues(new Uint8Array(16))
+    : Array.from({ length: 16 }, () => Math.floor(Math.random() * 256));
+
+  bytes[6] = (bytes[6]! & 0x0f) | 0x40;
+  bytes[8] = (bytes[8]! & 0x3f) | 0x80;
+
+  let uuid = '';
+  for (let index = 0; index < bytes.length; index += 1) {
+    if (index === 4 || index === 6 || index === 8 || index === 10) {
+      uuid += '-';
+    }
+    uuid += byteToHex(bytes[index]!);
+  }
+  return uuid;
+};
+
+/**
+ * Crypto UUIDv4 wrapper with fallback.
+ */
+export const uuidv4 = (): string =>
+  typeof crypto.randomUUID === 'function' ? crypto.randomUUID() : randomUUIDFallback();

package/src/util/validate.test.ts

@@ -0,0 +1,309 @@
+import {
+  isArray,
+  isArrayOf,
+  isBoolean,
+  isEnum,
+  isFunction,
+  isInstance,
+  isInteger,
+  isNonNegativeInteger,
+  isNonNegativeNumber,
+  isNull,
+  isNumber,
+  isPlainObject,
+  isPlainObjectOf,
+  isAnyOf,
+  isPositiveInteger,
+  isPositiveNumber,
+  isString,
+  isUndefined,
+  refineValidator,
+  isNumberLess,
+  isNumberGreater,
+  isNumberLessOrEqual,
+  isNumberGreaterOrEqual,
+  isIntegerLess,
+  isIntegerGreater,
+  isIntegerLessOrEqual,
+  isIntegerGreaterOrEqual,
+  isNumberInRange,
+  isIntegerInRange,
+  isArrayLengthEqual,
+  isArrayLengthInRange,
+  isStringLengthEqual,
+  isStringLengthInRange,
+  isNullOrUndefined,
+} from './validate.js';
+
+describe('validate', () => {
+  test('isArray', () => {
+    expect(isArray('string')).toBe(false);
+    expect(isArray([])).toBe(true);
+    expect(isArray([1, 2, 3])).toBe(true);
+    expect(isArray({ string: '1' })).toBe(false);
+    expect(isArray(0.1)).toBe(false);
+    expect(isArray(1)).toBe(false);
+    expect(isArray(false)).toBe(false);
+    expect(isArray(null)).toBe(false);
+    expect(isArray(true)).toBe(false);
+    expect(isArray(undefined)).toBe(false);
+    expect(isArray(() => true)).toBe(false);
+  });
+
+  test('isBoolean', () => {
+    expect(isBoolean('string')).toBe(false);
+    expect(isBoolean([])).toBe(false);
+    expect(isBoolean([1, 2, 3])).toBe(false);
+    expect(isBoolean({ string: '1' })).toBe(false);
+    expect(isBoolean(0.1)).toBe(false);
+    expect(isBoolean(1)).toBe(false);
+    expect(isBoolean(false)).toBe(true);
+    expect(isBoolean(null)).toBe(false);
+    expect(isBoolean(true)).toBe(true);
+    expect(isBoolean(undefined)).toBe(false);
+    expect(isBoolean(() => true)).toBe(false);
+  });
+
+  test('isNumber', () => {
+    expect(isNumber('string')).toBe(false);
+    expect(isNumber([])).toBe(false);
+    expect(isNumber([1, 2, 3])).toBe(false);
+    expect(isNumber({ string: '1' })).toBe(false);
+    expect(isNumber(0.1)).toBe(true);
+    expect(isNumber(1)).toBe(true);
+    expect(isNumber(false)).toBe(false);
+    expect(isNumber(null)).toBe(false);
+    expect(isNumber(Number.NaN)).toBe(false);
+    expect(isNumber(Number.POSITIVE_INFINITY)).toBe(false);
+    expect(isNumber(true)).toBe(false);
+    expect(isNumber(undefined)).toBe(false);
+    expect(isNumber(() => true)).toBe(false);
+  });
+
+  test('isPositiveNumber', () => {
+    expect(isPositiveNumber(0)).toBe(false);
+    expect(isPositiveNumber(1)).toBe(true);
+    expect(isPositiveNumber(1.1)).toBe(true);
+    expect(isPositiveNumber(-1)).toBe(false);
+    expect(isPositiveNumber(-1.1)).toBe(false);
+  });
+
+  test('isNonNegativeNumber', () => {
+    expect(isNonNegativeNumber(0)).toBe(true);
+    expect(isNonNegativeNumber(1)).toBe(true);
+    expect(isNonNegativeNumber(1.1)).toBe(true);
+    expect(isNonNegativeNumber(-1)).toBe(false);
+    expect(isNonNegativeNumber(-1.1)).toBe(false);
+  });
+
+  test('isInteger', () => {
+    expect(isInteger('string')).toBe(false);
+    expect(isInteger(() => true)).toBe(false);
+    expect(isInteger([])).toBe(false);
+    expect(isInteger([1, 2, 3])).toBe(false);
+    expect(isInteger({ string: '1' })).toBe(false);
+    expect(isInteger(0.1)).toBe(false);
+    expect(isInteger(1)).toBe(true);
+    expect(isInteger(false)).toBe(false);
+    expect(isInteger(null)).toBe(false);
+    expect(isInteger(Number.NaN)).toBe(false);
+    expect(isInteger(Number.POSITIVE_INFINITY)).toBe(false);
+    expect(isInteger(true)).toBe(false);
+    expect(isInteger(undefined)).toBe(false);
+  });
+
+  test('isPositiveInteger', () => {
+    expect(isPositiveInteger(0)).toBe(false);
+    expect(isPositiveInteger(1)).toBe(true);
+    expect(isPositiveInteger(1.1)).toBe(false);
+    expect(isPositiveInteger(-1)).toBe(false);
+    expect(isPositiveInteger(-1.1)).toBe(false);
+  });
+
+  test('isNonNegativeInteger', () => {
+    expect(isNonNegativeInteger(0)).toBe(true);
+    expect(isNonNegativeInteger(1)).toBe(true);
+    expect(isNonNegativeInteger(1.1)).toBe(false);
+    expect(isNonNegativeInteger(-1)).toBe(false);
+    expect(isNonNegativeInteger(-1.1)).toBe(false);
+  });
+
+  test('isString', () => {
+    expect(isString('string')).toBe(true);
+    expect(isString([])).toBe(false);
+    expect(isString([1, 2, 3])).toBe(false);
+    expect(isString({ string: '1' })).toBe(false);
+    expect(isString(0.1)).toBe(false);
+    expect(isString(1)).toBe(false);
+    expect(isString(false)).toBe(false);
+    expect(isString(null)).toBe(false);
+    expect(isString(true)).toBe(false);
+    expect(isString(undefined)).toBe(false);
+    expect(isString(() => true)).toBe(false);
+  });
+
+  test('isFunction', () => {
+    expect(isFunction('string')).toBe(false);
+    expect(isFunction([])).toBe(false);
+    expect(isFunction([1, 2, 3])).toBe(false);
+    expect(isFunction({ string: '1' })).toBe(false);
+    expect(isFunction(0.1)).toBe(false);
+    expect(isFunction(1)).toBe(false);
+    expect(isFunction(false)).toBe(false);
+    expect(isFunction(null)).toBe(false);
+    expect(isFunction(true)).toBe(false);
+    expect(isFunction(undefined)).toBe(false);
+    expect(isFunction(() => true)).toBe(true);
+  });
+
+  test('isNull', () => {
+    expect(isNull('string')).toBe(false);
+    expect(isNull([])).toBe(false);
+    expect(isNull([1, 2, 3])).toBe(false);
+    expect(isNull({ string: '1' })).toBe(false);
+    expect(isNull(0.1)).toBe(false);
+    expect(isNull(1)).toBe(false);
+    expect(isNull(false)).toBe(false);
+    expect(isNull(null)).toBe(true);
+    expect(isNull(true)).toBe(false);
+    expect(isNull(undefined)).toBe(false);
+    expect(isNull(() => true)).toBe(false);
+  });
+
+  test('isUndefined', () => {
+    expect(isUndefined('string')).toBe(false);
+    expect(isUndefined([])).toBe(false);
+    expect(isUndefined([1, 2, 3])).toBe(false);
+    expect(isUndefined({ string: '1' })).toBe(false);
+    expect(isUndefined(0.1)).toBe(false);
+    expect(isUndefined(1)).toBe(false);
+    expect(isUndefined(false)).toBe(false);
+    expect(isUndefined(null)).toBe(false);
+    expect(isUndefined(true)).toBe(false);
+    expect(isUndefined(undefined)).toBe(true);
+    expect(isUndefined(() => true)).toBe(false);
+  });
+
+  test('isNullOrUndefined', () => {
+    expect(isNullOrUndefined('string')).toBe(false);
+    expect(isNullOrUndefined([])).toBe(false);
+    expect(isNullOrUndefined([1, 2, 3])).toBe(false);
+    expect(isNullOrUndefined({ string: '1' })).toBe(false);
+    expect(isNullOrUndefined(0.1)).toBe(false);
+    expect(isNullOrUndefined(1)).toBe(false);
+    expect(isNullOrUndefined(false)).toBe(false);
+    expect(isNullOrUndefined(null)).toBe(true);
+    expect(isNullOrUndefined(true)).toBe(false);
+    expect(isNullOrUndefined(undefined)).toBe(true);
+    expect(isNullOrUndefined(() => true)).toBe(false);
+  });
+
+  test('isPlainObject', () => {
+    expect(isPlainObject('string')).toBe(false);
+    expect(isPlainObject(() => true)).toBe(false);
+    expect(isPlainObject([])).toBe(false);
+    expect(isPlainObject([1, 2, 3])).toBe(false);
+    expect(isPlainObject({ string: '1' })).toBe(true);
+    expect(isPlainObject(0.1)).toBe(false);
+    expect(isPlainObject(1)).toBe(false);
+    expect(isPlainObject(false)).toBe(false);
+    expect(isPlainObject(new Date())).toBe(false);
+    expect(isPlainObject(null)).toBe(false);
+    expect(isPlainObject(true)).toBe(false);
+    expect(isPlainObject(undefined)).toBe(false);
+  });
+
+  test('isInstance', () => {
+    class CustomError extends Error {
+      override name = 'CustomError';
+    }
+    // @ts-expect-error
+    expect(isInstance({}, {})).toBe(false);
+    expect(isInstance({}, Number)).toBe(false);
+    // @ts-expect-error
+    expect(isInstance(new CustomError(), {})).toBe(false);
+    expect(isInstance(new CustomError(), Error)).toBe(true);
+    expect(isInstance(new CustomError(), Number)).toBe(false);
+    expect(isInstance(new Date(), Date)).toBe(true);
+  });
+
+  test('isEnum', () => {
+    expect(isEnum(0, [1, 2])).toBe(false);
+    expect(isEnum(1, [1, 2])).toBe(true);
+    expect(isEnum('AB', ['AB', 'CD'])).toBe(true);
+    expect(isEnum('EF', ['AB', 'CD'])).toBe(false);
+    expect(isEnum('AB', { AB: 'AB', CD: 'CD' })).toBe(true);
+    expect(isEnum('EF', { AB: 'AB', CD: 'CD' })).toBe(false);
+    expect(isEnum('AB', new Set(['AB', 'CD']))).toBe(true);
+    expect(isEnum('EF', new Set(['AB', 'CD']))).toBe(false);
+    expect(isEnum('EF', null)).toBe(false);
+    expect(isEnum('EF', undefined)).toBe(false);
+    // @ts-expect-error
+    expect(isEnum('EF', 1)).toBe(false);
+    // @ts-expect-error
+    expect(isEnum('EF', 'string')).toBe(false);
+    // @ts-expect-error
+    expect(isEnum(false, 'string')).toBe(false);
+  });
+
+  test('isArrayOf', () => {
+    expect(isArrayOf(0.1, isNumber)).toBe(false);
+    expect(isArrayOf([0.1, 'string'], isNumber)).toBe(false);
+    expect(isArrayOf([0.1, 0.2], isNumber)).toBe(true);
+    expect(isArrayOf([0.1, 1, 2], isInteger)).toBe(false);
+    expect(isArrayOf([1, 2], isInteger)).toBe(true);
+    expect(isArrayOf([1, 'string', undefined], isAnyOf(isInteger, isNullOrUndefined))).toBe(false);
+    expect(isArrayOf([1, null, undefined], isAnyOf(isInteger, isNullOrUndefined))).toBe(true);
+  });
+
+  test('isPlainObjectOf', () => {
+    expect(isPlainObjectOf(0.1, isNumber)).toBe(false);
+    expect(isPlainObjectOf({ a: 0.1, b: 'string' }, isNumber)).toBe(false);
+    expect(isPlainObjectOf({ a: 0.1, b: 0.2 }, isNumber)).toBe(true);
+    expect(isPlainObjectOf({ a: 0.1, b: 1, c: 2 }, isInteger)).toBe(false);
+    expect(isPlainObjectOf({ a: 1, b: 2 }, isInteger)).toBe(true);
+  });
+
+  test('isAnyOf', () => {
+    expect(isAnyOf(isNumber, isNull)(1)).toBe(true);
+    expect(isAnyOf(isNumber, isNull)(null)).toBe(true);
+    expect(isAnyOf(isNumber, isNull)('string')).toBe(false);
+  });
+
+  test('refineValidator', () => {
+    expect(refineValidator(isNumber, (v) => v > 0)(-1)).toBe(false);
+    expect(refineValidator(isNumber, (v) => v > 0)(1)).toBe(true);
+    expect(refineValidator(isNumber, (v) => v > 0).name).toBe('isNumberRefined');
+  });
+
+  test('isRefinedExtensions', () => {
+    expect(isNumberLess(0)(-1.1)).toBe(true);
+    expect(isNumberLess(0)(0)).toBe(false);
+    expect(isNumberLessOrEqual(0)(0)).toBe(true);
+    expect(isNumberGreater(0)(0)).toBe(false);
+    expect(isNumberGreater(0)(1.1)).toBe(true);
+    expect(isNumberGreaterOrEqual(0)(0)).toBe(true);
+    expect(isNumberInRange(0, 1.1)(0)).toBe(true);
+    expect(isNumberInRange.name).toBe('isNumberInRange');
+
+    expect(isIntegerLess(0)(-1)).toBe(true);
+    expect(isIntegerLess(0)(0)).toBe(false);
+    expect(isIntegerLessOrEqual(0)(0)).toBe(true);
+    expect(isIntegerGreater(0)(0)).toBe(false);
+    expect(isIntegerGreater(0)(1)).toBe(true);
+    expect(isIntegerGreater(0)(1.1)).toBe(false);
+    expect(isIntegerGreaterOrEqual(0)(0)).toBe(true);
+    expect(isIntegerInRange(0, 1)(0)).toBe(true);
+    expect(isIntegerInRange(0, 1)(2)).toBe(false);
+
+    expect(isStringLengthEqual(1)('a')).toBe(true);
+    expect(isStringLengthEqual(1)('ab')).toBe(false);
+    expect(isStringLengthInRange(1, 2)('ab')).toBe(true);
+    expect(isStringLengthInRange(1, 2)('abc')).toBe(false);
+
+    expect(isArrayLengthEqual(1)([1])).toBe(true);
+    expect(isArrayLengthEqual(1)([1, 2])).toBe(false);
+    expect(isArrayLengthInRange(1, 2)([1, 2])).toBe(true);
+    expect(isArrayLengthInRange(1, 2)([1, 2, 3])).toBe(false);
+  });
+});