@datagrok/bio 2.11.28 → 2.11.30

package/package.json

@@ -5,7 +5,7 @@
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
   },
-  "version": "2.11.28",
+  "version": "2.11.30",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -34,15 +34,15 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.39.21",
+    "@datagrok-libraries/bio": "^5.39.24",
     "@datagrok-libraries/chem-meta": "^1.2.1",
-    "@datagrok-libraries/ml": "^6.4.1",
+    "@datagrok-libraries/ml": "^6.4.7",
     "@datagrok-libraries/tutorials": "^1.3.11",
-    "@datagrok-libraries/utils": "^4.1.36",
+    "@datagrok-libraries/utils": "^4.1.43",
     "@datagrok-libraries/math": "^1.0.7",
     "cash-dom": "^8.0.0",
     "css-loader": "^6.7.3",
-    "datagrok-api": "^1.16.0",
+    "datagrok-api": "^1.17.13",
     "dayjs": "^1.11.4",
     "fastest-levenshtein": "^1.0.16",
     "openchemlib": "6.0.1",
@@ -65,8 +65,8 @@
     "webpack": "^5.76.3",
     "webpack-bundle-analyzer": "latest",
     "webpack-cli": "^4.9.1",
-    "@datagrok/chem": "^1.8.8",
-    "@datagrok/helm": "^2.1.24",
+    "@datagrok/chem": "^1.8.11",
+    "@datagrok/helm": "^2.1.27",
     "@datagrok/dendrogram": "^1.2.22"
   },
   "scripts": {
@@ -74,12 +74,12 @@
     "link-bio": "npm link @datagrok-libraries/bio",
     "link-ml": "npm link @datagrok-libraries/ml",
     "link-utils": "npm link @datagrok-libraries/utils",
-    "link-all": "npm link @datagrok-libraries/chem-meta datagrok-api @datagrok-libraries/utils @datagrok-libraries/ml @datagrok-libraries/bio @datagrok-libraries/tutorials",
+    "link-all": "npm link @datagrok-libraries/chem-meta datagrok-api @datagrok-libraries/utils @datagrok-libraries/math @datagrok-libraries/ml @datagrok-libraries/bio @datagrok-libraries/tutorials",
     "debug-sequences1": "webpack && grok publish",
     "release-sequences1": "webpack && grok publish --release",
     "build-sequences1": "webpack",
     "build": "webpack",
-    "build-all": "npm --prefix ./../../libraries/chem-meta run build && npm --prefix ./../../js-api run build && npm --prefix ./../../libraries/utils run build && npm --prefix ./../../libraries/ml run build && npm --prefix ./../../libraries/bio run build && npm --prefix ./../../libraries/tutorials run build && npm run build",
+    "build-all": "npm --prefix ./../../libraries/chem-meta run build && npm --prefix ./../../js-api run build && npm --prefix ./../../libraries/utils run build && npm --prefix ./../../libraries/math run build && npm --prefix ./../../libraries/ml run build && npm --prefix ./../../libraries/bio run build && npm --prefix ./../../libraries/tutorials run build && npm run build",
     "debug-sequences1-local": "webpack && grok publish local",
     "release-sequences1-local": "webpack && grok publish local --release",
     "debug-sequences1-dev": "webpack && grok publish dev",

package/src/package.ts

@@ -71,11 +71,13 @@ import {detectMacromoleculeProbeDo} from './utils/detect-macromolecule-probe';
 import {ActivityCliffsEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-function-editor';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {BYPASS_LARGE_DATA_WARNING} from '@datagrok-libraries/ml/src/functionEditors/consts';
-import {getEmbeddingColsNames, multiColReduceDimensionality} from
-  '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
+import {
+  getEmbeddingColsNames, multiColReduceDimensionality
+} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
-import {ITSNEOptions, IUMAPOptions} from
-  '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
+import {
+  ITSNEOptions, IUMAPOptions
+} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
 
 export const _package = new BioPackage();
 
@@ -483,7 +485,7 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<s
 //input: double gapOpen = 1 {caption: Gap open penalty; default: 1; optional: true}
 //input: double gapExtend = 0.6 {caption: Gap extension penalty; default: 0.6; optional: true}
 // eslint-disable-next-line max-len
-//input: string fingerprintType = Morgan {caption: Fingerprint type; choices: ['Morgan', 'RDKit', 'Pattern']; default: Morgan; optional: true}
+//input: string fingerprintType = Morgan {caption: Fingerprint type; choices: ['Morgan', 'RDKit', 'Pattern', 'AtomPair', 'MACCS', 'TopologicalTorsion']; default: Morgan; optional: true}
 //output: object result
 export async function macromoleculePreprocessingFunction(
   col: DG.Column, metric: MmDistanceFunctionsNames, gapOpen: number = 1, gapExtend: number = 0.6,
@@ -557,13 +559,13 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
 //top-menu: Bio | Convert | To Atomic Level...
 //name: To Atomic Level
 //description: Converts sequences to molblocks
-//input: dataframe df [Input data table]
-//input: column macroMolecule {semType: Macromolecule}
-//input: bool nonlinear=false { description: Slower mode for cycling/branching HELM structures }
-export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column, nonlinear: boolean): Promise<void> {
+//input: dataframe table [Input data table]
+//input: column macroMolecule {caption: Sequence; semType: Macromolecule}
+//input: bool nonlinear =false {description: Slower mode for cycling/branching HELM structures}
+export async function toAtomicLevel(table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean): Promise<void> {
   const pi = DG.TaskBarProgressIndicator.create('Converting to atomic level ...');
   try {
-    await sequenceToMolfile(df, macroMolecule, nonlinear);
+    await sequenceToMolfile(table, seqCol, nonlinear);
   } finally {
     pi.close();
   }

package/src/tests/msa-tests.ts

@@ -81,12 +81,12 @@ MWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHPMWRSWYCKHP
   test('isCorrectHelm', async () => {
     await awaitContainerStart();
     await _testMSAOnColumn(helmFromCsv, helmToCsv, NOTATION.HELM, NOTATION.SEPARATOR, undefined, 'mafft');
-  });
+  }, {timeout: 60000});
 
   test('isCorrectHelmLong', async () => {
     await awaitContainerStart();
     await _testMSAOnColumn(longHelmFromCsv, longHelmToCsv, NOTATION.HELM, NOTATION.SEPARATOR, undefined, 'mafft');
-  });
+  }, {timeout: 60000});
 
   test('isCorrectSeparator', async () => {
     await _testMSAOnColumn(

package/src/tests/pepsea-tests.ts

@@ -20,5 +20,5 @@ category('PepSeA', () => {
     const alignedTestCol = table.getCol('MSA');
     for (let i = 0; i < alignedCol!.length; ++i)
       expect(alignedCol!.get(i) == alignedTestCol.get(i), true);
-  });
+  }, {timeout: 60000});
 });

package/src/tests/renderers-test.ts

@@ -4,14 +4,15 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 
 import {category, expect, test, awaitCheck, delay} from '@datagrok-libraries/utils/src/test';
+import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
 import {importFasta} from '../package';
 import {convertDo} from '../utils/convert';
-import * as C from '../utils/constants';
 import {generateLongSequence, generateManySequences, performanceTest} from './utils/sequences-generators';
-import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
+import {awaitGrid} from './utils';
+import * as C from '../utils/constants';
 
 category('renderers', () => {
   test('long sequence performance ', async () => {
@@ -62,8 +63,8 @@ category('renderers', () => {
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
 
     const resCellRenderer = seqCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, 'sequence');
@@ -82,8 +83,8 @@ category('renderers', () => {
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
 
     const resCellRenderer = seqCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, 'sequence');
@@ -104,8 +105,8 @@ category('renderers', () => {
     // call to calculate 'cell.renderer' tag
     await grok.data.detectSemanticTypes(df);
 
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
 
     const resCellRenderer = seqDiffCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, C.SEM_TYPES.MACROMOLECULE_DIFFERENCE);
@@ -125,8 +126,8 @@ category('renderers', () => {
     await grok.data.detectSemanticTypes(df);
 
     console.log('Bio: tests/renderers/afterMsa, table view');
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
 
     console.log('Bio: tests/renderers/afterMsa, src before test ' +
       `semType="${srcSeqCol!.semType}", units="${srcSeqCol!.getTag(DG.TAGS.UNITS)}", ` +
@@ -138,9 +139,8 @@ category('renderers', () => {
     expect(srcSeqCol.getTag(DG.TAGS.CELL_RENDERER), 'sequence');
 
     const msaSeqCol = await multipleSequenceAlignmentUI({col: srcSeqCol});
-    tv.grid.invalidate();
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
 
     expect(msaSeqCol.semType, DG.SEMTYPE.MACROMOLECULE);
     expect(msaSeqCol.getTag(DG.TAGS.UNITS), NOTATION.FASTA);
@@ -166,8 +166,8 @@ category('renderers', () => {
     await grok.data.detectSemanticTypes(df);
 
     const tgtCol: DG.Column = await convertDo(srcCol, NOTATION.SEPARATOR, '/');
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
 
     const resCellRenderer = tgtCol.getTag(DG.TAGS.CELL_RENDERER);
     expect(resCellRenderer, 'sequence');

package/src/tests/splitters-test.ts

@@ -3,25 +3,20 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {
-  after,
-  before,
-  category,
-  test,
-  expect,
-  expectArray,
-  delay,
-  awaitCheck
+  after, before, category, test, expect, expectArray, delay, awaitCheck
 } from '@datagrok-libraries/utils/src/test';
-import * as C from '../utils/constants';
-import {_package, getHelmMonomers} from '../package';
 import {
   TAGS as bioTAGS,
   splitterAsFasta,
   splitterAsHelm,
   NOTATION
 } from '@datagrok-libraries/bio/src/utils/macromolecule';
+
 import {splitToMonomersUI} from '../utils/split-to-monomers';
+import {awaitGrid} from './utils';
+import * as C from '../utils/constants';
 
+import {getHelmMonomers} from '../package';
 
 category('splitters', async () => {
   before(async () => {
@@ -107,8 +102,8 @@ category('splitters', async () => {
 
     // TODO: Check cell.renderer for columns of monomers
     const tv: DG.TableView = grok.shell.addTableView(newDf);
-    await awaitCheck(() => { return tv.grid.dataFrame != df; },
-      'View grid has wrong data frame', 100);
+    await awaitGrid(tv.grid);
+    expect(tv.grid.dataFrame.id, df.id);
   });
 
   test('getHelmMonomers', async () => {

package/src/tests/substructure-filters-tests.ts

@@ -1,14 +1,19 @@
-import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
 
-import {after, before, category, test, expect, delay, testEvent} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, test, expect, delay, testEvent, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
   LibSettings, getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 
 import {awaitGrid, readDataframe} from './utils';
-import {BioSubstructureFilter, HelmFilter, SeparatorFilter} from '../widgets/bio-substructure-filter';
+import {
+  BioSubstructureFilter, FastaBioFilter, SeparatorBioFilter, SeparatorFilterProps
+} from '../widgets/bio-substructure-filter';
+import {BioFilterProps} from '../widgets/bio-substructure-filter-types';
+import {HelmBioFilter} from '../widgets/bio-substructure-filter-helm';
 
 import {_package} from '../package-test';
 
@@ -34,17 +39,29 @@ category('substructureFilters', async () => {
   });
 
   test('fasta', async () => {
-    const fasta = await readDataframe('tests/filter_FASTA.csv');
+    const df = await readDataframe('tests/filter_FASTA.csv');
+    await grok.data.detectSemanticTypes(df);
+
+    const fSubStr: string = 'MD';
+    const fTrueCount: number = 3;
+
     const filter = new BioSubstructureFilter();
-    await grok.data.detectSemanticTypes(fasta);
-    filter.attach(fasta);
-    filter.bioFilter!.substructure = 'MD';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 3);
-    expect(filter.dataFrame!.filter.get(0), true);
-    expect(filter.dataFrame!.filter.get(3), true);
-    expect(filter.dataFrame!.filter.get(8), true);
-    expect(filter.dataFrame!.filter.get(1), false);
+    filter.attach(df);
+    await filter.awaitRendered();
+    try {
+      expect(!!filter.bioFilter, true);
+      expect(filter.bioFilter!.type, 'FastaBioFilter');
+      const bf = filter.bioFilter as FastaBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf.props = new BioFilterProps(fSubStr);
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, fTrueCount);
+      expect(filter.dataFrame?.filter.toBinaryString(), '10010000100000');
+    } finally {
+      filter.detach();
+    }
+    await filter.awaitRendered();
   });
 
   test('separator', async () => {
@@ -52,49 +69,254 @@ category('substructureFilters', async () => {
     const filter = new BioSubstructureFilter();
     await grok.data.detectSemanticTypes(msa);
     filter.attach(msa);
-    filter.bioFilter!.substructure = 'meI';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 7);
-    expect(filter.dataFrame!.filter.get(2), false);
-    filter.bioFilter!.substructure = '/meI';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 0);
-    filter.bioFilter!.substructure = 'meI-hHis';
-    (filter.bioFilter! as SeparatorFilter).separatorInput.value = '-';
-    await delay(100);
-    expect(filter.dataFrame!.filter.trueCount, 7);
-    expect(filter.dataFrame!.filter.get(2), false);
+    await filter.awaitRendered();
+    try {
+      expect(!!filter.bioFilter, true);
+      expect(filter.bioFilter!.type, 'SeparatorBioFilter');
+      const bf = filter.bioFilter as SeparatorBioFilter;
+
+      await testEvent(msa.onRowsFiltered, () => {}, () => {
+        bf.props = new SeparatorFilterProps('meI');
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, 7);
+      expect(filter.dataFrame!.filter.get(2), false);
+
+      await testEvent(msa.onRowsFiltered, () => {}, () => {
+        bf.props = new SeparatorFilterProps('/meI');
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, 0);
+
+      await testEvent(msa.onRowsFiltered, () => {}, () => {
+        bf.props = new SeparatorFilterProps('meI-hHis', '-');
+      }, 5000, 'testEvent onRowsFiltered');
+      expect(filter.dataFrame!.filter.trueCount, 7);
+      expect(filter.dataFrame!.filter.get(2), false);
+    } finally {
+      filter.detach();
+    }
+    await filter.awaitRendered();
   });
 
-  test('helm', async () => {
-    const helm = await readDataframe('tests/filter_HELM.csv');
-    const helmTableView = grok.shell.addTableView(helm);
+  // test('helm', async () => {
+  //   const df = await readDataframe('tests/filter_HELM.csv');
+  //   await grok.data.detectSemanticTypes(df);
+  //   const view = grok.shell.addTableView(df);
+  //
+  //   // // Helm filter calls waitForElementInDom
+  //   // const fg = view.getFiltersGroup({createDefaultFilters: false});
+  //   // _package.logger.debug('Bio tests: substructureFilters/helm, filter attaching.');
+  //   // const filter = new BioSubstructureFilter();
+  //   // filter.attach(df);
+  //   // _package.logger.debug('Bio tests: substructureFilters/helm, filter attached.');
+  //   // const fg = await df.plot.fromType(DG.VIEWER.FILTERS, {
+  //   //   filters: [
+  //   //     {type: 'Bio:bioSubstructureFilter', column: 'HELM string'}]
+  //   // }) as DG.FilterGroup;
+  //   // const fg2 = view.getFiltersGroup({createDefaultFilters: false});
+  //   const fg = view.getFiltersGroup();
+  //   await awaitCheck(() => fg.filters.length == 1, 'Filter panel has not been created', 3000);
+  //   await awaitGrid(view.grid);
+  //   const filter = fg.filters[0] as BioSubstructureFilter;
+  //   // TODO: Check filter type
+  //
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 1 changing.');
+  //   const bf = filter.bioFilter as HelmBioFilter;
+  //   await delay(1000); // to draw grid and filters
+  //   await bf.awaitRendered();
+  //
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 1 change awaiting.');
+  //   await testEvent(df.onRowsFiltered, () => {}, () => {
+  //     bf.props = new BioFilterProps('PEPTIDE1{C}$$$$V2.0');
+  //   }, 20000);
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 1 changed.');
+  //   expect(filter.dataFrame!.filter.trueCount, 2);
+  //   expect(filter.dataFrame!.filter.get(0), true);
+  //   expect(filter.dataFrame!.filter.get(3), true);
+  //
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 2 changing.');
+  //   await testEvent(df.onRowsFiltered, () => {}, () => {
+  //     bf.props = new BioFilterProps('PEPTIDE1{A.C}$$$$V2.0');
+  //   }, 20000);
+  //   await awaitGrid(view.grid);
+  //   _package.logger.debug('Bio tests: substructureFilters/helm, filter 2 changed.');
+  //   expect(filter.dataFrame!.filter.trueCount, 1);
+  //   expect(filter.dataFrame!.filter.get(3), true);
+  // }, {timeout: 30000});
+
+  test('helm-dialog', async () => {
+    const logPrefix = 'Bio tests: substructureFilters/helm-dialog';
+    const df = await readDataframe('tests/filter_HELM.csv');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    _package.logger.debug(`${logPrefix}, filter attaching.`);
     const filter = new BioSubstructureFilter();
-    await grok.data.detectSemanticTypes(helm);
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter attaching.');
-    filter.attach(helm);
-    _package.logger.debug('Bio/substructureFilters/helm, filter attached.');
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter 1 changing.');
-    (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{C}$$$$V2.0';
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter 1 change awaiting.');
-    await testEvent(helm.onRowsFiltered, () => {},
-      () => { filter.bioFilter!.onChanged.next(); }, 20000);
-    _package.logger.debug('Bio/substructureFilters/helm, filter 1 changed.');
-    expect(filter.dataFrame!.filter.trueCount, 2);
-    expect(filter.dataFrame!.filter.get(0), true);
-    expect(filter.dataFrame!.filter.get(3), true);
-
-    _package.logger.debug('Bio/substructureFilters/helm, filter 2 changing.');
-    (filter.bioFilter! as HelmFilter).helmSubstructure = 'PEPTIDE1{A.C}$$$$V2.0';
-    _package.logger.debug('Bio/substructureFilters/helm, filter 2 change awaiting.');
-    await testEvent(helm.onRowsFiltered, () => {},
-      () => { filter.bioFilter!.onChanged.next(); }, 20000);
-    await awaitGrid(helmTableView.grid);
-    _package.logger.debug('Bio/substructureFilters/helm, filter 2 changed.');
-    expect(filter.dataFrame!.filter.trueCount, 1);
-    expect(filter.dataFrame!.filter.get(3), true);
-  }, {timeout: 30000});
+    filter.attach(df);
+    const dlg = ui.dialog('Test filters').add(filter.root).show(); // to waitForElementInDom
+    await filter.awaitRendered();
+    try {
+      const bf = filter.bioFilter as HelmBioFilter;
+      expect(filter.bioFilter !== null, true, 'bioFilter is not created');
+
+      // filter 1
+      _package.logger.debug(`${logPrefix}, filter 1 change awaiting...`);
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf.props = new BioFilterProps('PEPTIDE1{A.C}$$$$V2.0');
+      }, 20000);
+      _package.logger.debug(`${logPrefix}, filter 1 changed.`);
+      expect(filter.dataFrame!.filter.trueCount, 1);
+      expect(filter.dataFrame!.filter.toBinaryString(), '0001');
+
+      // filter 2
+      _package.logger.debug(`${logPrefix}, filter 2 change awaiting...`);
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf.props = new BioFilterProps('PEPTIDE1{C}$$$$V2.0');
+      }, 20000);
+      await awaitGrid(view.grid);
+      _package.logger.debug(`${logPrefix}, filter 2 changed.`);
+      expect(filter.dataFrame!.filter.trueCount, 2);
+      expect(filter.dataFrame!.filter.toBinaryString(), '1001');
+    } finally {
+      dlg.close();
+    }
+    await filter.awaitRendered();
+  });
+
+  // Generates unhandled exception accessing isFiltering before bioFilter created
+  test('helm-view', async () => {
+    const logPrefix = 'Bio tests: substructureFilters/helm-view';
+    const df = await readDataframe('tests/filter_HELM.csv');
+    const col = df.getCol('HELM string');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    const fg = view.getFiltersGroup();
+
+    // await awaitCheck(() => fg.filters.length == 1, 'await filters.length == 1', 1000);
+    // const filter = fg.filters.filter((f) => f.columnName == col.name)[0] as BioSubstructureFilter;
+    await awaitGrid(view.grid);
+  });
+
+  test('sync-fasta', async () => {
+    const df = await _package.files.readCsv('tests/filter_FASTA.csv');
+    await grok.data.detectSemanticTypes(df);
+
+    const fSubStr: string = 'MD';
+    const fTrueCount: number = 3;
+
+    const f1 = await createFilter('fasta', df);
+    const f2 = await createFilter('fasta', df);
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    try {
+      expect(!!f1.bioFilter, true);
+      expect(!!f2.bioFilter, true);
+      expect(f1.bioFilter!.type, 'FastaBioFilter');
+      expect(f2.bioFilter!.type, 'FastaBioFilter');
+      const bf1 = f1.bioFilter as FastaBioFilter;
+      const bf2 = f2.bioFilter as FastaBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf1.props = new BioFilterProps(fSubStr);
+      }, 10000, 'await onRowsFiltered');
+      expect(df.filter.trueCount, fTrueCount);
+
+      await f1.awaitRendered();
+      expect(bf2.props.substructure, fSubStr);
+    } finally {
+      f1.detach();
+      f2.detach();
+    }
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+  });
+
+  // MSA filter has the second input field for separator
+  test('sync-msa', async () => {
+    const df = await _package.files.readCsv('tests/filter_MSA.csv');
+    await grok.data.detectSemanticTypes(df);
+
+    const fSubStr: string = 'hHis-Aca';
+    const fSepStr: string = '-';
+    const fTrueCount: number = 8;
+
+    const f1 = await createFilter('MSA', df);
+    const f2 = await createFilter('MSA', df);
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    try {
+      expect(!!f1.bioFilter, true);
+      expect(!!f2.bioFilter, true);
+      expect(f1.bioFilter!.type, 'SeparatorBioFilter');
+      expect(f2.bioFilter!.type, 'SeparatorBioFilter');
+      const bf1 = f1.bioFilter as SeparatorBioFilter;
+      const bf2 = f2.bioFilter as SeparatorBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf1.props = new SeparatorFilterProps(fSubStr, fSepStr);
+      }, 10000, 'await onRowsFiltered');
+      expect(df.filter.trueCount, fTrueCount);
+
+      expect(bf2.props.substructure, fSubStr);
+      expect(bf2.props.separator, fSepStr);
+    } finally {
+      f1.detach();
+      f2.detach();
+    }
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+  });
+
+  test('sync-helm', async () => {
+    const df = await _package.files.readCsv('tests/filter_HELM.csv');
+    await grok.data.detectSemanticTypes(df);
+    const view = grok.shell.addTableView(df);
+
+    const fSubStr: string = 'PEPTIDE1{A.C}$$$$V2.0';
+    const fTrueCount: number = 1;
+
+    const f1 = await createFilter('HELM string', df);
+    const f2 = await createFilter('HELM string', df);
+    const dlg = ui.dialog('Test filters').add(f1.root).add(f2.root).show(); // to waitForElementInDom
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    try {
+      expect(!!f1.bioFilter, true);
+      expect(!!f2.bioFilter, true);
+      expect(f1.bioFilter!.type, 'HelmBioFilter');
+      expect(f2.bioFilter!.type, 'HelmBioFilter');
+      const bf1 = f1.bioFilter as HelmBioFilter;
+      const bf2 = f2.bioFilter as HelmBioFilter;
+
+      await testEvent(df.onRowsFiltered, () => {}, () => {
+        bf1.props = new BioFilterProps(fSubStr);
+      }, 60000, 'await onRowsFiltered'); // wait to load monomers
+      await awaitGrid(view.grid);
+      //debugger;
+
+      _package.logger.debug('Bio tests: substructureFilters/sync-helm, before changed event');
+      await delay(f1.debounceTime * 2);
+      _package.logger.debug('Bio tests: substructureFilters/sync-helm, after changed event');
+      expect(df.filter.trueCount, fTrueCount);
+
+      await f1.awaitRendered();
+      expect(bf2.props.substructure, fSubStr);
+    } finally {
+      f1.detach();
+      f2.detach();
+      dlg.close();
+    }
+    await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
+    await awaitGrid(view.grid);
+  });
 });
+
+async function createFilter(colName: string, df: DG.DataFrame): Promise<BioSubstructureFilter> {
+  if (!df.columns.names().includes(colName)) {
+    throw new Error(`The column '${colName}' not found. ` +
+      `Available in data frame are ${JSON.stringify(df.columns.names())}`);
+  }
+
+  const filter = new BioSubstructureFilter();
+  filter.attach(df);
+  filter.applyState({columnName: colName});
+  filter.column = df.col(colName);
+  filter.columnName = colName;
+  //filter.tableName = df.name;
+  return filter;
+};