feat: ignore empty filters

package.json

@@ -40,8 +40,8 @@
   "devDependencies": {
     "@vitest/coverage-v8": "^3.2.4",
     "@zakodium/tsconfig": "^1.0.2",
-    "eslint": "^9.33.0",
-    "eslint-config-cheminfo-typescript": "^19.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-cheminfo-typescript": "^20.0.0",
     "jest-matcher-deep-close-to": "^3.0.2",
     "prettier": "^3.6.2",
     "rimraf": "^6.0.1",
@@ -54,6 +54,6 @@
     "cheminfo-types": "^1.8.1",
     "ml-gsd": "^13.0.1",
     "ml-savitzky-golay-generalized": "^4.2.0",
-    "ml-spectra-processing": "^14.17.0"
+    "ml-spectra-processing": "^14.17.1"
   }
 }

src/__tests__/filterXY.test.ts

@@ -1,49 +1,78 @@
-import { describe, expect, it } from 'vitest';
+import { expect, test } from 'vitest';
 
 import type { FilterXYType } from '../FilterXYType.ts';
 import linear from '../filters/__tests__/data/linear.ts';
 import { filterXY } from '../index.ts';
 
-describe('filterXY', () => {
-  it('filters', () => {
-    const filters: FilterXYType[] = [
-      { name: 'centerMedian' },
-      { name: 'fromTo', options: { from: 2, to: 8 } },
-    ];
+test('filters', () => {
+  const filters: FilterXYType[] = [
+    { name: 'centerMedian' },
+    { name: 'fromTo', options: { from: 2, to: 8 } },
+  ];
 
-    const result = filterXY(linear, filters);
+  const result = filterXY(linear, filters);
 
-    expect(result.data).toStrictEqual({
-      x: Float64Array.from([2, 3, 4, 5, 6, 7, 8]),
-      y: Float64Array.from([-1, 0, 1, 2, 1, 0, -1]),
-    });
+  expect(result.data).toStrictEqual({
+    x: Float64Array.from([2, 3, 4, 5, 6, 7, 8]),
+    y: Float64Array.from([-1, 0, 1, 2, 1, 0, -1]),
   });
+});
+
+test('reverseIfNeeded, not needed', () => {
+  const filters: FilterXYType[] = [{ name: 'reverseIfNeeded' }];
+  const data = {
+    x: Float64Array.from([1, 2, 3, 4, 5]),
+    y: Float64Array.from([1, 2, 3, 4, 1]),
+  };
+  const result = filterXY(data, filters);
 
-  it('reverseIfNeeded, not needed', () => {
-    const filters: FilterXYType[] = [{ name: 'reverseIfNeeded' }];
-    const data = {
-      x: Float64Array.from([1, 2, 3, 4, 5]),
-      y: Float64Array.from([1, 2, 3, 4, 1]),
-    };
-    const result = filterXY(data, filters);
-
-    expect(result.data).toStrictEqual({
-      x: Float64Array.from([1, 2, 3, 4, 5]),
-      y: Float64Array.from([1, 2, 3, 4, 1]),
-    });
+  expect(result.data).toStrictEqual({
+    x: Float64Array.from([1, 2, 3, 4, 5]),
+    y: Float64Array.from([1, 2, 3, 4, 1]),
   });
+});
 
-  it('reverseIfNeeded, needed', () => {
-    const filters: FilterXYType[] = [{ name: 'reverseIfNeeded' }];
-    const data = {
-      x: Float64Array.from([5, 4, 3, 2, 1]),
-      y: Float64Array.from([1, 2, 3, 4, 1]),
-    };
-    const result = filterXY(data, filters);
-
-    expect(result.data).toStrictEqual({
-      x: Float64Array.from([1, 2, 3, 4, 5]),
-      y: Float64Array.from([1, 4, 3, 2, 1]),
-    });
+test('reverseIfNeeded, needed', () => {
+  const filters: FilterXYType[] = [{ name: 'reverseIfNeeded' }];
+  const data = {
+    x: Float64Array.from([5, 4, 3, 2, 1]),
+    y: Float64Array.from([1, 2, 3, 4, 1]),
+  };
+  const result = filterXY(data, filters);
+
+  expect(result.data).toStrictEqual({
+    x: Float64Array.from([1, 2, 3, 4, 5]),
+    y: Float64Array.from([1, 4, 3, 2, 1]),
   });
 });
+
+test('reverseIfNeeded, with empty filter', () => {
+  const filters: FilterXYType[] = [
+    // @ts-expect-error testing empty filter
+    { name: '' },
+    // @ts-expect-error testing empty filter
+    {},
+    { name: 'reverseIfNeeded' },
+  ];
+  const data = {
+    x: Float64Array.from([5, 4, 3, 2, 1]),
+    y: Float64Array.from([1, 2, 3, 4, 1]),
+  };
+  const result = filterXY(data, filters);
+
+  expect(result.data).toStrictEqual({
+    x: Float64Array.from([1, 2, 3, 4, 5]),
+    y: Float64Array.from([1, 4, 3, 2, 1]),
+  });
+});
+
+test('unknown filter', () => {
+  // @ts-expect-error testing error
+  const filters: FilterXYType[] = [{ name: 'abc' }];
+  const data = {
+    x: Float64Array.from([5, 4, 3, 2, 1]),
+    y: Float64Array.from([1, 2, 3, 4, 1]),
+  };
+
+  expect(() => filterXY(data, filters)).toThrow('Unknown filter: abc');
+});

src/filterXY.ts

@@ -6,8 +6,8 @@
 
 /**
  * Apply filters on {x:[], y:[]}
  * @param data
  * @param filters
  * @returns A very important number
  */
 export function filterXY(data: DataXY, filters: FilterXYType[]) {
@@ -20,6 +20,11 @@
   for (const filter of filters) {
     const start = Date.now();
 
+    if (!filter.name) {
+      // we ignore empty filter names
+      continue;
+    }
+
     const filterFct = Filters[filter.name];
     if (!filterFct) {
       throw new Error(`Unknown filter: ${filter.name}`);

src/filters/x/calibrateX.ts

@@ -63,15 +63,15 @@ export function calibrateX(
   const fromIndex = xFindClosestIndex(data.x, from);
   const toIndex = xFindClosestIndex(data.x, to);
 
-  const peaks = gsd(
+  let peaks = gsd(
     {
       x: data.x.subarray(fromIndex, toIndex),
       y: data.y.subarray(fromIndex, toIndex),
     },
     gsdOptions,
-  )
-    .sort((a, b) => b.y - a.y)
-    .slice(0, nbPeaks);
+  );
+  peaks.sort((a, b) => b.y - a.y);
+  peaks = peaks.slice(0, nbPeaks);
 
   if (peaks.length < nbPeaks) return { data };