@datagrok-libraries/bio 2.8.4 → 2.8.7

package/package.json

@@ -5,7 +5,7 @@
   },
   "beta": true,
   "friendlyName": "Datagrok bio library",
-  "version": "2.8.4",
+  "version": "2.8.7",
   "description": "",
   "dependencies": {
     "@datagrok-libraries/utils": "^1.0.0",
@@ -29,14 +29,14 @@
     "link-api": "npm link datagrok-api",
     "link-utils": "npm link @datagrok-libraries/utils",
     "link-all": "npm link datagrok-api @datagrok-libraries/utils",
-    "debug-bio": "grok publish --rebuild",
-    "release-bio": "grok publish --rebuild --release",
+    "debug-bio": "grok publish",
+    "release-bio": "grok publish --release",
     "build-bio": "tsc",
     "build": "tsc",
-    "debug-bio-public": "grok publish public --rebuild",
-    "release-bio-public": "grok publish public --rebuild --release",
-    "debug-bio-local": "grok publish local --rebuild",
-    "release-bio-local": "grok publish local --rebuild --release",
+    "debug-bio-public": "grok publish public",
+    "release-bio-public": "grok publish public --release",
+    "debug-bio-local": "grok publish local",
+    "release-bio-local": "grok publish local --release",
     "lint": "eslint \"./src/**/*.ts\"",
     "lint-fix": "eslint \"./src/**/*.ts\" --fix"
   }

package/src/utils/fasta-handler.d.ts

@@ -0,0 +1,29 @@
+import * as DG from 'datagrok-api/dg';
+/** Class for parsing FASTA files */
+export declare class FastaFileHandler {
+    private _fileContent;
+    private _descriptionsArray;
+    private _sequencesArray;
+    private _columnsParsed;
+    get descriptionsArray(): string[];
+    get sequencesArray(): string[];
+    /**
+     * Helper method to parse a macromolecule from a FASTA file (string)
+     *
+     * @param {number} startOfSequence  index of macromolecule substring beginning
+     * @param {number} endOfSequence  index of macromolecule substring end
+  
+     * @return {string} parsed macromolecule
+     */
+    private parseMacromolecule;
+    /** Parse descriptions and sequences from a FASTA string */
+    private parseColumns;
+    /**
+     * File-handler method for import as FASTA
+     *
+     * @return {DG.DataFrame[]} dataframe with parsed FASTA content
+     */
+    importFasta(): DG.DataFrame[];
+    constructor(fileContent: string);
+}
+//# sourceMappingURL=fasta-handler.d.ts.map

package/src/utils/fasta-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fasta-handler.d.ts","sourceRoot":"","sources":["fasta-handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAItC,oCAAoC;AACpC,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,kBAAkB,CAAgB;IAC1C,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,cAAc,CAAkB;IAExC,IAAW,iBAAiB,IAAI,MAAM,EAAE,CAKvC;IAED,IAAW,cAAc,IAAI,MAAM,EAAE,CAKpC;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAS1B,2DAA2D;IAC3D,OAAO,CAAC,YAAY;IAkBpB;;;;OAIG;IACI,WAAW,IAAI,EAAE,CAAC,SAAS,EAAG;gBAezB,WAAW,EAAE,MAAM;CAGhC"}

package/src/utils/fasta-handler.js

@@ -0,0 +1,70 @@
+import * as DG from 'datagrok-api/dg';
+import { UnitsHandler } from './units-handler';
+/** Class for parsing FASTA files */
+export class FastaFileHandler {
+    constructor(fileContent) {
+        this._descriptionsArray = []; // parsed FASTA descriptions
+        this._sequencesArray = []; // parsed FASTA sequeces
+        this._columnsParsed = false;
+        this._fileContent = fileContent;
+    }
+    get descriptionsArray() {
+        if (this._columnsParsed)
+            return this._descriptionsArray;
+        else
+            throw new Error('Run parseColumns first');
+    }
+    get sequencesArray() {
+        if (this._columnsParsed)
+            return this._sequencesArray;
+        else
+            throw new Error('Run parseColumns first');
+    }
+    /**
+     * Helper method to parse a macromolecule from a FASTA file (string)
+     *
+     * @param {number} startOfSequence  index of macromolecule substring beginning
+     * @param {number} endOfSequence  index of macromolecule substring end
+  
+     * @return {string} parsed macromolecule
+     */
+    parseMacromolecule(startOfSequence, endOfSequence) {
+        const seq = this._fileContent.slice(startOfSequence, endOfSequence);
+        const seqArray = seq.split(/\s/);
+        return seqArray.join('');
+    }
+    /** Parse descriptions and sequences from a FASTA string */
+    parseColumns() {
+        // parse description and content
+        const regex = /^>(.*)$/gm; // match 'description' lines starting with >
+        let startOfSequence = 0;
+        let match; // match.index is the beginning of the matched line
+        while (match = regex.exec(this._fileContent)) {
+            const description = this._fileContent.substring(match.index + 1, regex.lastIndex);
+            this._descriptionsArray.push(description);
+            if (startOfSequence !== 0)
+                this._sequencesArray.push(this.parseMacromolecule(startOfSequence, match.index));
+            startOfSequence = regex.lastIndex + 1;
+        }
+        this._sequencesArray.push(this.parseMacromolecule(startOfSequence, -1));
+        this._columnsParsed = true;
+    }
+    /**
+     * File-handler method for import as FASTA
+     *
+     * @return {DG.DataFrame[]} dataframe with parsed FASTA content
+     */
+    importFasta() {
+        this.parseColumns();
+        const descriptionsArrayCol = DG.Column.fromStrings('description', this.descriptionsArray);
+        const sequenceCol = DG.Column.fromStrings('sequence', this.sequencesArray);
+        sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
+        // here should go the code from units handler
+        UnitsHandler.setUnitsToFastaColumn(sequenceCol);
+        return [DG.DataFrame.fromColumns([
+                descriptionsArrayCol,
+                sequenceCol,
+            ])];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,47 +1,13 @@
 import * as DG from 'datagrok-api/dg';
 import { SplitterFunc } from '../viewers/web-logo';
-/** enum type to simplify setting "user-friendly" notation if necessary */
-export declare const enum NOTATION {
-    FASTA = "FASTA",
-    SEPARATOR = "SEPARATOR",
-    HELM = "HELM"
-}
+import { UnitsHandler, NOTATION } from './units-handler';
 /** Class for handling conversion of notation systems in Macromolecule columns */
-export declare class NotationConverter {
-    private readonly _sourceColumn;
-    private _sourceUnits;
-    private _sourceNotation;
-    private _defaultGapSymbol;
-    private _defaultGapSymbolsDict;
+export declare class NotationConverter extends UnitsHandler {
     private _splitter;
     protected get splitter(): SplitterFunc;
-    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
      *
@@ -94,7 +60,7 @@ export declare class NotationConverter {
     private convertHelmToSeparator;
     /** Dispatcher method for notation conversion
      *
-     * @param {NOTATION} targetNotation   Notation we want to convert to
+     * @param {NOTATION} tgtNotation   Notation we want to convert to
      * @param {string | null} tgtSeparator   Possible separator
      * @return {DG.Column}                Converted column
      */

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

@@ -1 +1 @@
-{"version":3,"file":"notation-converter.d.ts","sourceRoot":"","sources":["notation-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,YAAY,EAAU,MAAM,qBAAqB,CAAC;AAE1D,0EAA0E;AAC1E,0BAAkB,QAAQ;IACxB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,IAAI,SAAS;CACd;AAED,iFAAiF;AACjF,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAY;IAC1C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,eAAe,CAAW;IAClC,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,sBAAsB,CAI5B;IAEF,OAAO,CAAC,SAAS,CAA6B;IAC9C,SAAS,KAAK,QAAQ,IAAI,YAAY,CAIrC;IAGD,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;IAwBpB;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,mBAAmB;IAkB3B;;;;;;;OAOG;IACI,mBAAmB,CACxB,aAAa,EAAE,MAAM,EACrB,eAAe,GAAE,MAAM,GAAG,IAAW,GACnC,MAAM;IAOV;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IA4B/B;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IAsCnB,OAAO,CAAC,sBAAsB;IAK9B;;;;;OAKG;IACI,OAAO,CAAC,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAE,MAAM,GAAG,IAAW,GAAG,EAAE,CAAC,MAAM;gBAmBjE,GAAG,EAAE,EAAE,CAAC,MAAM;CAYlC"}
+{"version":3,"file":"notation-converter.d.ts","sourceRoot":"","sources":["notation-converter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,YAAY,EAAU,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAC,YAAY,EAAE,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAEvD,iFAAiF;AACjF,qBAAa,iBAAkB,SAAQ,YAAY;IACjD,OAAO,CAAC,SAAS,CAA6B;IAC9C,SAAS,KAAK,QAAQ,IAAI,YAAY,CAIrC;IAEM,OAAO,CAAC,cAAc,EAAE,QAAQ,GAAG,OAAO;IAE1C,WAAW,CAAC,cAAc,EAAE,QAAQ,GAAG,OAAO;IAE9C,MAAM,CAAC,cAAc,EAAE,QAAQ,GAAG,OAAO;IAEhD;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,mBAAmB;IAkB3B;;;;;;;OAOG;IACI,mBAAmB,CACxB,aAAa,EAAE,MAAM,EACrB,eAAe,GAAE,MAAM,GAAG,IAAW,GACnC,MAAM;IAOV;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IA4B/B;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IAiDnB,OAAO,CAAC,sBAAsB;IAK9B;;;;;OAKG;IACI,OAAO,CAAC,WAAW,EAAE,QAAQ,EAAE,YAAY,GAAE,MAAM,GAAG,IAAW,GAAG,EAAE,CAAC,MAAM;gBAmBjE,GAAG,EAAE,EAAE,CAAC,MAAM;CAGlC"}

package/src/utils/notation-converter.js

@@ -1,87 +1,20 @@
-import * as DG from 'datagrok-api/dg';
 import { WebLogo } from '../viewers/web-logo';
+import { UnitsHandler } from './units-handler';
 /** Class for handling conversion of notation systems in Macromolecule columns */
-export class NotationConverter {
+export class NotationConverter extends UnitsHandler {
     constructor(col) {
-        this._defaultGapSymbolsDict = {
-            HELM: '*',
-            SEPARATOR: '',
-            FASTA: '-',
-        };
+        super(col);
         this._splitter = null;
-        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 splitter() {
         if (this._splitter === null)
-            this._splitter = WebLogo.getSplitterForColumn(this._sourceColumn);
+            this._splitter = WebLogo.getSplitterForColumn(this.column);
         return this._splitter;
     }
     ;
-    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.toLowerCase() + '(' + 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, 'Macromolecule');
-        }
-        return newColumn;
-    }
     /**
      * Convert a Macromolecule column from FASTA to SEPARATOR notation
      *
@@ -95,7 +28,7 @@ export class NotationConverter {
         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 fastaPolymer = this.column.get(idx);
             const fastaMonomersArray = this.splitter(fastaPolymer);
             for (let i = 0; i < fastaMonomersArray.length; i++) {
                 if (fastaMonomersArray[i] === fastaGapSymbol)
@@ -163,7 +96,7 @@ export class NotationConverter {
         const newColumn = this.getNewColumn("HELM" /* NOTATION.HELM */);
         // assign the values to the empty column
         newColumn.init((idx) => {
-            const sourcePolymer = this.sourceColumn.get(idx);
+            const sourcePolymer = this.column.get(idx);
             return this.convertToHelmHelper(sourcePolymer, sourceGapSymbol, prefix, leftWrapper, rightWrapper, postfix);
         });
         return newColumn;
@@ -180,7 +113,7 @@ export class NotationConverter {
         const newColumn = this.getNewColumn("FASTA" /* NOTATION.FASTA */);
         // assign the values to the empty column
         newColumn.init((idx) => {
-            const separatorPolymer = this.sourceColumn.get(idx);
+            const separatorPolymer = this.column.get(idx);
             // items can be monomers or separators
             const separatorItemsArray = this.splitter(separatorPolymer);
             const fastaMonomersArray = [];
@@ -212,6 +145,8 @@ export class NotationConverter {
      * @return {DG.Column} Converted column
      */
     convertHelm(tgtNotation, tgtSeparator = '', tgtGapSymbol = null) {
+        // This function must not contain calls of isDna() and isRna(), for
+        // source helm columns may contain RNA, DNA and PT across different rows
         if (tgtGapSymbol === null) {
             tgtGapSymbol = (this.toFasta(tgtNotation)) ?
                 this._defaultGapSymbolsDict.FASTA :
@@ -219,15 +154,22 @@ export class NotationConverter {
         }
         if (this.toSeparator(tgtNotation) && tgtSeparator === '')
             tgtSeparator = this.separator;
+        const helmWrappersRe = /(R\(|D\(|\)|P)/g;
         const newColumn = this.getNewColumn(tgtNotation);
         // assign the values to the empty column
         newColumn.init((idx) => {
-            const helmPolymer = this.sourceColumn.get(idx);
+            const helmPolymer = this.column.get(idx);
+            // we cannot use isDna() or isRna() because source helm columns can
+            // contain DNA, RNA and PT in different cells, so the corresponding
+            // tags cannot be set for the whole column
+            const isNucleotide = helmPolymer.startsWith('DNA') || helmPolymer.startsWith('RNA');
             // items can be monomers or helms
             const helmItemsArray = this.splitter(helmPolymer);
             const tgtMonomersArray = [];
             for (let i = 0; i < helmItemsArray.length; i++) {
-                const item = helmItemsArray[i];
+                let item = helmItemsArray[i];
+                if (isNucleotide)
+                    item = item.replace(helmWrappersRe, '');
                 if (item === this._defaultGapSymbolsDict.HELM) {
                     tgtMonomersArray.push(tgtGapSymbol);
                 }
@@ -250,13 +192,13 @@ export class NotationConverter {
     }
     /** Dispatcher method for notation conversion
      *
-     * @param {NOTATION} targetNotation   Notation we want to convert to
+     * @param {NOTATION} tgtNotation   Notation we want to convert to
      * @param {string | null} tgtSeparator   Possible separator
      * @return {DG.Column}                Converted column
      */
     convert(tgtNotation, tgtSeparator = null) {
         // possible exceptions
-        if (this.sourceNotation === tgtNotation)
+        if (this.notation === tgtNotation)
             throw new Error('tgt notation is invalid');
         if (this.toSeparator(tgtNotation) && tgtSeparator === null)
             throw new Error('tgt separator is not specified');
@@ -272,4 +214,4 @@ export class NotationConverter {
             return this.convertHelm(tgtNotation, tgtSeparator);
     }
 }
-//# 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 {SplitterFunc, 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 readonly _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 _splitter: SplitterFunc | null = null;\n  protected get splitter(): SplitterFunc {\n    if (this._splitter === null)\n      this._splitter = WebLogo.getSplitterForColumn(this._sourceColumn);\n    return this._splitter;\n  };\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.toLowerCase() + '(' + 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        '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} fastaGapSymbol  Gap symbol in FASTA, '-' by default\n   * @return {DG.Column}        A new column in SEPARATOR notation\n   */\n  private convertFastaToSeparator(separator: string, fastaGapSymbol: string | null = null): DG.Column {\n    if (fastaGapSymbol === null)\n      fastaGapSymbol = this.defaultGapSymbol;\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 = this.splitter(fastaPolymer);\n      for (let i = 0; i < fastaMonomersArray.length; i++) {\n        if (fastaMonomersArray[i] === fastaGapSymbol)\n          fastaMonomersArray[i] = this._defaultGapSymbolsDict.SEPARATOR;\n      }\n      return fastaMonomersArray.join(separator);\n    });\n    newColumn.setTag('separator', separator);\n    return newColumn;\n  }\n\n  /**\n   * Get the wrapper strings for HELM, depending on the type of the\n   * macromolecule (peptide, DNA, RNA)\n   *\n   * @return {string[]} Array of wrappers\n   */\n  private getHelmWrappers(): string[] {\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    return [prefix, leftWrapper, rightWrapper, postfix];\n  }\n\n  // A helper function for converting strings to HELM\n  private convertToHelmHelper(\n    sourcePolymer: string,\n    sourceGapSymbol: string,\n    prefix: string,\n    leftWrapper: string,\n    rightWrapper: string,\n    postfix: string\n  ): string {\n    const monomerArray = this.splitter(sourcePolymer);\n    const monomerHelmArray: string[] = monomerArray.map((mm: string) => {\n      if (mm === sourceGapSymbol)\n        return this._defaultGapSymbolsDict.HELM;\n      else\n        return `${leftWrapper}${mm}${rightWrapper}`;\n    });\n    return `${prefix}${monomerHelmArray.join('.')}${postfix}`;\n  }\n\n  /**\n   * Convert a string with SEPARATOR/FASTA notation to HELM\n   *\n   * @param {string} sourcePolymer  A string to be converted\n   * @param {string | null} sourceGapSymbol  An optional gap symbol, set to\n   * default values ('-' for FASTA and '' for SEPARATOR) unless specified\n   * @return {string}  The target HELM string\n   */\n  public convertStringToHelm(\n    sourcePolymer: string,\n    sourceGapSymbol: string | null = null\n  ) : string {\n    if (sourceGapSymbol === null)\n      sourceGapSymbol = this.defaultGapSymbol;\n    const [prefix, leftWrapper, rightWrapper, postfix] = this.getHelmWrappers();\n    return this.convertToHelmHelper(sourcePolymer, sourceGapSymbol, prefix, leftWrapper, rightWrapper, postfix);\n  }\n\n  /**\n   * Convert a column to HELM\n   *\n   * @param {string | null} sourceGapSymbol\n   * @return {DG.Column}\n   */\n  private convertToHelm(sourceGapSymbol: string | null = null): DG.Column {\n    if (sourceGapSymbol === null)\n      sourceGapSymbol = this.defaultGapSymbol;\n\n    const [prefix, leftWrapper, rightWrapper, postfix] = this.getHelmWrappers();\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      return this.convertToHelmHelper(sourcePolymer, sourceGapSymbol!, prefix, leftWrapper, rightWrapper, postfix);\n    });\n    return newColumn;\n  }\n\n  /**\n   * Convert SEPARATOR column to FASTA notation\n   *\n   * @param {string | null} fastaGapSymbol Optional gap symbol for FASTA\n   * @return {DG.Column}  Converted column\n   */\n  private convertSeparatorToFasta(fastaGapSymbol: string | null = null): DG.Column {\n    if (fastaGapSymbol === null)\n      fastaGapSymbol = this._defaultGapSymbolsDict.FASTA;\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 = this.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(fastaGapSymbol!);\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  /**\n   *  Convert HELM column to FASTA/SEPARATOR\n   *\n   * @param {string} tgtNotation    Target notation: FASTA or SEPARATOR\n   * @param {string} tgtSeparator   Optional target separator (for HELM ->\n   * @param {string | null} tgtGapSymbol   Optional target gap symbol\n   * SEPARATOR)\n   * @return {DG.Column} Converted column\n   */\n  private convertHelm(\n    tgtNotation: string,\n    tgtSeparator: string = '',\n    tgtGapSymbol: string | null = null\n  ): DG.Column {\n    if (tgtGapSymbol === null) {\n      tgtGapSymbol = (this.toFasta(tgtNotation as NOTATION)) ?\n        this._defaultGapSymbolsDict.FASTA :\n        this._defaultGapSymbolsDict.SEPARATOR;\n    }\n\n    if (this.toSeparator(tgtNotation as NOTATION) && tgtSeparator === '')\n      tgtSeparator = this.separator;\n\n    const newColumn = this.getNewColumn(tgtNotation as NOTATION);\n    // assign the values to the empty column\n    newColumn.init((idx: number) => {\n      const helmPolymer = this.sourceColumn.get(idx);\n      // items can be monomers or helms\n      const helmItemsArray = this.splitter(helmPolymer);\n      const tgtMonomersArray: string[] = [];\n      for (let i = 0; i < helmItemsArray.length; i++) {\n        const item = helmItemsArray[i];\n        if (item === this._defaultGapSymbolsDict.HELM) {\n          tgtMonomersArray.push(tgtGapSymbol!);\n        } else if (this.toFasta(tgtNotation as NOTATION) && item.length > 1) {\n          // the case of a multi-character monomer converted to FASTA\n          const monomer = '[' + item + ']';\n          tgtMonomersArray.push(monomer);\n        } else {\n          tgtMonomersArray.push(item);\n        }\n      }\n      return tgtMonomersArray.join(tgtSeparator);\n    });\n    return newColumn;\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(tgtNotation: NOTATION, tgtSeparator: string | null = null): DG.Column {\n    // possible exceptions\n    if (this.sourceNotation === tgtNotation)\n      throw new Error('tgt notation is invalid');\n    if (this.toSeparator(tgtNotation) && tgtSeparator === null)\n      throw new Error('tgt separator is not specified');\n\n    if (this.isFasta() && this.toSeparator(tgtNotation) && tgtSeparator !== null)\n      return this.convertFastaToSeparator(tgtSeparator);\n    else if ((this.isFasta() || this.isSeparator()) && this.toHelm(tgtNotation))\n      return this.convertToHelm();\n    else if (this.isSeparator() && this.toFasta(tgtNotation))\n      return this.convertSeparatorToFasta();\n    else if (this.isHelm() && this.toFasta(tgtNotation)) // the case of HELM\n      return this.convertHelm(tgtNotation);\n    else // this.isHelm() && this.toSeparator(tgtNotation)\n      return this.convertHelm(tgtNotation, tgtSeparator!);\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notation-converter.js","sourceRoot":"","sources":["notation-converter.ts"],"names":[],"mappings":"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","sourcesContent":["/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport {SplitterFunc, WebLogo} from '../viewers/web-logo';\nimport {UnitsHandler, NOTATION} from './units-handler';\n\n/** Class for handling conversion of notation systems in Macromolecule columns */\nexport class NotationConverter extends UnitsHandler {\n  private _splitter: SplitterFunc | null = null;\n  protected get splitter(): SplitterFunc {\n    if (this._splitter === null)\n      this._splitter = WebLogo.getSplitterForColumn(this.column);\n    return this._splitter;\n  };\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  /**\n   * Convert a Macromolecule column from FASTA to SEPARATOR notation\n   *\n   * @param {string} separator  A specific separator to be used\n   * @param {string} fastaGapSymbol  Gap symbol in FASTA, '-' by default\n   * @return {DG.Column}        A new column in SEPARATOR notation\n   */\n  private convertFastaToSeparator(separator: string, fastaGapSymbol: string | null = null): DG.Column {\n    if (fastaGapSymbol === null)\n      fastaGapSymbol = this.defaultGapSymbol;\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.column.get(idx);\n      const fastaMonomersArray = this.splitter(fastaPolymer);\n      for (let i = 0; i < fastaMonomersArray.length; i++) {\n        if (fastaMonomersArray[i] === fastaGapSymbol)\n          fastaMonomersArray[i] = this._defaultGapSymbolsDict.SEPARATOR;\n      }\n      return fastaMonomersArray.join(separator);\n    });\n    newColumn.setTag('separator', separator);\n    return newColumn;\n  }\n\n  /**\n   * Get the wrapper strings for HELM, depending on the type of the\n   * macromolecule (peptide, DNA, RNA)\n   *\n   * @return {string[]} Array of wrappers\n   */\n  private getHelmWrappers(): string[] {\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    return [prefix, leftWrapper, rightWrapper, postfix];\n  }\n\n  // A helper function for converting strings to HELM\n  private convertToHelmHelper(\n    sourcePolymer: string,\n    sourceGapSymbol: string,\n    prefix: string,\n    leftWrapper: string,\n    rightWrapper: string,\n    postfix: string\n  ): string {\n    const monomerArray = this.splitter(sourcePolymer);\n    const monomerHelmArray: string[] = monomerArray.map((mm: string) => {\n      if (mm === sourceGapSymbol)\n        return this._defaultGapSymbolsDict.HELM;\n      else\n        return `${leftWrapper}${mm}${rightWrapper}`;\n    });\n    return `${prefix}${monomerHelmArray.join('.')}${postfix}`;\n  }\n\n  /**\n   * Convert a string with SEPARATOR/FASTA notation to HELM\n   *\n   * @param {string} sourcePolymer  A string to be converted\n   * @param {string | null} sourceGapSymbol  An optional gap symbol, set to\n   * default values ('-' for FASTA and '' for SEPARATOR) unless specified\n   * @return {string}  The target HELM string\n   */\n  public convertStringToHelm(\n    sourcePolymer: string,\n    sourceGapSymbol: string | null = null\n  ) : string {\n    if (sourceGapSymbol === null)\n      sourceGapSymbol = this.defaultGapSymbol;\n    const [prefix, leftWrapper, rightWrapper, postfix] = this.getHelmWrappers();\n    return this.convertToHelmHelper(sourcePolymer, sourceGapSymbol, prefix, leftWrapper, rightWrapper, postfix);\n  }\n\n  /**\n   * Convert a column to HELM\n   *\n   * @param {string | null} sourceGapSymbol\n   * @return {DG.Column}\n   */\n  private convertToHelm(sourceGapSymbol: string | null = null): DG.Column {\n    if (sourceGapSymbol === null)\n      sourceGapSymbol = this.defaultGapSymbol;\n\n    const [prefix, leftWrapper, rightWrapper, postfix] = this.getHelmWrappers();\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.column.get(idx);\n      return this.convertToHelmHelper(sourcePolymer, sourceGapSymbol!, prefix, leftWrapper, rightWrapper, postfix);\n    });\n    return newColumn;\n  }\n\n  /**\n   * Convert SEPARATOR column to FASTA notation\n   *\n   * @param {string | null} fastaGapSymbol Optional gap symbol for FASTA\n   * @return {DG.Column}  Converted column\n   */\n  private convertSeparatorToFasta(fastaGapSymbol: string | null = null): DG.Column {\n    if (fastaGapSymbol === null)\n      fastaGapSymbol = this._defaultGapSymbolsDict.FASTA;\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.column.get(idx);\n      // items can be monomers or separators\n      const separatorItemsArray = this.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(fastaGapSymbol!);\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  /**\n   *  Convert HELM column to FASTA/SEPARATOR\n   *\n   * @param {string} tgtNotation    Target notation: FASTA or SEPARATOR\n   * @param {string} tgtSeparator   Optional target separator (for HELM ->\n   * @param {string | null} tgtGapSymbol   Optional target gap symbol\n   * SEPARATOR)\n   * @return {DG.Column} Converted column\n   */\n  private convertHelm(\n    tgtNotation: string,\n    tgtSeparator: string = '',\n    tgtGapSymbol: string | null = null\n  ): DG.Column {\n    // This function must not contain calls of isDna() and isRna(), for\n    // source helm columns may contain RNA, DNA and PT across different rows\n    if (tgtGapSymbol === null) {\n      tgtGapSymbol = (this.toFasta(tgtNotation as NOTATION)) ?\n        this._defaultGapSymbolsDict.FASTA :\n        this._defaultGapSymbolsDict.SEPARATOR;\n    }\n\n    if (this.toSeparator(tgtNotation as NOTATION) && tgtSeparator === '')\n      tgtSeparator = this.separator;\n\n    const helmWrappersRe = /(R\\(|D\\(|\\)|P)/g;\n    const newColumn = this.getNewColumn(tgtNotation as NOTATION);\n    // assign the values to the empty column\n    newColumn.init((idx: number) => {\n      const helmPolymer = this.column.get(idx);\n\n      // we cannot use isDna() or isRna() because source helm columns can\n      // contain DNA, RNA and PT in different cells, so the corresponding\n      // tags cannot be set for the whole column\n      const isNucleotide = helmPolymer.startsWith('DNA') || helmPolymer.startsWith('RNA');\n\n      // items can be monomers or helms\n      const helmItemsArray = this.splitter(helmPolymer);\n      const tgtMonomersArray: string[] = [];\n      for (let i = 0; i < helmItemsArray.length; i++) {\n        let item = helmItemsArray[i];\n        if (isNucleotide)\n          item = item.replace(helmWrappersRe, '');\n        if (item === this._defaultGapSymbolsDict.HELM) {\n          tgtMonomersArray.push(tgtGapSymbol!);\n        } else if (this.toFasta(tgtNotation as NOTATION) && item.length > 1) {\n          // the case of a multi-character monomer converted to FASTA\n          const monomer = '[' + item + ']';\n          tgtMonomersArray.push(monomer);\n        } else {\n          tgtMonomersArray.push(item);\n        }\n      }\n      return tgtMonomersArray.join(tgtSeparator);\n    });\n    return newColumn;\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} tgtNotation   Notation we want to convert to\n   * @param {string | null} tgtSeparator   Possible separator\n   * @return {DG.Column}                Converted column\n   */\n  public convert(tgtNotation: NOTATION, tgtSeparator: string | null = null): DG.Column {\n    // possible exceptions\n    if (this.notation === tgtNotation)\n      throw new Error('tgt notation is invalid');\n    if (this.toSeparator(tgtNotation) && tgtSeparator === null)\n      throw new Error('tgt separator is not specified');\n\n    if (this.isFasta() && this.toSeparator(tgtNotation) && tgtSeparator !== null)\n      return this.convertFastaToSeparator(tgtSeparator);\n    else if ((this.isFasta() || this.isSeparator()) && this.toHelm(tgtNotation))\n      return this.convertToHelm();\n    else if (this.isSeparator() && this.toFasta(tgtNotation))\n      return this.convertSeparatorToFasta();\n    else if (this.isHelm() && this.toFasta(tgtNotation)) // the case of HELM\n      return this.convertHelm(tgtNotation);\n    else // this.isHelm() && this.toSeparator(tgtNotation)\n      return this.convertHelm(tgtNotation, tgtSeparator!);\n  }\n\n  public constructor(col: DG.Column) {\n    super(col);\n  }\n}\n"]}

package/src/utils/units-handler.d.ts

@@ -0,0 +1,74 @@
+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 notation units in Macromolecule columns */
+export declare class UnitsHandler {
+    protected readonly _column: DG.Column;
+    protected _units: string;
+    protected _notation: NOTATION;
+    protected _defaultGapSymbol: string;
+    protected _defaultGapSymbolsDict: {
+        HELM: string;
+        SEPARATOR: string;
+        FASTA: string;
+    };
+    static readonly PeptideFastaAlphabet: Set<string>;
+    static readonly DnaFastaAlphabet: Set<string>;
+    static readonly RnaFastaAlphabet: Set<string>;
+    static setUnitsToFastaColumn(col: DG.Column): void;
+    protected get units(): string;
+    protected get column(): DG.Column;
+    get notation(): NOTATION;
+    get defaultGapSymbol(): string;
+    get separator(): string;
+    isFasta(): boolean;
+    isSeparator(): boolean;
+    isHelm(): boolean;
+    isRna(): boolean;
+    isDna(): boolean;
+    isPeptide(): boolean;
+    /** Associate notation types with the corresponding units */
+    /**
+     * @return {NOTATION}     Notation associated with the units type
+     */
+    protected getNotation(): NOTATION;
+    /**
+     * Create a new empty column of the specified notation type and the same
+     * length as column
+     *
+     * @param {NOTATION} targetNotation
+     * @return {DG.Column}
+     */
+    protected getNewColumn(targetNotation: NOTATION): DG.Column;
+    /**
+     * 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: DG.Column): DG.Column;
+    /**
+     * A helper function checking the validity of the 'units' string
+     *
+     * @param {string} units  the string to be validated
+     * @return {boolean}
+     */
+    static unitsStringIsValid(units: string): boolean;
+    /**
+     * 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: number, name: string, units: string): DG.Column;
+    constructor(col: DG.Column);
+}
+//# sourceMappingURL=units-handler.d.ts.map

package/src/utils/units-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units-handler.d.ts","sourceRoot":"","sources":["units-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAMtC,0EAA0E;AAC1E,0BAAkB,QAAQ;IACxB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,IAAI,SAAS;CACd;AAED,iEAAiE;AACjE,qBAAa,YAAY;IACvB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC;IACtC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC9B,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACpC,SAAS,CAAC,sBAAsB;;;;MAI9B;IAEF,gBAAuB,oBAAoB,cAGxC;IACH,gBAAuB,gBAAgB,cAAiC;IACxE,gBAAuB,gBAAgB,cAAiC;WAE1D,qBAAqB,CAAC,GAAG,EAAE,EAAE,CAAC,MAAM;IAsBlD,SAAS,KAAK,KAAK,IAAI,MAAM,CAAwB;IAErD,SAAS,KAAK,MAAM,IAAI,EAAE,CAAC,MAAM,CAAyB;IAE1D,IAAW,QAAQ,IAAI,QAAQ,CAA2B;IAE1D,IAAW,gBAAgB,IAAI,MAAM,CAAmC;IAExE,IAAW,SAAS,IAAI,MAAM,CAM7B;IAEM,OAAO,IAAI,OAAO;IAElB,WAAW,IAAI,OAAO;IAEtB,MAAM,IAAI,OAAO;IAEjB,KAAK,IAAI,OAAO;IAEhB,KAAK,IAAI,OAAO;IAEhB,SAAS,IAAI,OAAO;IAE3B,4DAA4D;IAC5D;;OAEG;IACH,SAAS,CAAC,WAAW,IAAI,QAAQ;IAWjC;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,CAAC,cAAc,EAAE,QAAQ,GAAG,EAAE,CAAC,MAAM;IAmB3D;;;;;;OAMG;WACW,YAAY,CAAC,WAAW,EAAE,EAAE,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM;IAM7D;;;;;OAKG;WACW,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAUxD;;;;;;;;OAQG;WACW,sBAAsB,CAClC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,EAAE,CAAC,MAAM;gBAYO,GAAG,EAAE,EAAE,CAAC,MAAM;CAYlC"}