feat: ignore empty filters

Author: lpatiny

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('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

@@ -20,6 +20,11 @@ export function filterXY(data: DataXY, filters: FilterXYType[]) {
   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}`);