@vpmedia/simplify 1.52.0 → 1.53.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [1.53.0] - 2025-12-17
+
+### 💼 Other
+
+- Update npmignore
+- *(deps)* Bump dependency versions
+- Update npmignore
+- *(deps)* Bump dependency versions
+
+### 📚 Documentation
+
+- Improve jsdoc comments
+
+### 🧪 Testing
+
+- Improve test coverage
+
+### ⚙️ Miscellaneous Tasks
+
+- Release
+- *(release)* V1.53.0
 ## [1.52.0] - 2025-12-16
 
 ### 💼 Other

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://badge.fury.io/js/@vpmedia%2Fsimplify.svg)](https://badge.fury.io/js/@vpmedia%2Fsimplify)
 [![Node.js CI](https://github.com/vpmedia/simplify/actions/workflows/ci.yml/badge.svg)](https://github.com/vpmedia/simplify/actions/workflows/ci.yml)
 
-@vpmedia/simplify TBD
+@vpmedia/simplify is a utility library for common JavaScript operations.
 
 ## Getting started
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vpmedia/simplify",
-  "version": "1.52.0",
+  "version": "1.53.0",
   "description": "@vpmedia/simplify",
   "author": "Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)",
   "license": "MIT",
@@ -22,26 +22,26 @@
     "eventemitter3": "^5.0.1"
   },
   "optionalDependencies": {
-    "@sentry/browser": "^10.30.0"
+    "@sentry/browser": "^10.31.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^20.2.0",
     "@commitlint/config-conventional": "^20.2.0",
     "@eslint/js": "^9.39.2",
-    "@types/node": "^25.0.2",
-    "@vitest/coverage-v8": "^4.0.15",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
     "eslint": "^9.39.2",
     "eslint-plugin-jsdoc": "^61.5.0",
-    "eslint-plugin-oxlint": "^1.32.0",
+    "eslint-plugin-oxlint": "^1.33.0",
     "eslint-plugin-unicorn": "^62.0.0",
     "globals": "^16.5.0",
     "jsdom": "^27.3.0",
-    "oxlint": "^1.32.0",
-    "oxlint-tsgolint": "^0.8.6",
+    "oxlint": "^1.33.0",
+    "oxlint-tsgolint": "^0.9.1",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.49.0",
-    "vitest": "^4.0.15"
+    "typescript-eslint": "^8.50.0",
+    "vitest": "^4.0.16"
   },
   "browserslist": [
     "> 0.5%",

package/src/util/addLeadingZero.js

@@ -1,8 +1,8 @@
 /**
- * TBD.
- * @param {number | string | null | undefined} value - TBD.
- * @param {number} size - TBD.
- * @returns {string | null} TBD.
+ * Add leading zeros to a value to ensure it has a minimum width.
+ * @param {number | string | null | undefined} value - The value to pad with leading zeros.
+ * @param {number} size - The minimum width of the resulting string.
+ * @returns {string | null} The value padded with leading zeros or null if the input is null/undefined.
  */
 export const addLeadingZero = (value, size = 2) => {
   if (value === null || value === undefined) {

package/src/util/capitalize.js

@@ -1,7 +1,7 @@
 /**
  * Capitalize a string.
- * @param {string | null | undefined} value - Ther input string.
- * @returns {string | null} TBD.
+ * @param {string | null | undefined} value - The input string to capitalize.
+ * @returns {string | null} The capitalized string or null if the input is null/undefined.
  */
 export const capitalize = (value) => {
   if (value === null || value === undefined) {

package/src/util/capitalize.test.js

@@ -1,6 +1,30 @@
 import { capitalize } from './capitalize.js';
 
-test('Tests capitalize first letter', () => {
-  expect(capitalize('test')).toBe('Test');
-  expect(capitalize(null)).toBe(null);
+describe('capitalize', () => {
+  test('Capitalizes first letter of string', () => {
+    expect(capitalize('test')).toBe('Test');
+    expect(capitalize('TEST')).toBe('Test');
+    expect(capitalize('tEST')).toBe('Test');
+  });
+
+  test('Handles null input', () => {
+    expect(capitalize(null)).toBe(null);
+  });
+
+  test('Handles empty string', () => {
+    expect(capitalize('')).toBe('');
+  });
+
+  test('Handles empty string with whitespace', () => {
+    expect(capitalize('   ')).toBe('   ');
+  });
+
+  test('Handles single character', () => {
+    expect(capitalize('a')).toBe('A');
+    expect(capitalize('A')).toBe('A');
+  });
+
+  test('Handles strings with numbers', () => {
+    expect(capitalize('test123')).toBe('Test123');
+  });
 });

package/src/util/deepMerge.test.js

@@ -22,4 +22,82 @@ describe('deepMerge', () => {
     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 });
+  });
 });

package/src/util/deg2rad.test.js

@@ -1,5 +1,5 @@
 import { deg2rad } from './deg2rad.js';
 
-test('TBD', () => {
+test('Converts degrees to radians', () => {
   expect(deg2rad(90)).toBe(1.5707963267948966);
 });

package/src/util/delayPromise.test.js

@@ -0,0 +1,21 @@
+import { delayPromise } from './delayPromise.js';
+
+describe('delayPromise', () => {
+  test('Returns a promise that resolves after specified delay', async () => {
+    const start = Date.now();
+    await delayPromise(10);
+    const end = Date.now();
+
+    // Should resolve within a reasonable time frame
+    expect(end - start).toBeGreaterThanOrEqual(10);
+  });
+
+  test('Handles zero delay correctly', async () => {
+    const start = Date.now();
+    await delayPromise(0);
+    const end = Date.now();
+
+    // Should resolve immediately
+    expect(end - start).toBeGreaterThanOrEqual(0);
+  });
+});

package/src/util/fixFloatPrecision.js

@@ -4,5 +4,13 @@
  * @returns {number} The fixed number.
  */
 export function 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));
 }

package/src/util/fixFloatPrecision.test.js

@@ -1,5 +1,27 @@
 import { fixFloatPrecision } from './fixFloatPrecision.js';
 
-test('TBD', () => {
-  expect(fixFloatPrecision(0.20000000000000004)).toBe(0.2);
+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);
+  });
 });

package/src/util/getObjValueByPath.js

@@ -1,8 +1,8 @@
 /**
  * Get object value by path.
- * @param {object} obj - TBD.
- * @param {string} path - TBD.
- * @returns {object | null} TBD.
+ * @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) {
@@ -11,7 +11,10 @@ export const getObjValueByPath = (obj, path) => {
   const keyParts = path.split('.');
   const nextKey = keyParts[0];
   if (keyParts.length === 1) {
-    return obj[nextKey];
+    return obj[nextKey] === undefined ? null : obj[nextKey];
+  }
+  if (obj[nextKey] === undefined || obj[nextKey] === null) {
+    return null;
   }
   return getObjValueByPath(obj[nextKey], keyParts.slice(1).join('.'));
 };

package/src/util/getObjValueByPath.test.js

@@ -1,6 +1,51 @@
 import { getObjValueByPath } from './getObjValueByPath.js';
 
-test('Tests getObjValueByPath', () => {
-  const source = { a: { b: { c: 'd' } } };
-  expect(getObjValueByPath(source, 'a.b.c')).toBe('d');
+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');
+  });
 });

package/src/util/getRandomInt.test.js

@@ -1,5 +1,24 @@
 import { getRandomInt } from './getRandomInt.js';
 
-test('TBD', () => {
-  expect(getRandomInt(1, 1)).toBe(1);
+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);
+  });
 });

package/src/util/getURLParam.js

@@ -3,12 +3,12 @@ import { sanitizeURLParam } from './sanitizeURLParam.js';
 const urlSearchParams = new URLSearchParams(window.location.search);
 
 /**
- * TBD.
+ * Get a URL parameter value.
  * @template T
- * @param {string} key - TBD.
- * @param {T} defaultValue - TBD.
- * @param {boolean} isSanitize - TBD.
- * @returns {string | T} TBD.
+ * @param {string} key - The name of the URL parameter to retrieve.
+ * @param {T} defaultValue - The default value to return if the parameter is not found.
+ * @param {boolean} isSanitize - Whether to sanitize the parameter value.
+ * @returns {string | T} The URL parameter value or the default value if not found.
  */
 export const getURLParam = (key, defaultValue = null, isSanitize = true) => {
   const paramValue = urlSearchParams.get(key);

package/src/util/getURLParam.test.js

@@ -1,5 +1,18 @@
 import { getURLParam } from './getURLParam.js';
 
-test('Tests getURLParam()', () => {
-  expect(getURLParam('key', 'fallback')).toBe('fallback');
+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');
+  });
 });

package/src/util/purgeObject.test.js

@@ -1,6 +1,6 @@
 import { purgeObject } from './purgeObject.js';
 
-test('TBD', () => {
+test('Purges object of null and undefined values', () => {
   const a = { k: 'v' };
   expect(a.k).toBe('v');
   purgeObject(a);

package/src/util/sanitizeURLParam.test.js

@@ -1,6 +1,30 @@
 import { sanitizeURLParam } from './sanitizeURLParam.js';
 
-test('Tests URL parameter sanitizer', () => {
-  expect(sanitizeURLParam('abc<>-123[]{}-()A_BC')).toBe('abc-123-A_BC');
-  expect(sanitizeURLParam(null)).toBe(null);
+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_');
+  });
 });

package/src/util/setObjValueByPath.js

@@ -1,8 +1,8 @@
 /**
- * Get object value by path.
- * @param {object} obj - TBD.
- * @param {string} path - TBD.
- * @param {object | null | undefined} value - TBD.
+ * 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) => {
@@ -16,6 +16,11 @@ export const setObjValueByPath = (obj, path, value) => {
   }
   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);
   }
-  setObjValueByPath(obj[nextKey], keyParts.slice(1).join('.'), value);
 };

package/src/util/setObjValueByPath.test.js

@@ -1,9 +1,47 @@
 import { getObjValueByPath } from './getObjValueByPath.js';
 import { setObjValueByPath } from './setObjValueByPath.js';
 
-test('Tests setObjValueByPath', () => {
-  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');
+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/underscoreToCamelCase.test.js

@@ -1,6 +1,6 @@
 import { underscoreToCamelCase } from './underscoreToCamelCase.js';
 
-test('TBD', () => {
+test('Converts underscore to camelCase', () => {
   expect(underscoreToCamelCase('test')).toBe('test');
   expect(underscoreToCamelCase('test_variable')).toBe('testVariable');
   expect(underscoreToCamelCase('test_variable_name')).toBe('testVariableName');

package/types/util/fixFloatPrecision.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fixFloatPrecision.d.ts","sourceRoot":"","sources":["../../src/util/fixFloatPrecision.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yCAHW,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"fixFloatPrecision.d.ts","sourceRoot":"","sources":["../../src/util/fixFloatPrecision.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yCAHW,MAAM,GACJ,MAAM,CAYlB"}

package/types/util/getObjValueByPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getObjValueByPath.d.ts","sourceRoot":"","sources":["../../src/util/getObjValueByPath.js"],"names":[],"mappings":"AAMO,uCAJI,MAAM,QACN,MAAM,GACJ,MAAM,GAAG,IAAI,CAYzB"}
+{"version":3,"file":"getObjValueByPath.d.ts","sourceRoot":"","sources":["../../src/util/getObjValueByPath.js"],"names":[],"mappings":"AAMO,uCAJI,MAAM,QACN,MAAM,GACJ,MAAM,GAAG,IAAI,CAezB"}

package/types/util/setObjValueByPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setObjValueByPath.d.ts","sourceRoot":"","sources":["../../src/util/setObjValueByPath.js"],"names":[],"mappings":"AAOO,uCALI,MAAM,QACN,MAAM,SACN,MAAM,GAAG,IAAI,GAAG,SAAS,QAgBnC"}
+{"version":3,"file":"setObjValueByPath.d.ts","sourceRoot":"","sources":["../../src/util/setObjValueByPath.js"],"names":[],"mappings":"AAOO,uCALI,MAAM,QACN,MAAM,SACN,MAAM,GAAG,IAAI,GAAG,SAAS,QAqBnC"}

package/.oxlintrc.json

@@ -1,72 +0,0 @@
-{
-  "$schema": "./node_modules/oxlint/configuration_schema.json",
-  "env": { "browser": true },
-  "plugins": [
-    "eslint",
-    "import",
-    "jsdoc",
-    "jsx-a11y",
-    "oxc",
-    "promise",
-    "react-perf",
-    "react",
-    "typescript",
-    "unicorn"
-  ],
-  "categories": {
-    "correctness": "warn",
-    "nursery": "warn",
-    "pedantic": "warn",
-    "perf": "warn",
-    "restriction": "warn",
-    "style": "warn",
-    "suspicious": "warn"
-  },
-  "rules": {
-    "arrow-body-style": "off",
-    "class-methods-use-this": "off",
-    "consistent-type-imports": "off",
-    "curly": "off",
-    "default-param-last": "off",
-    "explicit-module-boundary-types": "off",
-    "exports-last": "off",
-    "extensions": "off",
-    "filename-case": "off",
-    "first": "off",
-    "func-style": "off",
-    "group-exports": "off",
-    "id-length": "off",
-    "init-declarations": "off",
-    "max-dependencies": "off",
-    "max-params": "off",
-    "no-anonymous-default-export": "off",
-    "no-async-await": "off",
-    "no-await-in-loop": "off",
-    "no-console": "off",
-    "no-continue": "off",
-    "no-default-export": "off",
-    "no-empty-interface": "off",
-    "no-empty-object-type": "off",
-    "no-explicit-any": "off",
-    "no-magic-numbers": "off",
-    "no-named-export": "off",
-    "no-null": "off",
-    "no-optional-chaining": "off",
-    "no-param-reassign": "off",
-    "no-rest-spread-properties": "off",
-    "no-ternary": "off",
-    "no-undef": "off",
-    "no-undefined": "off",
-    "no-unused-expressions": "off",
-    "no-unused-vars": "off",
-    "numeric-operators-style": "off",
-    "numeric-separators-style": "off",
-    "prefer-default-export": "off",
-    "prefer-destructuring": "off",
-    "prefer-event-target": "off",
-    "prefer-global-this": "off",
-    "require-module-specifiers": "off",
-    "sort-imports": "off",
-    "sort-keys": "off"
-  }
-}

package/commitlint.config.js

@@ -1,117 +0,0 @@
-const config = {
-  rules: {
-    'body-leading-blank': [1, 'always'],
-    'body-max-line-length': [2, 'always', 100],
-    'footer-leading-blank': [1, 'always'],
-    'footer-max-line-length': [2, 'always', 100],
-    'header-max-length': [2, 'always', 100],
-    'header-trim': [2, 'always'],
-    'subject-case': [2, 'never', ['sentence-case', 'start-case', 'pascal-case', 'upper-case']],
-    'subject-empty': [2, 'never'],
-    'subject-full-stop': [2, 'never', '.'],
-    'type-case': [2, 'always', 'lower-case'],
-    'type-empty': [2, 'never'],
-    'type-enum': [
-      2,
-      'always',
-      ['build', 'chore', 'ci', 'docs', 'feat', 'fix', 'perf', 'refactor', 'revert', 'style', 'test'],
-    ],
-  },
-  prompt: {
-    questions: {
-      type: {
-        description: "Select the type of change that you're committing",
-        enum: {
-          feat: {
-            description: 'A new feature',
-            title: 'Features',
-            emoji: '✨',
-          },
-          fix: {
-            description: 'A bug fix',
-            title: 'Bug Fixes',
-            emoji: '🐛',
-          },
-          docs: {
-            description: 'Documentation only changes',
-            title: 'Documentation',
-            emoji: '📚',
-          },
-          style: {
-            description:
-              'Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)',
-            title: 'Styles',
-            emoji: '💎',
-          },
-          refactor: {
-            description: 'A code change that neither fixes a bug nor adds a feature',
-            title: 'Code Refactoring',
-            emoji: '📦',
-          },
-          perf: {
-            description: 'A code change that improves performance',
-            title: 'Performance Improvements',
-            emoji: '🚀',
-          },
-          test: {
-            description: 'Adding missing tests or correcting existing tests',
-            title: 'Tests',
-            emoji: '🚨',
-          },
-          build: {
-            description:
-              'Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)',
-            title: 'Builds',
-            emoji: '🛠',
-          },
-          ci: {
-            description:
-              'Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)',
-            title: 'Continuous Integrations',
-            emoji: '⚙️',
-          },
-          chore: {
-            description: "Other changes that don't modify src or test files",
-            title: 'Chores',
-            emoji: '♻️',
-          },
-          revert: {
-            description: 'Reverts a previous commit',
-            title: 'Reverts',
-            emoji: '🗑',
-          },
-        },
-      },
-      scope: {
-        description: 'What is the scope of this change (e.g. component or file name)',
-      },
-      subject: {
-        description: 'Write a short, imperative tense description of the change',
-      },
-      body: {
-        description: 'Provide a longer description of the change',
-      },
-      isBreaking: {
-        description: 'Are there any breaking changes?',
-      },
-      breakingBody: {
-        description: 'A BREAKING CHANGE commit requires a body. Please enter a longer description of the commit itself',
-      },
-      breaking: {
-        description: 'Describe the breaking changes',
-      },
-      isIssueAffected: {
-        description: 'Does this change affect any open issues?',
-      },
-      issuesBody: {
-        description:
-          'If issues are closed, the commit requires a body. Please enter a longer description of the commit itself',
-      },
-      issues: {
-        description: 'Add issue references (e.g. "fix #123", "re #123".)',
-      },
-    },
-  },
-};
-
-export default config;

package/eslint.config.js

@@ -1,62 +0,0 @@
-import { defineConfig } from 'eslint/config';
-import js from '@eslint/js';
-import jsdocPlugin from 'eslint-plugin-jsdoc';
-import unicornPlugin from 'eslint-plugin-unicorn';
-import globals from 'globals';
-
-export default defineConfig([
-  {
-    ignores: [
-      '.github/**/*.*',
-      '.idea/**/*.*',
-      '.vscode/**/*.*',
-      'build/**/*.*',
-      'coverage/**/*.*',
-      'dist/**/*.*',
-      'public/**/*.*',
-      'types/**/*.*',
-      'node_modules/**/*.*',
-    ],
-  },
-  {
-    languageOptions: {
-      globals: {
-        ...globals.vitest,
-        ...globals.browser,
-        ...globals.node,
-        ...globals.es2026,
-      },
-      parserOptions: {
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        ecmaFeatures: {
-          jsx: true,
-        },
-      },
-    },
-    files: ['**/*.{js,jsx,mjs,cjs,ts,tsx}'],
-    plugins: {
-      jsdoc: jsdocPlugin,
-      unicorn: unicornPlugin,
-    },
-    settings: {
-      'import/parsers': {
-        espree: ['.js', '.cjs', '.mjs', '.jsx'],
-      },
-      'import/resolver': {
-        node: true,
-      },
-    },
-    rules: {
-      ...js.configs.recommended.rules,
-      ...jsdocPlugin.configs['flat/recommended'].rules,
-      ...unicornPlugin.configs.recommended.rules,
-      'no-unused-vars': 'off',
-      'unicorn/filename-case': 'off',
-      'unicorn/no-null': 'off',
-      'unicorn/numeric-separators-style': 'off',
-      'unicorn/prefer-global-this': 'off',
-      'unicorn/prevent-abbreviations': 'off',
-    },
-  },
-]);

package/lefthook.yml

@@ -1,26 +0,0 @@
-# Lefthook configuration
-# @namespace javascript
-# @copyright Copyright (c) 2025-present VPMedia
-# @author Andras Csizmadia <andras@vpmedia.hu>
-# @version 1.0.0
-# @see https://github.com/evilmartians/lefthook/blob/master/docs/configuration.md
-
-pre-commit:
-  parallel: false
-  commands:
-    lint_yaml:
-      glob: "*.{yml,yaml}"
-      run: yq 'true' {staged_files} > /dev/null
-    format_js:
-      glob: "*.{js,jsx}"
-      run: |
-        set -e
-        pnpm exec prettier --write -- {staged_files} || true
-        git add {staged_files} &> /dev/null || true
-    lint_js:
-      glob: "*.{js,jsx}"
-      run: pnpm exec eslint {staged_files}
-commit-msg:
-  commands:
-    commitlint:
-      run: pnpm exec commitlint --edit {1}

package/pnpm-workspace.yaml

@@ -1,4 +0,0 @@
-onlyBuiltDependencies:
-  - esbuild
-trustPolicy: no-downgrade
-minimumReleaseAge: 2880