@datagrok/bio 1.7.14 → 1.7.19

package/setup.cmd

@@ -1,19 +1,15 @@
-cd ../../js-api
-call npm install
-call npm link
-cd ../libraries/utils
-call npm install
-call npm link
-call npm link datagrok-api
-cd ../libraries/ml
-call npm install
-call npm link
-call npm link @datagrok-libraries/utils
-cd ../libraries/bio
-call npm install
-call npm link
-call npm link @datagrok-libraries/utils
-cd ../../packages/Bio
-call npm install
-call npm link datagrok-api @datagrok-libraries/bio @datagrok-libraries/utils @datagrok-libraries/ml
-webpack
+call setup-unlink-clean.cmd
+
+set package_dir=%cd%
+
+set dirs=^
+\..\..\js-api\ ^
+\..\..\libraries\utils\ ^
+\..\..\libraries\ml\ ^
+\..\..\libraries\bio\ ^
+\
+
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm install
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm link
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm run link-all
+for %%p in (%dirs%) do cd %package_dir%\%%p & call npm run build

package/src/package-test.ts

@@ -11,6 +11,7 @@ import './tests/activity-cliffs-tests';
 import './tests/splitters-test';
 import './tests/renderers-test';
 import './tests/convert-test';
+import './tests/WebLogo-positions-test';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -22,14 +22,21 @@ import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
 import {lru} from './utils/cell-renderer';
 import {representationsWidget} from './widgets/representations';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
+
+
 
 //tags: init
 export async function initBio(): Promise<void> {
   // apparently HELMWebEditor requires dojo to be initialized first
+  if (DG.Func.find({package: 'Helm', name: 'initHelm'}) != null) {
+    grok.functions.call('Helm:initHelp');
+  }
   return new Promise((resolve, reject) => {
     // @ts-ignore
     dojo.ready(function() { resolve(null); });
-  });
+  });  
 }
 
 //name: Lru
@@ -240,26 +247,53 @@ export async function compositionAnalysis(): Promise<void> {
   // Higher priority for columns with MSA data to show with WebLogo.
   const tv = grok.shell.tv;
   const df = tv.dataFrame;
+  //@ts-ignore
+  const colList: DG.Column[] = df.columns.toList().filter((col) => {
+    if (col.semType != DG.SEMTYPE.MACROMOLECULE)
+      return false;
+
+    const colUH = new UnitsHandler(col);
+    // TODO: prevent for cyclic, branched or multiple chains in Helm
+    return true;
+  });
+
+  const handler = async (col: DG.Column) => {
+    if (!checkInputColumn(col, 'Composition'))
+      return;
+
+    const wlViewer = tv.addViewer('WebLogo', {sequenceColumnName: col.name});
+    grok.shell.tv.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.25);
+  };
 
-  const col: DG.Column | null = WebLogo.pickUpSeqCol2(df);
-  if (!col) {
+  let col: DG.Column | null = null;
+  if (colList.length == 0) {
     grok.shell.error('Current table does not contain sequences');
     return;
+  } else if (colList.length > 1) {
+    const colListNames: string [] = colList.map((col) => col.name);
+    const colInput: DG.InputBase = ui.choiceInput('Column', colListNames[0], colListNames);
+    ui.dialog({
+      title: 'R-Groups Analysis',
+      helpUrl: '/help/domains/bio/macromolecules.md#composition-analysis'
+    })
+      .add(ui.div([
+        colInput,
+      ]))
+      .onOK(async () => {
+        const col: DG.Column | null = colList.find((col) => col.name == colInput.value) ?? null;
+
+        if (col)
+          await handler(col);
+      })
+      .show();
+  } else {
+    col = colList[0];
   }
 
-  if (!checkInputColumn(col, 'Composition'))
+  if (!col)
     return;
 
-  const allowedNotations: string[] = ['fasta', 'separator'];
-  const units = col.getTag(DG.TAGS.UNITS);
-  if (!allowedNotations.some((n) => units.toUpperCase().startsWith(n.toUpperCase()))) {
-    grok.shell.warning('Composition analysis is allowed for ' +
-      `notation${allowedNotations.length > 1 ? 's' : ''} ${allowedNotations.map((n) => `"${n}"`).join(', ')}.`);
-    return;
-  }
-
-  const wlViewer = tv.addViewer('WebLogo', {sequenceColumnName: col.name});
-  grok.shell.tv.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.25);
+  await handler(col);
 }
 
 //top-menu: Bio | Sdf to Json lib...
@@ -269,17 +303,6 @@ export async function sdfToJsonLib(table: DG.DataFrame) {
   const jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
 }
 
-// helper function for importFasta
-function parseMacromolecule(
-  fileContent: string,
-  startOfSequence: number,
-  endOfSequence: number
-): string {
-  const seq = fileContent.slice(startOfSequence, endOfSequence);
-  const seqArray = seq.split(/\s/);
-  return seqArray.join('');
-}
-
 //name: Representations
 //tags: panel, widgets
 //input: cell macroMolecule {semType: Macromolecule}
@@ -287,7 +310,7 @@ function parseMacromolecule(
 export async function peptideMolecule(macroMolecule: DG.Cell): Promise<DG.Widget> {
   const monomersLibFile = await _package.files.readAsText(HELM_CORE_LIB_FILENAME);
   const monomersLibObject: any[] = JSON.parse(monomersLibFile);
-  
+
   return representationsWidget(macroMolecule, monomersLibObject);
 }
 
@@ -298,63 +321,8 @@ export async function peptideMolecule(macroMolecule: DG.Cell): Promise<DG.Widget
 //input: string fileContent
 //output: list tables
 export function importFasta(fileContent: string): DG.DataFrame [] {
-  const regex = /^>(.*)$/gm; // match lines starting with >
-  const descriptionsArray = [];
-  const sequencesArray: string[] = [];
-  let startOfSequence = 0;
-  let match; // match.index is the beginning of the matched line
-  while (match = regex.exec(fileContent)) {
-    const description = fileContent.substring(match.index + 1, regex.lastIndex);
-    descriptionsArray.push(description);
-    if (startOfSequence !== 0)
-      sequencesArray.push(parseMacromolecule(fileContent, startOfSequence, match.index));
-    startOfSequence = regex.lastIndex + 1;
-  }
-  sequencesArray.push(parseMacromolecule(fileContent, startOfSequence, -1));
-  const descriptionsArrayCol = DG.Column.fromStrings('description', descriptionsArray);
-  const sequenceCol = DG.Column.fromStrings('sequence', sequencesArray);
-  sequenceCol.semType = 'Macromolecule';
-  const stats: SeqColStats = WebLogo.getStats(sequenceCol, 5, WebLogo.splitterAsFasta);
-  const seqType = stats.sameLength ? 'SEQ.MSA' : 'SEQ';
-
-  const PeptideFastaAlphabet = new Set([
-    'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
-    'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',
-  ]);
-
-  const DnaFastaAlphabet = new Set(['A', 'C', 'G', 'T']);
-
-  const RnaFastaAlphabet = new Set(['A', 'C', 'G', 'U']);
-
-  //const SmilesRawAlphabet = new Set([
-  //  'O', 'C', 'c', 'N', 'S', 'F', '(', ')',
-  //  '1', '2', '3', '4', '5', '6', '7',
-  //  '+', '-', '@', '[', ']', '/', '\\', '#', '=']);
-
-  const alphabetCandidates: [string, Set<string>][] = [
-    ['PT', PeptideFastaAlphabet],
-    ['DNA', DnaFastaAlphabet],
-    ['RNA', RnaFastaAlphabet],
-  ];
-
-  //const alphabetCandidates: [string, Set<string>][] = [
-  //  ['NT', new Set(Object.keys(Nucleotides.Names))],
-  //  ['PT', new Set(Object.keys(Aminoacids.Names))],
-  //];
-
-  // Calculate likelihoods for alphabet_candidates
-  const alphabetCandidatesSim: number[] = alphabetCandidates.map(
-    (c) => WebLogo.getAlphabetSimilarity(stats.freq, c[1]));
-  const maxCos = Math.max(...alphabetCandidatesSim);
-  const alphabet = maxCos > 0.65 ? alphabetCandidates[alphabetCandidatesSim.indexOf(maxCos)][0] : 'UN';
-  sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
-  const units: string = `fasta:${seqType}:${alphabet}`;
-  sequenceCol.setTag(DG.TAGS.UNITS, units);
-
-  return [DG.DataFrame.fromColumns([
-    descriptionsArrayCol,
-    sequenceCol,
-  ])];
+  const ffh = new FastaFileHandler(fileContent);
+  return ffh.importFasta();
 }
 
 //name: Bio | Convert ...
@@ -388,6 +356,7 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
   const pi = DG.TaskBarProgressIndicator.create('Test detectMacromolecule...');
 
   const fileList = await grok.dapi.files.list(path, true, '');
+  //@ts-ignore
   const fileListToTest = fileList.filter((fi) => fi.fileName.endsWith('.csv'));
 
   let readyCount = 0;

package/src/tests/WebLogo-positions-test.ts

@@ -0,0 +1,68 @@
+import {after, before, category, test, expect, expectObject} from '@datagrok-libraries/utils/src/test';
+
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {PositionInfo, PositionMonomerInfo, WebLogo} from '@datagrok-libraries/bio/src/viewers/web-logo';
+
+category('WebLogo-positions', () => {
+  let tvList: DG.TableView[];
+  let dfList: DG.DataFrame[];
+
+  const csvDf1 = `seq
+    ATC-G-TTGC--
+    ATC-G-TTGC--
+    -TC-G-TTGC--
+    -TC-GCTTGC--
+    -TC-GCTTGC--`;
+
+
+  const resShrinkEmptyTailDf1: PositionInfo[] = [];
+
+  before(async () => {
+    tvList = [];
+    dfList = [];
+  });
+
+  after(async () => {
+    dfList.forEach((df: DG.DataFrame) => { grok.shell.closeTable(df); });
+    tvList.forEach((tv: DG.TableView) => tv.close());
+  });
+
+  test('allPositions', async () => {
+    const df: DG.DataFrame = DG.DataFrame.fromCsv(csvDf1);
+    const tv: DG.TableView = grok.shell.addTableView(df);
+
+    const wlViewer: WebLogo = await df.plot.fromType('WebLogo') as unknown as WebLogo;
+    tv.dockManager.dock(wlViewer.root, DG.DOCK_TYPE.DOWN);
+
+    tvList.push(tv);
+    dfList.push(df);
+
+    const positions: PositionInfo[] = wlViewer['positions'];
+
+    const resAllDf1: PositionInfo[] = [
+      new PositionInfo('1', {'A': new PositionMonomerInfo(2), '-': new PositionMonomerInfo(3)}),
+      new PositionInfo('2', {'T': new PositionMonomerInfo(5)}),
+      new PositionInfo('3', {'C': new PositionMonomerInfo(5)}),
+      new PositionInfo('4', {'-': new PositionMonomerInfo(5)}),
+      new PositionInfo('5', {'G': new PositionMonomerInfo(5)}),
+      new PositionInfo('6', {'-': new PositionMonomerInfo(3), 'C': new PositionMonomerInfo(2)}),
+      new PositionInfo('7', {'T': new PositionMonomerInfo(5)}),
+      new PositionInfo('8', {'T': new PositionMonomerInfo(5)}),
+      new PositionInfo('9', {'G': new PositionMonomerInfo(5)}),
+      new PositionInfo('10', {'C': new PositionMonomerInfo(5)}),
+      new PositionInfo('11', {'-': new PositionMonomerInfo(5)}),
+      new PositionInfo('12', {'-': new PositionMonomerInfo(5)})
+    ];
+    // check all positions are equal resAllDf1
+    for (let i = 0; i < positions.length; i++) {
+      expect(positions[i].name, resAllDf1[i].name);
+        for (const key in positions[i].freq) {
+          expect(positions[i].freq[key].count, resAllDf1[i].freq[key].count);
+        }
+    }
+
+  });
+
+});

package/src/tests/activity-cliffs-tests.ts

@@ -7,7 +7,7 @@ import {readDataframe} from './utils';
 import {getEmbeddingColsNames, sequenceSpace} from '../utils/sequence-space';
 import {drawTooltip, sequenceGetSimilarities} from '../utils/sequence-activity-cliffs';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
-import { encodeMonomers } from '../utils/utils';
+import {encodeMonomers} from '../utils/utils';
 
 
 category('activityCliffs', async () => {
@@ -53,6 +53,6 @@ category('activityCliffs', async () => {
 
     const cliffsLink = (Array.from(scatterPlot.root.children) as Element[])
       .filter((it) => it.className === 'ui-btn ui-btn-ok');
-    expect((cliffsLink[0] as HTMLElement).innerText, '105 cliffs');
+    expect((cliffsLink[0] as HTMLElement).innerText, '2362 cliffs');
   });
 });

package/src/tests/detectors-test.ts

@@ -124,6 +124,7 @@ MWRSWY-CKHP
     testActivityCliffsCsv = 'testActivityCliffsCsv',
     testSpgi100 = 'testSpgi100',
     testUnichemSources = 'testUnichemSources',
+    testDmvOffices = 'testDmvOffices',
   }
 
   const samples: { [key: string]: string } = {
@@ -143,6 +144,7 @@ MWRSWY-CKHP
     'testCerealCsv': 'System:AppData/Bio/tests/testCereal.csv',
     'testSpgi100': 'System:AppData/Bio/tests/testSpgi100.csv',
     'testUnichemSources': 'System:AppData/Bio/tests/testUnichemSources.csv',
+    'testDmvOffices': 'System:AppData/Bio/tests/testDmvOffices.csv',
   };
 
   const _samplesDfs: { [key: string]: Promise<DG.DataFrame> } = {};
@@ -186,7 +188,7 @@ MWRSWY-CKHP
     };
   };
 
-  test('NegativeEmpty', async () => {await _testNeg(readCsv('csvDfEmpty', csvDfEmpty), 'col1'); });
+  test('NegativeEmpty', async () => { await _testNeg(readCsv('csvDfEmpty', csvDfEmpty), 'col1'); });
   test('Negative1', async () => { await _testNeg(readCsv('csvDf1', csvDf1), 'col1'); });
   test('Negative2', async () => { await _testNeg(readCsv('csvDf2', csvDf2), 'col1'); });
   test('Negative3', async () => { await _testNeg(readCsv('csvDf3', csvDf3), 'col1'); });
@@ -347,6 +349,13 @@ MWRSWY-CKHP
   test('samplesTestUnichemSourcesNegativeBaseIdUrl', async () => {
     await _testNeg(readSamples(Samples.testUnichemSources), 'base_id_url');
   });
+
+  test('samplesTestDmvOfficesNegativeOfficeName', async () => {
+    await _testNeg(readSamples(Samples.testDmvOffices), 'Office Name');
+  });
+  test('samplesTestDmvOfficesNegativeCity', async () => {
+    await _testNeg(readSamples(Samples.testDmvOffices), 'City');
+  });
 });
 
 export async function _testNeg(readDf: DfReaderFunc, colName: string) {

package/src/tests/msa-tests.ts

@@ -1,10 +1,10 @@
-import {category, test} from '@datagrok-libraries/utils/src/test';
-import {
-  _testMSAIsCorrect,
-  _testTableIsNotEmpty,
-} from './utils';
-
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
+
+import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
+
+import {runKalign} from '../utils/multiple-sequence-alignment';
 //import * as grok from 'datagrok-api/grok';
 
 export const _package = new DG.Package();
@@ -13,22 +13,47 @@ export const _package = new DG.Package();
 category('MSA', async () => {
   //table = await grok.data.files.openTable('Demo:Files/bio/peptides.csv');
   const fromCsv = `seq
-  FWRWYVKHP
-  YNRWYVKHP
-  MWRSWYCKHP`;
+FWRWYVKHP
+YNRWYVKHP
+MWRSWYCKHP`;
   const toCsv = `seq
-  -F-W-R--W-Y-V-K-H-P
-  -Y-N-R--W-Y-V-K-H-P
-  -M-W-R-S-W-Y-C-K-H-P`;
-  const table: DG.DataFrame = DG.DataFrame.fromCsv(fromCsv);
-  const toTable: DG.DataFrame = DG.DataFrame.fromCsv(toCsv);
-  const alignedSequencesColumn = toTable.getCol('seq');
-
-  test('test_table.is_not_empty', async () => {
-    await _testTableIsNotEmpty(table);
+FWR-WYVKHP
+YNR-WYVKHP
+MWRSWYCKHP`;
+
+  const longFromCsv = `seq
+FWRWYVKHPFWRWYVKHPFWRWYVKHPFWRWYVKHPFWRWYVKHPFWRWYVKHPFWRWYVKHPFWRWYVKHP
+YNRWYVKHPYNRWYVKHPYNRWYVKHPYNRWYVKHPYNRWYVKHPYNRWYVKHPYNRWYVKHPYNRWYVKHP
+MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP`;
+
+  const longToCsv = `seq
+FWR-WYVKHPFWR-WYVKHPFWR-WYVKHPFWR-WYVKHPFWR-WYVKHPFWR-WYVKHPFWR-WYVKHPFWR-WYVKHP
+YNR-WYVKHPYNR-WYVKHPYNR-WYVKHPYNR-WYVKHPYNR-WYVKHPYNR-WYVKHPYNR-WYVKHPYNR-WYVKHP
+MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP`;
+
+  // test('test_table.is_not_empty', async () => {
+  //   await _testTableIsNotEmpty(table);
+  // });
+
+  test('isCorrect', async () => {
+    await _testMsaIsCorrect(fromCsv, toCsv);
   });
 
-  test('is_correct', async () => {
-    await _testMSAIsCorrect(alignedSequencesColumn);
+  test('isCorrectLong', async () => {
+    await _testMsaIsCorrect(longFromCsv, longToCsv);
   });
 });
+
+async function _testMsaIsCorrect(srcCsv: string, tgtCsv: string): Promise<void> {
+  const srcDf: DG.DataFrame = DG.DataFrame.fromCsv(srcCsv);
+  const tgtDf: DG.DataFrame = DG.DataFrame.fromCsv(tgtCsv);
+
+  const srcCol: DG.Column = srcDf.getCol('seq')!;
+  const semType: string = await grok.functions.call('Bio:detectMacromolecule', {col: srcCol});
+  if (semType)
+    srcCol.semType = semType;
+
+  const tgtCol: DG.Column = tgtDf.getCol('seq')!;
+  const msaCol: DG.Column = await runKalign(srcCol, true);
+  expectArray(msaCol.toList(), tgtCol.toList());
+}

package/src/tests/utils.ts

@@ -31,15 +31,3 @@ export async function createTableView(tableName: string): Promise<DG.TableView>
 export function _testTableIsNotEmpty(table: DG.DataFrame): void {
   expect(table.columns.length > 0 && table.rowCount > 0, true);
 }
-
-
-/**
- * Tests if MSA works and returns consistent result.
- *
- * @export
- * @param {DG.Column} col Aligned sequences column.
- */
-export async function _testMSAIsCorrect(col: DG.Column): Promise<void> {
-  const msaCol = await runKalign(col, true);
-  expect(msaCol.toList().every((v, i) => (v == col.get(i) || v == null)), true);
-}

package/src/utils/cell-renderer.ts

@@ -9,7 +9,7 @@ import * as ui from 'datagrok-api/ui';
 
 export const lru = new DG.LruCache<any, any>();
 const undefinedColor = 'rgb(100,100,100)';
-const grayColor = '#808080'
+const grayColor = '#808080';
 
 function getPalleteByType(paletteType: string): SeqPalette {
   switch (paletteType) {
@@ -68,9 +68,7 @@ function printLeftOrCentered(
   separator: string = '', last: boolean = false): number {
   g.textAlign = 'start';
   const colorPart = s.substring(0);
-  let grayPart = separator;
-  if (last)
-    grayPart = '';
+  let grayPart =  last ? '' : separator;
 
   const textSize = g.measureText(colorPart + grayPart);
   const indent = 5;
@@ -142,7 +140,6 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     const cell = gridCell.cell;
     const tag = gridCell.cell.column.getTag(DG.TAGS.UNITS);
     if (tag === 'HELM') {
-      console.log(findMonomers(cell.value));
       const monomers = findMonomers(cell.value);
       if (monomers.size == 0) {
         const host = ui.div([], {style: {width: `${w}px`, height: `${h}px`}});
@@ -173,17 +170,10 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         let x1 = x;
         const s: string = cell.value ?? '';
         let subParts: string[] = WebLogo.splitterAsHelm(s);
-        let color = undefinedColor;
         subParts.forEach((amino, index) => {
-          if (monomers.has(amino)) {
-            color = 'red';
-          } else {
-            color = grayColor;
-          }
+          let color = monomers.has(amino) ? 'red' : grayColor;
           g.fillStyle = undefinedColor;
-          let last = false;
-          if (index === subParts.length - 1)
-            last = true;
+          let last = index === subParts.length - 1;
           x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, 0, true, 1.0, '/', last);
         });
         g.restore();
@@ -215,10 +205,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       subParts.forEach((amino, index) => {
         color = palette.get(amino);
         g.fillStyle = undefinedColor;
-        let last = false;
-        if (index === subParts.length - 1)
-          last = true;
-
+        let last = index === subParts.length - 1;
         x1 = printLeftOrCentered(x1, y, w, h, g, amino, color, 0, true, 1.0, separator, last);
       });
 
@@ -239,16 +226,16 @@ export class AminoAcidsCellRenderer extends DG.GridCellRenderer {
   get defaultWidth(): number {return 30;}
 
   /**
-     * Cell renderer function.
-     *
-     * @param {CanvasRenderingContext2D} g Canvas rendering context.
-     * @param {number} x x coordinate on the canvas.
-     * @param {number} y y coordinate on the canvas.
-     * @param {number} w width of the cell.
-     * @param {number} h height of the cell.
-     * @param {DG.GridCell} gridCell Grid cell.
-     * @param {DG.GridCellStyle} cellStyle Cell style.
-     */
+   * Cell renderer function.
+   *
+   * @param {CanvasRenderingContext2D} g Canvas rendering context.
+   * @param {number} x x coordinate on the canvas.
+   * @param {number} y y coordinate on the canvas.
+   * @param {number} w width of the cell.
+   * @param {number} h height of the cell.
+   * @param {DG.GridCell} gridCell Grid cell.
+   * @param {DG.GridCellStyle} cellStyle Cell style.
+   */
   render(
     g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell,
     cellStyle: DG.GridCellStyle): void {
@@ -318,7 +305,7 @@ export class AlignedSequenceDifferenceCellRenderer extends DG.GridCellRenderer {
 
     const palette = getPalleteByType(gridCell.tableColumn!.tags[C.TAGS.ALPHABET]);
     for (let i = 0; i < subParts1.length; i++) {
-      const amino1 = subParts1[i]
+      const amino1 = subParts1[i];
       const amino2 = subParts2[i];
       const color1 = palette.get(amino1);
       const color2 = palette.get(amino2);

package/src/utils/multiple-sequence-alignment.ts

@@ -1,5 +1,10 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import {FastaFileHandler} from '@datagrok-libraries/bio/src/utils/fasta-handler';
+
 //@ts-ignore
 import Aioli from '@biowasm/aioli';
 
@@ -15,16 +20,6 @@ function _stringsToFasta(sequences: string[]): string {
   return sequences.reduce((a, v, i) => a + `>sample${i + 1}\n${v}\n`, '');
 }
 
-/**
- * Extracts array of sequences from simple fasta string.
- *
- * @param {string} fasta Fasta-formatted string.
- * @return {string[]} Output list of sequences.
- */
-function _fastaToStrings(fasta: string): string[] {
-  return fasta.replace(/>sample\d+(\r\n|\r|\n)/g, '').split('\n');
-}
-
 /**
  * Runs Aioli environment with kalign tool.
  *
@@ -56,7 +51,8 @@ export async function runKalign(srcCol: DG.Column, isAligned = false, unUsedName
   if (!buf)
     throw new Error(`kalign output no result`);
 
-  const aligned = _fastaToStrings(buf).slice(0, sequences.length);
+  const ffh = new FastaFileHandler(buf);
+  const aligned = ffh.sequencesArray; // array of sequences extracted from FASTA
   const tgtCol = DG.Column.fromStrings(unUsedName, aligned);
 
   // units

package/src/utils/utils.ts

@@ -14,7 +14,7 @@ export const HELM_CORE_FIELDS = ['symbol', 'molfile', 'rgroups', 'name'];
 
 export function encodeMonomers(col: DG.Column): DG.Column | null {
   let encodeSymbol = MONOMER_ENCODE_MIN;
-  const monomerSymbolDict:  { [key: string]: number }= {};
+  const monomerSymbolDict: { [key: string]: number } = {};
   const units = col.tags[DG.TAGS.UNITS];
   const sep = col.getTag('separator');
   const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, sep);
@@ -22,9 +22,9 @@ export function encodeMonomers(col: DG.Column): DG.Column | null {
   for (let i = 0; i < col.length; ++i) {
     let encodedMonomerStr = '';
     const monomers = splitterFunc(col.get(i));
-    monomers.forEach(m => {
-      if(!monomerSymbolDict[m]) {
-        if(encodeSymbol > MONOMER_ENCODE_MAX) {
+    monomers.forEach((m) => {
+      if (!monomerSymbolDict[m]) {
+        if (encodeSymbol > MONOMER_ENCODE_MAX) {
           grok.shell.error(`Not enougth symbols to encode monomers`);
           return null;
         }
@@ -32,7 +32,7 @@ export function encodeMonomers(col: DG.Column): DG.Column | null {
         encodeSymbol++;
       }
       encodedMonomerStr += String.fromCodePoint(monomerSymbolDict[m]);
-    })
+    });
     encodedStringArray.push(encodedMonomerStr);
   }
   return DG.Column.fromStrings('encodedMolecules', encodedStringArray);
@@ -129,4 +129,4 @@ export function createJsonMonomerLibFromSdf(table: DG.DataFrame): any {
     resultLib.push(monomer);
   }
   return resultLib;
-}
+}

package/src/widgets/representations.ts

@@ -9,6 +9,7 @@ import {getMacroMol} from '../utils/atomic-works';
  *
  * @export
  * @param {DG.Cell} macroMolecule macromolecule cell.
+ * @param {any[]} monomersLibObject
  * @return {Promise<DG.Widget>} Widget.
  */
 export async function representationsWidget(macroMolecule: DG.Cell, monomersLibObject: any[]): Promise<DG.Widget> {