Setup typescript

.eslintrc.yml

@@ -1,3 +1,3 @@
-extends: cheminfo
+extends: cheminfo-typescript
 parserOptions:
   sourceType: module

.github/workflows/nodejs.yml → .github/workflows/nodejs-ts.yml

@@ -10,3 +10,5 @@ jobs:
   nodejs:
     # Documentation: https://github.com/zakodium/workflows#nodejs-ci
     uses: zakodium/workflows/.github/workflows/nodejs.yml@nodejs-v1
+    with:
+      lint-check-types: true

.gitignore

@@ -36,4 +36,5 @@ jspm_packages
 # Optional REPL history
 .node_repl_history
 
-lib
+lib
+lib-esm

babel.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  "presets": ["@babel/preset-typescript"],
+  "plugins": ["@babel/plugin-transform-modules-commonjs"]
+}

package.json

@@ -2,23 +2,27 @@
   "name": "ml-tree-similarity",
   "version": "2.1.0",
   "description": "Compares two spectra using a tree similarity",
-  "main": "lib/index.js",
-  "module": "src/index.js",
-  "types": "tree-similarity.d.ts",
+  "main": "./lib/index.js",
+  "module": "./lib-esm/index.js",
+  "types": "./lib/index.d.ts",
   "files": [
     "lib",
     "src",
-    "tree-similarity.d.ts"
+    "lib-esm"
   ],
   "scripts": {
-    "compile": "rollup -c",
+    "check-types": "tsc --noEmit",
+    "clean": "rimraf lib lib-esm",
     "eslint": "eslint src",
     "eslint-fix": "npm run eslint -- --fix",
-    "prepack": "npm run compile",
+    "prepack": "npm run tsc",
     "prettier": "prettier --check src",
     "prettier-write": "prettier --write src",
-    "test": "npm run test-only && npm run eslint && npm run prettier",
-    "test-only": "vitest run --coverage"
+    "test": "npm run test-only && npm run eslint && npm run prettier && npm run check-types",
+    "test-only": "vitest run --coverage",
+    "tsc": "npm run clean && npm run tsc-cjs && npm run tsc-esm",
+    "tsc-cjs": "tsc --project tsconfig.cjs.json",
+    "tsc-esm": "tsc --project tsconfig.esm.json"
   },
   "repository": {
     "type": "git",
@@ -33,11 +37,13 @@
   "homepage": "https://github.com/mljs/tree-similarity#readme",
   "devDependencies": {
     "@babel/plugin-transform-modules-commonjs": "^7.23.3",
+    "@babel/preset-typescript": "^7.23.3",
     "@vitest/coverage-v8": "^1.2.2",
     "eslint": "^8.56.0",
-    "eslint-config-cheminfo": "^9.1.1",
+    "eslint-config-cheminfo-typescript": "^12.2.0",
     "prettier": "^3.2.5",
-    "rollup": "^4.9.6",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3",
     "vitest": "^1.2.2"
   },
   "dependencies": {

src/__tests__/compressTree.test.js → src/__tests__/compressTree.test.ts

@@ -1,12 +1,12 @@
 import { test, expect } from 'vitest';
 
 import { compressTree } from '../compressTree';
-import { createTree } from '../createTree';
+import { Tree, createTree } from '../createTree';
 
 test('compressTree', () => {
-  let x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-  let y = [0, 1, 2, 3, 0, 0, 0, 1, 0, 0, 0];
-  let tree = createTree({ x, y });
+  const x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+  const y = [0, 1, 2, 3, 0, 0, 0, 1, 0, 0, 0];
+  const tree = createTree({ x, y }) as Tree;
 
   expect(compressTree(tree, { fixed: 3 })).toStrictEqual({
     sum: 7,

src/__tests__/createTree.test.js → src/__tests__/createTree.test.ts

@@ -1,51 +1,55 @@
 import { describe, it, expect } from 'vitest';
 
-import { createTree } from '../createTree';
+import { Tree, createTree } from '../createTree';
 
 describe('simple trees', () => {
   it('two peaks, same height', () => {
-    let x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    let y = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
-    let tree = createTree({ x, y });
+    const x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    const y = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
+    const tree = createTree({ x, y }) as Tree;
 
     expect(tree.center).toBe(5);
     expect(tree.sum).toBe(2);
 
-    let left = tree.left;
+    const left = tree.left as Tree;
+    expect(left).not.toBe(null);
     expect(left.center).toBe(3);
     expect(left.sum).toBe(1);
     expect(left.left).toStrictEqual(null);
     expect(left.right).toStrictEqual(null);
 
-    let right = tree.right;
+    const right = tree.right as Tree;
+    expect(right).not.toBe(null);
     expect(right.center).toBe(7);
     expect(right.sum).toBe(1);
     expect(right.left).toStrictEqual(null);
     expect(right.right).toStrictEqual(null);
   });
 
   it('two peaks, same height (higher)', () => {
-    let x = new Array(101);
-    let y = new Array(101);
+    const x = new Array(101);
+    const y = new Array(101);
     for (let i = 0; i < 101; i++) {
       x[i] = i;
       y[i] = 0;
     }
     y[20] = 20;
     y[80] = 20;
 
-    let tree = createTree({ x, y });
+    const tree = createTree({ x, y }) as Tree;
 
     expect(tree.center).toBe(50);
     expect(tree.sum).toBe(40);
 
-    let left = tree.left;
+    const left = tree.left as Tree;
+    expect(left).not.toBe(null);
     expect(left.center).toBe(20);
     expect(left.sum).toBe(20);
     expect(left.left).toStrictEqual(null);
     expect(left.right).toStrictEqual(null);
 
-    let right = tree.right;
+    const right = tree.right as Tree;
+    expect(right).not.toBe(null);
     expect(right.center).toBe(80);
     expect(right.sum).toBe(20);
     expect(right.left).toStrictEqual(null);

src/__tests__/tree.test.js → src/__tests__/tree.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 
-import { createTree, treeSimilarity } from '../index';
+import { Tree, createTree, treeSimilarity } from '../index';
 
 const a = {
   x: [1, 2, 3, 4, 5, 6, 7],
@@ -18,4 +18,9 @@ describe('Tree similarity', () => {
       4,
     );
   });
+  it('should throw with wrong input', () => {
+    expect(() => treeSimilarity(createTree(a), {} as Tree)).toThrow(
+      'tree similarity expects tree as inputs',
+    );
+  });
 });

src/__tests__/treeSimilarity.test.js → src/__tests__/treeSimilarity.test.ts

@@ -5,10 +5,10 @@ import { treeSimilarity } from '../treeSimilarity';
 
 describe('simple trees', () => {
   it('same tree', () => {
-    let x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    let y = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
-    let tree1 = createTree({ x, y });
-    let tree2 = createTree({ x, y });
+    const x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    const y = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
+    const tree1 = createTree({ x, y });
+    const tree2 = createTree({ x, y });
 
     expect(treeSimilarity(tree1, tree2, { beta: 1 })).toBe(1);
   });

src/compressTree.js → src/compressTree.ts

@@ -1,12 +1,15 @@
+import { Tree } from './createTree';
+
 /**
  * Destructive compression in which we reduce the number of decimals
- * @param {object} tree
- * @param {object} [options={}]
- * @param {number} [options.fixed=undefined] - number of decimal ot keep
- * @returns
  */
-
-export function compressTree(tree, options = {}) {
+export function compressTree(
+  tree: Tree,
+  options: {
+    // number of decimal ot keep
+    fixed?: number;
+  } = {},
+): Tree {
   const { fixed } = options;
   return JSON.parse(
     JSON.stringify(tree, (key, value) => {

src/createTree.js → src/createTree.ts

@@ -1,19 +1,49 @@
 import binarySearch from 'binary-search';
+import { DataXY } from 'cheminfo-types';
 
-/**
- * @typedef {import("../tree-similarity").Tree} Tree
- * @typedef {import("../tree-similarity").CreateTreeOptions} CreateTreeOptions
- * @typedef {import("../tree-similarity").Spectrum} Spectrum
- */
+export interface Tree {
+  sum: number;
+  center: number;
+  /**
+   * left and right have the same structure than the parent,
+   * or are null if they are leaves
+   */
+  left: Tree | null;
+  right: Tree | null;
+}
+
+export interface CreateTreeOptions {
+  /**
+   * low limit of the tree
+   * @default x[0]
+   */
+  from?: number;
+  /**
+   * high limit of the tree
+   * @default x.at(-1)
+   */
+  to?: number;
+  /**
+   * minimal sum value to accept a node
+   * @default 0.01
+   */
+  threshold?: number;
+  /**
+   * minimal window width to create a node
+   * @default 0.16
+   */
+  minWindow?: number;
+}
 
 /**
  * Function that creates the tree
- * @param {Spectrum} spectrum
- * @param {CreateTreeOptions} [options]
- * @return { Tree | null }
  */
-export function createTree(spectrum, options = {}) {
-  const { x, y } = spectrum;
+
+export function createTree(
+  dataXY: DataXY,
+  options: CreateTreeOptions = {},
+): Tree | null {
+  const { x, y } = dataXY;
   const {
     minWindow = 0.16,
     threshold = 0.01,
@@ -30,7 +60,7 @@ function mainCreateTree(x, y, from, to, minWindow, threshold) {
   }
 
   // search first point
-  let start = binarySearch(x, from, (a, b) => a - b);
+  let start = binarySearch(x, from, (a: number, b: number) => a - b);
   if (start < 0) {
     start = ~start;
   }

src/index.ts

@@ -0,0 +1,3 @@
+export * from './treeSimilarity';
+export * from './createTree';
+export { compressTree } from './compressTree';

src/treeSimilarity.ts

@@ -0,0 +1,47 @@
+import { Tree } from './createTree';
+
+export interface TreeSimilarityOptions {
+  alpha?: number;
+  beta?: number;
+  gamma?: number;
+}
+
+/**
+ * Similarity between two nodes
+ * @return similarity measure between tree nodes
+ */
+export function treeSimilarity(
+  treeA: Tree | null,
+  treeB: Tree | null,
+  options: TreeSimilarityOptions = {},
+): number {
+  const { alpha = 0.1, beta = 0.33, gamma = 0.001 } = options;
+
+  if (treeA === null || treeB === null) {
+    return 0;
+  }
+
+  if (!isTree(treeA) || !isTree(treeB)) {
+    throw new Error('tree similarity expects tree as inputs');
+  }
+
+  if (treeA.sum === 0 && treeB.sum === 0) {
+    return 1;
+  }
+
+  const C =
+    (alpha * Math.min(treeA.sum, treeB.sum)) / Math.max(treeA.sum, treeB.sum) +
+    (1 - alpha) * Math.exp(-gamma * Math.abs(treeA.center - treeB.center));
+
+  return (
+    beta * C +
+    ((1 - beta) *
+      (treeSimilarity(treeA.left, treeB.left, options) +
+        treeSimilarity(treeA.right, treeB.right, options))) /
+      2
+  );
+}
+
+function isTree(tree: object): tree is Tree {
+  return ['sum', 'center', 'left', 'right'].every((key) => key in tree);
+}