@kent-tokyo/chematic 0.1.3 → 0.1.5

package/README.md

@@ -2,38 +2,66 @@
 
 WebAssembly bindings for [chematic](https://github.com/kent-tokyo/chematic), a pure-Rust cheminformatics library.
 
-This crate exposes `#[wasm_bindgen]` bindings so that chematic can be used directly from JavaScript and TypeScript in the browser or Node.js.
+Published to npm as [`@kent-tokyo/chematic`](https://www.npmjs.com/package/@kent-tokyo/chematic).
+
+## Installation
+
+```sh
+npm install @kent-tokyo/chematic
+```
 
 ## Features
 
 - Parse SMILES strings into molecule handles
-- Compute molecular descriptors: molecular weight, TPSA, formula, heavy atom count, H-bond donors/acceptors
+- Molecular descriptors: MW, TPSA, LogP, Fsp3, QED, exact mass, rotatable bonds, HBD/HBA, aromatic ring count
 - Lipinski Rule-of-Five check
 - Canonical SMILES generation
-- ECFP4 fingerprints and Tanimoto similarity
+- ECFP4, AtomPair, and Topological Torsion fingerprints with Tanimoto similarity
+- BRICS fragment count
 
 ## Usage
 
-Build with [wasm-pack](https://rustwasm.github.io/wasm-pack/):
+```js
+import init, {
+  parse_smiles,
+  tanimoto_ecfp4,
+  tanimoto_atom_pair,
+  tanimoto_torsion,
+  brics_fragment_count,
+} from '@kent-tokyo/chematic';
 
-```sh
-wasm-pack build --target web
-```
+await init();
 
-Then in JavaScript/TypeScript:
+const mol = parse_smiles('CC(=O)Oc1ccccc1C(=O)O'); // aspirin
 
-```js
-import init, { parse_smiles, tanimoto_ecfp4 } from './pkg/chematic_wasm.js';
+// Descriptors
+console.log(mol.atom_count());          // 13
+console.log(mol.molecular_weight());    // ~180.16
+console.log(mol.formula());             // "C9H8O4"
+console.log(mol.tpsa());               // ~63.6
+console.log(mol.logp_crippen());        // ~1.2
+console.log(mol.fsp3());               // ~0.111
+console.log(mol.qed());                // drug-likeness score [0, 1]
+console.log(mol.exact_mass());         // ~180.042
+console.log(mol.hbd_count());          // 1
+console.log(mol.hba_count());          // 4
+console.log(mol.rotatable_bond_count()); // 3
+console.log(mol.aromatic_ring_count()); // 1
+console.log(mol.lipinski_passes());     // true
+console.log(mol.canonical_smiles());    // canonical SMILES string
 
-await init();
+// BRICS fragmentation
+console.log(brics_fragment_count(mol)); // ≥ 2
 
-const mol = parse_smiles('c1ccccc1');
-console.log(mol.atom_count());       // 6
-console.log(mol.molecular_weight()); // ~78.11
-console.log(mol.formula());          // "C6H6"
-console.log(mol.lipinski_passes());  // true
+// Fingerprint similarity
+const caffeine = parse_smiles('Cn1cnc2c1c(=O)n(c(=O)n2C)C');
+console.log(tanimoto_ecfp4(mol, caffeine));    // ECFP4 Tanimoto
+console.log(tanimoto_atom_pair(mol, caffeine)); // AtomPair Tanimoto
+console.log(tanimoto_torsion(mol, caffeine));   // Torsion Tanimoto
+```
+
+## Building from source
 
-const aspirin = parse_smiles('CC(=O)Oc1ccccc1C(=O)O');
-const sim = tanimoto_ecfp4(mol, aspirin);
-console.log(sim); // < 1.0
+```sh
+wasm-pack build --target bundler --release
 ```

package/chematic_wasm.d.ts

@@ -9,6 +9,10 @@ export class MolHandle {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Number of aromatic rings (all ring atoms aromatic).
+     */
+    aromatic_ring_count(): number;
     /**
      * Number of heavy atoms (explicit atoms in the graph; does not count implicit H).
      */
@@ -21,10 +25,36 @@ export class MolHandle {
      * Canonical SMILES string.
      */
     canonical_smiles(): string;
+    /**
+     * 2D SVG depiction of the molecule (CPK coloring).
+     */
+    depict_svg(): string;
+    /**
+     * Returns `true` if the molecule passes Egan's absorption criteria
+     * (TPSA ≤ 131.6 Ų and LogP ≤ 5.88).
+     */
+    egan_passes(): boolean;
+    /**
+     * Monoisotopic (exact) mass.
+     */
+    exact_mass(): number;
+    /**
+     * Sum of formal charges.
+     */
+    formal_charge_sum(): number;
     /**
      * Molecular formula string (Hill notation: C first, H second, then alphabetical).
      */
     formula(): string;
+    /**
+     * Fraction of sp3 carbons (Fsp3).
+     */
+    fsp3(): number;
+    /**
+     * Returns `true` if the molecule passes Ghose's drug-likeness filter
+     * (MW 160–480, LogP −0.4–5.6, HeavyAtoms 20–70, MR 40–130).
+     */
+    ghose_passes(): boolean;
     /**
      * Number of hydrogen bond acceptors (Lipinski: all N and O atoms).
      */
@@ -41,16 +71,84 @@ export class MolHandle {
      * Returns `true` if the molecule satisfies Lipinski's Rule of Five.
      */
     lipinski_passes(): boolean;
+    /**
+     * Crippen–Wildman octanol/water partition coefficient (LogP).
+     */
+    logp_crippen(): number;
+    /**
+     * Wildman–Crippen molar refractivity (MR).
+     */
+    molar_refractivity(): number;
     /**
      * Average molecular weight (Da).
      */
     molecular_weight(): number;
+    /**
+     * Number of non-aromatic rings containing at least one heteroatom.
+     */
+    num_aliphatic_heterocycles(): number;
+    /**
+     * Number of aromatic rings containing at least one heteroatom (N, O, S, …).
+     */
+    num_aromatic_heterocycles(): number;
+    /**
+     * Number of bridgehead atoms (shared by ≥2 rings with ≥3 ring bonds).
+     */
+    num_bridgehead_atoms(): number;
+    /**
+     * Number of heteroatoms (non-C, non-H heavy atoms).
+     */
+    num_heteroatoms(): number;
+    /**
+     * Number of fully saturated rings containing at least one heteroatom.
+     */
+    num_saturated_heterocycles(): number;
+    /**
+     * Number of spiro atoms (sole shared atom between exactly 2 rings).
+     */
+    num_spiro_atoms(): number;
+    /**
+     * Number of assigned stereocenters (R/S).
+     */
+    num_stereocenters(): number;
+    /**
+     * Returns `true` if the molecule has no PAINS structural alerts.
+     */
+    pains_passes(): boolean;
+    /**
+     * Quantitative Estimate of Drug-likeness (QED); range [0, 1].
+     */
+    qed(): number;
+    /**
+     * Returns `true` if the molecule passes the REOS (Rapid Elimination Of Swill) filter.
+     */
+    reos_passes(): boolean;
+    /**
+     * Total number of rings (SSSR count).
+     */
+    ring_count(): number;
+    /**
+     * Number of rotatable bonds.
+     */
+    rotatable_bond_count(): number;
     /**
      * Topological polar surface area (Ų).
      */
     tpsa(): number;
+    /**
+     * Returns `true` if the molecule passes Veber's oral bioavailability criteria
+     * (TPSA ≤ 140 Ų and rotatable bonds ≤ 10).
+     */
+    veber_passes(): boolean;
 }
 
+/**
+ * Number of BRICS fragments produced by fragmenting the molecule.
+ *
+ * Returns 1 if no BRICS-breakable bonds exist (whole molecule is one fragment).
+ */
+export function brics_fragment_count(mol: MolHandle): number;
+
 /**
  * Compute the ECFP4 fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  */
@@ -63,7 +161,22 @@ export function ecfp4_bitvec(mol: MolHandle): Uint8Array;
  */
 export function parse_smiles(s: string): MolHandle;
 
+/**
+ * Tanimoto similarity between two molecules using AtomPair fingerprints.
+ */
+export function tanimoto_atom_pair(a: MolHandle, b: MolHandle): number;
+
 /**
  * Tanimoto similarity between two molecules using ECFP4 fingerprints.
  */
 export function tanimoto_ecfp4(a: MolHandle, b: MolHandle): number;
+
+/**
+ * Tanimoto similarity between two molecules using FCFP4 fingerprints (pharmacophore-based).
+ */
+export function tanimoto_fcfp4(a: MolHandle, b: MolHandle): number;
+
+/**
+ * Tanimoto similarity between two molecules using Topological Torsion fingerprints.
+ */
+export function tanimoto_torsion(a: MolHandle, b: MolHandle): number;

package/chematic_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./chematic_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    MolHandle, ecfp4_bitvec, parse_smiles, tanimoto_ecfp4
+    MolHandle, brics_fragment_count, ecfp4_bitvec, parse_smiles, tanimoto_atom_pair, tanimoto_ecfp4, tanimoto_fcfp4, tanimoto_torsion
 } from "./chematic_wasm_bg.js";

package/chematic_wasm_bg.js

@@ -19,6 +19,14 @@ export class MolHandle {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_molhandle_free(ptr, 0);
     }
+    /**
+     * Number of aromatic rings (all ring atoms aromatic).
+     * @returns {number}
+     */
+    aromatic_ring_count() {
+        const ret = wasm.molhandle_aromatic_ring_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Number of heavy atoms (explicit atoms in the graph; does not count implicit H).
      * @returns {number}
@@ -51,6 +59,47 @@ export class MolHandle {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * 2D SVG depiction of the molecule (CPK coloring).
+     * @returns {string}
+     */
+    depict_svg() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.molhandle_depict_svg(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns `true` if the molecule passes Egan's absorption criteria
+     * (TPSA ≤ 131.6 Ų and LogP ≤ 5.88).
+     * @returns {boolean}
+     */
+    egan_passes() {
+        const ret = wasm.molhandle_egan_passes(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Monoisotopic (exact) mass.
+     * @returns {number}
+     */
+    exact_mass() {
+        const ret = wasm.molhandle_exact_mass(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sum of formal charges.
+     * @returns {number}
+     */
+    formal_charge_sum() {
+        const ret = wasm.molhandle_formal_charge_sum(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Molecular formula string (Hill notation: C first, H second, then alphabetical).
      * @returns {string}
@@ -67,6 +116,23 @@ export class MolHandle {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Fraction of sp3 carbons (Fsp3).
+     * @returns {number}
+     */
+    fsp3() {
+        const ret = wasm.molhandle_fsp3(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns `true` if the molecule passes Ghose's drug-likeness filter
+     * (MW 160–480, LogP −0.4–5.6, HeavyAtoms 20–70, MR 40–130).
+     * @returns {boolean}
+     */
+    ghose_passes() {
+        const ret = wasm.molhandle_ghose_passes(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Number of hydrogen bond acceptors (Lipinski: all N and O atoms).
      * @returns {number}
@@ -99,6 +165,22 @@ export class MolHandle {
         const ret = wasm.molhandle_lipinski_passes(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Crippen–Wildman octanol/water partition coefficient (LogP).
+     * @returns {number}
+     */
+    logp_crippen() {
+        const ret = wasm.molhandle_logp_crippen(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Wildman–Crippen molar refractivity (MR).
+     * @returns {number}
+     */
+    molar_refractivity() {
+        const ret = wasm.molhandle_molar_refractivity(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Average molecular weight (Da).
      * @returns {number}
@@ -107,6 +189,102 @@ export class MolHandle {
         const ret = wasm.molhandle_molecular_weight(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Number of non-aromatic rings containing at least one heteroatom.
+     * @returns {number}
+     */
+    num_aliphatic_heterocycles() {
+        const ret = wasm.molhandle_num_aliphatic_heterocycles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of aromatic rings containing at least one heteroatom (N, O, S, …).
+     * @returns {number}
+     */
+    num_aromatic_heterocycles() {
+        const ret = wasm.molhandle_num_aromatic_heterocycles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of bridgehead atoms (shared by ≥2 rings with ≥3 ring bonds).
+     * @returns {number}
+     */
+    num_bridgehead_atoms() {
+        const ret = wasm.molhandle_num_bridgehead_atoms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of heteroatoms (non-C, non-H heavy atoms).
+     * @returns {number}
+     */
+    num_heteroatoms() {
+        const ret = wasm.molhandle_num_heteroatoms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of fully saturated rings containing at least one heteroatom.
+     * @returns {number}
+     */
+    num_saturated_heterocycles() {
+        const ret = wasm.molhandle_num_saturated_heterocycles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of spiro atoms (sole shared atom between exactly 2 rings).
+     * @returns {number}
+     */
+    num_spiro_atoms() {
+        const ret = wasm.molhandle_num_spiro_atoms(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of assigned stereocenters (R/S).
+     * @returns {number}
+     */
+    num_stereocenters() {
+        const ret = wasm.molhandle_num_stereocenters(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Returns `true` if the molecule has no PAINS structural alerts.
+     * @returns {boolean}
+     */
+    pains_passes() {
+        const ret = wasm.molhandle_pains_passes(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Quantitative Estimate of Drug-likeness (QED); range [0, 1].
+     * @returns {number}
+     */
+    qed() {
+        const ret = wasm.molhandle_qed(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns `true` if the molecule passes the REOS (Rapid Elimination Of Swill) filter.
+     * @returns {boolean}
+     */
+    reos_passes() {
+        const ret = wasm.molhandle_reos_passes(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Total number of rings (SSSR count).
+     * @returns {number}
+     */
+    ring_count() {
+        const ret = wasm.molhandle_ring_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of rotatable bonds.
+     * @returns {number}
+     */
+    rotatable_bond_count() {
+        const ret = wasm.molhandle_rotatable_bond_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Topological polar surface area (Ų).
      * @returns {number}
@@ -115,9 +293,31 @@ export class MolHandle {
         const ret = wasm.molhandle_tpsa(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Returns `true` if the molecule passes Veber's oral bioavailability criteria
+     * (TPSA ≤ 140 Ų and rotatable bonds ≤ 10).
+     * @returns {boolean}
+     */
+    veber_passes() {
+        const ret = wasm.molhandle_veber_passes(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) MolHandle.prototype[Symbol.dispose] = MolHandle.prototype.free;
 
+/**
+ * Number of BRICS fragments produced by fragmenting the molecule.
+ *
+ * Returns 1 if no BRICS-breakable bonds exist (whole molecule is one fragment).
+ * @param {MolHandle} mol
+ * @returns {number}
+ */
+export function brics_fragment_count(mol) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.brics_fragment_count(mol.__wbg_ptr);
+    return ret >>> 0;
+}
+
 /**
  * Compute the ECFP4 fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  * @param {MolHandle} mol
@@ -148,6 +348,19 @@ export function parse_smiles(s) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Tanimoto similarity between two molecules using AtomPair fingerprints.
+ * @param {MolHandle} a
+ * @param {MolHandle} b
+ * @returns {number}
+ */
+export function tanimoto_atom_pair(a, b) {
+    _assertClass(a, MolHandle);
+    _assertClass(b, MolHandle);
+    const ret = wasm.tanimoto_atom_pair(a.__wbg_ptr, b.__wbg_ptr);
+    return ret;
+}
+
 /**
  * Tanimoto similarity between two molecules using ECFP4 fingerprints.
  * @param {MolHandle} a
@@ -160,6 +373,32 @@ export function tanimoto_ecfp4(a, b) {
     const ret = wasm.tanimoto_ecfp4(a.__wbg_ptr, b.__wbg_ptr);
     return ret;
 }
+
+/**
+ * Tanimoto similarity between two molecules using FCFP4 fingerprints (pharmacophore-based).
+ * @param {MolHandle} a
+ * @param {MolHandle} b
+ * @returns {number}
+ */
+export function tanimoto_fcfp4(a, b) {
+    _assertClass(a, MolHandle);
+    _assertClass(b, MolHandle);
+    const ret = wasm.tanimoto_fcfp4(a.__wbg_ptr, b.__wbg_ptr);
+    return ret;
+}
+
+/**
+ * Tanimoto similarity between two molecules using Topological Torsion fingerprints.
+ * @param {MolHandle} a
+ * @param {MolHandle} b
+ * @returns {number}
+ */
+export function tanimoto_torsion(a, b) {
+    _assertClass(a, MolHandle);
+    _assertClass(b, MolHandle);
+    const ret = wasm.tanimoto_torsion(a.__wbg_ptr, b.__wbg_ptr);
+    return ret;
+}
 export function __wbg___wbindgen_throw_1506f2235d1bdba0(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }

package/package.json

@@ -5,7 +5,7 @@
     "kent-tokyo <kent-tokyo@users.noreply.github.com>"
   ],
   "description": "WebAssembly bindings for chematic — use chematic from JavaScript/TypeScript",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
@@ -26,11 +26,9 @@
   ],
   "keywords": [
     "cheminformatics",
-    "chemistry",
-    "smiles",
     "wasm",
-    "rdkit",
-    "fingerprints",
-    "tanimoto"
+    "webassembly",
+    "smiles",
+    "chemistry"
   ]
 }