chore: update dependencies

Author: lpatiny

eslint.config.mjs

@@ -1,5 +1,5 @@
-import cheminfo from 'eslint-config-cheminfo-typescript';
 import { defineConfig } from 'eslint/config';
+import cheminfo from 'eslint-config-cheminfo-typescript';
 
 export default defineConfig([
   ...cheminfo,
@@ -9,6 +9,7 @@ export default defineConfig([
       'jsdoc/lines-before-block': 'off',
       'no-loss-of-precision': 'off',
       '@typescript-eslint/prefer-for-of': 'off',
+      'unicorn/no-array-reverse': 'off',
       'unicorn/import-style': [
         'error',
         {

package.json

@@ -84,19 +84,19 @@
   },
   "homepage": "https://github.com/mljs/spectra-processing#readme",
   "devDependencies": {
-    "@types/node": "^22.15.2",
-    "@vitest/coverage-v8": "^3.1.2",
+    "@types/node": "^24.2.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "cheminfo-build": "^1.2.1",
-    "eslint": "^9.25.1",
-    "eslint-config-cheminfo-typescript": "^18.0.0",
+    "eslint": "^9.32.0",
+    "eslint-config-cheminfo-typescript": "^19.0.0",
     "jest-matcher-deep-close-to": "^3.0.2",
     "jscpd": "^4.0.5",
     "ml-spectra-fitting": "^4.2.4",
-    "prettier": "^3.5.3",
+    "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
     "spectrum-generator": "^8.1.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "binary-search": "^1.3.6",

src/__tests__/index.test.ts

@@ -1,8 +1,9 @@
-import { expect, it } from 'vitest';
+import { expect, test } from 'vitest';
 
 import * as SpectraProcessing from '../index';
 
-it('test existence of exported functions', () => {
+test('test existence of exported functions', () => {
   const exports = Object.keys(SpectraProcessing);
+
   expect(exports).toMatchSnapshot();
 });

src/matrix/__tests__/matrixAbsoluteMedian.test.ts

@@ -8,5 +8,6 @@ test('matrixAbsoluteMedian', () => {
     [1, 2, 3],
   ];
   const absoluteMedian = matrixAbsoluteMedian(matrix);
+
   expect(absoluteMedian).toBe(2);
 });

src/matrix/__tests__/matrixApplyNumericalDecoding.test.ts

@@ -26,5 +26,6 @@ test('should return an array of numbers', () => {
   );
 
   const nonNumbers = matrix.flat().filter((value) => typeof value !== 'number');
+
   expect(nonNumbers).toHaveLength(0);
 });

src/matrix/__tests__/matrixAutoCorrelation.test.ts

@@ -9,12 +9,14 @@ test('simple', () => {
     [3, 1],
   ];
   const result = matrixAutoCorrelation(matrix);
+
   expect(result[0]).toBeCloseTo(1, 10);
   expect(result[1]).toBeCloseTo(-1, 10);
 });
 
 test('test matrixAutoCorrelation too small', () => {
   const matrix = [[0]];
+
   expect(() => matrixAutoCorrelation(matrix)).toThrow(
     'can not calculate info if matrix contains less than 2 rows',
   );

src/matrix/__tests__/matrixBoxPlot.test.ts

@@ -17,6 +17,7 @@ test('test matrixBoxPlot even', () => {
     [10, 100],
     [11, 110],
   ];
+
   expect(matrixBoxPlot(matrix)).toStrictEqual({
     q1: Float64Array.from([2.5, 25]),
     median: Float64Array.from([5.5, 55]),
@@ -28,6 +29,7 @@ test('test matrixBoxPlot even', () => {
 
 test('test matrixBoxPlot even small', () => {
   const matrix = [[0], [1], [2], [3], [4], [5]];
+
   expect(matrixBoxPlot(matrix)).toStrictEqual({
     q1: Float64Array.from([1]),
     median: Float64Array.from([2.5]),
@@ -39,6 +41,7 @@ test('test matrixBoxPlot even small', () => {
 
 test('test matrixBoxPlot odd', () => {
   const matrix = [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10]];
+
   expect(matrixBoxPlot(matrix)).toStrictEqual({
     q1: Float64Array.from([2]),
     median: Float64Array.from([5]),
@@ -50,6 +53,7 @@ test('test matrixBoxPlot odd', () => {
 
 test('test matrixBoxPlot odd small', () => {
   const matrix = [[0], [1], [2], [3], [4]];
+
   expect(matrixBoxPlot(matrix)).toStrictEqual({
     q1: Float64Array.from([0.5]),
     median: Float64Array.from([2]),
@@ -61,6 +65,7 @@ test('test matrixBoxPlot odd small', () => {
 
 test('test matrixBoxPlot too small', () => {
   const matrix = [[0], [1], [2], [4]];
+
   expect(() => matrixBoxPlot(matrix)).toThrow(
     'can not calculate info if matrix contains less than 5 rows',
   );

src/matrix/__tests__/matrixCenterZMean.test.ts

@@ -9,6 +9,7 @@ test('matrixCenterZMean', () => {
     [3, 1, 3, 1],
   ];
   const result = matrixCenterZMean(data);
+
   expect(result).toStrictEqual([
     Float64Array.from([-1, 1, 0, 0]),
     Float64Array.from([0, 0, -1, 1]),

src/matrix/__tests__/matrixCholeskySolver.test.ts

@@ -8,6 +8,7 @@ import { matrixCholeskySolver } from '../matrixCholeskySolver';
 import { matrixCuthillMckee } from '../matrixCuthillMckee';
 
 type Func = (b: NumberArray) => NumberArray;
+
 test('solve a least square system', () => {
   const x = xSequentialFillFromTo({ from: 0, to: Math.PI, size: 101 });
   const noise = x.map(() => Math.random() * 0.1 - 0.05);
@@ -22,17 +23,23 @@ test('solve a least square system', () => {
   const weighted = addWeights(upperTriangularNonZeros, y, weights);
 
   const cho = matrixCholeskySolver(weighted.leftHandSide, dimension) as Func;
+
   expect(cho).not.toBeNull();
+
   const smoothed = cho(weighted.rightHandSide);
+
   expect(smoothed[50]).toBeLessThan(0.2);
   expect(smoothed[50]).toBeGreaterThan(-0.2);
 
   //ignore the outlier, it implicates the smooth should pass closer to zero.
   weights[50] = 0;
   const weighted2 = addWeights(upperTriangularNonZeros, y, weights);
   const cho2 = matrixCholeskySolver(weighted.leftHandSide, dimension) as Func;
+
   expect(cho2).not.toBeNull();
+
   const smoothed2 = cho2(weighted2.rightHandSide);
+
   expect(smoothed2[50]).toBeLessThan(smoothed[50]);
 
   const permutationEncodedArray = matrixCuthillMckee(
@@ -46,6 +53,8 @@ test('solve a least square system', () => {
   ) as Func;
 
   expect(cho3).not.toBeNull();
+
   const smoothed3 = cho2(weighted2.rightHandSide);
-  expect(smoothed3[50]).toEqual(smoothed3[50]);
+
+  expect(smoothed3[50]).toStrictEqual(smoothed3[50]);
 });

src/matrix/__tests__/matrixClone.test.ts

@@ -6,6 +6,7 @@ import { datasetForEncoding } from './fixtures/encoding';
 
 test('should return an array of numbers', () => {
   const matrix = matrixClone(datasetForEncoding);
+
   expect(matrix).toStrictEqual(datasetForEncoding);
   expect(matrix).not.toBe(datasetForEncoding);
 });