feat: update dependencies and improve return type of filterXY

package.json

@@ -38,22 +38,22 @@
   },
   "homepage": "https://github.com/mljs/signal-processing#readme",
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.16",
     "@zakodium/tsconfig": "^1.0.2",
-    "eslint": "^9.35.0",
-    "eslint-config-cheminfo-typescript": "^20.0.0",
+    "eslint": "^9.39.2",
+    "eslint-config-cheminfo-typescript": "^21.0.1",
     "jest-matcher-deep-close-to": "^3.0.2",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.9.2",
-    "typescript-json-schema": "^0.65.1",
-    "vitest": "^3.2.4"
+    "prettier": "^3.7.4",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "typescript-json-schema": "^0.67.1",
+    "vitest": "^4.0.16"
   },
   "dependencies": {
     "baselines": "^1.1.9",
-    "cheminfo-types": "^1.8.1",
-    "ml-gsd": "^13.0.1",
+    "cheminfo-types": "^1.10.0",
+    "ml-gsd": "^13.1.1",
     "ml-savitzky-golay-generalized": "^4.2.0",
-    "ml-spectra-processing": "^14.17.1"
+    "ml-spectra-processing": "^14.19.0"
   }
 }

src/__tests__/filterXY.test.ts

@@ -74,5 +74,5 @@ test('unknown filter', () => {
     y: Float64Array.from([1, 2, 3, 4, 1]),
   };
 
-  expect(() => filterXY(data, filters)).toThrow('Unknown filter: abc');
+  expect(() => filterXY(data, filters)).toThrowError('Unknown filter: abc');
 });

src/filterMatrix.ts

@@ -1,4 +1,4 @@
-import type { DoubleMatrix } from 'ml-spectra-processing';
+import type { DoubleMatrix } from 'cheminfo-types';
 
 import type { FilterMatrixType } from './FilterMatrixType.ts';
 
@@ -12,7 +12,7 @@
     data: matrix,
   };
 
   const logs: any = [];
 
   /**
    * todo

src/filterXY.ts

@@ -1,4 +1,4 @@
-import type { DataXY } from 'cheminfo-types';
+import type { DataXY, DoubleArray } from 'cheminfo-types';
 import { xEnsureFloat64, xyGrowingX } from 'ml-spectra-processing';
 
 import type { FilterXYType } from './FilterXYType.ts';
@@ -6,11 +6,14 @@
 
 /**
  * Apply filters on {x:[], y:[]}
  * @param data
  * @param filters
- * @returns A very important number
+ * @returns
  */
-export function filterXY(data: DataXY, filters: FilterXYType[]) {
+export function filterXY(
+  data: DataXY,
+  filters: FilterXYType[],
+): { logs: Array<{ name: string; time: number }>; data: DataXY<DoubleArray> } {
   let result = {
     data: xyGrowingX({ x: xEnsureFloat64(data.x), y: xEnsureFloat64(data.y) }),
   };

src/filters/baseline/airPLSBaseline.ts

@@ -6,10 +6,12 @@
   name: 'airPLSBaseline';
 }
 
 /**
  * @param data
  */
-export function airPLSBaseline(data: DataXY<Float64Array>) {
+export function airPLSBaseline(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   data.y = baselineFct(data.y).correctedSpectrum;
   return { data };
 }

src/filters/baseline/iterativePolynomialBaseline.ts

@@ -6,10 +6,12 @@
   name: 'iterativePolynomialBaseline';
 }
 
 /**
  * @param data
  */
-export function iterativePolynomialBaseline(data: DataXY<Float64Array>) {
+export function iterativePolynomialBaseline(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   data.y = baselineFct(data.y).correctedSpectrum;
   return { data };
 }

src/filters/baseline/rollingAverageBaseline.ts

@@ -9,7 +9,9 @@ export interface RollingAverageBaselineFilter {
 /**
  * @param data
  */
-export function rollingAverageBaseline(data: DataXY<Float64Array>) {
+export function rollingAverageBaseline(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   data.y = baselineFct(data.y).correctedSpectrum;
   return { data };
 }

src/filters/baseline/rollingBallBaseline.ts

@@ -9,7 +9,9 @@ export interface RollingBallBaselineFilter {
 /**
  * @param data
  */
-export function rollingBallBaseline(data: DataXY<Float64Array>) {
+export function rollingBallBaseline(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   data.y = baselineFct(data.y).correctedSpectrum;
   return { data };
 }

src/filters/baseline/rollingMedianBaseline.ts

@@ -9,7 +9,9 @@ export interface RollingMedianBaselineFilter {
 /**
  * @param data
  */
-export function rollingMedianBaseline(data: DataXY<Float64Array>) {
+export function rollingMedianBaseline(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   data.y = baselineFct(data.y).correctedSpectrum;
   return { data };
 }

src/filters/scaling/centerMean.ts

@@ -9,7 +9,9 @@ export interface CenterMeanFilter {
  * Center the mean
  * @param data
  */
-export function centerMean(data: DataXY<Float64Array>) {
+export function centerMean(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   const { y } = data;
   const mean = xMean(y);
   for (let i = 0; i < y.length; i++) {

src/filters/scaling/centerMedian.ts

@@ -9,7 +9,9 @@ export interface CenterMedianFilter {
  * Center the median
  * @param data
  */
-export function centerMedian(data: DataXY<Float64Array>) {
+export function centerMedian(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   const { y } = data;
   const median = xMedian(y);
   for (let i = 0; i < y.length; i++) {

src/filters/scaling/divideBySD.ts

@@ -9,7 +9,9 @@ export interface DivideBySDFilter {
  * Center the mean
  * @param data
  */
-export function divideBySD(data: DataXY<Float64Array>) {
+export function divideBySD(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   const { y } = data;
   const sd = xStandardDeviation(y);
   for (let i = 0; i < y.length; i++) {

src/filters/scaling/normed.ts

@@ -19,7 +19,7 @@ export type NormedOptions = Omit<
 export function normed(
   data: DataXY<Float64Array>,
   options: NormedOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   xNormed(data.y, { ...options, output: data.y });
   return { data };
 }

src/filters/scaling/paretoNormalization.ts

@@ -9,7 +9,9 @@ export interface ParetoNormalizationFilter {
  * Filter that allows to
  * @param data
  */
-export function paretoNormalization(data: DataXY<Float64Array>) {
+export function paretoNormalization(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array>;
+} {
   return {
     data: {
       x: data.x,

src/filters/scaling/rescale.ts

@@ -19,7 +19,7 @@ export type RescaleOptions = Omit<
 export function rescale(
   data: DataXY<Float64Array>,
   options: RescaleOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   xRescale(data.y, { ...options, output: data.y });
   return { data };
 }

src/filters/sg/firstDerivative.ts

@@ -17,7 +17,7 @@ export type FirstDerivativeOptions = Omit<SGGOptions, 'derivative'>;
 export function firstDerivative(
   data: DataXY<Float64Array>,
   options: FirstDerivativeOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { x, y } = data;
   return { data: { x, y: sgg(y, x, { ...options, derivative: 1 }) } };
 }

src/filters/sg/savitzkyGolay.ts

@@ -17,7 +17,7 @@ export type SavitzkyGolayOptions = SGGOptions;
 export function savitzkyGolay(
   data: DataXY<Float64Array>,
   options: SavitzkyGolayOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { x, y } = data;
   return { data: { x, y: sgg(y, x, options) } };
 }

src/filters/sg/secondDerivative.ts

@@ -17,7 +17,7 @@ export type SecondDerivativeOptions = Omit<SGGOptions, 'derivative'>;
 export function secondDerivative(
   data: DataXY<Float64Array>,
   options: SecondDerivativeOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { x, y } = data;
   return { data: { x, y: sgg(y, x, { ...options, derivative: 2 }) } };
 }

src/filters/sg/thirdDerivative.ts

@@ -17,7 +17,7 @@ export type ThirdDerivativeOptions = Omit<SGGOptions, 'derivative'>;
 export function thirdDerivative(
   data: DataXY<Float64Array>,
   options: ThirdDerivativeOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { x, y } = data;
   return { data: { x, y: sgg(y, x, { ...options, derivative: 3 }) } };
 }

src/filters/x/__tests__/calibrateX.test.ts

@@ -23,7 +23,7 @@ describe('calibrateX', () => {
       y: Float64Array.from([1, 1, 5, 1]),
     };
 
-    expect(() => calibrateX(data, { from: 1, to: 10 })).toThrow(
+    expect(() => calibrateX(data, { from: 1, to: 10 })).toThrowError(
       'Window size is higher than the data lengt',
     );
   });

src/filters/x/calibrateX.ts

@@ -43,7 +43,7 @@ export interface CalibrateOptions {
 export function calibrateX(
   data: DataXY<Float64Array>,
   options: CalibrateOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const {
     targetX = 0,
     nbPeaks = 1,

src/filters/x/ensureGrowing.ts

@@ -10,6 +10,8 @@ export interface EnsureGrowingFilter {
  * http://www-groups.mcs.st-andrews.ac.uk/~john/analysis/Lectures/L8.html
  * @param data
  */
-export function ensureGrowing(data: DataXY<Float64Array>) {
+export function ensureGrowing(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array | number[]>;
+} {
   return { data: xyEnsureGrowingX(data) };
 }

src/filters/x/equallySpaced.ts

@@ -42,6 +42,6 @@ export interface EquallySpacedOptions {
 export function equallySpaced(
   data: DataXY<Float64Array>,
   options: EquallySpacedOptions = {},
-) {
+): { data: DataXY<number[]> } {
   return { data: xyEquallySpaced(data, options) };
 }

src/filters/x/filterX.ts

@@ -37,7 +37,7 @@ export interface FilterXOptions {
 export function filterX(
   data: DataXY<Float64Array>,
   options: FilterXOptions = {},
-) {
+): { data: DataXY<number[]> } {
   return {
     data: xyFilterX(data, options),
   };

src/filters/x/fromTo.ts

@@ -16,7 +16,7 @@ export type FromToOptions = Parameters<typeof xGetFromToIndex>[1];
 export function fromTo(
   data: DataXY<Float64Array>,
   options: FromToOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { fromIndex, toIndex } = xGetFromToIndex(data.x, options);
   return {
     data: {

src/filters/x/reverseIfNeeded.ts

@@ -10,6 +10,8 @@ export interface ReverseIfNeededFilter {
  * http://www-groups.mcs.st-andrews.ac.uk/~john/analysis/Lectures/L8.html
  * @param data
  */
-export function reverseIfNeeded(data: DataXY<Float64Array>) {
+export function reverseIfNeeded(data: DataXY<Float64Array>): {
+  data: DataXY<Float64Array | number[]>;
+} {
   return { data: xyGrowingX(data) };
 }

src/filters/x/setMaxX.ts

@@ -20,7 +20,7 @@ export interface SetMaxXOptions {
 export function setMaxX(
   data: DataXY<Float64Array>,
   options: SetMaxXOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { max = 1 } = options;
   const existingMax = xMaxValue(data.x);
   if (existingMax === max) {

src/filters/x/setMinX.ts

@@ -20,7 +20,7 @@ export interface SetMinXOptions {
 export function setMinX(
   data: DataXY<Float64Array>,
   options: SetMinXOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { min = 0 } = options;
   const existingMin = xMinValue(data.x);
   if (existingMin === min) {

src/filters/x/xFunction.ts

@@ -23,7 +23,7 @@ export interface XFunctionOptions {
 export function xFunction(
   data: DataXY<Float64Array>,
   options: XFunctionOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   return {
     data: {
       x: xApplyFunctionStr(data.x, {

src/filters/y/setMaxY.ts

@@ -20,7 +20,7 @@ export interface SetMaxYOptions {
 export function setMaxY(
   data: DataXY<Float64Array>,
   options: SetMaxYOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { max = 1 } = options;
   const existingMax = xMaxValue(data.y);
   if (existingMax === max) {

src/filters/y/setMinY.ts

@@ -20,7 +20,7 @@ export interface SetMinYOptions {
 export function setMinY(
   data: DataXY<Float64Array>,
   options: SetMinYOptions = {},
-) {
+): { data: DataXY<Float64Array> } {
   const { min = 0 } = options;
   const existingMin = xMinValue(data.y);
   if (existingMin === min) {

src/matrixFilters/centerZMean.ts

@@ -1,4 +1,4 @@
-import type { DoubleMatrix } from 'ml-spectra-processing';
+import type { DoubleMatrix } from 'cheminfo-types';
 import { matrixCenterZMean } from 'ml-spectra-processing';
 
 export interface MatrixCenterZMeanFilter {

src/matrixFilters/pqn.ts

@@ -1,4 +1,4 @@
-import type { DoubleMatrix } from 'ml-spectra-processing';
+import type { DoubleMatrix } from 'cheminfo-types';
 import { matrixPQN } from 'ml-spectra-processing';
 
 export interface PQNFilter {

src/matrixFilters/zRescale.ts

@@ -1,4 +1,4 @@
-import type { DoubleMatrix } from 'ml-spectra-processing';
+import type { DoubleMatrix } from 'cheminfo-types';
 import { matrixZRescale } from 'ml-spectra-processing';
 
 export interface MatrixZRescaleFilter {