@datagrok-libraries/bio 2.6.0 → 2.7.0

package/package.json

@@ -5,7 +5,7 @@
   },
   "beta": true,
   "friendlyName": "Datagrok bio library",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "",
   "dependencies": {
     "@datagrok-libraries/utils": "^1.0.0",

package/src/utils/notation-converter.d.ts

@@ -0,0 +1,64 @@
+import * as DG from 'datagrok-api/dg';
+/** enum type to simplify setting "user-friendly" notation if necessary */
+export declare const enum NOTATION {
+    FASTA = "FASTA",
+    SEPARATOR = "SEPARATOR",
+    HELM = "HELM"
+}
+/** Class for handling conversion of notation systems in Macromolecule columns */
+export declare class NotationConverter {
+    private _sourceColumn;
+    private _sourceUnits;
+    private _sourceNotation;
+    private _defaultGapSymbol;
+    private _defaultGapSymbolsDict;
+    private get sourceUnits();
+    private get sourceColumn();
+    get sourceNotation(): NOTATION;
+    get defaultGapSymbol(): string;
+    get separator(): string;
+    isFasta(): boolean;
+    isSeparator(): boolean;
+    isHelm(): boolean;
+    toFasta(targetNotation: NOTATION): boolean;
+    toSeparator(targetNotation: NOTATION): boolean;
+    toHelm(targetNotation: NOTATION): boolean;
+    isRna(): boolean;
+    isDna(): boolean;
+    isPeptide(): boolean;
+    /** Associate notation types with the corresponding units */
+    /**
+     * @return {NOTATION}     Notation associated with the units type
+     */
+    private getSourceNotation;
+    /**
+     * Create a new empty column of the specified notation type and the same
+     * length as sourceColumn
+     *
+     * @param {NOTATION} targetNotation
+     * @return {DG.Column}
+     */
+    private getNewColumn;
+    /**
+     * Convert a Macromolecule column from FASTA to SEPARATOR notation
+     *
+     * @param {string} separator  A specific separator to be used
+     * @param {string} gapSymbol  Gap symbol in FASTA, '-' by default
+     * @return {DG.Column}        A new column in SEPARATOR notation
+     */
+    private convertFastaToSeparator;
+    private convertToHelm;
+    private handleSeparatorItemForFasta;
+    private convertSeparatorToFasta;
+    private convertHelmToFasta;
+    private convertHelmToSeparator;
+    /** Dispatcher method for notation conversion
+     *
+     * @param {NOTATION} targetNotation   Notation we want to convert to
+     * @param {string | null} tgtSeparator   Possible separator
+     * @return {DG.Column}                Converted column
+     */
+    convert(targetNotation: NOTATION, tgtSeparator?: string | null): DG.Column;
+    constructor(col: DG.Column);
+}
+//# sourceMappingURL=notation-converter.d.ts.map

package/src/utils/notation-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notation-converter.d.ts","sourceRoot":"","sources":["notation-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAGtC,0EAA0E;AAC1E,0BAAkB,QAAQ;IACxB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,IAAI,SAAS;CACd;AAED,iFAAiF;AACjF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,sBAAsB,CAI5B;IAEF,OAAO,KAAK,WAAW,GAAwC;IAE/D,OAAO,KAAK,YAAY,GAA4C;IAEpE,IAAW,cAAc,IAAI,QAAQ,CAAiC;IAEtE,IAAW,gBAAgB,IAAI,MAAM,CAAmC;IAExE,IAAW,SAAS,IAAI,MAAM,CAM7B;IAEM,OAAO,IAAI,OAAO;IAElB,WAAW,IAAI,OAAO;IAEtB,MAAM,IAAI,OAAO;IAEjB,OAAO,CAAC,cAAc,EAAE,QAAQ,GAAG,OAAO;IAE1C,WAAW,CAAC,cAAc,EAAE,QAAQ,GAAG,OAAO;IAE9C,MAAM,CAAC,cAAc,EAAE,QAAQ,GAAG,OAAO;IAEzC,KAAK,IAAI,OAAO;IAEhB,KAAK,IAAI,OAAO;IAEhB,SAAS,IAAI,OAAO;IAE3B,4DAA4D;IAC5D;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAyBpB;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAkB/B,OAAO,CAAC,aAAa;IA0CrB,OAAO,CAAC,2BAA2B;IAmBnC,OAAO,CAAC,uBAAuB;IA2C/B,OAAO,CAAC,kBAAkB;IAK1B,OAAO,CAAC,sBAAsB;IAK9B;;;;;OAKG;IACI,OAAO,CAAC,cAAc,EAAE,QAAQ,EAAE,YAAY,GAAE,MAAM,GAAG,IAAW,GAAG,EAAE,CAAC,MAAM;gBAmBpE,GAAG,EAAE,EAAE,CAAC,MAAM;CAYlC"}

package/src/utils/notation-converter.js

@@ -0,0 +1,222 @@
+import * as DG from 'datagrok-api/dg';
+import { WebLogo } from '../viewers/web-logo';
+/** Class for handling conversion of notation systems in Macromolecule columns */
+export class NotationConverter {
+    constructor(col) {
+        this._defaultGapSymbolsDict = {
+            helm: '*',
+            separator: '',
+            fasta: '-',
+        };
+        this._sourceColumn = col;
+        const units = this._sourceColumn.tags[DG.TAGS.UNITS];
+        if (units !== null)
+            this._sourceUnits = units;
+        else
+            throw new Error('Units are not specified in column');
+        this._sourceNotation = this.getSourceNotation();
+        this._defaultGapSymbol = (this.isFasta()) ? this._defaultGapSymbolsDict.fasta :
+            (this.isHelm()) ? this._defaultGapSymbolsDict.helm :
+                this._defaultGapSymbolsDict.separator;
+    }
+    get sourceUnits() { return this._sourceUnits; }
+    get sourceColumn() { return this._sourceColumn; }
+    get sourceNotation() { return this._sourceNotation; }
+    get defaultGapSymbol() { return this._defaultGapSymbol; }
+    get separator() {
+        const separator = this.sourceColumn.getTag('separator');
+        if (separator !== null)
+            return separator;
+        else
+            throw new Error('Separator not set');
+    }
+    isFasta() { return this.sourceNotation === "FASTA" /* NOTATION.FASTA */; }
+    isSeparator() { return this.sourceNotation === "SEPARATOR" /* NOTATION.SEPARATOR */; }
+    isHelm() { return this.sourceNotation === "HELM" /* NOTATION.HELM */; }
+    toFasta(targetNotation) { return targetNotation === "FASTA" /* NOTATION.FASTA */; }
+    toSeparator(targetNotation) { return targetNotation === "SEPARATOR" /* NOTATION.SEPARATOR */; }
+    toHelm(targetNotation) { return targetNotation === "HELM" /* NOTATION.HELM */; }
+    isRna() { return this.sourceUnits.toLowerCase().endsWith('rna'); }
+    isDna() { return this.sourceUnits.toLowerCase().endsWith('dna'); }
+    isPeptide() { return this.sourceUnits.toLowerCase().endsWith('pt'); }
+    /** Associate notation types with the corresponding units */
+    /**
+     * @return {NOTATION}     Notation associated with the units type
+     */
+    getSourceNotation() {
+        if (this.sourceUnits.toLowerCase().startsWith('fasta'))
+            return "FASTA" /* NOTATION.FASTA */;
+        else if (this.sourceUnits.toLowerCase().startsWith('separator'))
+            return "SEPARATOR" /* NOTATION.SEPARATOR */;
+        else if (this.sourceUnits.toLowerCase().startsWith('helm'))
+            return "HELM" /* NOTATION.HELM */;
+        else
+            throw new Error('The column has units that do not correspond to any notation');
+    }
+    /**
+     * Create a new empty column of the specified notation type and the same
+     * length as sourceColumn
+     *
+     * @param {NOTATION} targetNotation
+     * @return {DG.Column}
+     */
+    getNewColumn(targetNotation) {
+        const col = this.sourceColumn;
+        const len = col.length;
+        const name = targetNotation + '(' + col.name + ')';
+        const newColName = col.dataFrame.columns.getUnusedName(name);
+        // dummy code
+        const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill(''));
+        newColumn.semType = DG.SEMTYPE.MACROMOLECULE;
+        newColumn.setTag(DG.TAGS.UNITS, this.sourceUnits.replace(this.sourceNotation.toLowerCase().toString(), targetNotation.toLowerCase().toString()));
+        // TODO: specify cell renderers for all cases
+        if (this.toFasta(targetNotation)) {
+            newColumn.setTag(DG.TAGS.CELL_RENDERER, 
+            // TODO: replace by the enumeration value
+            'Macromolecule');
+        }
+        return newColumn;
+    }
+    /**
+     * Convert a Macromolecule column from FASTA to SEPARATOR notation
+     *
+     * @param {string} separator  A specific separator to be used
+     * @param {string} gapSymbol  Gap symbol in FASTA, '-' by default
+     * @return {DG.Column}        A new column in SEPARATOR notation
+     */
+    convertFastaToSeparator(separator, gapSymbol = '-') {
+        // a function splitting FASTA sequence into an array of monomers:
+        const splitterAsFasta = WebLogo.splitterAsFasta;
+        const newColumn = this.getNewColumn("SEPARATOR" /* NOTATION.SEPARATOR */);
+        // assign the values to the newly created empty column
+        newColumn.init((idx) => {
+            const fastaPolymer = this.sourceColumn.get(idx);
+            const fastaMonomersArray = splitterAsFasta(fastaPolymer);
+            for (let i = 0; i < fastaMonomersArray.length; i++) {
+                if (fastaMonomersArray[i] === gapSymbol)
+                    fastaMonomersArray[i] = '';
+            }
+            return fastaMonomersArray.join(separator);
+        });
+        return newColumn;
+    }
+    convertToHelm(sourceGapSymbol = null) {
+        if (sourceGapSymbol === null)
+            sourceGapSymbol = this.defaultGapSymbol;
+        // A function splitting a sequence into an array of monomers according to
+        // its notation
+        const splitter = WebLogo.getSplitterForColumn(this.sourceColumn);
+        const prefix = (this.isDna()) ? 'DNA1{' :
+            (this.isRna()) ? 'RNA1{' :
+                (this.isPeptide()) ? 'PEPTIDE1{' :
+                    'Unknown'; // this case should be handled as exceptional
+        if (prefix === 'Unknown')
+            throw new Error('Neither peptide, nor nucleotide');
+        const postfix = '}$$$';
+        const leftWrapper = (this.isDna()) ? 'D(' :
+            (this.isRna()) ? 'R(' : ''; // no wrapper for peptides
+        const rightWrapper = (this.isDna() || this.isRna()) ? ')P' : ''; // no wrapper for peptides
+        const newColumn = this.getNewColumn("HELM" /* NOTATION.HELM */);
+        // assign the values to the empty column
+        newColumn.init((idx) => {
+            const sourcePolymer = this.sourceColumn.get(idx);
+            const sourceMonomersArray = splitter(sourcePolymer);
+            const helmArray = [prefix];
+            let firstIteration = true;
+            for (let i = 0; i < sourceMonomersArray.length; i++) {
+                const dot = firstIteration ? '' : '.';
+                let token = sourceMonomersArray[i];
+                if (token === sourceGapSymbol)
+                    token = this._defaultGapSymbolsDict.helm;
+                const item = [dot, leftWrapper, token, rightWrapper];
+                helmArray.push(item.join(''));
+                firstIteration = false;
+            }
+            helmArray.push(postfix);
+            return helmArray.join('');
+        });
+        return newColumn;
+    }
+    handleSeparatorItemForFasta(idx, separatorItemsArray, separator, gapSymbol, fastaMonomersArray) {
+        const item = separatorItemsArray[idx];
+        if (item.length > 1) {
+            // the case of a multi-character monomer
+            const monomer = '[' + item + ']';
+            fastaMonomersArray.push(monomer);
+        }
+        if (item === separator) {
+            if (idx !== 0 && separatorItemsArray[idx - 1] === separator)
+                fastaMonomersArray.push(gapSymbol);
+        }
+    }
+    convertSeparatorToFasta(separator = null, gapSymbol = '-') {
+        // TODO: implementation
+        // * similarly to fasta2separator, divide string into monomers
+        // * adjacent separators is a gap (symbol to be specified)
+        // * the monomers MUST be single-character onles, otherwise forbid
+        // * NO, they can be multi-characters
+        // conversion
+        // * consider automatic determining the separator
+        if (separator === null)
+            separator = this.separator;
+        // a function splitting FASTA sequence into an array of monomers
+        //const splitterAsSeparator = WebLogo.getSplitterWithSeparator(separator);
+        const splitter = WebLogo.getSplitterForColumn(this.sourceColumn);
+        const newColumn = this.getNewColumn("FASTA" /* NOTATION.FASTA */);
+        // assign the values to the empty column
+        newColumn.init((idx) => {
+            const separatorPolymer = this.sourceColumn.get(idx);
+            // items can be monomers or separators
+            const separatorItemsArray = splitter(separatorPolymer);
+            const fastaMonomersArray = [];
+            for (let i = 0; i < separatorItemsArray.length; i++) {
+                const item = separatorItemsArray[i];
+                if (item.length === 0) {
+                    fastaMonomersArray.push(gapSymbol);
+                }
+                else if (item.length > 1) {
+                    // the case of a multi-character monomer
+                    const monomer = '[' + item + ']';
+                    fastaMonomersArray.push(monomer);
+                }
+                else {
+                    fastaMonomersArray.push(item);
+                }
+            }
+            return fastaMonomersArray.join('');
+        });
+        return newColumn;
+    }
+    convertHelmToFasta() {
+        // TODO: implementation
+        return this.getNewColumn("FASTA" /* NOTATION.FASTA */);
+    }
+    convertHelmToSeparator() {
+        // TODO: implementatioreturn this.getNewColumn();
+        return this.getNewColumn("SEPARATOR" /* NOTATION.SEPARATOR */);
+    }
+    /** Dispatcher method for notation conversion
+     *
+     * @param {NOTATION} targetNotation   Notation we want to convert to
+     * @param {string | null} tgtSeparator   Possible separator
+     * @return {DG.Column}                Converted column
+     */
+    convert(targetNotation, tgtSeparator = null) {
+        // possible exceptions
+        if (this.sourceNotation === targetNotation)
+            throw new Error('Target notation is invalid');
+        if (this.toSeparator(targetNotation) && tgtSeparator === null)
+            throw new Error('Target separator is not specified');
+        if (this.isFasta() && this.toSeparator(targetNotation) && tgtSeparator !== null)
+            return this.convertFastaToSeparator(tgtSeparator);
+        else if ((this.isFasta() || this.isSeparator()) && this.toHelm(targetNotation))
+            return this.convertToHelm();
+        else if (this.isSeparator() && this.toFasta(targetNotation))
+            return this.convertSeparatorToFasta(tgtSeparator);
+        else if (this.isHelm() && this.toFasta(targetNotation))
+            return this.convertHelmToFasta();
+        else
+            return this.convertHelmToSeparator();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notation-converter.js","sourceRoot":"","sources":["notation-converter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as DG from 'datagrok-api/dg';\nimport {WebLogo} from '../viewers/web-logo';\n\n/** enum type to simplify setting \"user-friendly\" notation if necessary */\nexport const enum NOTATION {\n  FASTA = 'FASTA',\n  SEPARATOR = 'SEPARATOR',\n  HELM = 'HELM'\n}\n\n/** Class for handling conversion of notation systems in Macromolecule columns */\nexport class NotationConverter {\n  private _sourceColumn: DG.Column; // the column to be converted\n  private _sourceUnits: string; // units, of the form fasta:SEQ:NT, etc.\n  private _sourceNotation: NOTATION; // current notation (without :SEQ:NT, etc.)\n  private _defaultGapSymbol: string;\n  private _defaultGapSymbolsDict = {\n    helm: '*',\n    separator: '',\n    fasta: '-',\n  };\n\n  private get sourceUnits(): string { return this._sourceUnits; }\n\n  private get sourceColumn(): DG.Column { return this._sourceColumn; }\n\n  public get sourceNotation(): NOTATION { return this._sourceNotation; }\n\n  public get defaultGapSymbol(): string { return this._defaultGapSymbol; }\n\n  public get separator(): string {\n    const separator = this.sourceColumn.getTag('separator');\n    if (separator !== null)\n      return separator;\n    else\n      throw new Error('Separator not set');\n  }\n\n  public isFasta(): boolean { return this.sourceNotation === NOTATION.FASTA; }\n\n  public isSeparator(): boolean { return this.sourceNotation === NOTATION.SEPARATOR; }\n\n  public isHelm(): boolean { return this.sourceNotation === NOTATION.HELM; }\n\n  public toFasta(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.FASTA; }\n\n  public toSeparator(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.SEPARATOR; }\n\n  public toHelm(targetNotation: NOTATION): boolean { return targetNotation === NOTATION.HELM; }\n\n  public isRna(): boolean { return this.sourceUnits.toLowerCase().endsWith('rna'); }\n\n  public isDna(): boolean { return this.sourceUnits.toLowerCase().endsWith('dna'); }\n\n  public isPeptide(): boolean { return this.sourceUnits.toLowerCase().endsWith('pt'); }\n\n  /** Associate notation types with the corresponding units */\n  /**\n   * @return {NOTATION}     Notation associated with the units type\n   */\n  private getSourceNotation(): NOTATION {\n    if (this.sourceUnits.toLowerCase().startsWith('fasta'))\n      return NOTATION.FASTA;\n    else if (this.sourceUnits.toLowerCase().startsWith('separator'))\n      return NOTATION.SEPARATOR;\n    else if (this.sourceUnits.toLowerCase().startsWith('helm'))\n      return NOTATION.HELM;\n    else\n      throw new Error('The column has units that do not correspond to any notation');\n  }\n\n  /**\n   * Create a new empty column of the specified notation type and the same\n   * length as sourceColumn\n   *\n   * @param {NOTATION} targetNotation\n   * @return {DG.Column}\n   */\n  private getNewColumn(targetNotation: NOTATION): DG.Column {\n    const col = this.sourceColumn;\n    const len = col.length;\n    const name = targetNotation + '(' + col.name + ')';\n    const newColName = col.dataFrame.columns.getUnusedName(name);\n    // dummy code\n    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill(''));\n    newColumn.semType = DG.SEMTYPE.MACROMOLECULE;\n    newColumn.setTag(\n      DG.TAGS.UNITS,\n      this.sourceUnits.replace(\n        this.sourceNotation.toLowerCase().toString(),\n        targetNotation.toLowerCase().toString()\n      )\n    );\n    // TODO: specify cell renderers for all cases\n    if (this.toFasta(targetNotation)) {\n      newColumn.setTag(\n        DG.TAGS.CELL_RENDERER,\n        // TODO: replace by the enumeration value\n        'Macromolecule');\n    }\n    return newColumn;\n  }\n\n  /**\n   * Convert a Macromolecule column from FASTA to SEPARATOR notation\n   *\n   * @param {string} separator  A specific separator to be used\n   * @param {string} gapSymbol  Gap symbol in FASTA, '-' by default\n   * @return {DG.Column}        A new column in SEPARATOR notation\n   */\n  private convertFastaToSeparator(separator: string, gapSymbol: string = '-'): DG.Column {\n    // a function splitting FASTA sequence into an array of monomers:\n    const splitterAsFasta = WebLogo.splitterAsFasta;\n\n    const newColumn = this.getNewColumn(NOTATION.SEPARATOR);\n    // assign the values to the newly created empty column\n    newColumn.init((idx: number) => {\n      const fastaPolymer = this.sourceColumn.get(idx);\n      const fastaMonomersArray = splitterAsFasta(fastaPolymer);\n      for (let i = 0; i < fastaMonomersArray.length; i++) {\n        if (fastaMonomersArray[i] === gapSymbol)\n          fastaMonomersArray[i] = '';\n      }\n      return fastaMonomersArray.join(separator);\n    });\n    return newColumn;\n  }\n\n  private convertToHelm(sourceGapSymbol: string | null = null) {\n    if (sourceGapSymbol === null)\n      sourceGapSymbol = this.defaultGapSymbol;\n    // A function splitting a sequence into an array of monomers according to\n    // its notation\n    const splitter = WebLogo.getSplitterForColumn(this.sourceColumn);\n\n    const prefix = (this.isDna()) ? 'DNA1{' :\n      (this.isRna()) ? 'RNA1{' :\n        (this.isPeptide()) ? 'PEPTIDE1{' :\n          'Unknown'; // this case should be handled as exceptional\n\n    if (prefix === 'Unknown')\n      throw new Error('Neither peptide, nor nucleotide');\n\n    const postfix = '}$$$';\n    const leftWrapper = (this.isDna()) ? 'D(' :\n      (this.isRna()) ? 'R(' : ''; // no wrapper for peptides\n    const rightWrapper = (this.isDna() || this.isRna()) ? ')P' : ''; // no wrapper for peptides\n\n    const newColumn = this.getNewColumn(NOTATION.HELM);\n    // assign the values to the empty column\n    newColumn.init((idx: number) => {\n      const sourcePolymer = this.sourceColumn.get(idx);\n      const sourceMonomersArray = splitter(sourcePolymer);\n      const helmArray = [prefix];\n      let firstIteration = true;\n      for (let i = 0; i < sourceMonomersArray.length; i++) {\n        const dot = firstIteration ? '' : '.';\n        let token = sourceMonomersArray[i];\n        if (token === sourceGapSymbol)\n          token = this._defaultGapSymbolsDict.helm;\n        const item = [dot, leftWrapper, token, rightWrapper];\n        helmArray.push(item.join(''));\n        firstIteration = false;\n      }\n      helmArray.push(postfix);\n      return helmArray.join('');\n    });\n    return newColumn;\n  }\n\n  private handleSeparatorItemForFasta(\n    idx: number,\n    separatorItemsArray: string[],\n    separator: string,\n    gapSymbol: string,\n    fastaMonomersArray: string[]\n  ): void {\n    const item = separatorItemsArray[idx];\n    if (item.length > 1) {\n      // the case of a multi-character monomer\n      const monomer = '[' + item + ']';\n      fastaMonomersArray.push(monomer);\n    }\n    if (item === separator) {\n      if (idx !== 0 && separatorItemsArray[idx - 1] === separator)\n        fastaMonomersArray.push(gapSymbol);\n    }\n  }\n\n  private convertSeparatorToFasta(\n    separator: string | null = null,\n    gapSymbol: string = '-'\n  ): DG.Column {\n    // TODO: implementation\n    // * similarly to fasta2separator, divide string into monomers\n    // * adjacent separators is a gap (symbol to be specified)\n    // * the monomers MUST be single-character onles, otherwise forbid\n    // * NO, they can be multi-characters\n    // conversion\n    // * consider automatic determining the separator\n\n    if (separator === null)\n      separator = this.separator;\n\n    // a function splitting FASTA sequence into an array of monomers\n    //const splitterAsSeparator = WebLogo.getSplitterWithSeparator(separator);\n    const splitter = WebLogo.getSplitterForColumn(this.sourceColumn);\n\n    const newColumn = this.getNewColumn(NOTATION.FASTA);\n    // assign the values to the empty column\n    newColumn.init((idx: number) => {\n      const separatorPolymer = this.sourceColumn.get(idx);\n      // items can be monomers or separators\n      const separatorItemsArray = splitter(separatorPolymer);\n      const fastaMonomersArray: string[] = [];\n      for (let i = 0; i < separatorItemsArray.length; i++) {\n        const item = separatorItemsArray[i];\n        if (item.length === 0) {\n          fastaMonomersArray.push(gapSymbol);\n        } else if (item.length > 1) {\n          // the case of a multi-character monomer\n          const monomer = '[' + item + ']';\n          fastaMonomersArray.push(monomer);\n        } else {\n          fastaMonomersArray.push(item);\n        }\n      }\n      return fastaMonomersArray.join('');\n    });\n    return newColumn;\n  }\n\n  private convertHelmToFasta(): DG.Column {\n    // TODO: implementation\n    return this.getNewColumn(NOTATION.FASTA);\n  }\n\n  private convertHelmToSeparator(): DG.Column {\n    // TODO: implementatioreturn this.getNewColumn();\n    return this.getNewColumn(NOTATION.SEPARATOR);\n  }\n\n  /** Dispatcher method for notation conversion\n   *\n   * @param {NOTATION} targetNotation   Notation we want to convert to\n   * @param {string | null} tgtSeparator   Possible separator\n   * @return {DG.Column}                Converted column\n   */\n  public convert(targetNotation: NOTATION, tgtSeparator: string | null = null): DG.Column {\n    // possible exceptions\n    if (this.sourceNotation === targetNotation)\n      throw new Error('Target notation is invalid');\n    if (this.toSeparator(targetNotation) && tgtSeparator === null)\n      throw new Error('Target separator is not specified');\n\n    if (this.isFasta() && this.toSeparator(targetNotation) && tgtSeparator !== null)\n      return this.convertFastaToSeparator(tgtSeparator);\n    else if ((this.isFasta() || this.isSeparator()) && this.toHelm(targetNotation))\n      return this.convertToHelm();\n    else if (this.isSeparator() && this.toFasta(targetNotation))\n      return this.convertSeparatorToFasta(tgtSeparator!);\n    else if (this.isHelm() && this.toFasta(targetNotation))\n      return this.convertHelmToFasta();\n    else\n      return this.convertHelmToSeparator();\n  }\n\n  public constructor(col: DG.Column) {\n    this._sourceColumn = col;\n    const units = this._sourceColumn.tags[DG.TAGS.UNITS];\n    if (units !== null)\n      this._sourceUnits = units;\n    else\n      throw new Error('Units are not specified in column');\n    this._sourceNotation = this.getSourceNotation();\n    this._defaultGapSymbol = (this.isFasta()) ? this._defaultGapSymbolsDict.fasta :\n      (this.isHelm()) ? this._defaultGapSymbolsDict.helm :\n        this._defaultGapSymbolsDict.separator;\n  }\n}\n"]}