@vpmedia/simplify 1.74.0 → 1.76.0

package/src/util/number.test.ts

@@ -0,0 +1,124 @@
+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/number.ts

@@ -0,0 +1,58 @@
+import { TypeCheckError } from '../typecheck/TypeCheckError.js';
+
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+
+const PRECISION = 12;
+const EPSILON = 1e-11;
+
+/**
+ * Converts degrees to radians.
+ */
+export const deg2rad = (degrees: number): number => {
+  if (!Number.isFinite(degrees)) {
+    throw new TypeCheckError('Argument degrees must be a finite number', { value: degrees });
+  }
+  return degrees * DEG_TO_RAD;
+};
+
+/**
+ * Converts radians to degrees.
+ */
+export const rad2deg = (radians: number): number => {
+  if (!Number.isFinite(radians)) {
+    throw new TypeCheckError('Argument radians must be a finite number', { value: radians });
+  }
+  return radians * RAD_TO_DEG;
+};
+
+/**
+ * Returns random integer in range.
+ */
+export const getRandomInt = (min: number, max: number): number => {
+  if (!Number.isFinite(min)) {
+    throw new TypeCheckError('Argument min must be finite number', { value: min });
+  }
+  if (!Number.isFinite(max)) {
+    throw new TypeCheckError('Argument max must be finite number', { value: max });
+  }
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+/**
+ * Normalizes floating point precision (e.g. 0.20000000000000004 → 0.2).
+ */
+export const fixFloatPrecision = (value: number | string | null | undefined): number => {
+  const parsedValue = typeof value === 'string' ? Number(value) : value;
+  if (parsedValue === null || parsedValue === undefined || !Number.isFinite(parsedValue)) {
+    return Number.NaN;
+  }
+  return Math.abs(parsedValue) < EPSILON ? 0 : Number(parsedValue.toPrecision(PRECISION));
+};
+
+export const isGreater = (value: number, min: number): boolean => value > min;
+export const isGreaterOrEqual = (value: number, min: number): boolean => value >= min;
+export const isLess = (value: number, min: number): boolean => value < min;
+export const isLessOrEqual = (value: number, min: number): boolean => value <= min;
+export const isInRange = (value: number, min: number, max: number): boolean => value >= min && value <= max;
+export const isEqual = (value: number, expected: number): boolean => value === expected;

package/src/util/object.test.ts

@@ -0,0 +1,203 @@
+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: string | null } = { 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', () => {
+    setObjValueByPath(null, 'a.b.c', 'value');
+    setObjValueByPath(undefined, 'a.b.c', 'value');
+  });
+
+  test('Handles null or undefined path', () => {
+    const source = { a: 'b' };
+    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: Record<string, unknown> = { 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/{object.js → object.ts}

@@ -1,10 +1,11 @@
 const PROHIBITED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 
+type AnyRecord = Record<string, any>;
+
 /**
  * Purges object properties to free up memory.
- * @param {object} target - The target object.
  */
-export const purgeObject = (target) => {
+export const purgeObject = (target: AnyRecord | null | undefined): void => {
   if (!target) {
     return;
   }
@@ -15,11 +16,8 @@ export const purgeObject = (target) => {
 
 /**
  * Merge two objects.
- * @param {object} target - Target merge object.
- * @param {object} source - Source merge object.
- * @returns {object} Merged result object.
  */
-export const deepMerge = (target, source) => {
+export const deepMerge = (target: AnyRecord | null, source: AnyRecord | null): AnyRecord | null => {
   if (typeof target !== 'object' || target === null) {
     return source;
   }
@@ -45,24 +43,19 @@ export const deepMerge = (target, source) => {
 
 /**
  * Returns the sum value of an array of objects field.
- * @param {object[]} arr - The list of input objects.
- * @param {string} prop - The object property key.
- * @returns {number} The sum value.
  */
-export const getObjArrayPropSum = (arr, prop) => arr.reduce((accumulator, object) => accumulator + object[prop], 0);
+export const getObjArrayPropSum = (arr: AnyRecord[], prop: string): number =>
+  arr.reduce((accumulator, object) => accumulator + (object[prop] as number), 0);
 
 /**
  * Get object value by path.
- * @param {object} obj - The source object to get the value from.
- * @param {string} path - The path to the property in dot notation (e.g. 'a.b.c').
- * @returns {object | null} The value at the specified path or null if not found.
  */
-export const getObjValueByPath = (obj, path) => {
+export const getObjValueByPath = (obj: AnyRecord | null | undefined, path: string | null | undefined): unknown => {
   if (!obj || !path) {
     return null;
   }
   const keyParts = path.split('.');
-  const [nextKey] = keyParts;
+  const nextKey = keyParts[0]!;
   if (keyParts.length === 1) {
     return obj[nextKey] === undefined ? null : obj[nextKey];
   }
@@ -74,24 +67,24 @@ export const getObjValueByPath = (obj, path) => {
 
 /**
  * Set object value by path.
- * @param {object} obj - The source object to set the value in.
- * @param {string} path - The path to the property in dot notation (e.g. 'a.b.c').
- * @param {object | null | undefined} value - The value to set at the specified path.
  * @throws {SyntaxError} Error when illegal path value has been provided.
  */
-export const setObjValueByPath = (obj, path, value) => {
+export const setObjValueByPath = (
+  obj: AnyRecord | null | undefined,
+  path: string | null | undefined,
+  value: unknown
+): void => {
   if (!obj || !path) {
     return;
   }
   const keyParts = path.split('.');
-  const [nextKey] = keyParts;
+  const nextKey = keyParts[0]!;
   if (PROHIBITED_KEYS.has(nextKey)) {
     throw new SyntaxError(`Security violation error. Cannot use "${nextKey}" as parameter.`);
   }
   if (keyParts.length === 1) {
     obj[nextKey] = value;
   } else {
-    // Create the nested object if it doesn't exist
     if (obj[nextKey] === undefined || obj[nextKey] === null) {
       obj[nextKey] = {};
     }

package/src/util/query.test.ts

@@ -0,0 +1,71 @@
+/**
+ * @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');
+  });
+});

package/src/util/query.ts

@@ -0,0 +1,35 @@
+const urlSearchParams = new URLSearchParams(globalThis.location?.search);
+
+/**
+ * Sanitizes URL parameters allowing only alpha-numeric characters and dash.
+ */
+export function sanitizeURLParam(input: string): string;
+export function sanitizeURLParam(input: null | undefined): null | undefined;
+export function sanitizeURLParam(input: string | null | undefined): string | null | undefined;
+export function sanitizeURLParam(input: string | null | undefined): string | null | undefined {
+  if (!input) {
+    return input;
+  }
+  return input.replaceAll(/[^\w-]/giu, '');
+}
+
+/**
+ * Get a URL parameter value.
+ */
+export function getURLParam<T = null>(
+  key: string | null | undefined,
+  defaultValue?: T,
+  isSanitize?: boolean
+): string | T {
+  if (!key) {
+    return (defaultValue ?? null) as T;
+  }
+  const paramValue = urlSearchParams.get(key);
+  if (paramValue === null || paramValue === undefined) {
+    return (defaultValue ?? null) as T;
+  }
+  if (isSanitize !== false) {
+    return sanitizeURLParam(paramValue) as string;
+  }
+  return paramValue;
+}

package/src/util/state.test.ts

@@ -0,0 +1,47 @@
+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/{state.js → state.ts}

@@ -2,17 +2,14 @@ import { underscoreToCamelCase } from './string.js';
 
 /**
  * Maps server data to client data.
- * @param {object} data - The server input data.
- * @param {boolean} isRecursive - Use recursive serialization.
- * @returns {object} The output data.
  */
-export const serverDataToState = (data, isRecursive = false) => {
+export const serverDataToState = (data: unknown, isRecursive = false): any => {
   if (Array.isArray(data)) {
     return data.map((entry) => serverDataToState(entry, isRecursive));
   }
 
   if (data !== null && typeof data === 'object') {
-    const result = {};
+    const result: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(data)) {
       const clientKey = underscoreToCamelCase(key);
       result[clientKey] = isRecursive ? serverDataToState(value, isRecursive) : value;
@@ -20,5 +17,5 @@ export const serverDataToState = (data, isRecursive = false) => {
     return result;
   }
 
-  return data; // Return primitives as-is
+  return data;
 };