@datagrok/bio 2.15.3 → 2.15.6

package/src/tests/scoring.ts

@@ -10,7 +10,7 @@ import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monom
 
 import {getMonomerLibHelper, sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
@@ -41,8 +41,7 @@ PEPTIDE1{[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[1Nal].[
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+    await monomerLibHelper.loadMonomerLibForTests(); // load default libraries
   });
 
   after(async () => {

package/src/tests/seq-handler-get-helm-tests.ts

@@ -5,9 +5,8 @@ import * as DG from 'datagrok-api/dg';
 import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION, TAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 category('SeqHandler: getHelm', () => {
@@ -19,8 +18,7 @@ category('SeqHandler: getHelm', () => {
     userLibSettings = await getUserLibSettings();
 
     // Test 'helm' requires default monomer library loaded
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+    await monomerLibHelper.loadMonomerLibForTests(); // load default libraries
   });
 
   after(async () => {

package/src/tests/seq-handler-splitted-tests.ts

@@ -4,8 +4,9 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 
 import {category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
-import {GapOriginals, SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {GapOriginals} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 
 enum Tests {
   fasta = 'fasta',
@@ -135,7 +136,10 @@ PEPTIDE1{meI.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.T.dK.Thr_PO3H2}$$$$`
       expect(sh.separator === testData.tgt.separator, true);
 
       const resSplitted: string[][] = wu.count(0).take(sh.length)
-        .map((rowIdx) => wu(sh.getSplitted(rowIdx).originals).toArray()).toArray();
+        .map((rowIdx) => {
+          const seqSS = sh.getSplitted(rowIdx);
+          return wu.count(0).take(seqSS.length).map((posIdx) => seqSS.getOriginal(posIdx)).toArray();
+        }).toArray();
       expectArray(resSplitted, testData.tgt.splitted);
     });
   }

package/src/tests/splitters-test.ts

@@ -144,13 +144,13 @@ PEPTIDE1{hHis.Aca.Cys_SEt}$$$,5.72388
 });
 
 export async function _testFastaSplitter(src: string, tgt: string[]) {
-  const res: ISeqSplitted = splitterAsFasta(src);
-  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
-  expectArray(wu(res.originals).toArray(), tgt);
+  const resSS: ISeqSplitted = splitterAsFasta(src);
+  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(resSS)} .`);
+  expectArray(wu.count(0).take(resSS.length).map((p) => resSS.getOriginal(p)).toArray(), tgt);
 }
 
 export async function _testHelmSplitter(src: string, tgt: string[]) {
-  const res: ISeqSplitted = splitterAsHelm(src);
-  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(res)} .`);
-  expectArray(wu(res.originals).toArray(), tgt);
+  const resSS: ISeqSplitted = splitterAsHelm(src);
+  console.debug(`Bio: tests: splitters: src=${JSON.stringify(src)}, res=${JSON.stringify(resSS)} .`);
+  expectArray(wu.count(0).take(resSS.length).map((p) => resSS.getOriginal(p)).toArray(), tgt);
 }

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

@@ -8,7 +8,7 @@ import wu from 'wu';
 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 {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
@@ -36,8 +36,7 @@ category('bio-substructure-filters', async () => {
     userLibSettings = await getUserLibSettings();
 
     // Test 'helm' requires default monomer library loaded
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+    await monomerLibHelper.loadMonomerLibForTests(); // load default libraries
   });
 
   after(async () => {

package/src/tests/to-atomic-level-tests.ts

@@ -6,19 +6,19 @@ import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
 
 import {before, after, category, test, expectArray, expect} from '@datagrok-libraries/utils/src/test';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
-  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+  getUserLibSettings, setUserLibSettings
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
-import {toAtomicLevel} from '../package';
 import {_package} from '../package-test';
-import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
 const appPath = 'System:AppData/Bio';
 const fileSource = new DG.FileSource(appPath);
@@ -60,12 +60,17 @@ category('toAtomicLevel', async () => {
   /** Backup actual user's monomer libraries settings */
   let userLibSettings: UserLibSettings;
 
+  let monomerLib: IMonomerLib;
+  let rdKitModule: RDModule;
+
   before(async () => {
+    rdKitModule = await getRdKitModule();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
     // Clear settings to test default
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true);
+    await monomerLibHelper.loadMonomerLibForTests();
+
+    monomerLib = monomerLibHelper.getMonomerLib();
 
     for (const [testName, testData] of Object.entries(TestsData)) {
       const inputPath = testData.inPath;
@@ -83,7 +88,8 @@ category('toAtomicLevel', async () => {
 
   async function getTestResult(source: DG.DataFrame, target: DG.DataFrame): Promise<void> {
     const inputCol = source.getCol(inputColName);
-    await toAtomicLevel(source, inputCol, false);
+    // await toAtomicLevel(source, inputCol, false);
+    await grok.functions.call('Bio:toAtomicLevel', {table: source, seqCol: inputCol, nonlinear: false});
     const obtainedCol = source.getCol(outputColName);
     const expectedCol = target.getCol(outputColName);
     const obtainedArray: string[] = wu(obtainedCol.values()).map((mol) => polishMolfile(mol)).toArray();
@@ -212,19 +218,18 @@ PEPTIDE1{Lys_Boc.hHis.Aca.Cys_SEt.T.dK.Thr_PO3H2.Aca.Tyr_PO3H2.Thr_PO3H2.Aca.Tyr
     const resCol = (await _testToAtomicLevel(srcDf, 'seq', monomerLibHelper))!;
     expect(polishMolfile(resCol.get(0)), polishMolfile(tgtMol));
   });
+
+  async function _testToAtomicLevel(
+    df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper
+  ): Promise<DG.Column | null> {
+    const seqCol: DG.Column<string> = df.getCol(seqColName);
+    const res = await _toAtomicLevel(df, seqCol, monomerLib, rdKitModule);
+    if (res.warnings.length > 0)
+      _package.logger.warning(`_toAtomicLevel() warnings ${res.warnings.join('\n')}`);
+    return res.molCol;
+  }
 });
 
-async function _testToAtomicLevel(
-  df: DG.DataFrame, seqColName: string = 'seq', monomerLibHelper: IMonomerLibHelper
-): Promise<DG.Column | null> {
-  const rdKitModule = await getRdKitModule();
-  const seqCol: DG.Column<string> = df.getCol(seqColName);
-  const monomerLib: IMonomerLib = monomerLibHelper.getMonomerLib();
-  const res = await _toAtomicLevel(df, seqCol, monomerLib);
-  if (res.warnings.length > 0)
-    _package.logger.warning(`_toAtomicLevel() warnings ${res.warnings.join('\n')}`);
-  return res.col;
-}
 
 function polishMolfile(mol: string): string {
   return mol.replaceAll('\r\n', '\n')

package/src/tests/to-atomic-level-ui-tests.ts

@@ -4,28 +4,36 @@ import * as grok from 'datagrok-api/grok';
 import {after, before, category, expect, expectArray, test} from '@datagrok-libraries/utils/src/test';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {sequenceToMolfile} from '../utils/sequence-to-mol';
-import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
-import {getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+import {getUserLibSettings, setUserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
 import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
-import {ConverterFunc} from './types';
-import {_package} from '../package';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
+type TestDataTargetType = { atomCount: number, bondCount: number };
+type TestDataType = {
+  src: { seq: string, units: NOTATION },
+  tgt: TestDataTargetType,
+};
 
 category('toAtomicLevel-ui', () => {
 
   let monomerLibHelper: IMonomerLibHelper;
   let userLibSettings: UserLibSettings;
-  let helmHelper: IHelmHelper;
+  let monomerLib: IMonomerLib;
+  let rdKitModule: RDModule;
 
   before(async () => {
-    helmHelper = await getHelmHelper(); // init Helm package
+    rdKitModule = await getRdKitModule();
     monomerLibHelper = await getMonomerLibHelper();
     userLibSettings = await getUserLibSettings();
 
     // Test 'helm' requires default monomer library loaded
-    await setUserLibSettingsForTests();
-    await monomerLibHelper.loadMonomerLib(true); // load default libraries
+    await monomerLibHelper.loadMonomerLibForTests(); // load default libraries
+
+    monomerLib = monomerLibHelper.getMonomerLib();
   });
 
   after(async () => {
@@ -33,42 +41,72 @@ category('toAtomicLevel-ui', () => {
     await setUserLibSettings(userLibSettings);
     await monomerLibHelper.loadMonomerLib(true); // load user settings libraries
   });
-  const fastaCsv = `seq
-MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
-MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL
-MMELVLKTIIGPIVVGVVLRIVDKWLNKDK
-`;
-  const helmCsv = `seq
-PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Aze.dV.E.N.dV.Phe_4Me}$$$$
-PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.meM.D-Chg.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$
-PEPTIDE1{meI.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.D-Cit.N.D-Orn.D-aThr.Phe_4Me}$$$$
-`;
 
-  test('toAtomicLevel-fasta-linear', async () => {
-    const df = DG.DataFrame.fromCsv(fastaCsv);
-    await grok.data.detectSemanticTypes(df);
-    const seqCol = df.getCol('seq');
-    await _testToAtomicLevelFunc(df, seqCol, false);
-  });
+  const tests: { [testName: string]: TestDataType } = {
+    'fasta': {
+      src: {seq: 'MDYKETLLMPK', units: NOTATION.FASTA,},
+      tgt: {atomCount: 94, bondCount: 95,},
+    },
+    'fasta-with-gap': {
+      src: {seq: 'MD-YKETLLMPK', units: NOTATION.FASTA,},
+      tgt: {atomCount: 94, bondCount: 95,},
+    },
+    'helm': {
+      src: {seq: 'PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2}$$$$', units: NOTATION.HELM,},
+      tgt: {atomCount: 68, bondCount: 68,},
+    },
+    'helm-with-gap': {
+      src: {seq: 'PEPTIDE1{meI.hHis.*.Aca.N.T.dK.Thr_PO3H2}$$$$', units: NOTATION.HELM,},
+      tgt: {atomCount: 68, bondCount: 68,},
+    },
+  };
 
-  test('toAtomicLevel-fasta-nonlinear', async () => {
-    const df = DG.DataFrame.fromCsv(fastaCsv);
-    await grok.data.detectSemanticTypes(df);
-    const seqCol = df.getCol('seq');
-    await _testToAtomicLevelFunc(df, seqCol, true);
-  });
+//   const fastaCsv = `seq
+// MDYKETLLMPKTDFPMRGGLPNKEPQIQEKW
+// MIEVFLFGIVLGLIPITLAGLFVTAYLQYRRGDQLDL
+// MMELVLKTIIGPIVVGVVLRIVDKWLNKDK
+// `;
+//   const helmCsv = `seq
+// PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Aze.dV.E.N.dV.Phe_4Me}$$$$
+// PEPTIDE1{meI.hHis.Aca.N.T.dK.Thr_PO3H2.Aca.meM.D-Chg.dV.E.N.D-Orn.D-aThr.Phe_4Me}$$$$
+// PEPTIDE1{meI.Aca.N.T.dK.Thr_PO3H2.Aca.D-Tyr_Et.Tyr_ab-dehydroMe.dV.D-Cit.N.D-Orn.D-aThr.Phe_4Me}$$$$
+// `;
 
-  test('toAtomicLevel-helm', async () => {
-    const df = DG.DataFrame.fromCsv(helmCsv);
+  const getSeqCol = async (testData: TestDataType): Promise<DG.Column<string>> => {
+    const seq = testData.src.seq;
+    const df = DG.DataFrame.fromColumns([DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'seq', [seq])]);
     await grok.data.detectSemanticTypes(df);
-    const seqCol = df.getCol('seq');
-    await _testToAtomicLevelFunc(df, seqCol, true);
-  });
+    return df.getCol('seq');
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}-linear`, async () => {
+      const seqCol = await getSeqCol(testData);
+      await _testToAtomicLevelFunc(seqCol, false, testData.tgt);
+    });
+  }
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}-nonlinear`, async () => {
+      const seqCol = await getSeqCol(testData);
+      await _testToAtomicLevelFunc(seqCol, true, testData.tgt);
+    });
+  }
 
   async function _testToAtomicLevelFunc(
-    table: DG.DataFrame, seqCol: DG.Column<string>, nonlinear: boolean
+    seqCol: DG.Column<string>, nonlinear: boolean, tgt: TestDataTargetType,
   ): Promise<void> {
-    const molCol = await sequenceToMolfile(table, seqCol, nonlinear, monomerLibHelper.getMonomerLib());
-    expect(molCol!.semType, DG.SEMTYPE.MOLECULE);
+    const res = (await sequenceToMolfile(seqCol.dataFrame, seqCol, nonlinear, false, monomerLib, rdKitModule))!;
+    expect(res.molCol!.semType, DG.SEMTYPE.MOLECULE);
+    const resMolStr = res.molCol!.get(0)!;
+    const resRdMol = rdKitModule.get_mol(resMolStr);
+    expect(resRdMol != null, true, 'No molecule generated');
+    try {
+      const resAtomCount = resRdMol.get_num_atoms();
+      const resBondCount = resRdMol.get_num_bonds();
+      expect(resAtomCount, tgt.atomCount);
+      expect(resBondCount, tgt.bondCount);
+    } finally {
+      resRdMol.delete();
+    }
   }
 });

package/src/tests/types.ts

@@ -2,6 +2,4 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-export type DfReaderFunc = () => Promise<DG.DataFrame>;
-
 export type ConverterFunc = (srcCol: DG.Column) => DG.Column;

package/src/tests/utils/detectors-utils.ts

@@ -0,0 +1,63 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {expect} from '@datagrok-libraries/utils/src/test';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+
+export type DetectorTestData = { [testName: string]: { csv: string, neg?: string[], pos?: { [colName: string]: PosCol } } };
+
+export type DfReaderFunc = () => Promise<DG.DataFrame>;
+
+export class PosCol {
+  constructor(
+    public readonly units: NOTATION,
+    public readonly aligned: ALIGNMENT | null,
+    public readonly alphabet: string | null,
+    public readonly alphabetSize: number,
+    public readonly alphabetIsMultichar?: boolean,
+    public readonly separator?: string,
+  ) { };
+}
+
+export async function _testNeg(readDf: DfReaderFunc, colName: string) {
+  const df: DG.DataFrame = await readDf();
+  const col: DG.Column = df.getCol(colName)!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
+  if (semType)
+    col.semType = semType;
+
+  if (col.semType === DG.SEMTYPE.MACROMOLECULE) {
+    const msg = `Negative test detected semType='${col.semType}', units='${col.meta.units}'.`;
+    throw new Error(msg);
+  }
+}
+
+export async function _testPos(
+  readDf: DfReaderFunc, colName: string, units: string, aligned: string | null,
+  alphabet: string | null, alphabetSize: number, alphabetIsMultichar?: boolean,
+  separator: string | null = null,
+) {
+  const df: DG.DataFrame = await readDf();
+  const col: DG.Column = df.col(colName)!;
+  const semType: string = await grok.functions
+    .call('Bio:detectMacromolecule', {col: col}) as unknown as string;
+  if (semType)
+    col.semType = semType;
+
+  expect(col.semType, DG.SEMTYPE.MACROMOLECULE);
+  expect(col.meta.units, units);
+  expect(col.getTag(bioTAGS.aligned), aligned);
+  expect(col.getTag(bioTAGS.alphabet), alphabet);
+  if (separator)
+    expect(col.getTag(bioTAGS.separator), separator);
+
+  const sh = SeqHandler.forColumn(col);
+  expect(sh.getAlphabetSize(), alphabetSize);
+  expect(sh.getAlphabetIsMultichar(), alphabetIsMultichar);
+  if (!sh.isHelm()) {
+    expect(sh.aligned, aligned);
+    expect(sh.alphabet, alphabet);
+  }
+}

package/src/tests/utils.ts

@@ -7,7 +7,7 @@ import {asRenderer, IRenderer, isRenderer} from '@datagrok-libraries/bio/src/typ
 import {startDockerContainer} from '../utils/docker';
 
 import {_package} from '../package-test';
-import {CellRendererBackBase, getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {CellRendererBackBase, getGridCellColTemp} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 
 export async function loadFileAsText(name: string): Promise<string> {
   return await _package.files.readAsText(name);
@@ -47,7 +47,7 @@ export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<
     if (gridCol) {
       const gridCell = grid.cell(gridCol.name, 0);
       const [_gridCol, _tableCol, temp] =
-        getGridCellRendererBack<void, CellRendererBackBase<void>>(gridCell);
+        getGridCellColTemp<void, CellRendererBackBase<void>>(gridCell);
 
       const renderer = asRenderer(temp.rendererBack);
       if (renderer) await renderer.awaitRendered();

package/src/utils/cell-renderer-custom.ts

@@ -0,0 +1,62 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import * as ui from 'datagrok-api/ui';
+
+import {getGridCellColTemp, CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+export class MacromoleculeCustomCellRenderer extends DG.GridCellRenderer {
+  get name(): string { return 'sequence'; }
+
+  get cellType(): string { return 'sequence'; }
+
+  get defaultHeight(): number | null { return 30; }
+
+  get defaultWidth(): number | null { return 230; }
+
+  getRendererBack(gridCell: DG.GridCell): CellRendererBackBase<string> {
+    const [gridCol, tableCol, temp] = getGridCellColTemp<string, any>(gridCell);
+    const sh = SeqHandler.forColumn(tableCol);
+    if (sh.notation !== NOTATION.CUSTOM)
+      throw new Error(`Unexpected notation: '${sh.notation}'.`);
+    const back = sh.getRendererBack(gridCol, tableCol);
+    return back;
+  }
+
+  override onMouseLeave(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onMouseLeave(gridCell, e);
+  }
+
+  override onMouseMove(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onMouseMove(gridCell, e);
+  }
+
+  override onClick(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onClick(gridCell, e);
+  }
+
+  override onDoubleClick(gridCell: DG.GridCell, e: MouseEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onDoubleClick(gridCell, e);
+  }
+
+  override onKeyDown(gridCell: DG.GridCell, e: KeyboardEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onKeyDown(gridCell, e);
+  }
+
+  override onKeyPress(gridCell: DG.GridCell, e: KeyboardEvent) {
+    const back = this.getRendererBack(gridCell);
+    back.onKeyPress(gridCell, e);
+  }
+
+  override render(g: CanvasRenderingContext2D, x: number, y: number, w: number, h: number, gridCell: DG.GridCell, cellStyle: DG.GridCellStyle) {
+    const back = this.getRendererBack(gridCell);
+    back.render(g, x, y, w, h, gridCell, cellStyle);
+  }
+}
+