@vpmedia/simplify 1.53.0 → 1.55.0

package/CHANGELOG.md

@@ -1,3 +1,55 @@
+## [1.55.0] - 2026-01-12
+
+### 🚀 Features
+
+- Added type guard helpers
+- Improve validate utils
+- Improve type check validators
+
+### 💼 Other
+
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+
+### 🚜 Refactor
+
+- Improve naming conventions
+- Improve runtime type checking utils
+- Improve type checker validators
+- Improved validators
+- Merged util methods to more compact structure
+
+### ⚙️ Miscellaneous Tasks
+
+- Release
+- Cleanup
+- Improve linting with oxlint
+- Fixed lint errors
+- Fixed lint errors
+- *(release)* V1.55.0
+## [1.54.0] - 2025-12-29
+
+### 💼 Other
+
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bump dependency versions
+- *(deps)* Bumped package versions
+
+### ⚙️ Miscellaneous Tasks
+
+- Release
+- *(release)* V1.54.0
 ## [1.53.0] - 2025-12-17
 
 ### 💼 Other

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vpmedia/simplify",
-  "version": "1.53.0",
+  "version": "1.55.0",
   "description": "@vpmedia/simplify",
   "author": "Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)",
   "license": "MIT",
@@ -22,25 +22,25 @@
     "eventemitter3": "^5.0.1"
   },
   "optionalDependencies": {
-    "@sentry/browser": "^10.31.0"
+    "@sentry/browser": "^10.32.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.2.0",
-    "@commitlint/config-conventional": "^20.2.0",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
     "@eslint/js": "^9.39.2",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.5",
     "@vitest/coverage-v8": "^4.0.16",
     "eslint": "^9.39.2",
-    "eslint-plugin-jsdoc": "^61.5.0",
-    "eslint-plugin-oxlint": "^1.33.0",
+    "eslint-plugin-jsdoc": "^62.0.0",
+    "eslint-plugin-oxlint": "^1.38.0",
     "eslint-plugin-unicorn": "^62.0.0",
-    "globals": "^16.5.0",
-    "jsdom": "^27.3.0",
-    "oxlint": "^1.33.0",
-    "oxlint-tsgolint": "^0.9.1",
+    "globals": "^17.0.0",
+    "jsdom": "^27.4.0",
+    "oxlint": "^1.38.0",
+    "oxlint-tsgolint": "^0.11.0",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.50.0",
+    "typescript-eslint": "^8.52.0",
     "vitest": "^4.0.16"
   },
   "browserslist": [
@@ -50,11 +50,11 @@
     "iOS >= 14"
   ],
   "scripts": {
-    "build": "exit 0",
-    "check": "pnpm lint && pnpm test && pnpm typecheck",
+    "build": "rm -rf types && tsc -p ./tsconfig.build.json",
+    "check": "pnpm build && pnpm lint && pnpm test && pnpm typecheck",
     "format": "prettier --write \"./**/*.{js,jsx,mjs,cjs,ts,tsx,json,css}\"",
-    "lint": "eslint \"**/*.{js,jsx}\"",
+    "lint": "oxlint src && eslint",
     "test": "vitest --coverage",
-    "typecheck": "rm -rf types && tsc"
+    "typecheck": "tsc"
   }
 }

package/src/index.js

@@ -11,22 +11,12 @@ export * from './pagelifecycle/const.js';
 export * from './pagelifecycle/event.js';
 export * from './pagelifecycle/typedef.js';
 export * from './pagelifecycle/util.js';
-export { addLeadingZero } from './util/addLeadingZero.js';
-export { capitalize } from './util/capitalize.js';
-export { deepMerge } from './util/deepMerge.js';
-export { deg2rad } from './util/deg2rad.js';
-export { delayPromise } from './util/delayPromise.js';
-export { FetchError, fetchRetry, HTTP_0_ANY } from './util/fetchRetry.js';
-export { fixFloatPrecision } from './util/fixFloatPrecision.js';
-export { getErrorDetails } from './util/getErrorDetails.js';
-export { getObjValueByPath } from './util/getObjValueByPath.js';
-export { getRandomInt } from './util/getRandomInt.js';
-export { getURLParam } from './util/getURLParam.js';
-export { loadJSON } from './util/loadJSON.js';
-export { purgeObject } from './util/purgeObject.js';
-export { addFloat, fixFloat, subFloat } from './util/safeFloat.js';
-export { sanitizeURLParam } from './util/sanitizeURLParam.js';
-export { saveAsFile } from './util/saveAsFile.js';
-export { serverDataToState } from './util/serverDataToState.js';
-export { setObjValueByPath } from './util/setObjValueByPath.js';
-export { underscoreToCamelCase } from './util/underscoreToCamelCase.js';
+export * from './util/async.js';
+export * from './util/error.js';
+export { FetchError, fetchRetry, HTTP_0_ANY } from './util/fetch.js';
+export * from './util/number.js';
+export * from './util/object.js';
+export * from './util/query.js';
+export * from './util/state.js';
+export * from './util/string.js';
+export * from './util/validate.js';

package/src/logging/Logger.js

@@ -1,4 +1,4 @@
-import { getURLParam } from '../util/getURLParam.js';
+import { getURLParam } from '../util/query.js';
 import {
   LOG_LEVEL_DEBUG,
   LOG_LEVEL_ERROR,

package/src/logging/OpenTelemetryLogHandler.js

@@ -7,7 +7,7 @@ export class OpenTelemetryLogHandler extends AbstractLogHandler {
    * @param {number} level - Log handler level.
    * @param {(logger: import('./Logger.js').Logger, timestamp: number, level: number, message: string, extra: object | null | undefined, error: Error | null | undefined) => void} emitter - Log handler emitter.
    */
-  constructor(level = LOG_LEVEL_DEBUG, emitter) {
+  constructor(level, emitter) {
     super(level);
     this.emitter = emitter;
   }

package/src/logging/util.js

@@ -1,3 +1,5 @@
+/* eslint-disable dot-notation */
+
 import { LOG_LEVEL_NAMES } from './const.js';
 
 /**

package/src/logging/util.test.js

@@ -12,11 +12,14 @@ import {
   LOG_LEVEL_SILENT,
   LOG_LEVEL_WARNING,
 } from './const.js';
+import { Logger } from './Logger.js';
 import { formatLogMessage, getLogLevelName } from './util.js';
 
 test('formatLogMessage()', () => {
   expect(
-    formatLogMessage({ name: 'loggerName' }, Date.now, LOG_LEVEL_INFO, 'logMessage').endsWith('[loggerName] logMessage')
+    formatLogMessage(new Logger('loggerName'), Date.now(), LOG_LEVEL_INFO, 'logMessage').endsWith(
+      '[loggerName] logMessage'
+    )
   ).toBe(true);
 });
 

package/src/pagelifecycle/util.js

@@ -1,3 +1,5 @@
+/* oxlint-disable prefer-await-to-callbacks */
+
 /**
  * Page lifecycle helper.
  * @see https://developer.chrome.com/docs/web-platform/page-lifecycle-api
@@ -28,19 +30,8 @@ let currentDocumentState = null;
 
 let isInitialized = false;
 
-/** @type {{[key: string]: (() => void)[]}} */
-let callbacks = {};
-
-/**
- * Add callback for a specific state change.
- * @param {import('./typedef.js').DocumentState | import('./typedef.js').PageLifecycleState} state - Callback state condition.
- * @param {() => void} callback - Callback function.
- */
-export const addPageLifecycleCallback = (state, callback) => {
-  const stateCallbacks = callbacks[state] ?? [];
-  stateCallbacks.push(callback);
-  callbacks[state] = stateCallbacks;
-};
+/** @type {Record<string, (() => void)[]>} */
+const callbacks = {};
 
 /**
  * Run callbacks for a specific state change.
@@ -135,17 +126,13 @@ export const initPageLifecycle = () => {
  * Returns the current page lifecycle state.
  * @returns {string | null | undefined} Current page lifecycle state.
  */
-export const getPageLifecycleState = () => {
-  return currentPageLifecycleState;
-};
+export const getPageLifecycleState = () => currentPageLifecycleState;
 
 /**
  * Returns the current document state.
  * @returns {import('./typedef.js').DocumentState | null | undefined} Current document state.
  */
-export const getDocumentState = () => {
-  return currentDocumentState;
-};
+export const getDocumentState = () => currentDocumentState;
 
 /**
  * Returns the event emitter instance.
@@ -162,6 +149,15 @@ export const getPageLifecycleEventEmitter = () => {
  * Returns the page lifecycle observer initialized state.
  * @returns {boolean} Page lifecycle observer initialized flag.
  */
-export const isPageLifecycleInitialized = () => {
-  return isInitialized;
+export const isPageLifecycleInitialized = () => isInitialized;
+
+/**
+ * Add callback for a specific state change.
+ * @param {import('./typedef.js').DocumentState | import('./typedef.js').PageLifecycleState} state - Callback state condition.
+ * @param {() => void} callback - Callback function.
+ */
+export const addPageLifecycleCallback = (state, callback) => {
+  const stateCallbacks = callbacks[state] ?? [];
+  stateCallbacks.push(callback);
+  callbacks[state] = stateCallbacks;
 };

package/src/util/async.js

@@ -0,0 +1,20 @@
+/**
+ * Returns a promise with delayed resolve.
+ * @param {number} delayMS - Promise resolve delay in milliseconds.
+ * @returns {Promise<void>} Delayed resolve promise.
+ */
+export const delayPromise = (delayMS) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, delayMS);
+  });
+
+/**
+ * Load JSON file using a fetch GET request.
+ * @param {string} url - URL to load.
+ * @returns {Promise<string>} The parsed JSON data.
+ */
+export const loadJSON = async (url) => {
+  const response = await fetch(url);
+  const json = await response.json();
+  return JSON.stringify(json);
+};

package/src/util/{delayPromise.test.js → async.test.js}

@@ -1,4 +1,4 @@
-import { delayPromise } from './delayPromise.js';
+import { delayPromise } from './async.js';
 
 describe('delayPromise', () => {
   test('Returns a promise that resolves after specified delay', async () => {

package/src/util/{getErrorDetails.test.js → error.test.js}

@@ -1,4 +1,4 @@
-import { getErrorDetails } from './getErrorDetails.js';
+import { getErrorDetails } from './error.js';
 
 test('Tests getErrorDetails', () => {
   const error = new Error('Test error', { cause: 'Test cause' });

package/src/util/{fetchRetry.js → fetch.js}

@@ -1,3 +1,5 @@
+/* oxlint-disable no-await-in-loop */
+
 import {
   HTTP_401_UNAUTHORIZED,
   HTTP_403_FORBIDDEN,
@@ -5,8 +7,8 @@ import {
   HTTP_422_UNPROCESSABLE_ENTITY,
 } from '../const/http_status.js';
 import { Logger } from '../logging/Logger.js';
-import { delayPromise } from './delayPromise.js';
-import { getErrorDetails } from './getErrorDetails.js';
+import { delayPromise } from './async.js';
+import { getErrorDetails } from './error.js';
 
 const logger = new Logger('fetch');
 
@@ -37,11 +39,11 @@ export class FetchError extends Error {
  * @returns {Promise<Response>} Fetch result.
  */
 export const fetchRetry = async (resource, fetchOptions, retryOptions) => {
-  retryOptions = retryOptions ?? {};
+  retryOptions ??= {};
   retryOptions.timeout = Math.max(retryOptions.timeout ?? 30000, 1);
   retryOptions.delay = Math.max(retryOptions.delay ?? 1000, 1);
   retryOptions.numTries = Math.max(retryOptions.numTries ?? 1, 1);
-  retryOptions.statusExcludes = retryOptions.statusExcludes ?? [
+  retryOptions.statusExcludes ??= [
     HTTP_401_UNAUTHORIZED,
     HTTP_403_FORBIDDEN,
     HTTP_405_METHOD_NOT_ALLOWED,

package/src/util/number.js

@@ -0,0 +1,116 @@
+/**
+ * Converts degrees to radians.
+ * @param {number} deg - Degree value.
+ * @returns {number} Radian value.
+ */
+export const deg2rad = (deg) => deg * (Math.PI / 180);
+
+/**
+ * Returns random integer in range.
+ * @param {number} min - Min value.
+ * @param {number} max - Max value.
+ * @returns {number} Random integer in given range.
+ */
+export const getRandomInt = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+
+/**
+ * Fixes floating point number (0.20000000000000004 -> 0.2).
+ * @param {number | string} value - Number to fix.
+ * @returns {number} The fixed number.
+ */
+export const fixFloatPrecision = (value) => {
+  // Handle string inputs by converting to number first
+  if (typeof value === 'string') {
+    value = Number(value);
+  }
+  if (value >= 0 && value < 0.00000000001) {
+    const valuePlusOne = value + 1;
+    return Number.parseFloat(valuePlusOne.toPrecision(12)) - 1;
+  }
+  return Number.parseFloat(value.toPrecision(12));
+};
+
+/**
+ * Convenience method for floating point precision handling.
+ * @param {number} value - The number to process.
+ * @param {number} p - The precision. Defaults to 2.
+ * @returns {number} The processed value.
+ */
+export const fixFloat = (value, p = 2) => Number.parseFloat(value.toFixed(p));
+
+/**
+ * Adds two value with floating point precision.
+ * @param {number} a - The number a.
+ * @param {number} b - The number b.
+ * @returns {number} The processed value.
+ */
+export const addFloat = (a, b) => {
+  const p = 100;
+  return fixFloat((a * p + b * p) / p);
+};
+
+/**
+ * Substracts two value with floating point precision.
+ * @param {number} a - The number a.
+ * @param {number} b - The number b.
+ * @returns {number} The processed value.
+ */
+export const subFloat = (a, b) => {
+  const p = 100;
+  return fixFloat((a * p - b * p) / p);
+};
+
+/**
+ * Value greater than check.
+ * @param {number} value - Input value.
+ * @param {number} min - Limit that `value` must be greater than.
+ * @returns {boolean} `true` is check success.
+ * @private
+ */
+export const isGt = (value, min) => value > min;
+
+/**
+ * Value greater than check.
+ * @param {number} value - Input value.
+ * @param {number} min - Limit that `value` must be greater or equal than.
+ * @returns {boolean} `true` is check success.
+ * @private
+ */
+export const isGtOrEq = (value, min) => value >= min;
+
+/**
+ * Value less than check.
+ * @param {number} value - Input value.
+ * @param {number} min - Limit that `value` must be greater than.
+ * @returns {boolean} `true` is check success.
+ * @private
+ */
+export const isLe = (value, min) => value < min;
+
+/**
+ * Value less than check.
+ * @param {number} value - Input value.
+ * @param {number} min - Limit that `value` must be greater than.
+ * @returns {boolean} `true` is check success.
+ * @private
+ */
+export const isLeOrEq = (value, min) => value <= min;
+
+/**
+ * Value greater than check.
+ * @param {number} value - Input value.
+ * @param {number} min - Limit `value` must be greater or equal than.
+ * @param {number} max - Limit `value` must be less or equal than.
+ * @returns {boolean} `true` is check success.
+ * @private
+ */
+export const isInRange = (value, min, max) => value >= min && value <= max;
+
+/**
+ * Value equal check.
+ * @param {number} value - Input value.
+ * @param {number} expected - `expected` that `value` must equal.
+ * @returns {boolean} `true` is check success.
+ * @private
+ */
+export const isEq = (value, expected) => value === expected;

package/src/util/number.test.js

@@ -0,0 +1,115 @@
+import {
+  addFloat,
+  fixFloat,
+  fixFloatPrecision,
+  getRandomInt,
+  isEq,
+  isGt,
+  isGtOrEq,
+  isInRange,
+  isLe,
+  isLeOrEq,
+  subFloat,
+  deg2rad,
+} from './number.js';
+
+test('Converts degrees to radians', () => {
+  expect(deg2rad(90)).toBe(1.5707963267948966);
+});
+
+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);
+  });
+
+  test('Handles integer numbers', () => {
+    expect(fixFloatPrecision(5)).toBe(5);
+  });
+
+  test('Handles string input', () => {
+    expect(fixFloatPrecision('5.123456789')).toBe(5.123456789);
+  });
+});
+
+describe('getRandomInt', () => {
+  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);
+  });
+});
+
+test('fixFloat()', () => {
+  expect(fixFloat(0.20000000000000004)).toBe(0.2);
+});
+
+test('addFloat()', () => {
+  expect(addFloat(0.20000000000000004, 0.1000001)).toBe(0.3);
+});
+
+test('subFloat()', () => {
+  expect(subFloat(0.20000000000000004, 0.1000001)).toBe(0.1);
+});
+
+describe('number', () => {
+  test('isEq', () => {
+    expect(isEq(1, 0)).toBe(false);
+    expect(isEq(1, 1)).toBe(true);
+  });
+
+  test('isGt', () => {
+    expect(isGt(1, 0)).toBe(true);
+    expect(isGt(1, 1)).toBe(false);
+  });
+
+  test('isGtOrEq', () => {
+    expect(isGtOrEq(1, 0)).toBe(true);
+    expect(isGtOrEq(1, 1)).toBe(true);
+    expect(isGtOrEq(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(isLe(1, 0)).toBe(false);
+    expect(isLe(0, 0)).toBe(false);
+    expect(isLe(0, 1)).toBe(true);
+  });
+
+  test('isLeOrEq', () => {
+    expect(isLeOrEq(1, 0)).toBe(false);
+    expect(isLeOrEq(0, 0)).toBe(true);
+    expect(isLeOrEq(0, 1)).toBe(true);
+  });
+});

package/src/util/object.js

@@ -0,0 +1,97 @@
+/**
+ * Purges object properties to free up memory.
+ * @param {object} target - The target object.
+ */
+export const purgeObject = (target) => {
+  if (!target) {
+    return;
+  }
+  const reference = target;
+  for (const entry of Object.keys(target)) {
+    reference[entry] = null;
+  }
+};
+
+/**
+ * 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) => {
+  if (typeof target !== 'object' || target === null) {
+    return source;
+  }
+  if (typeof source !== 'object' || source === null) {
+    return target;
+  }
+  for (const key of Object.keys(source)) {
+    if (key !== '__proto__' && key !== 'constructor') {
+      if (typeof source[key] === 'object' && source[key] !== null) {
+        if (!target[key] || typeof target[key] !== 'object') {
+          target[key] = {};
+        }
+        deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    }
+  }
+
+  return target;
+};
+
+/**
+ * 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);
+/**
+ * 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) => {
+  if (!obj || !path) {
+    return null;
+  }
+  const keyParts = path.split('.');
+  const [nextKey] = keyParts;
+  if (keyParts.length === 1) {
+    return obj[nextKey] === undefined ? null : obj[nextKey];
+  }
+  if (obj[nextKey] === undefined || obj[nextKey] === null) {
+    return null;
+  }
+  return getObjValueByPath(obj[nextKey], keyParts.slice(1).join('.'));
+};
+
+/**
+ * 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) => {
+  if (!obj || !path) {
+    return;
+  }
+  const keyParts = path.split('.');
+  const [nextKey] = keyParts;
+  if (nextKey === '__proto__') {
+    throw new SyntaxError('Security violation error. Cannot use "__proto__" 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] = {};
+    }
+    setObjValueByPath(obj[nextKey], keyParts.slice(1).join('.'), value);
+  }
+};