@datagrok/bio 2.12.17 → 2.12.19

package/package.json

@@ -5,7 +5,7 @@
     "name": "Aleksandr Tanas",
     "email": "atanas@datagrok.ai"
   },
-  "version": "2.12.17",
+  "version": "2.12.19",
   "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,12 +34,12 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.41.0",
+    "@datagrok-libraries/bio": "^5.41.5",
     "@datagrok-libraries/chem-meta": "^1.2.5",
     "@datagrok-libraries/math": "^1.1.5",
     "@datagrok-libraries/ml": "^6.6.5",
     "@datagrok-libraries/tutorials": "^1.3.12",
-    "@datagrok-libraries/utils": "^4.2.2",
+    "@datagrok-libraries/utils": "^4.2.5",
     "@webgpu/types": "^0.1.40",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
@@ -57,7 +57,7 @@
   "devDependencies": {
     "@datagrok/chem": "^1.9.2",
     "@datagrok/dendrogram": "^1.2.29",
-    "@datagrok/helm": "^2.1.34",
+    "@datagrok/helm": "^2.2.1",
     "@types/node": "^17.0.24",
     "@types/wu": "latest",
     "@typescript-eslint/eslint-plugin": "latest",

package/src/package.ts

@@ -11,9 +11,7 @@ import {DimReductionBaseEditor, PreprocessFunctionReturnType}
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {BitArrayMetrics, KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
-import {
-  TAGS as bioTAGS,
-} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler, SeqTemps} from '@datagrok-libraries/bio/src/utils/seq-handler';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
@@ -51,7 +49,7 @@ import {demoBio01bUI} from './demo/bio01b-hierarchical-clustering-and-activity-c
 import {demoBio03UI} from './demo/bio03-atomic-level';
 import {demoBio05UI} from './demo/bio05-helm-msa-sequence-space';
 import {checkInputColumnUI} from './utils/check-input-column';
-import {multipleSequenceAlignmentUI} from './utils/multiple-sequence-alignment-ui';
+import {MsaWarning, multipleSequenceAlignmentUI} from './utils/multiple-sequence-alignment-ui';
 import {WebLogoApp} from './apps/web-logo-app';
 import {SplitToMonomersFunctionEditor} from './function-edtiors/split-to-monomers-editor';
 import {splitToMonomersUI} from './utils/split-to-monomers';
@@ -75,6 +73,8 @@ import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimen
 import {
   ITSNEOptions, IUMAPOptions
 } from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer';
+import {generateLongSequence, generateLongSequence2} from '@datagrok-libraries/bio/src/utils/generator';
+
 import {CyclizedNotationProvider} from './utils/cyclized';
 import {getMolColumnFromHelm} from './utils/helm-to-molfile/utils';
 
@@ -86,8 +86,8 @@ export const _package = new BioPackage();
 //name: getMonomerLibHelper
 //description:
 //output: object result
-export function getMonomerLibHelper(): IMonomerLibHelper {
-  return MonomerLibManager.instance;
+export async function getMonomerLibHelper(): Promise<IMonomerLibHelper> {
+  return await MonomerLibManager.getInstance();
 }
 
 export let hydrophobPalette: SeqPaletteCustom | null = null;
@@ -104,12 +104,20 @@ export class SeqPaletteCustom implements SeqPalette {
   }
 }
 
+let monomerLib: IMonomerLib | null = null;
+
 //tags: init
 export async function initBio() {
-  _package.logger.debug('Bio: initBio(), started');
+  const logPrefix = 'Bio: initBio()';
+  _package.logger.debug(`${logPrefix}, start`);
   const module = await grok.functions.call('Chem:getRdKitModule');
+  const t1: number = window.performance.now();
   await Promise.all([
-    (async () => { await MonomerLibManager.instance.loadLibraries(); })(),
+    (async () => {
+      const monomerLibManager = await MonomerLibManager.getInstance();
+      await monomerLibManager.loadLibraries();
+      monomerLib = monomerLibManager.getBioLib();
+    })(),
     (async () => {
       const pkgProps = await _package.getProperties();
       const bioPkgProps = new BioPackageProperties(pkgProps);
@@ -117,9 +125,10 @@ export async function initBio() {
     })(),
   ]).finally(() => {
     _package.completeInit();
+    const t2: number = window.performance.now();
+    _package.logger.debug(`${logPrefix}, loading ET: ${t2 - t1} ms`);
   });
 
-  const monomerLib = MonomerLibManager.instance.getBioLib();
   const monomers: string[] = [];
   const logPs: number[] = [];
 
@@ -159,10 +168,16 @@ export function sequenceTooltip(col: DG.Column): DG.Widget<any> {
   return resWidget;
 }
 
+// Keep for backward compatibility
 //name: getBioLib
 //output: object monomerLib
 export function getBioLib(): IMonomerLib {
-  return MonomerLibManager.instance.getBioLib();
+  return monomerLib!;
+}
+
+// For sync internal use, on initialized package
+export function getMonomerLib(): IMonomerLib | null {
+  return monomerLib!;
 }
 
 //name: getSeqHandler
@@ -571,7 +586,8 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
 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(table, seqCol, nonlinear);
+    const monomerLib = (await getMonomerLibHelper()).getBioLib();
+    await sequenceToMolfile(table, seqCol, nonlinear, monomerLib);
   } finally {
     pi.close();
   }
@@ -582,7 +598,15 @@ export async function toAtomicLevel(table: DG.DataFrame, seqCol: DG.Column, nonl
 //description: Performs multiple sequence alignment
 //tags: bio, panel
 export function multipleSequenceAlignmentDialog(): void {
-  multipleSequenceAlignmentUI();
+  multipleSequenceAlignmentUI()
+    .catch((err: any) => {
+      const [errMsg, _errStack] = errInfo(err);
+      if (err instanceof MsaWarning) {
+        _package.logger.warning(errMsg);
+        return;
+      }
+      throw err;
+    });
 }
 
 //name: Multiple Sequence Alignment
@@ -930,6 +954,26 @@ export async function getRegionHelmApp(): Promise<void> {
   }
 }
 
+// -- Tests long seq --
+
+//name: longSeqTableSeparator
+export function longSeqTableSeparator(): void {
+  const df = DG.DataFrame.fromColumns(generateLongSequence());
+  grok.shell.addTableView(df);
+}
+
+//name: longSeqTableFasta
+export function longSeqTableFasta(): void {
+  const df = DG.DataFrame.fromColumns([generateLongSequence2(NOTATION.FASTA)]);
+  grok.shell.addTableView(df);
+}
+
+//name: longSeqTableHelm
+export function longSeqTableHelm(): void {
+  const df = DG.DataFrame.fromColumns([generateLongSequence2(NOTATION.HELM)]);
+  grok.shell.addTableView(df);
+}
+
 // -- Handle context menu --
 
 ///name: addCopyMenu

package/src/tests/monomer-libraries-tests.ts

@@ -8,8 +8,6 @@ import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/sr
 import {
   getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
-import {MonomerLibFileManager} from '../utils/monomer-lib/library-file-manager/file-manager';
-import {MonomerLibFileEventManager} from '../utils/monomer-lib/library-file-manager/event-manager';
 
 
 category('monomerLibraries', () => {
@@ -51,8 +49,7 @@ category('monomerLibraries', () => {
   test('empty', async () => {
     // exclude all monomer libraries for empty set
     const libSettings = await getUserLibSettings();
-    const libFileEventManager = MonomerLibFileEventManager.getInstance();
-    const libFileManager = await MonomerLibFileManager.getInstance(libFileEventManager);
+    const libFileManager = await monomerLibHelper.getFileManager();
 
     let libFnList = libFileManager.getValidLibraryPaths();
     if (libFnList.length === 0)

package/src/tests/renderers-monomer-placer-tests.ts

@@ -4,16 +4,36 @@ import * as ui from 'datagrok-api/ui';
 
 import wu from 'wu';
 
-import {category, test} from '@datagrok-libraries/utils/src/test';
-import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
+import {after, before, category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {MonomerPlacer, hitBounds} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
-
-import {MonomerLibManager} from '../utils/monomer-lib/lib-manager';
+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 {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
 
 import {_package} from '../package-test';
 
 category('renderers: monomerPlacer', () => {
+  let libHelper: IMonomerLibHelper;
+  let libSettings: UserLibSettings;
+
+  before(async () => {
+    libHelper = await getMonomerLibHelper();
+    libSettings = await getUserLibSettings();
+
+    await setUserLibSettingsForTests();
+    await libHelper.awaitLoaded();
+    await libHelper.loadLibraries(true);
+  });
+
+  after(async () => {
+    await setUserLibSettings(libSettings);
+    await libHelper.loadLibraries(true);
+  });
+
   const tests = {
     splitter: {
       /**
@@ -45,7 +65,7 @@ category('renderers: monomerPlacer', () => {
         'id1,m1-M-m3-mon4-mon5-N-T-MON8-N9\n' +
         'id2,m1-mon2-m3-mon4-mon5-Num--MON8-N9\n' +
         'id3,\n' + // empty
-        'id4,mon1-M-mon3-mon4-mon5---MON8-N9\n',
+        'id4,mon1-M-mon3-mon4-mon5---MON8-N9\n', // [ 5, 38, 71, 104, 137, 170, 203, 236, 269, 295 ]
       testList: [
         {src: {row: 0, x: -1}, tgt: {pos: null}},
         {src: {row: 1, x: 0}, tgt: {pos: null}},
@@ -54,12 +74,12 @@ category('renderers: monomerPlacer', () => {
         {src: {row: 1, x: 5}, tgt: {pos: 0}},
         {src: {row: 1, x: 37}, tgt: {pos: 0}},
         {src: {row: 1, x: 38}, tgt: {pos: 1}},
-        {src: {row: 1, x: 170}, tgt: {pos: 4}},
+        {src: {row: 1, x: 170}, tgt: {pos: 5}},
         {src: {row: 1, x: 200}, tgt: {pos: 5}},
         {src: {row: 2, x: 20}, tgt: {pos: null}}, // empty value
-        {src: {row: 3, x: 170}, tgt: {pos: 4}},
+        {src: {row: 3, x: 170}, tgt: {pos: 5}},
         {src: {row: 3, x: 200}, tgt: {pos: 5}},
-        {src: {row: 3, x: 282}, tgt: {pos: null}},
+        {src: {row: 3, x: 297}, tgt: {pos: null}},
       ]
     },
     fastaMsa: {
@@ -88,6 +108,8 @@ id3,QHIRE--LT
 
   for (const [testName, testData] of Object.entries(tests)) {
     test(`getPosition-${testName}`, async () => {
+      const libHelper = await getMonomerLibHelper();
+      const monomerLib = libHelper.getBioLib();
       const df: DG.DataFrame = DG.DataFrame.fromCsv(testData.csv);
       await grok.data.detectSemanticTypes(df);
       const seqCol: DG.Column = df.getCol('seq');
@@ -103,25 +125,50 @@ id3,QHIRE--LT
           separatorWidth: sepWidth,
           monomerToShort: monomerToShort,
           monomerLengthLimit: monLength,
-          monomerLib: MonomerLibManager.instance.getBioLib(),
         };
       });
 
+      const width: number = 10000;
       const testList = testData.testList;
       // simulate rendering
       for (let rowI: number = 0; rowI < seqCol.length; ++rowI)
-        colTemp.getCellMonomerLengths(rowI);
+        colTemp.getCellMonomerLengths(rowI, 10000);
 
       const errorList: string[] = [];
       for (const [test, _testI] of wu.enumerate(testList)) {
-        const res = {pos: colTemp.getPosition(test.src.row, test.src.x)};
+        const res = {pos: colTemp.getPosition(test.src.row, test.src.x, width)};
         if (test.tgt.pos != res.pos) {
           errorList.push(`Test src ${JSON.stringify(test.src)} expected tgt ${JSON.stringify(test.tgt)},` +
             ` but get ${JSON.stringify({res})}`);
         }
       }
       if (errorList.length > 0)
-        throw new Error('Test failed error(s):\n' + errorList.join(', n'));
+        throw new Error('Test failed error(s):\n' + errorList.join(', \n'));
+    });
+  }
+});
+
+category('renderers: monomerPlacer', () => {
+  const boundsTestData = {
+    bounds: [10, 20, 30, 40, 50, 60],
+    tests: {
+      left: {x: 3, tgt: null},
+      c0left: {x: 10, tgt: 0},
+      c0mid: {x: 12, tgt: 0},
+      c0right: {x: 19, tgt: 0},
+      c1left: {x: 20, tgt: 1},
+      c2right: {x: 39, tgt: 2},
+      c4left: {x: 50, tgt: 4},
+      c4right: {x: 59, tgt: 4},
+      max: {x: 60, tgt: null},
+      right: {x: 65, tgt: null},
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(boundsTestData.tests)) {
+    test('hitBounds-' + testName, async () => {
+      const res = hitBounds(boundsTestData.bounds, testData.x);
+      expect(res, testData.tgt);
     });
   }
 });

package/src/tests/renderers-test.ts

@@ -8,10 +8,11 @@ import {fromEvent} from 'rxjs';
 import {category, expect, test, delay, testEvent} from '@datagrok-libraries/utils/src/test';
 import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {generateLongSequence, generateManySequences} from '@datagrok-libraries/bio/src/utils/generator';
 
 import {importFasta} from '../package';
 import {convertDo} from '../utils/convert';
-import {generateLongSequence, generateManySequences, performanceTest} from './utils/sequences-generators';
+import {performanceTest} from './utils/sequences-generators';
 import {multipleSequenceAlignmentUI} from '../utils/multiple-sequence-alignment-ui';
 import {awaitGrid} from './utils';
 import * as C from '../utils/constants';
@@ -23,9 +24,6 @@ category('renderers', () => {
     await performanceTest(generateLongSequence, 'Long sequences');
   });
 
-  test('many sequence performance', async () => {
-    await performanceTest(generateManySequences, 'Many sequences');
-  });
   test('many sequence performance', async () => {
     await performanceTest(generateManySequences, 'Many sequences');
   });
@@ -56,7 +54,7 @@ category('renderers', () => {
 
   test('scatterPlotTooltip', async () => {
     await _testScatterPlotTooltip();
-  });
+  }, {skipReason: 'GROK-15679'});
 
   async function _rendererMacromoleculeFasta() {
     const csv: string = await grok.dapi.files.readAsText('System:AppData/Bio/samples/FASTA.csv');

package/src/tests/scoring.ts

@@ -4,9 +4,9 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, test, expectFloat, before, after} from '@datagrok-libraries/utils/src/test';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 
-import {sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
+import {getMonomerLibHelper, sequenceIdentityScoring, sequenceSimilarityScoring} from '../package';
 import {
   getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
 } from '@datagrok-libraries/bio/src/monomer-works/lib-settings';

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

@@ -185,6 +185,7 @@ category('bio-substructure-filters', async () => {
       dlg.close();
     }
     await filter.awaitRendered();
+    await delay(3000); //TODO: await for grid.onLookChanged
   });
 
   // Generates unhandled exception accessing isFiltering before bioFilter created
@@ -308,6 +309,7 @@ category('bio-substructure-filters', async () => {
     }
     await Promise.all([f1.awaitRendered(), f2.awaitRendered()]);
     await awaitGrid(view.grid);
+    await delay(3000); //TODO: await for grid.onLookChanged
   });
 
   // two seq columns

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

@@ -7,7 +7,7 @@ import wu from 'wu';
 
 import {before, after, category, test, expectArray, expect} from '@datagrok-libraries/utils/src/test';
 import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+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 {

package/src/tests/utils/sequences-generators.ts

@@ -7,26 +7,6 @@ import {expect} from '@datagrok-libraries/utils/src/test';
 
 import {awaitGrid} from '../utils';
 
-
-export function generateManySequences(): DG.Column[] {
-  const columns: DG.Column[] = [];
-  columns.push(DG.Column.fromList('string', 'MSA',
-    new Array(10 ** 6).fill(
-      'meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr//Phe_4Me')),
-  );
-  columns.push(DG.Column.fromList('string', 'Activity', new Array(10 ** 6).fill('5.30751')));
-  return columns;
-}
-
-export function generateLongSequence(): DG.Column[] {
-  const columns: DG.Column[] = [];
-  const longSequence =
-    `meI/hHis/Aca/N/T/dE/Thr_PO3H2/Aca/D-Tyr_Et/Tyr_ab-dehydroMe/dV/E/N/D-Orn/D-aThr`.repeat(10 ** 5);
-  columns.push(DG.Column.fromList('string', 'MSA', new Array(10 ** 2).fill(longSequence)));
-  columns.push(DG.Column.fromList('string', 'Activity', new Array(10 ** 2).fill('7.30751')));
-  return columns;
-}
-
 export async function performanceTest(generateFunc: () => DG.Column[], testName: string) {
   const columns = generateFunc();
   const df: DG.DataFrame = DG.DataFrame.fromColumns(columns);

package/src/tests/utils.ts

@@ -2,10 +2,12 @@ import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 
 import {delay, expect, testEvent} from '@datagrok-libraries/utils/src/test';
+import {asRenderer, IRenderer, isRenderer} from '@datagrok-libraries/bio/src/types/renderer';
 
 import {startDockerContainer} from '../utils/docker';
 
 import {_package} from '../package-test';
+import {CellRendererBackBase, getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 
 export async function loadFileAsText(name: string): Promise<string> {
   return await _package.files.readAsText(name);
@@ -38,4 +40,17 @@ export async function awaitGrid(grid: DG.Grid, timeout: number = 5000): Promise<
   await delay(0);
   await testEvent(grid.onAfterDrawContent, () => {},
     () => { grid.invalidate(); }, timeout);
+
+  const colCount = grid.columns.length;
+  for (let colI = 0; colI < colCount; ++colI) {
+    const gridCol = grid.columns.byIndex(colI);
+    if (gridCol) {
+      const gridCell = grid.cell(gridCol.name, 0);
+      const [_gridCol, _tableCol, temp] =
+        getGridCellRendererBack<void, CellRendererBackBase<void>>(gridCell);
+
+      const renderer = asRenderer(temp.rendererBack);
+      if (renderer) await renderer.awaitRendered();
+    }
+  }
 }

package/src/utils/cell-renderer.ts

@@ -3,7 +3,6 @@ import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
 
 import wu from 'wu';
-import {Unsubscribable} from 'rxjs';
 
 import {printLeftOrCentered, DrawStyle, TAGS as mmcrTAGS} from '@datagrok-libraries/bio/src/utils/cell-renderer';
 import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
@@ -22,7 +21,7 @@ import {GapOriginals, SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-ha
 import {ISeqSplitted, SeqSplittedBase} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {alphabetPolymerTypes, IMonomerLib} from '@datagrok-libraries/bio/src/types/index';
+import {alphabetPolymerTypes, IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {getGridCellRendererBack} from '@datagrok-libraries/bio/src/utils/cell-renderer-back-base';
 
 import {
@@ -31,14 +30,16 @@ import {
 } from '../utils/cell-renderer-consts';
 import * as C from './constants';
 
-import {_package, getBioLib} from '../package';
+import {_package, getMonomerLib} from '../package';
 
 type TempType = { [tagName: string]: any };
 
 const undefinedColor = 'rgb(100,100,100)';
 const monomerToShortFunction: MonomerToShortFunc = monomerToShort;
 
-function getUpdatedWidth(grid: DG.Grid | null, g: CanvasRenderingContext2D, x: number, w: number, dpr: number): number {
+function getUpdatedWidth(
+  grid: DG.Grid | null | undefined, g: CanvasRenderingContext2D, x: number, w: number, dpr: number
+): number {
   return !!grid ? Math.max(Math.min(grid.canvas.width / dpr - x, w)) : Math.max(g.canvas.width / dpr - x, 0);
 }
 
@@ -99,7 +100,7 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     //   maxLengthWordsSum[posI] = maxLengthWordsSum[posI - 1] + maxLengthWords[posI];
     // const maxIndex = maxLengthWords.length;
     const argsX = e.offsetX - gridCell.gridColumn.left + (gridCell.gridColumn.left - gridCellBounds.x);
-    const left: number | null = seqColTemp.getPosition(gridCell.tableRowIndex!, argsX);
+    const left: number | null = seqColTemp.getPosition(gridCell.tableRowIndex!, argsX, gridCellBounds.width);
 
     const seqCList: SeqSplittedBase = SeqHandler.forColumn(tableCol)
       .getSplitted(gridCell.tableRowIndex!).canonicals;
@@ -113,8 +114,8 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
           const alphabet = sh.alphabet ?? ALPHABET.UN;
           const polymerType = alphabetPolymerTypes[alphabet as ALPHABET];
 
-          const lib: IMonomerLib = seqColTemp.props.monomerLib!;
-          return lib.getTooltip(polymerType, monomerSymbol);
+          const lib: IMonomerLib | null = getMonomerLib();
+          return lib ? lib.getTooltip(polymerType, monomerSymbol) : ui.divText('Monomer library is not available');
         })();
       }
       tooltipElements.push(monomerDiv);
@@ -142,23 +143,17 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
     _cellStyle: DG.GridCellStyle
   ): void {
     const logPrefix: string = 'MacromoleculeSequenceCellRenderer.render()';
+
+    const dpr = window.devicePixelRatio;
+    const [gridCol, tableCol, _temp] =
+      getGridCellRendererBack<string, MonomerPlacer>(gridCell);
+    if (!tableCol) return;
+    const tableColTemp: TempType = tableCol.temp;
+
     let gapLength = 0;
     const msaGapLength = 8;
     let maxLengthOfMonomer = 50; // in case of long monomer representation, do not limit max length
 
-    // TODO: Store temp data to GridColumn
-    // Now the renderer requires data frame table Column underlying GridColumn
-    let grid: DG.Grid | undefined = undefined;
-    try { grid = gridCell.grid; } catch (err: any) {
-      grid = undefined;
-      const [errMsg, errStack] = errInfo(err);
-      _package.logger.error(errMsg, undefined, errStack);
-    }
-    const tableCol: DG.Column = gridCell.cell.column;
-    if (!grid || !tableCol) return;
-
-    const tableColTemp: TempType = tableCol.temp;
-
     // Cell renderer settings
     const tempMonomerWidth: string | null = tableColTemp[tempTAGS.monomerWidth];
     const monomerWidth: string = (tempMonomerWidth != null) ? tempMonomerWidth : 'short';
@@ -170,46 +165,41 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         (!isNaN(tagMaxMonomerLength) ? tagMaxMonomerLength : _package.properties?.MaxMonomerLength) ?? 4;
     }
 
-    const [gridCol, _tc, temp] =
+    const [_gc, _tc, temp] =
       getGridCellRendererBack<string, MonomerPlacer>(gridCell);
-    let seqColTemp: MonomerPlacer = temp['rendererBack'];
+    let seqColTemp: MonomerPlacer = temp.rendererBack;
     if (!seqColTemp) {
-      seqColTemp = new MonomerPlacer(gridCol, tableCol, _package.logger,
+      seqColTemp = temp.rendererBack = new MonomerPlacer(gridCol, tableCol, _package.logger,
         () => {
           const sh = SeqHandler.forColumn(tableCol);
           return {
             seqHandler: sh,
             monomerCharWidth: 7, separatorWidth: !sh.isMsa() ? gapLength : msaGapLength,
             monomerToShort: monomerToShortFunction, monomerLengthLimit: maxLengthOfMonomer,
-            monomerLib: getBioLib()
           };
         });
     }
 
-    if (tableCol.tags[mmcrTags.RendererSettingsChanged] === rendererSettingsChangedState.true) {
-      gapLength = tableColTemp[mmcrTemps.gapLength] as number ?? gapLength;
-      // this event means that the mm renderer settings have changed, particularly monomer representation and max width.
-      seqColTemp.setMonomerLengthLimit(maxLengthOfMonomer);
-      seqColTemp.setSeparatorWidth(seqColTemp.isMsa() ? msaGapLength : gapLength);
-      tableCol.setTag(mmcrTags.RendererSettingsChanged, rendererSettingsChangedState.false);
-    }
-
-    const [maxLengthWords, maxLengthWordsSum]: [number[], number[]] =
-      seqColTemp.getCellMonomerLengths(gridCell.tableRowIndex!);
-    const _maxIndex = maxLengthWords.length;
-
-    // Store updated seqColTemp to the col temp
-    if (seqColTemp.updated) temp['rendererBack'] = seqColTemp;
-
     g.save();
     try {
-      const dpr = window.devicePixelRatio;
-      const grid = gridCell.gridRow !== -1 ? gridCell.grid : null;
+      if (tableCol.tags[mmcrTags.RendererSettingsChanged] === rendererSettingsChangedState.true) {
+        gapLength = tableColTemp[mmcrTemps.gapLength] as number ?? gapLength;
+        // this event means that the mm renderer settings have changed,
+        // particularly monomer representation and max width.
+        seqColTemp.setMonomerLengthLimit(maxLengthOfMonomer);
+        seqColTemp.setSeparatorWidth(seqColTemp.isMsa() ? msaGapLength : gapLength);
+        tableCol.setTag(mmcrTags.RendererSettingsChanged, rendererSettingsChangedState.false);
+      }
+
+      const [maxLengthWords, maxLengthWordsSum]: [number[], number[]] =
+        seqColTemp.getCellMonomerLengths(gridCell.tableRowIndex!, w);
+      const _maxIndex = maxLengthWords.length;
+
       const value: any = gridCell.cell.value;
       const rowIdx = gridCell.cell.rowIndex;
       const paletteType = tableCol.getTag(bioTAGS.alphabet);
       const minDistanceRenderer = 50;
-      w = getUpdatedWidth(grid, g, x, w, dpr);
+      w = getUpdatedWidth(gridCol?.grid, g, x, w, dpr);
       g.beginPath();
       g.rect(x + this.padding, y + this.padding, w - this.padding - 1, h - this.padding * 2);
       g.clip();
@@ -223,7 +213,8 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       const palette = getPaletteByType(paletteType);
 
       const separator = tableCol.getTag(bioTAGS.separator) ?? '';
-      const splitLimit = w / 5;
+      const minMonWidth = seqColTemp.props.separatorWidth + 1 * seqColTemp.props.monomerCharWidth;
+      const splitLimit = Math.ceil(w / minMonWidth);
       const sh = SeqHandler.forColumn(tableCol);
 
       const tempReferenceSequence: string | null = tableColTemp[tempTAGS.referenceSequence];
@@ -247,7 +238,8 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
       if (aligned && aligned.includes('MSA') && units == NOTATION.SEPARATOR)
         drawStyle = DrawStyle.MSA;
 
-      for (let posIdx: number = 0; posIdx < subParts.length; ++posIdx) {
+      const visibleSeqLength = Math.min(subParts.length, splitLimit);
+      for (let posIdx: number = 0; posIdx < visibleSeqLength; ++posIdx) {
         const amino: string = subParts.getOriginal(posIdx);
         color = palette.get(amino);
         g.fillStyle = undefinedColor;
@@ -259,8 +251,9 @@ export class MacromoleculeSequenceCellRenderer extends DG.GridCellRenderer {
         if (minDistanceRenderer > w) break;
       }
     } catch (err: any) {
-      const errMsg: string = err instanceof Error ? err.message : !!err ? err.toString() : 'Error \'undefined\'';
-      _package.logger.error(`Bio: MacromoleculeSequenceCellRenderer.render() error: ${errMsg}`);
+      const [errMsg, errStack] = errInfo(err);
+      seqColTemp.logger.error(errMsg, undefined, errStack);
+      seqColTemp.errors.push(err);
       //throw err; // Do not throw to prevent disabling renderer
     } finally {
       g.restore();