Datasets:

introvoyz041
/

molmoda

// Sometimes it's necessary to process many SMILES in bulk, without the expense
// of converting to OpenBabel or rdkit. These functions example direct
// manipulation of SMILES string. Probably not as good as the Open Babel
// implementations, so use sparingly.
import memoize from "lodash.memoize";
/**
 * Counts heavy atoms in a SMILES fragment, ignoring hydrogens
 * and handling two-letter elements correctly.
 *
 * @param {string} smilesStr  Input SMILES string
 * @returns {number}  Number of heavy atoms
 */
export const easyCountHeavyAtomsSmiles = memoize(function (
    smilesStr: string
): number {
    let count = 0;
    let i = 0;
    while (i < smilesStr.length) {
        // Skip anything in parentheses/numbers/symbols
        if ("()[]{}0123456789-=#+%@".includes(smilesStr[i])) {
            i++;
            continue;
        }

        // Check for bracketed atoms like [Fe] or [Cl]
        if (smilesStr[i] === "[") {
            i++;
            // Get the element name from within brackets
            let elem = "";
            while (i < smilesStr.length && smilesStr[i] !== "]") {
                elem += smilesStr[i];
                i++;
            }
            // Only count if it's not hydrogen
            if (!elem.startsWith("H")) {
                count++;
            }
            i++;
            continue;
        }

        // Handle both regular single-letter elements (C, N, O, etc.)
        // and aromatic atoms (c, n, o, etc.)
        if ("CNOPSFBIcnopsbi".includes(smilesStr[i])) {
            count++;
        }

        i++;
    }
    return count;
});

/**
 * Takes a SMILES string that may contain multiple fragments (separated by
 * periods) and returns only the largest fragment based on heavy atom count.
 * Handles both bracketed and unbracketed atoms correctly. NOTE: It is better to
 * do this via Open Babel, but sometimes it's necessary just to quickly desalt
 * many smiles strings (for example, to process data from a PubChem API call.) I
 * recommend using this function sparingly.
 *
 * @param {string} smilesStr  Input SMILES string that may contain multiple
 *       fragments
 * @returns {string} SMILES string containing only the largest fragment
 */
export const easyDesaltSMILES = memoize(function (smilesStr: string): string {
    // If there's no period in the smilesStr, just return that string.
    if (!smilesStr.includes(".")) {
        return smilesStr;
    }

    // Split on periods that aren't inside brackets
    const fragments = smilesStr.split(".");

    // Find the fragment with the most heavy atoms
    let maxAtoms = 0;
    let largestFragment = fragments[0];

    fragments.forEach((fragment) => {
        const heavyAtomCount = easyCountHeavyAtomsSmiles(fragment);
        if (heavyAtomCount > maxAtoms) {
            maxAtoms = heavyAtomCount;
            largestFragment = fragment;
        }
    });

    return largestFragment;
});

// export function testEasySmilesDesalt() {

//     // Basic salts
//     console.log(easyDesaltSMILES("CC(=O)O.[Na+]"))  // Should return "CC(=O)O"
//     console.log(easyDesaltSMILES("c1ccccc1.[Cl-]"))  // Should return "c1ccccc1"
//     console.log(easyDesaltSMILES("[Na+].CC#N"))  // Should return "CC#N"

//     // Multiple fragments (should return largest)
//     console.log(easyDesaltSMILES("CCO.CCCCO.CC"))  // Should return "CCCCO"
//     console.log(easyDesaltSMILES("c1ccccc1.c1ccccc1Cl"))  // Should return "c1ccccc1Cl"

//     // Water and hydrates
//     console.log(easyDesaltSMILES("CCN.[H]O[H]"))  // Should return "CCN"
//     console.log(easyDesaltSMILES("CC(=O)O.O"))  // Should return "CC(=O)O"

//     // Aromatic compounds with [nH]
//     console.log(easyDesaltSMILES("c1ccc[nH]c1.[Na+]"))  // Should return "c1ccc[nH]c1"
//     console.log(easyDesaltSMILES("[Cl-].c1cc[nH]cc1"))  // Should return "c1cc[nH]cc1"

//     // Multiple salts
//     console.log(easyDesaltSMILES("[Na+].[Cl-].CCO"))  // Should return "CCO"
//     console.log(easyDesaltSMILES("CC(=O)[O-].[Na+].[H]O[H]"))  // Should return "CC(=O)[O-]"

//     // Complex cases
//     console.log(easyDesaltSMILES("CCN(CC)CC.[Zn+2].[Cl-].[Cl-]"))  // Should return "CCN(CC)CC"
//     console.log(easyDesaltSMILES("c1ccccc1.O.O.O.[Na+]"))  // Should return "c1ccccc1"
//     console.log(easyDesaltSMILES("[Ca+2].CC(=O)[O-].CC(=O)[O-]"))  // Should return either CC(=O)[O-] fragment
//     console.log(easyDesaltSMILES("[Na+].C1CC[NH2+]CC1.[Cl-]"))  // Should return "C1CC[NH2+]CC1"
// }

/**
 * Neutralizes charges in a SMILES string by replacing common charged
 * atoms with their neutral unbracketed equivalents.
 * For example: [O-] -> O, [NH+] -> N, etc.
 *
 * @param {string} smilesStr Input SMILES string with potential charges
 * @returns {string} SMILES string with common charged atoms neutralized
 */
export const easyNeutralizeSMILES = memoize(function (
    smilesStr: string
): string {
    // Handle empty or null input
    if (!smilesStr) {
        return smilesStr;
    }

    // Define patterns for common charged atoms and their replacements
    const replacementPatterns = [
        // Oxygen patterns
        { pattern: /\[O-\]/g, replacement: "O" },
        { pattern: /\[OH-\]/g, replacement: "O" },
        { pattern: /\[OH\+\]/g, replacement: "O" },
        { pattern: /\[OH2\+\]/g, replacement: "O" },

        // Sulfur patterns
        { pattern: /\[S-\]/g, replacement: "S" },
        { pattern: /\[SH-\]/g, replacement: "S" },
        { pattern: /\[SH\+\]/g, replacement: "S" },

        // Nitrogen patterns
        { pattern: /\[NH\+\]/g, replacement: "N" },
        { pattern: /\[N-\]/g, replacement: "N" },
        { pattern: /\[NH2\+\]/g, replacement: "N" },
        { pattern: /\[NH3\+\]/g, replacement: "N" },
        { pattern: /\[NH4\+\]/g, replacement: "N" },

        // Carbon patterns
        { pattern: /\[CH-\]/g, replacement: "C" },
        { pattern: /\[CH2-\]/g, replacement: "C" },
        { pattern: /\[CH\+\]/g, replacement: "C" },
        { pattern: /\[CH2\+\]/g, replacement: "C" },
        { pattern: /\[CH3\+\]/g, replacement: "C" },

        // Phosphorus patterns
        { pattern: /\[P-\]/g, replacement: "P" },
        { pattern: /\[PH-\]/g, replacement: "P" },
        { pattern: /\[PH\+\]/g, replacement: "P" },
        { pattern: /\[PH2\+\]/g, replacement: "P" },

        // Halogens
        { pattern: /\[F-\]/g, replacement: "F" },
        { pattern: /\[Cl-\]/g, replacement: "Cl" },
        { pattern: /\[Br-\]/g, replacement: "Br" },
        { pattern: /\[I-\]/g, replacement: "I" },
        { pattern: /\[At-\]/g, replacement: "At" },

        // Aromatic charged atoms
        { pattern: /\[n-\]/g, replacement: "n" },
        { pattern: /\[c-\]/g, replacement: "c" },
        { pattern: /\[o-\]/g, replacement: "o" },
        { pattern: /\[s-\]/g, replacement: "s" },
        { pattern: /\[p-\]/g, replacement: "p" },

        // Boron patterns
        { pattern: /\[B-\]/g, replacement: "B" },
        { pattern: /\[BH-\]/g, replacement: "B" },
        { pattern: /\[BH2-\]/g, replacement: "B" },
        { pattern: /\[BH3-\]/g, replacement: "B" },
        { pattern: /\[BH4-\]/g, replacement: "B" },

        // Silicon patterns
        { pattern: /\[Si-\]/g, replacement: "Si" },

        // Selenium patterns
        { pattern: /\[Se-\]/g, replacement: "Se" },

        // Ammonium patterns with different numbers
        { pattern: /\[NH\d*\+\d*\]/g, replacement: "N" },

        // Common anions
        { pattern: /\[OH-\]/g, replacement: "O" },
        { pattern: /\[SH-\]/g, replacement: "S" },

        // Other issues
        { pattern: /\[c\]/g, replacement: "c" },
        { pattern: /\[n\]/g, replacement: "n" },
        { pattern: /\[o\]/g, replacement: "o" },
        { pattern: /\[s\]/g, replacement: "s" },
        { pattern: /\[p\]/g, replacement: "p" },

        { pattern: /\[C\]/g, replacement: "C" },
        { pattern: /\[N\]/g, replacement: "N" },
        { pattern: /\[O\]/g, replacement: "O" },
        { pattern: /\[S\]/g, replacement: "S" },
        { pattern: /\[P\]/g, replacement: "P" },

        // Need to remove cis/trans isomers, too.
        { pattern: /\//g, replacement: "" },
        { pattern: /\\/g, replacement: "" },

        // Catch-alls for any charges not covered above
        // Note: These should be at the end as they're more general patterns
        // { pattern: /\[([A-Za-z][a-z]?)\+\d*\]/g, replacement: '$1' },
        // { pattern: /\[([A-Za-z][a-z]?)-\d*\]/g, replacement: '$1' }
    ];

    // Apply each replacement pattern
    let neutralized = smilesStr;
    replacementPatterns.forEach(({ pattern, replacement }) => {
        neutralized = neutralized.replace(pattern, replacement);
    });

    // Clean up any periods that might be left over from salt removal
    neutralized = neutralized.replace(/^\.$/, ""); // Period by itself
    neutralized = neutralized.replace(/^\.+/, ""); // Leading periods
    neutralized = neutralized.replace(/\.+$/, ""); // Trailing periods
    neutralized = neutralized.replace(/\.+/g, "."); // Multiple consecutive periods

    return neutralized;
});