@datagrok-libraries/bio 5.44.4 → 5.45.0

package/src/utils/seq-handler.js

@@ -1,748 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import wu from 'wu';
-/* eslint-disable max-len */
-import { ALPHABET, candidateAlphabets, getSplitterWithSeparator, NOTATION, positionSeparator, splitterAsFasta, splitterAsHelm, TAGS } from './macromolecule';
-import { detectAlphabet, splitterAsFastaSimple, StringListSeqSplitted } from './macromolecule/utils';
-import { mmDistanceFunctions, MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
-import { getMonomerLibHelper } from '../monomer-works/monomer-utils';
-import { HELM_WRAPPERS_REGEXP, PHOSPHATE_SYMBOL } from './const';
-import { GAP_SYMBOL, GapOriginals } from './macromolecule/consts';
-import { HelmTypes } from '../helm/consts';
-/* eslint-enable max-len */
-export const SeqTemps = new class {
-    constructor() {
-        /** Column's temp slot name for a SeqHandler object */
-        this.seqHandler = `seq-handler`;
-        this.notationProvider = `seq-handler.notation-provider`;
-    }
-}();
-/** Class for handling notation units in Macromolecule columns and
- * conversion of notation systems in Macromolecule columns
- */
-export class SeqHandler {
-    constructor(col) {
-        this.notationProvider = null;
-        this._splitter = null;
-        this.cached = true;
-        this._splitted = null;
-        this.columnVersion = null;
-        this._stats = null;
-        this._maxLength = null;
-        this._posList = null;
-        this._joiner = undefined;
-        if (col.type !== DG.TYPE.STRING)
-            throw new Error(`Unexpected column type '${col.type}', must be '${DG.TYPE.STRING}'.`);
-        this._column = col;
-        const units = this._column.meta.units;
-        if (units !== null && units !== undefined)
-            this._units = units;
-        else
-            throw new Error('Units are not specified in column');
-        this._notation = this.getNotation();
-        this._defaultGapOriginal = (this.isFasta()) ? GapOriginals[NOTATION.FASTA] :
-            (this.isHelm()) ? GapOriginals[NOTATION.HELM] :
-                GapOriginals[NOTATION.SEPARATOR];
-        if (!this.column.tags.has(TAGS.aligned) || !this.column.tags.has(TAGS.alphabet) ||
-            (!this.column.tags.has(TAGS.alphabetIsMultichar) && !this.isHelm() && this.alphabet === ALPHABET.UN)) {
-            // The following detectors and setters are to be called because the column is likely
-            // as the UnitsHandler constructor was called on the column.
-            if (this.isFasta())
-                SeqHandler.setUnitsToFastaColumn(this);
-            else if (this.isSeparator()) {
-                const separator = col.getTag(TAGS.separator);
-                SeqHandler.setUnitsToSeparatorColumn(this, separator);
-            }
-            else if (this.isHelm())
-                SeqHandler.setUnitsToHelmColumn(this);
-            else
-                throw new Error(`Unexpected units '${this.column.meta.units}'.`);
-        }
-        // if (!this.column.tags.has(TAGS.alphabetSize)) {
-        //   if (this.isHelm())
-        //     throw new Error(`For column '${this.column.name}' of notation '${this.notation}' ` +
-        //       `tag '${TAGS.alphabetSize}' is mandatory.`);
-        //   else if (['UN'].includes(this.alphabet))
-        //     throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +
-        //       `tag '${TAGS.alphabetSize}' is mandatory.`);
-        // }
-        if (!this.column.tags.has(TAGS.alphabetIsMultichar)) {
-            if (this.isHelm())
-                this.column.setTag(TAGS.alphabetIsMultichar, 'true');
-            else if (['UN'].includes(this.alphabet)) {
-                throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +
-                    `tag '${TAGS.alphabetIsMultichar}' is mandatory.`);
-            }
-        }
-        if (this.column.meta.units === NOTATION.CUSTOM) {
-            // this.column.temp[SeqTemps.notationProvider] must be set at detector stage
-            this.notationProvider = this.column.temp[SeqTemps.notationProvider] ?? null;
-        }
-        this.columnVersion = this.column.version;
-    }
-    static setUnitsToFastaColumn(uh) {
-        if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.meta.units !== NOTATION.FASTA)
-            throw new Error(`The column of notation '${NOTATION.FASTA}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);
-        uh.column.meta.units = NOTATION.FASTA;
-        SeqHandler.setTags(uh);
-    }
-    static setUnitsToSeparatorColumn(uh, separator) {
-        if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.meta.units !== NOTATION.SEPARATOR)
-            throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);
-        if (!separator)
-            throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must have the separator tag.`);
-        uh.column.meta.units = NOTATION.SEPARATOR;
-        uh.column.setTag(TAGS.separator, separator);
-        SeqHandler.setTags(uh);
-    }
-    static setUnitsToHelmColumn(uh) {
-        if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE)
-            throw new Error(`The column of notation '${NOTATION.HELM}' must be '${DG.SEMTYPE.MACROMOLECULE}'`);
-        uh.column.meta.units = NOTATION.HELM;
-        SeqHandler.setTags(uh);
-    }
-    /** From detectMacromolecule */
-    static setTags(uh) {
-        const units = uh.column.meta.units;
-        if ([NOTATION.FASTA, NOTATION.SEPARATOR].includes(units)) {
-            // Empty monomer alphabet is allowed, only if alphabet tag is annotated
-            if (!uh.column.getTag(TAGS.alphabet) && Object.keys(uh.stats.freq).length === 0)
-                throw new Error('Alphabet is empty and not annotated.');
-            let aligned = uh.column.getTag(TAGS.aligned);
-            if (aligned === null) {
-                aligned = uh.stats.sameLength ? "SEQ.MSA" /* ALIGNMENT.SEQ_MSA */ : "SEQ" /* ALIGNMENT.SEQ */;
-                uh.column.setTag(TAGS.aligned, aligned);
-            }
-            let alphabet = uh.column.getTag(TAGS.alphabet);
-            if (alphabet === null) {
-                alphabet = detectAlphabet(uh.stats.freq, candidateAlphabets);
-                uh.column.setTag(TAGS.alphabet, alphabet);
-            }
-            if (alphabet === ALPHABET.UN) {
-                const alphabetSize = Object.keys(uh.stats.freq).length;
-                const alphabetIsMultichar = Object.keys(uh.stats.freq).some((m) => m.length > 1);
-                uh.column.setTag(TAGS.alphabetSize, alphabetSize.toString());
-                uh.column.setTag(TAGS.alphabetIsMultichar, alphabetIsMultichar ? 'true' : 'false');
-            }
-        }
-    }
-    get column() { return this._column; }
-    get length() { return this._column.length; }
-    get units() { return this._units; }
-    get notation() { return this._notation; }
-    get defaultGapOriginal() { return this._defaultGapOriginal; }
-    get separator() {
-        const separator = this.column.getTag(TAGS.separator) ?? undefined;
-        if (this.notation === NOTATION.SEPARATOR && separator === undefined)
-            throw new Error(`Separator is mandatory  for column '${this.column.name}' of notation '${this.notation}'.`);
-        return separator;
-    }
-    get aligned() {
-        const aligned = this.column.getTag(TAGS.aligned);
-        // TAGS.aligned is mandatory for columns of NOTATION.FASTA and NOTATION.SEPARATOR
-        if (!aligned && (this.isFasta() || this.isSeparator()))
-            throw new Error('Tag aligned not set');
-        return aligned;
-    }
-    /** Alphabet name (upper case) */
-    get alphabet() {
-        const alphabet = this.column.getTag(TAGS.alphabet);
-        // TAGS.alphabet is mandatory for columns of NOTATION.FASTA and NOTATION.SEPARATOR
-        if (!alphabet && (this.isFasta() || this.isSeparator()))
-            throw new Error('Tag alphabet not set');
-        return alphabet;
-    }
-    get defaultBiotype() {
-        return this.alphabet === ALPHABET.RNA || this.alphabet === ALPHABET.DNA ? HelmTypes.NUCLEOTIDE : HelmTypes.AA;
-    }
-    get helmCompatible() {
-        return this.column.getTag(TAGS.isHelmCompatible);
-    }
-    getAlphabetSize() {
-        if (this.notation == NOTATION.HELM || this.alphabet == ALPHABET.UN) {
-            const alphabetSizeStr = this.column.getTag(TAGS.alphabetSize);
-            let alphabetSize;
-            if (alphabetSizeStr)
-                alphabetSize = parseInt(alphabetSizeStr);
-            else {
-                // calculate alphabetSize on demand
-                const stats = this.stats;
-                alphabetSize = Object.keys(stats.freq).length;
-            }
-            return alphabetSize;
-        }
-        else {
-            switch (this.alphabet) {
-                case ALPHABET.PT:
-                    return 20;
-                case ALPHABET.DNA:
-                case ALPHABET.RNA:
-                    return 4;
-                case 'NT':
-                    console.warn(`Unexpected alphabet 'NT'.`);
-                    return 4;
-                default:
-                    throw new Error(`Unexpected alphabet '${this.alphabet}'.`);
-            }
-        }
-    }
-    getAlphabetIsMultichar() {
-        if (this.notation === NOTATION.HELM)
-            return true;
-        else if (this.alphabet !== ALPHABET.UN)
-            return false;
-        else
-            return this.column.getTag(TAGS.alphabetIsMultichar) === 'true';
-    }
-    // /** */
-    // public get splitted(): ISeqSplitted[] {
-    //   // TODO: Disable cache or invalidate on changing data
-    //   if (this._splitted === null) {
-    //     const splitter = this.splitter;
-    //     const colLength: number = this._column.length;
-    //     this._splitted = new Array(colLength);
-    //     const catIdxList = this._column.getRawData();
-    //     const catList: string[] = this._column.categories;
-    //     for (let rowIdx: number = 0; rowIdx < colLength; rowIdx++) {
-    //       const seq: string = catList[catIdxList[rowIdx]];
-    //       this._splitted[rowIdx] = splitter(seq);
-    //     }
-    //   }
-    //   return this._splitted;
-    // }
-    getSplitted(rowIdx, limit) {
-        if (!this.cached || limit !== undefined) {
-            const seq = this.column.get(rowIdx);
-            return this.getSplitter(limit)(seq);
-        }
-        else {
-            if (this.column.version !== this.columnVersion || this._splitted === null) {
-                this.columnVersion = this.column.version;
-                this._splitted = new Array(this.column.length);
-            }
-            let resSS = this._splitted[rowIdx] ? this._splitted[rowIdx].deref() : undefined;
-            if (!resSS) {
-                const seq = this.column.get(rowIdx);
-                resSS = this.splitter(seq);
-                this._splitted[rowIdx] = new WeakRef(resSS);
-            }
-            return resSS;
-        }
-    }
-    /** Any Macromolecule can be represented on Helm format. The reverse is not always possible. */
-    async getHelm(rowIdx, options) {
-        const seq = this.column.get(rowIdx);
-        if (this.notationProvider) {
-            const helmCol = await this.notationProvider.getHelm(this.column, options);
-            return helmCol.get(rowIdx);
-        }
-        else
-            return this.convertToHelm(seq);
-    }
-    get stats() {
-        if (this._stats === null) {
-            const freq = {};
-            let sameLength = true;
-            let firstLength = null;
-            const colLen = this.column.length;
-            for (let rowIdx = 0; rowIdx < colLen; ++rowIdx) {
-                const mSeq = this.getSplitted(rowIdx);
-                if (firstLength == null)
-                    firstLength = mSeq.length;
-                else if (mSeq.length !== firstLength)
-                    sameLength = false;
-                for (let posIdx = 0; posIdx < mSeq.length; ++posIdx) {
-                    const cm = mSeq.getCanonical(posIdx);
-                    if (!(cm in freq))
-                        freq[cm] = 0;
-                    freq[cm] += 1;
-                }
-            }
-            this._stats = { freq: freq, sameLength: sameLength };
-        }
-        return this._stats;
-    }
-    get maxLength() {
-        if (this._maxLength === null) {
-            this._maxLength = this.column.length === 0 ? 0 :
-                Math.max(...wu.count(0).take(this.column.length).map((rowIdx) => this.getSplitted(rowIdx).length));
-        }
-        return this._maxLength;
-    }
-    get posList() {
-        if (this._posList === null) {
-            const posListTxt = this.column.getTag(TAGS.positionNames);
-            this._posList = posListTxt ? posListTxt.split(positionSeparator).map((p) => p.trim()) :
-                wu.count(1).take(this.maxLength).map((pos) => pos.toString()).toArray();
-        }
-        return this._posList;
-    }
-    isFasta() { return this.notation === NOTATION.FASTA; }
-    isSeparator() { return this.notation === NOTATION.SEPARATOR; }
-    isHelm() { return this.notation === NOTATION.HELM; }
-    isRna() { return this.alphabet === ALPHABET.RNA; }
-    isDna() { return this.alphabet === ALPHABET.DNA; }
-    isPeptide() { return this.alphabet === ALPHABET.PT; }
-    isMsa() { return this.aligned ? this.aligned.toUpperCase().includes('MSA') : false; }
-    isHelmCompatible() { return this.helmCompatible === 'true'; }
-    /** Checks {@link om} for being a gap
-     * @param {string} om Original monomer of sequence symbol
-     * @return {boolean}
-     */
-    isGap(om) {
-        return !om || om === this._defaultGapOriginal;
-    }
-    /** Associate notation types with the corresponding units */
-    /**
-     * @return {NOTATION}     Notation associated with the units type
-     */
-    getNotation() {
-        if (this.units.toLowerCase().startsWith(NOTATION.FASTA))
-            return NOTATION.FASTA;
-        else if (this.units.toLowerCase().startsWith(NOTATION.SEPARATOR))
-            return NOTATION.SEPARATOR;
-        else if (this.units.toLowerCase().startsWith(NOTATION.HELM))
-            return NOTATION.HELM;
-        else if (this.units.toLowerCase().startsWith(NOTATION.CUSTOM))
-            return NOTATION.CUSTOM;
-        else
-            throw new Error(`Column '${this.column.name}' has unexpected notation '${this.units}'.`);
-    }
-    /**
-     * Get the wrapper strings for HELM, depending on the type of the
-     * macromolecule (peptide, DNA, RNA)
-     *
-     * @return {string[]} Array of wrappers
-     */
-    getHelmWrappers() {
-        const prefix = (this.isDna()) ? 'RNA1{' :
-            (this.isRna() || this.isHelmCompatible()) ? 'RNA1{' : 'PEPTIDE1{';
-        const postfix = '}$$$$';
-        const leftWrapper = (this.isDna()) ? 'd(' :
-            (this.isRna()) ? 'r(' : '';
-        const rightWrapper = (this.isDna() || this.isRna()) ? ')p' : '';
-        return [prefix, leftWrapper, rightWrapper, postfix];
-    }
-    /**
-     * Create a new empty column of the specified notation type and the same
-     * length as column
-     *
-     * @param {NOTATION} tgtNotation
-     * @return {DG.Column}
-     */
-    getNewColumn(tgtNotation, tgtSeparator, colName, data) {
-        const col = this.column;
-        const name = tgtNotation.toLowerCase() + '(' + col.name + ')';
-        const newColName = colName ?? col.dataFrame?.columns.getUnusedName(name) ?? name;
-        const newColumn = DG.Column.fromList('string', newColName, data ?? new Array(this.column.length).fill(''));
-        newColumn.semType = DG.SEMTYPE.MACROMOLECULE;
-        newColumn.meta.units = tgtNotation;
-        if (tgtNotation === NOTATION.SEPARATOR) {
-            if (!tgtSeparator)
-                throw new Error(`Notation \'${NOTATION.SEPARATOR}\' requires separator value.`);
-            newColumn.setTag(TAGS.separator, tgtSeparator);
-        }
-        newColumn.setTag(DG.TAGS.CELL_RENDERER, tgtNotation === NOTATION.HELM ? 'helm' : 'sequence'); // cell.renderer
-        const srcAligned = col.getTag(TAGS.aligned);
-        if (srcAligned)
-            newColumn.setTag(TAGS.aligned, srcAligned);
-        let srcAlphabet = col.getTag(TAGS.alphabet);
-        if (!srcAlphabet && this.notation === NOTATION.HELM && tgtNotation !== NOTATION.HELM)
-            srcAlphabet = ALPHABET.UN;
-        if (srcAlphabet != null)
-            newColumn.setTag(TAGS.alphabet, srcAlphabet);
-        let srcAlphabetSize = col.getTag(TAGS.alphabetSize);
-        if (srcAlphabet != null && srcAlphabetSize)
-            newColumn.setTag(TAGS.alphabetSize, srcAlphabetSize);
-        const srcAlphabetIsMultichar = col.getTag(TAGS.alphabetIsMultichar);
-        if (srcAlphabet != null && srcAlphabetIsMultichar !== undefined)
-            newColumn.setTag(TAGS.alphabetIsMultichar, srcAlphabetIsMultichar);
-        if (tgtNotation == NOTATION.HELM) {
-            srcAlphabetSize = this.getAlphabetSize().toString();
-            newColumn.setTag(TAGS.alphabetSize, srcAlphabetSize);
-        }
-        return newColumn;
-    }
-    /** Creates a new column on data of {@link seqList} with the same tags */
-    getNewColumnFromList(name, seqList) {
-        return this.getNewColumn(this.notation, this.separator, name, seqList);
-    }
-    /**
-     * Create a new empty column using templateCol as a template
-     *
-     * @param {DG.Column} templateCol  the properties and units of this column are used as a
-     * template to build the new one
-     * @return {DG.Column}
-     */
-    static getNewColumn(templateCol) {
-        const col = SeqHandler.forColumn(templateCol);
-        const targetNotation = col.notation;
-        return col.getNewColumn(targetNotation);
-    }
-    /**
-     * A helper function checking the validity of the 'units' string
-     *
-     * @param {string} units  the string to be validated
-     * @return {boolean}
-     */
-    static unitsStringIsValid(units) {
-        units = units.toLowerCase();
-        const prefixes = [NOTATION.FASTA, NOTATION.SEPARATOR, NOTATION.HELM];
-        const postfixes = ['rna', 'dna', 'pt'];
-        const prefixCriterion = prefixes.some((p) => units.startsWith(p.toLowerCase()));
-        return prefixCriterion;
-    }
-    /**
-     * Construct a new column of semantic type MACROMOLECULE from the list of
-     * specified parameters
-     *
-     * @param {number}    len  the length of the new column
-     * @param {string}    name  the name of the new column
-     * @param {string}    units  the units of the new column
-     * @return {DG.Column}
-     */
-    static getNewColumnFromParams(len, name, units) {
-        // WARNING: in this implementation is is impossible to verify the uniqueness
-        // of the new column's name
-        // TODO: verify the validity of units parameter
-        if (!SeqHandler.unitsStringIsValid(units))
-            throw new Error('Invalid format of \'units\' parameter');
-        const newColumn = DG.Column.fromList('string', name, new Array(len).fill(''));
-        newColumn.semType = DG.SEMTYPE.MACROMOLECULE;
-        newColumn.meta.units = units;
-        return newColumn;
-    }
-    /** Gets function to split seq value to monomers */
-    getSplitter(limit) {
-        let splitter = null;
-        splitter = this.notationProvider ? this.notationProvider.splitter : null;
-        if (splitter)
-            return splitter;
-        if (this.units.toLowerCase().startsWith(NOTATION.FASTA)) {
-            const alphabet = this.column.getTag(TAGS.alphabet);
-            if (alphabet !== null && !this.getAlphabetIsMultichar())
-                return splitterAsFastaSimple;
-            else
-                return splitterAsFasta;
-        }
-        else if (this.units.toLowerCase().startsWith(NOTATION.SEPARATOR))
-            return getSplitterWithSeparator(this.separator, limit);
-        else if (this.units.toLowerCase().startsWith(NOTATION.HELM))
-            return splitterAsHelm;
-        else
-            throw new Error(`Unexpected units ${this.units} .`);
-        // TODO: Splitter for HELM
-    }
-    split(seq) {
-        return this.splitter(seq);
-    }
-    getDistanceFunctionName() {
-        // TODO add support for helm and separator notation
-        if (!this.isFasta())
-            throw new Error('Only FASTA notation is supported');
-        if (this.isMsa())
-            return MmDistanceFunctionsNames.HAMMING;
-        switch (this.alphabet) {
-            case ALPHABET.DNA:
-            case ALPHABET.RNA:
-                // As DNA and RNA scoring matrices are same as identity matrices(mostly),
-                // we can use very fast and optimized Levenshtein distance library
-                return MmDistanceFunctionsNames.LEVENSHTEIN;
-            case ALPHABET.PT:
-                return MmDistanceFunctionsNames.LEVENSHTEIN;
-            // For default case, let's use Levenshtein distance
-            default:
-                return MmDistanceFunctionsNames.LEVENSHTEIN;
-        }
-    }
-    getDistanceFunction() {
-        return mmDistanceFunctions[this.getDistanceFunctionName()]();
-    }
-    // checks if the separator notation is compatible with helm library
-    async checkHelmCompatibility() {
-        // check first for the column tag to avoid extra processing
-        if (this.column.tags.has(TAGS.isHelmCompatible))
-            return this.column.getTag(TAGS.isHelmCompatible) === 'true';
-        // get the monomer lib and check against the column
-        const monomerLibHelper = await getMonomerLibHelper();
-        const bioLib = monomerLibHelper.getMonomerLib();
-        // retrieve peptides
-        const peptides = bioLib.getMonomerSymbolsByType("PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */);
-        // convert the peptides list to a set for faster lookup
-        const peptidesSet = new Set(peptides);
-        // get splitter for given separator and check if all monomers are in the lib
-        const splitterFunc = getSplitterWithSeparator(this.separator);
-        // iterate over the columns, split them and check if all monomers are in the lib
-        //TODO maybe add missing threshold so that if there are not too many missing monomers
-        // the column is still considered helm compatible
-        const catIdxSet = new Set();
-        const rowCount = this.column.length;
-        const colRawData = this.column.getRawData();
-        for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {
-            const catI = colRawData[rowIdx];
-            if (!(catI in catIdxSet)) {
-                catIdxSet.add(catI);
-                const seqSS = this.getSplitted(rowIdx);
-                for (let posIdx = 0; posIdx < seqSS.length; ++posIdx) {
-                    const cm = seqSS.getCanonical(posIdx);
-                    if (!peptidesSet.has(cm)) {
-                        this.column.setTag(TAGS.isHelmCompatible, 'false');
-                        return false;
-                    }
-                }
-            }
-        }
-        this.column.setTag(TAGS.isHelmCompatible, 'true');
-        return true;
-    }
-    // -- Notation Converter --
-    get splitter() {
-        if (this._splitter === null)
-            this._splitter = this.getSplitter();
-        return this._splitter;
-    }
-    toFasta(targetNotation) { return targetNotation === NOTATION.FASTA; }
-    toSeparator(targetNotation) { return targetNotation === NOTATION.SEPARATOR; }
-    toHelm(targetNotation) { return targetNotation === NOTATION.HELM; }
-    /**
-     *  Convert HELM string to FASTA/SEPARATOR
-     *
-     * @param {string} srcSeq    A string to be converted
-     * @param {string} tgtNotation    Target notation: FASTA or SEPARATOR
-     * @param {string} tgtSeparator   Optional target separator (for HELM ->
-     * @param {string | null} tgtGapOriginal   Optional target gap symbol
-     * SEPARATOR)
-     * @return {string} Converted string
-     */
-    convertHelmToFastaSeparator(srcSeq, tgtNotation, tgtSeparator, tgtGapOriginal) {
-        if (!tgtGapOriginal) {
-            tgtGapOriginal = (this.toFasta(tgtNotation)) ?
-                GapOriginals[NOTATION.FASTA] :
-                GapOriginals[NOTATION.SEPARATOR];
-        }
-        if (!tgtSeparator)
-            tgtSeparator = (this.toFasta(tgtNotation)) ? '' : this.separator;
-        const isNucleotide = srcSeq.startsWith('RNA');
-        // items can be monomers or helms
-        const helmItemsArray = this.splitter(srcSeq);
-        const tgtMonomersArray = [];
-        for (let posIdx = 0; posIdx < helmItemsArray.length; ++posIdx) {
-            let om = helmItemsArray.getOriginal(posIdx);
-            if (isNucleotide)
-                om = om.replace(HELM_WRAPPERS_REGEXP, '');
-            if (om === GapOriginals[NOTATION.HELM])
-                tgtMonomersArray.push(tgtGapOriginal);
-            else if (this.toFasta(tgtNotation) && om.length > 1) {
-                // the case of a multi-character monomer converted to FASTA
-                const monomer = '[' + om + ']';
-                tgtMonomersArray.push(monomer);
-            }
-            else
-                tgtMonomersArray.push(om);
-        }
-        return tgtMonomersArray.join(tgtSeparator);
-    }
-    /** Dispatcher method for notation conversion
-     *
-     * @param {NOTATION} tgtNotation   Notation we want to convert to
-     * @param {string | null} tgtSeparator   Possible separator
-     * @return {DG.Column}                Converted column
-     */
-    convert(tgtNotation, tgtSeparator) {
-        // Get joiner from the source column units handler (this) knowing about the source sequence.
-        // For example, converting DNA Helm to fasta requires removing the r(X)p decoration.
-        const joiner = this.getJoiner({ notation: tgtNotation, separator: tgtSeparator });
-        const newColumn = this.getNewColumn(tgtNotation, tgtSeparator);
-        // assign the values to the newly created empty column
-        newColumn.init((rowIdx) => {
-            const srcSS = this.getSplitted(rowIdx);
-            return joiner(srcSS);
-        });
-        return newColumn;
-    }
-    /**
-     * @param name
-     * @param startIdx Start position index of the region (0-based)
-     * @param endIdx   End position index of the region (0-based, inclusive)
-     */
-    getRegion(startIdx, endIdx, name) {
-        const regCol = this.getNewColumn(this.notation, this.separator);
-        regCol.name = name;
-        const startIdxVal = startIdx ?? 0;
-        const endIdxVal = endIdx ?? this.maxLength - 1;
-        const joiner = this.getJoiner();
-        const regLength = endIdxVal - startIdxVal + 1;
-        const gapOM = GapOriginals[this.notation];
-        regCol.init((rowI) => {
-            const seqS = this.getSplitted(rowI);
-            // Custom slicing instead of array method to maintain gaps
-            const regOMList = new Array(regLength);
-            for (let regJPos = 0; regJPos < regLength; ++regJPos) {
-                const seqJPos = startIdxVal + regJPos;
-                regOMList[regJPos] = seqJPos < seqS.length ? seqS.getOriginal(seqJPos) : gapOM;
-            }
-            return joiner(new StringListSeqSplitted(regOMList, gapOM));
-        });
-        const getRegionOfPositionNames = (str) => {
-            const srcPosList = str.split(',').map((p) => p.trim());
-            const regPosList = new Array(regLength);
-            for (let regJPos = 0; regJPos < regLength; ++regJPos) {
-                const srcJPos = startIdxVal + regJPos;
-                regPosList[regJPos] = srcJPos < srcPosList.length ? srcPosList[srcJPos] : '?';
-            }
-            return regPosList.join(positionSeparator);
-        };
-        const srcPositionNamesStr = this.column.getTag(TAGS.positionNames);
-        if (srcPositionNamesStr)
-            regCol.setTag(TAGS.positionNames, getRegionOfPositionNames(srcPositionNamesStr));
-        const srcPositionLabelsStr = this.column.getTag(TAGS.positionLabels);
-        if (srcPositionLabelsStr)
-            regCol.setTag(TAGS.positionLabels, getRegionOfPositionNames(srcPositionLabelsStr));
-        return regCol;
-    }
-    get joiner() {
-        if (!this._joiner)
-            this._joiner = this.getJoiner();
-        return this._joiner;
-    }
-    getJoiner(opts) {
-        const notation = opts ? opts.notation : this.notation;
-        const separator = opts ? opts.separator : this.separator;
-        let res;
-        const srcSh = this;
-        switch (notation) {
-            case NOTATION.FASTA: {
-                res = function (srcSS) { return srcSh.joinToFasta(srcSS, srcSh.isHelm()); };
-                break;
-            }
-            case NOTATION.SEPARATOR: {
-                if (!separator)
-                    throw new Error(`Separator is mandatory for notation '${notation}'.`);
-                res = function (srcSS) { return joinToSeparator(srcSS, separator, srcSh.isHelm()); };
-                break;
-            }
-            case NOTATION.HELM: {
-                const isDnaOrRna = srcSh.alphabet === ALPHABET.DNA || srcSh.alphabet === ALPHABET.RNA;
-                const wrappers = srcSh.getHelmWrappers();
-                res = function (srcSS) { return joinToHelm(srcSS, wrappers, isDnaOrRna); };
-                break;
-            }
-            default:
-                throw new Error(`Unexpected notation '${notation}'.`);
-        }
-        return res;
-    }
-    getConverter(tgtUnits, tgtSeparator = undefined) {
-        if (tgtUnits === NOTATION.SEPARATOR && !tgtSeparator)
-            throw new Error(`Target separator is not specified for target units '${NOTATION.SEPARATOR}'.`);
-        const srcSh = this;
-        if (tgtUnits === NOTATION.FASTA)
-            return function (srcSeq) { return srcSh.convertToFasta(srcSeq); };
-        if (tgtUnits === NOTATION.HELM)
-            return function (srcSeq) { return srcSh.convertToHelm(srcSeq); };
-        else if (tgtUnits === NOTATION.SEPARATOR)
-            return function (srcSeq) { return srcSh.convertToSeparator(srcSeq, tgtSeparator); };
-        else
-            throw new Error();
-    }
-    /** Gets a column's UnitsHandler object from temp slot or creates a new and stores it to the temp slot. */
-    static forColumn(col) {
-        // TODO: Invalidate col.temp[Temps.uh] checking column's metadata
-        let res = col.temp[SeqTemps.seqHandler];
-        if (!res || res.columnVersion !== col.version)
-            res = col.temp[SeqTemps.seqHandler] = new SeqHandler(col);
-        return res;
-    }
-    // -- joiners & converters --
-    joinToFasta(seqS, isHelm) {
-        const resMList = new Array(seqS.length);
-        for (let posIdx = 0; posIdx < seqS.length; ++posIdx) {
-            const cm = seqS.getOriginal(posIdx);
-            let om = seqS.getOriginal(posIdx);
-            if (isHelm)
-                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
-            if (cm === GAP_SYMBOL)
-                om = GapOriginals[NOTATION.FASTA];
-            else if (cm === PHOSPHATE_SYMBOL)
-                om = '';
-            else if (om.length > 1)
-                om = '[' + om + ']';
-            resMList[posIdx] = om;
-        }
-        return resMList.join('');
-    }
-    convertToFasta(src) {
-        const srcUhSplitter = this.splitter;
-        const srcSS = this.isHelm() ? this.splitterAsHelmNucl(src) : srcUhSplitter(src);
-        return this.joinToFasta(srcSS, this.isHelm());
-    }
-    convertToSeparator(src, tgtSeparator) {
-        const srcSS = this.isHelm() ? this.splitterAsHelmNucl(src) : this.splitter(src);
-        return joinToSeparator(srcSS, tgtSeparator, this.isHelm());
-    }
-    convertToHelm(src) {
-        if (this.notation == NOTATION.HELM)
-            return src;
-        const wrappers = this.getHelmWrappers();
-        const isDnaOrRna = src.startsWith('DNA') || src.startsWith('RNA');
-        const srcSS = this.splitter(src);
-        return joinToHelm(srcSS, wrappers, isDnaOrRna);
-    }
-    /** Splits Helm sequence adjusting nucleotides to single char symbols. (!) Removes lone phosphorus. */
-    splitterAsHelmNucl(src) {
-        const srcMList = this.splitter(src);
-        const tgtMList = new Array(srcMList.length);
-        const isDna = src.startsWith('DNA');
-        const isRna = src.startsWith('RNA');
-        for (let posIdx = 0; posIdx < srcMList.length; ++posIdx) {
-            let om = srcMList.getOriginal(posIdx);
-            if (isDna || isRna) {
-                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
-                om = om === PHOSPHATE_SYMBOL ? null : om;
-            }
-            tgtMList[posIdx] = om ? om : null;
-        }
-        return new StringListSeqSplitted(tgtMList.filter((om) => !!om), GapOriginals[NOTATION.HELM]);
-    }
-    // Custom notation provider
-    getRendererBack(gridCol, tableCol) {
-        const temp = this.column.temp;
-        let res = temp.rendererBack;
-        if (!res)
-            res = temp.rendererBack = this.notationProvider.createCellRendererBack(gridCol, tableCol);
-        return res;
-    }
-}
-// -- joiners --
-function joinToSeparator(seqS, tgtSeparator, isHelm) {
-    const resMList = new Array(seqS.length);
-    for (let posIdx = 0; posIdx < seqS.length; ++posIdx) {
-        const cm = seqS.getCanonical(posIdx);
-        let om = seqS.getOriginal(posIdx);
-        if (isHelm)
-            om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
-        if (cm === GAP_SYMBOL)
-            om = GapOriginals[NOTATION.SEPARATOR];
-        else if (cm === PHOSPHATE_SYMBOL)
-            om = '';
-        resMList[posIdx] = om;
-    }
-    return resMList.join(tgtSeparator);
-}
-function joinToHelm(srcSS, wrappers, isDnaOrRna) {
-    const [prefix, leftWrapper, rightWrapper, postfix] = wrappers;
-    const resOMList = new Array(srcSS.length);
-    for (let posIdx = 0; posIdx < srcSS.length; ++posIdx) {
-        const cm = srcSS.getCanonical(posIdx);
-        let om = srcSS.getOriginal(posIdx);
-        if (cm === GAP_SYMBOL)
-            om = GapOriginals[NOTATION.HELM];
-        else {
-            if (isDnaOrRna)
-                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
-            om = om.length === 1 ? `${leftWrapper}${om}${rightWrapper}` : `${leftWrapper}[${om}]${rightWrapper}`;
-        }
-        resOMList[posIdx] = om;
-    }
-    return `${prefix}${resOMList.join('.')}${postfix}`;
-}
-//# sourceMappingURL=seq-handler.js.map