@vpmedia/simplify 1.71.0 → 1.72.0

package/src/util/event_emitter.test.js

@@ -1,231 +0,0 @@
-/* eslint-disable unicorn/prefer-event-target, no-empty-function, no-invalid-this, func-names, func-style, unicorn/consistent-function-scoping */
-
-import { describe, it, expect } from 'vitest';
-import { EventEmitter } from './event_emitter.js';
-
-describe('EventEmitter3 basics', () => {
-  it('can be instantiated', () => {
-    const e = new EventEmitter();
-    expect(e).toBeInstanceOf(EventEmitter);
-  });
-
-  it('supports subclassing', () => {
-    class Beast extends EventEmitter {}
-    const beast = new Beast();
-
-    expect(beast).toBeInstanceOf(Beast);
-    expect(beast).toBeInstanceOf(EventEmitter);
-  });
-});
-
-describe('emit()', () => {
-  it('returns false when no listeners exist', () => {
-    const e = new EventEmitter();
-    expect(e.emit('foo')).toBe(false);
-  });
-
-  it('returns true when listeners exist', () => {
-    const e = new EventEmitter();
-    e.on('foo', () => {});
-    expect(e.emit('foo')).toBe(true);
-  });
-
-  it('invokes listeners with provided arguments', async () => {
-    const e = new EventEmitter();
-
-    await new Promise((resolve) => {
-      e.on('foo', (a, b) => {
-        expect(a).toBe(1);
-        expect(b).toBe(2);
-        resolve();
-      });
-
-      e.emit('foo', 1, 2);
-    });
-  });
-
-  it('binds the correct context', async () => {
-    const e = new EventEmitter();
-    const ctx = { value: 42 };
-
-    await new Promise((resolve) => {
-      e.on(
-        'foo',
-        function () {
-          // @ts-expect-error
-          expect(this).toBe(ctx);
-          resolve();
-        },
-        ctx
-      );
-
-      e.emit('foo');
-    });
-  });
-
-  it('supports many listeners for the same event', () => {
-    const e = new EventEmitter();
-    const calls = [];
-
-    e.on('foo', () => calls.push(1));
-    e.on('foo', () => calls.push(2));
-
-    e.emit('foo');
-
-    expect(calls).toEqual([1, 2]);
-  });
-});
-
-describe('once()', () => {
-  it('fires the listener only once', () => {
-    const e = new EventEmitter();
-    let calls = 0;
-
-    e.once('foo', () => {
-      calls += 1;
-    });
-
-    e.emit('foo');
-    e.emit('foo');
-
-    expect(calls).toBe(1);
-    expect(e.listenerCount('foo')).toBe(0);
-  });
-
-  it('passes arguments correctly', async () => {
-    const e = new EventEmitter();
-
-    await new Promise((resolve) => {
-      e.once('foo', (...args) => {
-        expect(args).toEqual([1, 2, 3]);
-        resolve();
-      });
-
-      e.emit('foo', 1, 2, 3);
-    });
-  });
-});
-
-describe('listeners() and listenerCount()', () => {
-  it('returns an empty array when no listeners exist', () => {
-    const e = new EventEmitter();
-    expect(e.listeners('foo')).toEqual([]);
-    expect(e.listenerCount('foo')).toBe(0);
-  });
-
-  it('returns only listener functions (not internals)', () => {
-    const e = new EventEmitter();
-    function fn() {}
-
-    e.on('foo', fn);
-
-    expect(e.listeners('foo')).toEqual([fn]);
-  });
-
-  it('does not expose internal listener storage', () => {
-    const e = new EventEmitter();
-    function fn() {}
-
-    e.on('foo', fn);
-    const listeners = e.listeners('foo');
-    listeners.push(() => {});
-
-    expect(e.listeners('foo')).toEqual([fn]);
-  });
-});
-
-describe('off()', () => {
-  it('removes all listeners for an event when fn is omitted', () => {
-    const e = new EventEmitter();
-
-    e.on('foo', () => {});
-    e.on('foo', () => {});
-
-    e.off('foo');
-
-    expect(e.listenerCount('foo')).toBe(0);
-  });
-
-  it('removes a specific listener', () => {
-    const e = new EventEmitter();
-    function fn() {}
-
-    e.on('foo', fn);
-    e.off('foo', fn);
-
-    expect(e.listeners('foo')).toEqual([]);
-  });
-
-  it('removes listeners matching both function and context', () => {
-    const e = new EventEmitter();
-    const ctx1 = {};
-    const ctx2 = {};
-    function fn() {}
-
-    e.on('foo', fn, ctx1);
-    e.on('foo', fn, ctx2);
-
-    e.off('foo', fn, ctx1);
-
-    expect(e.listenerCount('foo')).toBe(1);
-  });
-});
-
-describe('removeAllListeners()', () => {
-  it('removes listeners for a single event', () => {
-    const e = new EventEmitter();
-
-    e.on('foo', () => {});
-    e.on('bar', () => {});
-
-    e.removeAllListeners('foo');
-
-    expect(e.listenerCount('foo')).toBe(0);
-    expect(e.listenerCount('bar')).toBe(1);
-  });
-
-  it('removes all listeners when no event is specified', () => {
-    const e = new EventEmitter();
-
-    e.on('foo', () => {});
-    e.on('bar', () => {});
-
-    e.removeAllListeners();
-
-    expect(e.eventNames()).toEqual([]);
-  });
-});
-
-describe('eventNames()', () => {
-  it('returns an empty array when no events exist', () => {
-    const e = new EventEmitter();
-    expect(e.eventNames()).toEqual([]);
-  });
-
-  it('returns all registered event names', () => {
-    const e = new EventEmitter();
-
-    e.on('foo', () => {});
-    e.on('bar', () => {});
-
-    expect(e.eventNames()).toContain('foo');
-    expect(e.eventNames()).toContain('bar');
-  });
-
-  it('supports symbol event names', () => {
-    const e = new EventEmitter();
-    const sym = Symbol('test');
-
-    e.on(sym, () => {});
-    expect(e.eventNames()).toContain(sym);
-  });
-
-  it('events map is instance field', () => {
-    const e1 = new EventEmitter();
-    const e2 = new EventEmitter();
-    e1.on('event', () => {});
-    expect(e1.listenerCount('event')).toBe(1);
-    expect(e1.listenerCount('no-event')).toBe(0);
-    expect(e2.listenerCount('event')).toBe(0);
-  });
-});

package/src/util/fetch.test.js

@@ -1,62 +0,0 @@
-import { HTTP_404_NOT_FOUND } from '../const/http_status.js';
-import { fetchRetry, FetchError } from './fetch.js';
-
-describe('FetchError', () => {
-  test('constructor', () => {
-    const error = new FetchError('message', 'url', { method: 'GET' }, null);
-    expect(error.message).toEqual('message');
-    expect(error.resource).toEqual('url');
-    expect(error.fetchOptions).toMatchObject({ method: 'GET' });
-    expect(error.response).toBe(null);
-  });
-});
-
-describe('fetchRetry', () => {
-  test('fetch OK', async () => {
-    const response = await fetchRetry('/test.json', {
-      cache: 'no-cache',
-      keepalive: false,
-      method: 'GET',
-      redirect: 'error',
-    });
-    const json = await response.json();
-    const expectedJSON = {
-      success: true,
-      method: 'GET',
-    };
-    expect(json).toEqual(expectedJSON);
-  });
-  test('fetch unknown scheme', async () => {
-    try {
-      await fetchRetry('htps://', {});
-    } catch (error) {
-      const typedError = error instanceof Error ? error : new Error(String(error));
-      expect(typedError.message).toEqual('fetch failed');
-      const typedErrorCause =
-        typedError.cause instanceof Error ? typedError.cause : new Error(String(typedError.cause));
-      expect(typedErrorCause.message).toEqual('unknown scheme');
-    }
-  });
-  test('fetch 404 error with retry', async () => {
-    try {
-      await fetchRetry(
-        '/test_error.json',
-        {
-          cache: 'no-cache',
-          keepalive: false,
-          method: 'POST',
-          redirect: 'error',
-        },
-        { numTries: 2, statusExcludes: [], delay: 1 }
-      );
-    } catch (error) {
-      const typedError = error instanceof Error ? error : new Error(String(error));
-      expect(typedError).toBeInstanceOf(FetchError);
-      if (typedError instanceof FetchError) {
-        expect(typedError.message).toBe('Fetch error 404');
-        expect(typedError.response.status).toBe(HTTP_404_NOT_FOUND);
-        expect(typedError.cause).toBe(HTTP_404_NOT_FOUND);
-      }
-    }
-  });
-});

package/src/util/number.test.js

@@ -1,126 +0,0 @@
-/* eslint-disable unicorn/no-useless-undefined */
-
-import { TypeCheckError } from '../typecheck/TypeCheckError.js';
-import {
-  fixFloatPrecision,
-  getRandomInt,
-  isEqual,
-  isGreater,
-  isGreaterOrEqual,
-  isInRange,
-  isLess,
-  isLessOrEqual,
-  deg2rad,
-  rad2deg,
-} from './number.js';
-
-test('Converts angle in degrees to radians', () => {
-  expect(deg2rad(90)).toBe(1.5707963267948966);
-  // @ts-expect-error
-  expect(() => deg2rad('')).toThrowError(TypeCheckError);
-});
-
-test('Converts angle in radians to degrees', () => {
-  expect(rad2deg(1.5707963267948966)).toBe(90);
-  // @ts-expect-error
-  expect(() => rad2deg('')).toThrowError(TypeCheckError);
-});
-
-describe('fixFloatPrecision', () => {
-  test('Fixes float precision issues', () => {
-    expect(fixFloatPrecision(0.20000000000000004)).toBe(0.2);
-  });
-
-  test('Handles zero', () => {
-    expect(fixFloatPrecision(0)).toBe(0);
-  });
-
-  test('Handles negative numbers', () => {
-    expect(fixFloatPrecision(-0.20000000000000004)).toBe(-0.2);
-  });
-
-  test('Handles very small numbers', () => {
-    expect(fixFloatPrecision(0.0000000000001)).toBe(0);
-    expect(fixFloatPrecision(-0.0000000000001)).toBe(0);
-  });
-
-  test('Handles integer numbers', () => {
-    expect(fixFloatPrecision(5)).toBe(5);
-  });
-
-  test('Handles string number input', () => {
-    expect(fixFloatPrecision('5.123456789')).toBe(5.123456789);
-  });
-
-  test('Throws error for invalid input', () => {
-    expect(fixFloatPrecision('abc')).toBe(Number.NaN);
-    expect(fixFloatPrecision(null)).toBe(Number.NaN);
-    expect(fixFloatPrecision(undefined)).toBe(Number.NaN);
-  });
-});
-
-describe('getRandomInt', () => {
-  test('Throws error if min or max is not finite number', () => {
-    // @ts-expect-error
-    expect(() => getRandomInt('', 1)).toThrowError(TypeCheckError);
-    // @ts-expect-error
-    expect(() => getRandomInt(1, '')).toThrowError(TypeCheckError);
-  });
-
-  test('Returns random integer within range when min equals max', () => {
-    expect(getRandomInt(1, 1)).toBe(1);
-  });
-
-  test('Returns random integer within range when min is less than max', () => {
-    const result = getRandomInt(1, 10);
-    expect(result).toBeGreaterThanOrEqual(1);
-    expect(result).toBeLessThanOrEqual(10);
-  });
-
-  test('Works with negative numbers', () => {
-    const result = getRandomInt(-5, -1);
-    expect(result).toBeGreaterThanOrEqual(-5);
-    expect(result).toBeLessThanOrEqual(-1);
-  });
-
-  test('Works with zero range', () => {
-    const result = getRandomInt(0, 0);
-    expect(result).toBe(0);
-  });
-});
-
-describe('number', () => {
-  test('isEq', () => {
-    expect(isEqual(1, 0)).toBe(false);
-    expect(isEqual(1, 1)).toBe(true);
-  });
-
-  test('isGt', () => {
-    expect(isGreater(1, 0)).toBe(true);
-    expect(isGreater(1, 1)).toBe(false);
-  });
-
-  test('isGtOrEq', () => {
-    expect(isGreaterOrEqual(1, 0)).toBe(true);
-    expect(isGreaterOrEqual(1, 1)).toBe(true);
-    expect(isGreaterOrEqual(1, 2)).toBe(false);
-  });
-
-  test('isGtOrEq', () => {
-    expect(isInRange(1, 0, 2)).toBe(true);
-    expect(isInRange(1, 0, 1)).toBe(true);
-    expect(isInRange(2, 0, 1)).toBe(false);
-  });
-
-  test('isLe', () => {
-    expect(isLess(1, 0)).toBe(false);
-    expect(isLess(0, 0)).toBe(false);
-    expect(isLess(0, 1)).toBe(true);
-  });
-
-  test('isLeOrEq', () => {
-    expect(isLessOrEqual(1, 0)).toBe(false);
-    expect(isLessOrEqual(0, 0)).toBe(true);
-    expect(isLessOrEqual(0, 1)).toBe(true);
-  });
-});

package/src/util/object.test.js

@@ -1,205 +0,0 @@
-import { getObjValueByPath, setObjValueByPath, purgeObject, deepMerge } from './object.js';
-
-describe('deepMerge', () => {
-  test('should override deep properties correctly', () => {
-    const defaultObj = { a: { b: 1, c: 2 }, d: 3 };
-    const overrideObj = { a: { b: 42 } };
-    const expectedResult = { a: { b: 42, c: 2 }, d: 3 };
-
-    expect(deepMerge({ ...defaultObj }, overrideObj)).toEqual(expectedResult);
-  });
-
-  test('should not modify the original target object', () => {
-    const target = { x: { y: 10 } };
-    const source = { x: { y: 20 } };
-    const copy = { ...target };
-
-    deepMerge(target, source);
-    expect(target).toEqual(copy);
-  });
-
-  test('should handle non-object values correctly', () => {
-    expect(deepMerge(null, { a: 1 })).toEqual({ a: 1 });
-    expect(deepMerge({ a: 1 }, null)).toEqual({ a: 1 });
-  });
-
-  test('should handle arrays correctly', () => {
-    const target = { arr: [1, 2] };
-    const source = { arr: [3, 4] };
-
-    expect(deepMerge(target, source)).toEqual({ arr: [3, 4] });
-  });
-
-  test('should handle nested arrays correctly', () => {
-    const target = { obj: { arr: [1, 2] } };
-    const source = { obj: { arr: [3, 4] } };
-
-    expect(deepMerge(target, source)).toEqual({ obj: { arr: [3, 4] } });
-  });
-
-  test('should handle string values', () => {
-    const target = { str: 'hello' };
-    const source = { str: 'world' };
-
-    expect(deepMerge(target, source)).toEqual({ str: 'world' });
-  });
-
-  test('should handle number values', () => {
-    const target = { num: 42 };
-    const source = { num: 100 };
-
-    expect(deepMerge(target, source)).toEqual({ num: 100 });
-  });
-
-  test('should handle boolean values', () => {
-    const target = { bool: true };
-    const source = { bool: false };
-
-    expect(deepMerge(target, source)).toEqual({ bool: false });
-  });
-
-  test('should handle undefined values', () => {
-    const target = { undef: undefined };
-    const source = { undef: 'value' };
-
-    expect(deepMerge(target, source)).toEqual({ undef: 'value' });
-  });
-
-  test('should handle null values', () => {
-    const target = { nullVal: null };
-    const source = { nullVal: 'value' };
-
-    expect(deepMerge(target, source)).toEqual({ nullVal: 'value' });
-  });
-
-  test('should handle mixed property types', () => {
-    const target = {
-      str: 'hello',
-      num: 42,
-      arr: [1, 2],
-      obj: { nested: 'value' },
-    };
-    const source = {
-      str: 'world',
-      num: 100,
-      arr: [3, 4],
-      obj: { nested: 'newValue' },
-    };
-
-    expect(deepMerge(target, source)).toEqual({
-      str: 'world',
-      num: 100,
-      arr: [3, 4],
-      obj: { nested: 'newValue' },
-    });
-  });
-
-  test('should handle constructor and __proto__ protection', () => {
-    const target = { a: 1 };
-    const source = { b: 2 };
-
-    expect(deepMerge(target, source)).toEqual({ a: 1, b: 2 });
-  });
-});
-
-test('Purges object of null and undefined values', () => {
-  const a = { k: 'v' };
-  expect(a.k).toBe('v');
-  purgeObject(a);
-  expect(a.k).toBe(null);
-});
-
-describe('getObjValueByPath', () => {
-  test('Gets object value by path', () => {
-    const source = { a: { b: { c: 'd' } } };
-    expect(getObjValueByPath(source, 'a.b.c')).toBe('d');
-  });
-
-  test('Returns null when object is null or undefined', () => {
-    expect(getObjValueByPath(null, 'a.b.c')).toBeNull();
-    expect(getObjValueByPath(undefined, 'a.b.c')).toBeNull();
-  });
-
-  test('Returns null when path is empty or null', () => {
-    expect(getObjValueByPath({ a: 'b' }, '')).toBeNull();
-    expect(getObjValueByPath({ a: 'b' }, null)).toBeNull();
-  });
-
-  test('Returns null when property does not exist', () => {
-    const source = { a: { b: 'c' } };
-    expect(getObjValueByPath(source, 'a.b.c')).toBeNull();
-  });
-
-  test('Returns null when property is undefined', () => {
-    const source = { a: { b: undefined } };
-    expect(getObjValueByPath(source, 'a.b')).toBeNull();
-  });
-
-  test('Handles single-level paths correctly', () => {
-    const source = { a: 'value' };
-    expect(getObjValueByPath(source, 'a')).toBe('value');
-  });
-
-  test('Handles nested paths correctly', () => {
-    const source = {
-      level1: {
-        level2: {
-          level3: 'deepValue',
-        },
-      },
-    };
-    expect(getObjValueByPath(source, 'level1.level2.level3')).toBe('deepValue');
-  });
-
-  test('Handles arrays in paths', () => {
-    const source = {
-      items: [{ name: 'item1' }, { name: 'item2' }],
-    };
-    expect(getObjValueByPath(source, 'items.0.name')).toBe('item1');
-  });
-});
-
-describe('setObjValueByPath', () => {
-  test('Sets object value by path', () => {
-    const source = { a: { b: { c: 'd' } } };
-    expect(getObjValueByPath(source, 'a.b.c')).toBe('d');
-    setObjValueByPath(source, 'a.b.c', 'newValue');
-    expect(getObjValueByPath(source, 'a.b.c')).toBe('newValue');
-  });
-
-  test('Handles null or undefined object', () => {
-    // Should not throw error
-    setObjValueByPath(null, 'a.b.c', 'value');
-    setObjValueByPath(undefined, 'a.b.c', 'value');
-  });
-
-  test('Handles null or undefined path', () => {
-    const source = { a: 'b' };
-    // Should not throw error
-    setObjValueByPath(source, null, 'value');
-    setObjValueByPath(source, undefined, 'value');
-  });
-
-  test('Sets value at root level', () => {
-    const source = { a: 'oldValue' };
-    setObjValueByPath(source, 'a', 'newValue');
-    expect(source.a).toBe('newValue');
-  });
-
-  test('Creates new nested properties', () => {
-    const source = { a: { b: 'existing' } };
-    setObjValueByPath(source, 'a.c.d', 'newNestedValue');
-    expect(getObjValueByPath(source, 'a.c.d')).toBe('newNestedValue');
-  });
-
-  test('Handles array paths', () => {
-    const source = { items: [{ name: 'item1' }] };
-    setObjValueByPath(source, 'items.0.name', 'updatedItem');
-    expect(getObjValueByPath(source, 'items.0.name')).toBe('updatedItem');
-  });
-
-  test('Throws error for __proto__ path', () => {
-    const source = { a: 'b' };
-    expect(() => setObjValueByPath(source, '__proto__.test', 'value')).toThrow(SyntaxError);
-  });
-});

package/src/util/query.test.js

@@ -1,73 +0,0 @@
-/* eslint-disable jsdoc/check-tag-names, jsdoc/valid-types */
-
-/**
- * @vitest-environment-options { "url": "https://localhost/app/?language=en&token=123-456-öüó%24D" }
- */
-
-import { getURLParam, sanitizeURLParam } from './query.js';
-
-describe('getURLParam', () => {
-  test('Returns fallback value when parameter is not found', () => {
-    const result = getURLParam('nonexistent', 'fallback');
-    expect(result).toBe('fallback');
-  });
-
-  test('Handles null/undefined input gracefully', () => {
-    const result = getURLParam(null, 'fallback');
-    expect(result).toBe('fallback');
-  });
-
-  test('Returns default value when param is null', () => {
-    const result = getURLParam('key', 'default');
-    expect(result).toBe('default');
-  });
-
-  test('Handles valid url parameter sanitized', () => {
-    expect(getURLParam('language')).toBe('en');
-    expect(getURLParam('token')).toBe('123-456-D');
-  });
-
-  test('Handles valid url parameter unsanitized', () => {
-    expect(getURLParam('token', null, false)).toBe('123-456-öüó$D');
-  });
-});
-
-describe('sanitizeURLParam', () => {
-  test('Sanitizes URL parameter correctly', () => {
-    expect(sanitizeURLParam('abc<>-123[]{}-()A_BC')).toBe('abc-123-A_BC');
-  });
-
-  test('Handles null input', () => {
-    expect(sanitizeURLParam(null)).toBe(null);
-  });
-
-  test('Handles empty string', () => {
-    expect(sanitizeURLParam('')).toBe('');
-  });
-
-  test('Handles valid characters', () => {
-    expect(sanitizeURLParam('abc123')).toBe('abc123');
-    expect(sanitizeURLParam('test-parameter')).toBe('test-parameter');
-    expect(sanitizeURLParam('test_parameter')).toBe('test_parameter');
-  });
-
-  test('Handles special characters', () => {
-    expect(sanitizeURLParam('test@#$%')).toBe('test');
-    expect(sanitizeURLParam('test!@#$%^&*()')).toBe('test');
-  });
-
-  test('Handles unicode characters', () => {
-    expect(sanitizeURLParam('test_äöü')).toBe('test_');
-  });
-
-  test('Handles edge cases with various special characters', () => {
-    expect(sanitizeURLParam('test!!!@@@')).toBe('test');
-    expect(sanitizeURLParam('test_param-123')).toBe('test_param-123');
-    expect(sanitizeURLParam('test param')).toBe('testparam');
-  });
-
-  test('Handles very long parameter names', () => {
-    const longParam = 'a'.repeat(1000);
-    expect(typeof sanitizeURLParam(longParam)).toBe('string');
-  });
-});