@vpmedia/simplify 1.70.0 → 1.72.0

package/src/util/state.test.js

@@ -1,47 +0,0 @@
-import { serverDataToState } from './state.js';
-
-describe('state', () => {
-  test('serverDataToState() recursive', () => {
-    const state = serverDataToState(
-      {
-        my_array: [{ key_a: 'value1' }],
-        my_data: { key_a: 'value1' },
-        my_list: [1, 2, 3],
-        my_null: null,
-        my_number: 1000,
-        my_string: 'a',
-        my_var: 'test',
-      },
-      true
-    );
-    expect(state.myArray[0].keyA).toBe('value1');
-    expect(state.myData.keyA).toBe('value1');
-    expect(state.myList[0]).toBe(1);
-    expect(state.myNull).toBe(null);
-    expect(state.myNumber).toBe(1000);
-    expect(state.myString).toBe('a');
-    expect(state.myVar).toBe('test');
-  });
-
-  test('serverDataToState() non-recursive', () => {
-    const state = serverDataToState(
-      {
-        my_array: [{ key_a: 'value1' }],
-        my_data: { key_a: 'value1' },
-        my_list: [1, 2, 3],
-        my_null: null,
-        my_number: 1000,
-        my_string: 'a',
-        my_var: 'test',
-      },
-      false
-    );
-    expect(state.myArray[0].key_a).toBe('value1');
-    expect(state.myData.key_a).toBe('value1');
-    expect(state.myList[0]).toBe(1);
-    expect(state.myNull).toBe(null);
-    expect(state.myNumber).toBe(1000);
-    expect(state.myString).toBe('a');
-    expect(state.myVar).toBe('test');
-  });
-});

package/src/util/string.test.js

@@ -1,66 +0,0 @@
-/* eslint-disable unicorn/no-useless-undefined */
-
-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/uuid.test.js

@@ -1,39 +0,0 @@
-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 = null;
-
-  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', () => {
-    // @ts-expect-error
-    crypto.randomUUID = vi.fn(() => 'mock-uuid');
-    const uuid = uuidv4();
-    expect(uuid).toBe('mock-uuid');
-    expect(crypto.randomUUID).toHaveBeenCalled();
-  });
-
-  it('randomUUIDFallback fallback works if crypto.randomUUID not available', () => {
-    const uuid = randomUUIDFallback();
-    expect(uuid).toMatch(uuidV4Regex);
-  });
-});

package/src/util/validate.test.js

@@ -1,311 +0,0 @@
-/* eslint-disable unicorn/no-useless-undefined */
-
-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 {}
-    // @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', () => {
-    // @ts-expect-error
-    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', () => {
-    // @ts-expect-error
-    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);
-  });
-});

package/tests/mocks/handlers/fetch.js

@@ -1,34 +0,0 @@
-import { http, HttpResponse } from 'msw';
-
-export const fetchHandlers = [
-  http.get('/test.json', () => {
-    const response = HttpResponse.json(
-      {
-        success: true,
-        method: 'GET',
-      },
-      { status: 200 }
-    );
-    return response;
-  }),
-  http.post('/test.json', () => {
-    const response = HttpResponse.json(
-      {
-        success: true,
-        method: 'POST',
-      },
-      { status: 200 }
-    );
-    return response;
-  }),
-  http.post('/test_error.json', () => {
-    const response = HttpResponse.json(
-      {
-        success: false,
-        method: 'POST',
-      },
-      { status: 404 }
-    );
-    return response;
-  }),
-];

package/tests/mocks/handlers.js

@@ -1,3 +0,0 @@
-import { fetchHandlers } from './handlers/fetch.js';
-
-export const handlers = [...fetchHandlers];

package/tsconfig.build.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "jsx": "react-jsx",
-    "module": "NodeNext",
-    "moduleResolution": "nodenext",
-    "types": ["node", "vitest/globals"],
-    "allowJs": true,
-    "checkJs": true,
-    "declaration": true,
-    "declarationMap": true,
-    "emitDeclarationOnly": true,
-    "declarationDir": "./types",
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitAny": false,
-    "strictNullChecks": false,
-    "skipLibCheck": true
-  },
-  "include": ["./src/**/*"],
-  "exclude": ["./src/**/*.test.js"]
-}

package/vitest.setup.js

@@ -1,17 +0,0 @@
-import { setupServer } from 'msw/node';
-import { beforeAll } from 'vitest';
-import { handlers } from './tests/mocks/handlers.js';
-
-const server = setupServer(...handlers);
-
-beforeAll(() => {
-  server.listen();
-});
-
-afterEach(() => {
-  server.resetHandlers();
-});
-
-afterAll(() => {
-  server.close();
-});