@kent-tokyo/chematic 0.1.5 → 0.1.10

package/chematic_wasm.d.ts

@@ -1,6 +1,35 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * Style options for [`MolHandle::depict_svg_opts`].
+ *
+ * Construct with `new DepictOptions()`, then call setters:
+ * ```js
+ * const opts = new DepictOptions();
+ * opts.set_background("transparent");
+ * opts.set_dark(true);
+ * opts.set_width(240);
+ * opts.set_height(240);
+ * ```
+ */
+export class DepictOptions {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor();
+    set_atom_ids(v: boolean): void;
+    set_background(bg: string): void;
+    set_dark(dark: boolean): void;
+    set_height(h: number): void;
+    set_highlight_atoms(atoms: Uint32Array): void;
+    set_highlight_bonds(bonds: Uint32Array): void;
+    set_highlight_color(color: string): void;
+    set_kekulize(v: boolean): void;
+    set_padding(p: number): void;
+    set_show_atom_indices(v: boolean): void;
+    set_width(w: number): void;
+}
+
 /**
  * A handle to a parsed molecule.  Owns the molecule behind an `Rc` so that
  * it can be cheaply cloned on the JS side without copying atom/bond data.
@@ -17,6 +46,10 @@ export class MolHandle {
      * Number of heavy atoms (explicit atoms in the graph; does not count implicit H).
      */
     atom_count(): number;
+    /**
+     * Bertz complexity index (BertzCT).
+     */
+    bertz_ct(): number;
     /**
      * Number of bonds.
      */
@@ -25,10 +58,54 @@ export class MolHandle {
      * Canonical SMILES string.
      */
     canonical_smiles(): string;
+    /**
+     * Kier–Hall χ0 molecular connectivity index.
+     */
+    chi0(): number;
+    /**
+     * Kier–Hall χ0v valence-weighted connectivity index.
+     */
+    chi0v(): number;
+    /**
+     * Kier–Hall χ1 molecular connectivity index.
+     */
+    chi1(): number;
+    /**
+     * Kier–Hall χ1v valence-weighted connectivity index.
+     */
+    chi1v(): number;
+    /**
+     * Kier–Hall χ2 molecular connectivity index.
+     */
+    chi2(): number;
+    /**
+     * Kier–Hall χ2v valence-weighted connectivity index.
+     */
+    chi2v(): number;
+    /**
+     * Kier–Hall χ3 molecular connectivity index.
+     */
+    chi3(): number;
+    /**
+     * Kier–Hall χ3v valence-weighted connectivity index.
+     */
+    chi3v(): number;
+    /**
+     * Kier–Hall χ4 molecular connectivity index.
+     */
+    chi4(): number;
+    /**
+     * Kier–Hall χ4v valence-weighted connectivity index.
+     */
+    chi4v(): number;
     /**
      * 2D SVG depiction of the molecule (CPK coloring).
      */
     depict_svg(): string;
+    /**
+     * 2D SVG depiction with style options.
+     */
+    depict_svg_opts(opts: DepictOptions): string;
     /**
      * Returns `true` if the molecule passes Egan's absorption criteria
      * (TPSA ≤ 131.6 Ų and LogP ≤ 5.88).
@@ -67,6 +144,22 @@ export class MolHandle {
      * Number of non-hydrogen heavy atoms.
      */
     heavy_atom_count(): number;
+    /**
+     * Hall–Kier κ1 shape index.
+     */
+    kappa1(): number;
+    /**
+     * Hall–Kier κ2 shape index.
+     */
+    kappa2(): number;
+    /**
+     * Hall–Kier κ3 shape index.
+     */
+    kappa3(): number;
+    /**
+     * Labute approximate surface area (Ų).
+     */
+    labute_asa(): number;
     /**
      * Returns `true` if the molecule satisfies Lipinski's Rule of Five.
      */
@@ -83,6 +176,12 @@ export class MolHandle {
      * Average molecular weight (Da).
      */
     molecular_weight(): number;
+    /**
+     * Morgan count fingerprint as a JSON object string (`{"<hash>": count, …}`).
+     *
+     * `radius` controls the ECFP radius (2 = ECFP4-equivalent).
+     */
+    morgan_fp_counts_json(radius: number): string;
     /**
      * Number of non-aromatic rings containing at least one heteroatom.
      */
@@ -140,8 +239,17 @@ export class MolHandle {
      * (TPSA ≤ 140 Ų and rotatable bonds ≤ 10).
      */
     veber_passes(): boolean;
+    /**
+     * Wiener topological index (sum of all pairwise shortest-path distances).
+     */
+    wiener_index(): number;
 }
 
+/**
+ * Return a copy of the molecule with all implicit hydrogens converted to explicit H atoms.
+ */
+export function add_hydrogens(mol: MolHandle): MolHandle;
+
 /**
  * Number of BRICS fragments produced by fragmenting the molecule.
  *
@@ -149,11 +257,24 @@ export class MolHandle {
  */
 export function brics_fragment_count(mol: MolHandle): number;
 
+/**
+ * Render a grid SVG from newline-separated SMILES (one per line).
+ *
+ * Lines that fail to parse are silently skipped.
+ * `cols` controls the number of columns (each cell is 200×200 px).
+ */
+export function depict_svg_grid(smiles_block: string, cols: number): string;
+
 /**
  * Compute the ECFP4 fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  */
 export function ecfp4_bitvec(mol: MolHandle): Uint8Array;
 
+/**
+ * Returns `true` if the SMILES string can be parsed without error.
+ */
+export function is_valid_smiles(s: string): boolean;
+
 /**
  * Parse a SMILES string into a `MolHandle`.
  *
@@ -161,6 +282,20 @@ export function ecfp4_bitvec(mol: MolHandle): Uint8Array;
  */
 export function parse_smiles(s: string): MolHandle;
 
+/**
+ * Return a copy of the molecule with all explicit hydrogen atoms removed.
+ */
+export function remove_hydrogens(mol: MolHandle): MolHandle;
+
+/**
+ * Apply a SMIRKS reaction template and return product SMILES as a JSON string.
+ *
+ * `reactants_smiles`: pipe-separated SMILES, one per reactant slot in the SMIRKS.
+ * Returns a JSON array of arrays: `[["product_smi", …], …]`.
+ * Returns a JS error on parse failure or arity mismatch.
+ */
+export function run_reactants(smirks: string, reactants_smiles: string): string;
+
 /**
  * Tanimoto similarity between two molecules using AtomPair fingerprints.
  */

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, brics_fragment_count, ecfp4_bitvec, parse_smiles, tanimoto_atom_pair, tanimoto_ecfp4, tanimoto_fcfp4, tanimoto_torsion
+    DepictOptions, MolHandle, add_hydrogens, brics_fragment_count, depict_svg_grid, ecfp4_bitvec, is_valid_smiles, parse_smiles, remove_hydrogens, run_reactants, tanimoto_atom_pair, tanimoto_ecfp4, tanimoto_fcfp4, tanimoto_torsion
 } from "./chematic_wasm_bg.js";

package/chematic_wasm_bg.js

@@ -1,3 +1,109 @@
+/**
+ * Style options for [`MolHandle::depict_svg_opts`].
+ *
+ * Construct with `new DepictOptions()`, then call setters:
+ * ```js
+ * const opts = new DepictOptions();
+ * opts.set_background("transparent");
+ * opts.set_dark(true);
+ * opts.set_width(240);
+ * opts.set_height(240);
+ * ```
+ */
+export class DepictOptions {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DepictOptionsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_depictoptions_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.depictoptions_new();
+        this.__wbg_ptr = ret;
+        DepictOptionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {boolean} v
+     */
+    set_atom_ids(v) {
+        wasm.depictoptions_set_atom_ids(this.__wbg_ptr, v);
+    }
+    /**
+     * @param {string} bg
+     */
+    set_background(bg) {
+        const ptr0 = passStringToWasm0(bg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.depictoptions_set_background(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} dark
+     */
+    set_dark(dark) {
+        wasm.depictoptions_set_dark(this.__wbg_ptr, dark);
+    }
+    /**
+     * @param {number} h
+     */
+    set_height(h) {
+        wasm.depictoptions_set_height(this.__wbg_ptr, h);
+    }
+    /**
+     * @param {Uint32Array} atoms
+     */
+    set_highlight_atoms(atoms) {
+        const ptr0 = passArray32ToWasm0(atoms, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.depictoptions_set_highlight_atoms(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {Uint32Array} bonds
+     */
+    set_highlight_bonds(bonds) {
+        const ptr0 = passArray32ToWasm0(bonds, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.depictoptions_set_highlight_bonds(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {string} color
+     */
+    set_highlight_color(color) {
+        const ptr0 = passStringToWasm0(color, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.depictoptions_set_highlight_color(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {boolean} v
+     */
+    set_kekulize(v) {
+        wasm.depictoptions_set_kekulize(this.__wbg_ptr, v);
+    }
+    /**
+     * @param {number} p
+     */
+    set_padding(p) {
+        wasm.depictoptions_set_padding(this.__wbg_ptr, p);
+    }
+    /**
+     * @param {boolean} v
+     */
+    set_show_atom_indices(v) {
+        wasm.depictoptions_set_show_atom_indices(this.__wbg_ptr, v);
+    }
+    /**
+     * @param {number} w
+     */
+    set_width(w) {
+        wasm.depictoptions_set_width(this.__wbg_ptr, w);
+    }
+}
+if (Symbol.dispose) DepictOptions.prototype[Symbol.dispose] = DepictOptions.prototype.free;
+
 /**
  * A handle to a parsed molecule.  Owns the molecule behind an `Rc` so that
  * it can be cheaply cloned on the JS side without copying atom/bond data.
@@ -35,6 +141,14 @@ export class MolHandle {
         const ret = wasm.molhandle_atom_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Bertz complexity index (BertzCT).
+     * @returns {number}
+     */
+    bertz_ct() {
+        const ret = wasm.molhandle_bertz_ct(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Number of bonds.
      * @returns {number}
@@ -59,6 +173,86 @@ export class MolHandle {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Kier–Hall χ0 molecular connectivity index.
+     * @returns {number}
+     */
+    chi0() {
+        const ret = wasm.molhandle_chi0(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ0v valence-weighted connectivity index.
+     * @returns {number}
+     */
+    chi0v() {
+        const ret = wasm.molhandle_chi0v(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ1 molecular connectivity index.
+     * @returns {number}
+     */
+    chi1() {
+        const ret = wasm.molhandle_chi1(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ1v valence-weighted connectivity index.
+     * @returns {number}
+     */
+    chi1v() {
+        const ret = wasm.molhandle_chi1v(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ2 molecular connectivity index.
+     * @returns {number}
+     */
+    chi2() {
+        const ret = wasm.molhandle_chi2(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ2v valence-weighted connectivity index.
+     * @returns {number}
+     */
+    chi2v() {
+        const ret = wasm.molhandle_chi2v(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ3 molecular connectivity index.
+     * @returns {number}
+     */
+    chi3() {
+        const ret = wasm.molhandle_chi3(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ3v valence-weighted connectivity index.
+     * @returns {number}
+     */
+    chi3v() {
+        const ret = wasm.molhandle_chi3v(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ4 molecular connectivity index.
+     * @returns {number}
+     */
+    chi4() {
+        const ret = wasm.molhandle_chi4(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Kier–Hall χ4v valence-weighted connectivity index.
+     * @returns {number}
+     */
+    chi4v() {
+        const ret = wasm.molhandle_chi4v(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * 2D SVG depiction of the molecule (CPK coloring).
      * @returns {string}
@@ -75,6 +269,24 @@ export class MolHandle {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * 2D SVG depiction with style options.
+     * @param {DepictOptions} opts
+     * @returns {string}
+     */
+    depict_svg_opts(opts) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            _assertClass(opts, DepictOptions);
+            const ret = wasm.molhandle_depict_svg_opts(this.__wbg_ptr, opts.__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).
@@ -157,6 +369,38 @@ export class MolHandle {
         const ret = wasm.molhandle_heavy_atom_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Hall–Kier κ1 shape index.
+     * @returns {number}
+     */
+    kappa1() {
+        const ret = wasm.molhandle_kappa1(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Hall–Kier κ2 shape index.
+     * @returns {number}
+     */
+    kappa2() {
+        const ret = wasm.molhandle_kappa2(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Hall–Kier κ3 shape index.
+     * @returns {number}
+     */
+    kappa3() {
+        const ret = wasm.molhandle_kappa3(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Labute approximate surface area (Ų).
+     * @returns {number}
+     */
+    labute_asa() {
+        const ret = wasm.molhandle_labute_asa(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Returns `true` if the molecule satisfies Lipinski's Rule of Five.
      * @returns {boolean}
@@ -189,6 +433,25 @@ export class MolHandle {
         const ret = wasm.molhandle_molecular_weight(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Morgan count fingerprint as a JSON object string (`{"<hash>": count, …}`).
+     *
+     * `radius` controls the ECFP radius (2 = ECFP4-equivalent).
+     * @param {number} radius
+     * @returns {string}
+     */
+    morgan_fp_counts_json(radius) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.molhandle_morgan_fp_counts_json(this.__wbg_ptr, radius);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Number of non-aromatic rings containing at least one heteroatom.
      * @returns {number}
@@ -302,9 +565,28 @@ export class MolHandle {
         const ret = wasm.molhandle_veber_passes(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Wiener topological index (sum of all pairwise shortest-path distances).
+     * @returns {number}
+     */
+    wiener_index() {
+        const ret = wasm.molhandle_wiener_index(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) MolHandle.prototype[Symbol.dispose] = MolHandle.prototype.free;
 
+/**
+ * Return a copy of the molecule with all implicit hydrogens converted to explicit H atoms.
+ * @param {MolHandle} mol
+ * @returns {MolHandle}
+ */
+export function add_hydrogens(mol) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.add_hydrogens(mol.__wbg_ptr);
+    return MolHandle.__wrap(ret);
+}
+
 /**
  * Number of BRICS fragments produced by fragmenting the molecule.
  *
@@ -318,6 +600,30 @@ export function brics_fragment_count(mol) {
     return ret >>> 0;
 }
 
+/**
+ * Render a grid SVG from newline-separated SMILES (one per line).
+ *
+ * Lines that fail to parse are silently skipped.
+ * `cols` controls the number of columns (each cell is 200×200 px).
+ * @param {string} smiles_block
+ * @param {number} cols
+ * @returns {string}
+ */
+export function depict_svg_grid(smiles_block, cols) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(smiles_block, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.depict_svg_grid(ptr0, len0, cols);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Compute the ECFP4 fingerprint as a bit-packed byte vector (256 bytes = 2048 bits).
  * @param {MolHandle} mol
@@ -331,6 +637,18 @@ export function ecfp4_bitvec(mol) {
     return v1;
 }
 
+/**
+ * Returns `true` if the SMILES string can be parsed without error.
+ * @param {string} s
+ * @returns {boolean}
+ */
+export function is_valid_smiles(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.is_valid_smiles(ptr0, len0);
+    return ret !== 0;
+}
+
 /**
  * Parse a SMILES string into a `MolHandle`.
  *
@@ -348,6 +666,50 @@ export function parse_smiles(s) {
     return MolHandle.__wrap(ret[0]);
 }
 
+/**
+ * Return a copy of the molecule with all explicit hydrogen atoms removed.
+ * @param {MolHandle} mol
+ * @returns {MolHandle}
+ */
+export function remove_hydrogens(mol) {
+    _assertClass(mol, MolHandle);
+    const ret = wasm.remove_hydrogens(mol.__wbg_ptr);
+    return MolHandle.__wrap(ret);
+}
+
+/**
+ * Apply a SMIRKS reaction template and return product SMILES as a JSON string.
+ *
+ * `reactants_smiles`: pipe-separated SMILES, one per reactant slot in the SMIRKS.
+ * Returns a JSON array of arrays: `[["product_smi", …], …]`.
+ * Returns a JS error on parse failure or arity mismatch.
+ * @param {string} smirks
+ * @param {string} reactants_smiles
+ * @returns {string}
+ */
+export function run_reactants(smirks, reactants_smiles) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(smirks, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(reactants_smiles, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.run_reactants(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Tanimoto similarity between two molecules using AtomPair fingerprints.
  * @param {MolHandle} a
@@ -416,6 +778,9 @@ export function __wbindgen_init_externref_table() {
     table.set(offset + 2, true);
     table.set(offset + 3, false);
 }
+const DepictOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_depictoptions_free(ptr, 1));
 const MolHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_molhandle_free(ptr, 1));
@@ -435,6 +800,14 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -443,6 +816,13 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

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.5",
+  "version": "0.1.10",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",