@datagrok/peptides 0.8.8 → 0.8.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@datagrok/peptides",
-	"version": "0.8.8",
+	"version": "0.8.9",
 	"description": "",
 	"dependencies": {
 		"@biowasm/aioli": ">=2.4.0",
@@ -8,11 +8,9 @@
 		"@datagrok-libraries/ml": ">=0.0.14",
 		"@datagrok-libraries/statistics": ">=0.1.5",
 		"@datagrok-libraries/utils": ">=0.0.22",
-		"@types/d3": "^7.0.0",
-		"@types/jquery": "^3.5.6",
 		"cash-dom": "latest",
 		"d3": "latest",
-		"datagrok-api": ">=0.115.0",
+		"datagrok-api": ">=0.123.0",
 		"dayjs": "latest",
 		"file-loader": "^6.2.0",
 		"jstat": "^1.9.5",
@@ -20,14 +18,16 @@
 		"rxjs": "^6.5.5"
 	},
 	"devDependencies": {
-		"@typescript-eslint/eslint-plugin": "^4.29.1",
-		"@typescript-eslint/parser": "^4.29.1",
+		"@types/d3": "^7.0.0",
+		"@types/jquery": "^3.5.6",
+		"@typescript-eslint/eslint-plugin": "latest",
+		"@typescript-eslint/parser": "latest",
 		"css-loader": "^5.2.4",
-		"eslint": "^7.32.0",
-		"eslint-config-google": "^0.14.0",
+		"eslint": "latest",
+		"eslint-config-google": "latest",
 		"style-loader": "^2.0.0",
-		"ts-loader": "^9.2.5",
-		"typescript": "^4.4.4",
+		"ts-loader": "latest",
+		"typescript": "latest",
 		"webpack": "latest",
 		"webpack-cli": "latest"
 	},

package/src/describe.ts

@@ -1,11 +1,12 @@
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {splitAlignedPeptides} from './utils/split-aligned';
+// import {splitAlignedPeptides} from './utils/split-aligned';
 import {tTest} from '@datagrok-libraries/statistics/src/tests';
 import {fdrcorrection} from '@datagrok-libraries/statistics/src/multiple-tests';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
 import {ChemPalette} from './utils/chem-palette';
 import {setAARRenderer} from './utils/cell-renderer';
+import {PeptidesController} from './peptides';
 
 const cp = new ChemPalette('grok');
 
@@ -54,26 +55,23 @@ const groupDescription: {[key: string]: {'description': string, 'aminoAcids': st
   }
 }*/
 
-function joinDataFrames(
-  activityColumnScaled: string,
-  df: DG.DataFrame,
-  positionColumns: string[],
-  splitSeqDf: DG.DataFrame,
-  activityColumn: string,
-) {
-  if (df.col(activityColumnScaled))
-  (df.columns as DG.ColumnList).remove(activityColumnScaled);
+function joinDataFrames(df: DG.DataFrame, positionColumns: string[], splitSeqDf: DG.DataFrame, activityColumn: string) {
+  // if (df.col(activityColumnScaled))
+  //   (df.columns as DG.ColumnList).remove(activityColumnScaled);
 
 
   //FIXME: this column usually duplicates, so remove it then
-  if (df.col(`${activityColumnScaled} (2)`))
-    (df.columns as DG.ColumnList).remove(`${activityColumnScaled} (2)`);
+  // if (df.col(`${activityColumnScaled} (2)`))
+  //   (df.columns as DG.ColumnList).remove(`${activityColumnScaled} (2)`);
 
 
   // append splitSeqDf columns to source table and make sure columns are not added more than once
-  const dfColsSet = new Set(df.columns.names());
-  if (!positionColumns.every((col: string) => dfColsSet.has(col)))
-    df.join(splitSeqDf, [activityColumn], [activityColumn], df.columns.names(), positionColumns, 'inner', true);
+  const dfColsSet = new Set((df.columns as DG.ColumnList).names());
+  if (!positionColumns.every((col: string) => dfColsSet.has(col))) {
+    df.join(
+      splitSeqDf, [activityColumn], [activityColumn], (df.columns as DG.ColumnList).names(), positionColumns, 'inner',
+      true);
+  }
 }
 
 function sortSourceGrid(sourceGrid: DG.Grid) {
@@ -96,35 +94,33 @@ function sortSourceGrid(sourceGrid: DG.Grid) {
   }
 }
 
-async function scaleActivity(
-  activityScaling: string,
-  activityColumn: string,
-  activityColumnScaled: string,
-  sourceGrid: DG.Grid,
-  splitSeqDf: DG.DataFrame,
-) {
-  const df = sourceGrid.dataFrame!;
-  switch (activityScaling) {
-  case 'lg':
-    await df.columns.addNewCalculated(activityColumnScaled, 'Log10(${' + activityColumn + '})');
-    splitSeqDf.columns.add(df.getCol(activityColumnScaled));
-    sourceGrid.col(activityColumnScaled)!.name = `Log10(${activityColumn})`;
-    sourceGrid.columns.setOrder([`Log10(${activityColumn})`]);
-    break;
-  case '-lg':
-    await df.columns.addNewCalculated(activityColumnScaled, '-1*Log10(${' + activityColumn + '})');
-    splitSeqDf.columns.add(df.getCol(activityColumnScaled));
-    sourceGrid.col(activityColumnScaled)!.name = `-Log10(${activityColumn})`;
-    sourceGrid.columns.setOrder([`-Log10(${activityColumn})`]);
-    break;
-  default:
-    await df.columns.addNewCalculated(activityColumnScaled, '${' + activityColumn + '}');
-    splitSeqDf.columns.add(df.getCol(activityColumnScaled));
-    sourceGrid.col(activityColumnScaled)!.name = `${activityColumn}`;
-    sourceGrid.columns.setOrder([`${activityColumn}`]);
-    break;
-  }
-}
+// export async function scaleActivity(
+//   activityScaling: string, activityColumn: string, activityColumnScaled: string, df: DG.DataFrame,
+// ): Promise<[DG.DataFrame, string]> {
+//   // const df = sourceGrid.dataFrame!;
+//   const tempDf = df.clone(null, [activityColumn]);
+
+//   let formula = '${' + activityColumn + '}';
+//   let newColName = activityColumn;
+//   switch (activityScaling) {
+//   case 'none':
+//     break;
+//   case 'lg':
+//     formula = `Log10(${formula})`;
+//     newColName = `Log10(${newColName})`;
+//     break;
+//   case '-lg':
+//     formula = `-1*Log10(${formula})`;
+//     newColName = `-Log10(${newColName})`;
+//     break;
+//   default:
+//     throw new Error(`ScalingError: method \`${activityScaling}\` is not available.`);
+//   }
+
+//   await (tempDf.columns as DG.ColumnList).addNewCalculated(activityColumnScaled, formula);
+
+//   return [tempDf, newColName];
+// }
 
 async function calculateStatistics(
   matrixDf: DG.DataFrame,
@@ -145,12 +141,12 @@ async function calculateStatistics(
   matrixDf = matrixDf.clone(matrixDf.filter);
 
   // calculate additional stats
-  await matrixDf.columns.addNewCalculated('Ratio', '${count}/'.concat(`${peptidesCount}`));
+  await (matrixDf.columns as DG.ColumnList).addNewCalculated('Ratio', '${count}/'.concat(`${peptidesCount}`));
 
   //calculate p-values based on t-test
   let pvalues: Float32Array = new Float32Array(matrixDf.rowCount).fill(1);
-  const mdCol: DG.Column = matrixDf.columns.addNewFloat('Mean difference');
-  const pValCol: DG.Column = matrixDf.columns.addNewFloat('pValue');
+  const mdCol: DG.Column = (matrixDf.columns as DG.ColumnList).addNewFloat('Mean difference');
+  const pValCol: DG.Column = (matrixDf.columns as DG.ColumnList).addNewFloat('pValue');
   for (let i = 0; i < matrixDf.rowCount; i++) {
     const position = matrixDf.get(positionColName, i);
     const aar = matrixDf.get(aminoAcidResidue, i);
@@ -194,7 +190,7 @@ async function setCategoryOrder(
 ) {
   const sortArgument = twoColorMode ? 'Absolute Mean difference' : 'Mean difference';
   if (twoColorMode)
-    await statsDf.columns.addNewCalculated('Absolute Mean difference', 'Abs(${Mean difference})');
+    await (statsDf.columns as DG.ColumnList).addNewCalculated('Absolute Mean difference', 'Abs(${Mean difference})');
 
   const aarWeightsDf = statsDf.groupBy([aminoAcidResidue]).sum(sortArgument, 'weight').aggregate();
   const aarList = aarWeightsDf.getCol(aminoAcidResidue).toList();
@@ -254,11 +250,11 @@ function createGrids(
   sarVGrid.col('pValue')!.name = 'P-Value';
 
   if (!grouping) {
-    let tempCol = matrixDf.columns.byName(aminoAcidResidue);
+    let tempCol = (matrixDf.columns as DG.ColumnList).byName(aminoAcidResidue);
     if (tempCol)
       setAARRenderer(tempCol, sarGrid);
 
-    tempCol = sequenceDf.columns.byName(aminoAcidResidue);
+    tempCol = (sequenceDf.columns as DG.ColumnList).byName(aminoAcidResidue);
     if (tempCol)
       setAARRenderer(tempCol, sarGrid);
   }
@@ -267,14 +263,8 @@ function createGrids(
 }
 
 function setCellRendererFunc(
-  renderColNames: string[],
-  positionColName: string,
-  aminoAcidResidue: string,
-  statsDf: DG.DataFrame,
-  twoColorMode: boolean,
-  sarGrid: DG.Grid,
-  sarVGrid: DG.Grid,
-) {
+    renderColNames: string[], positionColName: string, aminoAcidResidue: string, statsDf: DG.DataFrame,
+    twoColorMode: boolean, sarGrid: DG.Grid, sarVGrid: DG.Grid) {
   const mdCol = statsDf.getCol('Mean difference');
   const cellRendererFunc = function(args: DG.GridCellRenderArgs) {
     args.g.save();
@@ -327,12 +317,8 @@ function setCellRendererFunc(
         args.g.beginPath();
         args.g.fillStyle = coef;
         args.g.arc(
-          args.bounds.x + args.bounds.width / 2,
-          args.bounds.y + args.bounds.height / 2,
-          radius < 3 ? 3 : radius,
-          0,
-          Math.PI * 2,
-          true,
+          args.bounds.x + args.bounds.width / 2, args.bounds.y + args.bounds.height / 2, radius < 3 ? 3 : radius, 0,
+          Math.PI * 2, true,
         );
         args.g.closePath();
 
@@ -347,27 +333,15 @@ function setCellRendererFunc(
 }
 
 function setTooltipFunc(
-  renderColNames: string[],
-  statsDf: DG.DataFrame,
-  aminoAcidResidue: string,
-  positionColName: string,
-  peptidesCount: number,
-  grouping: boolean,
-  sarGrid: DG.Grid,
-  sarVGrid: DG.Grid,
-) {
+    renderColNames: string[], statsDf: DG.DataFrame, aminoAcidResidue: string, positionColName: string,
+    peptidesCount: number, grouping: boolean, sarGrid: DG.Grid, sarVGrid: DG.Grid) {
   const onCellTooltipFunc = async function(cell: DG.GridCell, x: number, y: number) {
     if (
-      !cell.isRowHeader &&
-      !cell.isColHeader &&
-      cell.tableColumn !== null &&
-      cell.cell.value !== null &&
-      cell.tableRowIndex !== null &&
-      renderColNames.indexOf(cell.tableColumn.name) !== -1
-    ) {
+        !cell.isRowHeader && !cell.isColHeader && cell.tableColumn !== null && cell.cell.value !== null &&
+        cell.tableRowIndex !== null && renderColNames.indexOf(cell.tableColumn.name) !== -1) {
       const tooltipMap: { [index: string]: string } = {};
 
-      for (const col of statsDf.columns.names()) {
+      for (const col of (statsDf.columns as DG.ColumnList).names()) {
         if (col !== aminoAcidResidue && col !== positionColName) {
           const currentPosition = cell.tableColumn.name !== 'Mean difference' ?
             cell.tableColumn.name : cell.grid.table.get(positionColName, cell.tableRowIndex);
@@ -412,7 +386,6 @@ function setTooltipFunc(
 function postProcessGrids(
   sourceGrid: DG.Grid,
   invalidIndexes: number[],
-  matrixDf: DG.DataFrame,
   grouping: boolean,
   aminoAcidResidue: string,
   sarGrid: DG.Grid,
@@ -424,9 +397,20 @@ function postProcessGrids(
       cell.style.backColor = DG.Color.lightLightGray;
   });
 
-  for (const col of matrixDf.columns.names())
-    sarGrid.col(col)!.width = sarGrid.props.rowHeight;
-
+  const mdCol: DG.GridColumn = sarVGrid.col('Mean difference')!;
+  mdCol.name = 'Diff';
+
+  for (const grid of [sarGrid, sarVGrid]) {
+    grid.props.rowHeight = 20;
+    grid.columns.rowHeader!.width = 20;
+    for (let i = 0; i < grid.columns.length; ++i) {
+      const col = grid.columns.byIndex(i)!;
+      if (grid == sarVGrid && col.name !== 'Diff' && col.name !== 'AAR')
+        col.width = 45;
+      else
+        col.width = grid.props.rowHeight;
+    }
+  }
 
   if (grouping) {
     sarGrid.col(aminoAcidResidue)!.name = 'Groups';
@@ -435,8 +419,6 @@ function postProcessGrids(
 
   sarGrid.props.allowEdit = false;
   sarVGrid.props.allowEdit = false;
-
-  sarVGrid.col('Mean difference')!.name = 'Diff';
 }
 
 export async function describe(
@@ -451,28 +433,45 @@ export async function describe(
   //Split the aligned sequence into separate AARs
   let splitSeqDf: DG.DataFrame | undefined;
   let invalidIndexes: number[];
-  const col: DG.Column = df.columns.bySemType('alignedSequence');
-  [splitSeqDf, invalidIndexes] = splitAlignedPeptides(col);
+  const col: DG.Column = (df.columns as DG.ColumnList).bySemType('alignedSequence')!;
+  [splitSeqDf, invalidIndexes] = PeptidesController.splitAlignedPeptides(col);
   splitSeqDf.name = 'Split sequence';
 
-  const positionColumns = splitSeqDf.columns.names();
+  const positionColumns = (splitSeqDf.columns as DG.ColumnList).names();
   const activityColumnScaled = `${activityColumn}Scaled`;
-  const renderColNames: string[] = splitSeqDf.columns.names();
-  const positionColName = 'Position';
+  const renderColNames: string[] = (splitSeqDf.columns as DG.ColumnList).names();
+  const positionColName = 'Pos';
   const aminoAcidResidue = 'AAR';
 
-  splitSeqDf.columns.add(df.getCol(activityColumn));
+  (splitSeqDf.columns as DG.ColumnList).add(df.getCol(activityColumn));
 
-  joinDataFrames(activityColumnScaled, df, positionColumns, splitSeqDf, activityColumn);
+  joinDataFrames(df, positionColumns, splitSeqDf, activityColumn);
 
-  for (const col of df.columns) {
+  for (const col of (df.columns as DG.ColumnList)) {
     if (splitSeqDf.col(col.name) && col.name != activityColumn)
       setAARRenderer(col, sourceGrid);
   }
 
   sortSourceGrid(sourceGrid);
 
-  await scaleActivity(activityScaling, activityColumn, activityColumnScaled, sourceGrid, splitSeqDf);
+  const [scaledDf, newColName] = await PeptidesController.scaleActivity(
+    activityScaling, activityColumn, activityColumnScaled, df);
+  //TODO: make another func
+  const scaledCol = scaledDf.getCol(activityColumnScaled);
+  const oldScaledCol = df.getCol(activityColumnScaled);
+  const oldScaledColGridName = oldScaledCol.temp['gridName'];
+  const oldScaledGridCol = sourceGrid.col(oldScaledColGridName);
+
+  (splitSeqDf.columns as DG.ColumnList).add(scaledCol);
+  (df.columns as DG.ColumnList).replace(oldScaledCol, scaledCol);
+  if (newColName === activityColumn)
+    sourceGrid.col(activityColumn)!.name = `~${activityColumn}`;
+  if (oldScaledGridCol !== null) {
+    oldScaledGridCol.name = newColName;
+    oldScaledGridCol.visible = true;
+  }
+  sourceGrid.columns.setOrder([newColName]);
+
   splitSeqDf = splitSeqDf.clone(initialBitset);
 
   //unpivot a table and handle duplicates
@@ -528,7 +527,7 @@ export async function describe(
     renderColNames, statsDf, aminoAcidResidue, positionColName, peptidesCount, grouping, sarGrid, sarVGrid,
   );
 
-  postProcessGrids(sourceGrid, invalidIndexes, matrixDf, grouping, aminoAcidResidue, sarGrid, sarVGrid);
+  postProcessGrids(sourceGrid, invalidIndexes, grouping, aminoAcidResidue, sarGrid, sarVGrid);
 
   //TODO: return class instead
   return [sarGrid, sarVGrid, statsDf, groupMapping];

package/src/model.ts

@@ -1,104 +1,125 @@
 import * as DG from 'datagrok-api/dg';
 
 import {describe} from './describe';
-import {Subject} from 'rxjs';
+import {Subject, Observable} from 'rxjs';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {addViewerToHeader, StackedBarChart} from './viewers/stacked-barchart-viewer';
 
-/**
- * Model class for SAR viewers that retrieves and stores data.
- *
- * @class SARViewerModel
- */
-class SARViewerModel {
-  private viewerGrid: Subject<DG.Grid> = new Subject<DG.Grid>();
-  private viewerVGrid: Subject<DG.Grid> = new Subject<DG.Grid>();
-  private statsDf: Subject<DG.DataFrame> = new Subject<DG.DataFrame>();
-  private groupMapping: Subject<StringDictionary> = new Subject<StringDictionary>();
-  public viewerGrid$;
-  public viewerVGrid$;
-  public statsDf$;
-  public groupMapping$;
+export class PeptidesModel {
+  // private _viewerGrid: DG.Grid;
+  // private viewerVGrid: DG.Grid;
+  // private _statsDf: DG.DataFrame;
+  // private groupMapping: StringDictionary;
   private dataFrame: DG.DataFrame | null;
   private activityColumn: string | null;
   private activityScaling: string | null;
   private sourceGrid: DG.Grid | null;
   private twoColorMode: boolean | null;
   private initialBitset: DG.BitSet | null;
-  private isUpdating = false;
-  grouping: boolean;
-
-  /**
-   * Creates an instance of SARViewerModel.
-   *
-   * @memberof SARViewerModel
-   */
-  constructor() {
-    this.dataFrame = null;
+  private isUpdating: boolean = false;
+  private grouping: boolean = false;
+  private substFlag = false;
+  private statsDataFrameSubject = new Subject<DG.DataFrame>();
+  private sarGridSubject = new Subject<DG.Grid>();
+  private sarVGridSubject = new Subject<DG.Grid>();
+  private groupMappingSubject = new Subject<StringDictionary>();
+  private substFlagSubject = new Subject<boolean>();
+  private static _modelName = 'peptidesModel';
+
+  private constructor(dataFrame: DG.DataFrame) {
+    this.dataFrame = dataFrame;
     this.activityColumn = null;
     this.activityScaling = null;
     this.sourceGrid = null;
     this.twoColorMode = null;
     this.initialBitset = null;
-    this.grouping = false;
-    this.viewerGrid$ = this.viewerGrid.asObservable();
-    this.viewerVGrid$ = this.viewerVGrid.asObservable();
-    this.statsDf$ = this.statsDf.asObservable();
-    this.groupMapping$ = this.groupMapping.asObservable();
+
+    // this._statsDf = DG.DataFrame.create();
+    // this._viewerGrid = DG.Grid.create(this.statsDf);
+    // this.viewerVGrid = DG.Grid.create(this.statsDf);
+    // this.groupMapping = {};
+
+    // this.statsDataFrameObservable = new Observable(subject => subject.next(this.statsDf));
+    // this.sarGridObservable = new Observable(subject => subject.next(this.viewerGrid));
+    // this.sarVGridObservable = new Observable(subject => subject.next(this.viewerVGrid));
+    // this.groupMappingObservable = new Observable(subject => subject.next(this.groupMapping));
+  }
+
+  // get statsDf() {
+  //   return this._statsDf;
+  // }
+
+  // get viewerGrid() {
+  //   return this._viewerGrid;
+  // }
+
+  get onStatsDataFrameChanged(): Observable<DG.DataFrame> {
+    return this.statsDataFrameSubject.asObservable();
+  }
+
+  get onSARGridChanged(): Observable<DG.Grid> {
+    return this.sarGridSubject.asObservable();
+  }
+
+  get onSARVGridChanged(): Observable<DG.Grid> {
+    return this.sarVGridSubject.asObservable();
+  }
+
+  get onGroupMappingChanged(): Observable<StringDictionary> {
+    return this.groupMappingSubject.asObservable();
+  }
+
+  get onSubstFlagChanged(): Observable<boolean> {
+    return this.substFlagSubject.asObservable();
   }
 
-  /**
-   * Updates data with using specified parameters.
-   *
-   * @param {DG.DataFrame} df Working table.
-   * @param {string} activityCol Activity column name.
-   * @param {string} activityScaling Activity scaling method.
-   * @param {DG.Grid} sourceGrid Working table grid.
-   * @param {boolean} twoColorMode Bidirectional analysis enabled.
-   * @param {(DG.BitSet | null)} initialBitset Initial bitset.
-   * @param {boolean} grouping Grouping enabled.
-   * @memberof SARViewerModel
-   */
   async updateData(
-    df: DG.DataFrame,
-    activityCol: string,
-    activityScaling: string,
-    sourceGrid: DG.Grid,
-    twoColorMode: boolean,
-    initialBitset: DG.BitSet | null,
-    grouping: boolean,
-  ) {
-    this.dataFrame = df;
-    this.activityColumn = activityCol;
-    this.activityScaling = activityScaling;
-    this.sourceGrid = sourceGrid;
-    this.twoColorMode = twoColorMode;
-    this.initialBitset = initialBitset;
-    this.grouping = grouping;
+    df: DG.DataFrame | null, activityCol: string | null, activityScaling: string | null, sourceGrid: DG.Grid | null,
+    twoColorMode: boolean | null, initialBitset: DG.BitSet | null, grouping: boolean | null) {
+    this.dataFrame = df ?? this.dataFrame;
+    this.activityColumn = activityCol ?? this.activityColumn;
+    this.activityScaling = activityScaling ?? this.activityScaling;
+    this.sourceGrid = sourceGrid ?? this.sourceGrid;
+    this.twoColorMode = twoColorMode ?? this.twoColorMode;
+    this.initialBitset = initialBitset ?? this.initialBitset;
+    this.grouping = grouping ?? this.grouping;
     await this.updateDefault();
   }
 
-  /**
-   * Update data using current parameters.
-   *
-   * @memberof SARViewerModel
-   */
   async updateDefault() {
-    if (
-      this.dataFrame && this.activityColumn && this.activityScaling &&
-        this.sourceGrid && this.twoColorMode !== null && !this.isUpdating
-    ) {
+    if (this.dataFrame && this.activityColumn && this.activityScaling && this.sourceGrid &&
+        this.twoColorMode !== null && !this.isUpdating) {
       this.isUpdating = true;
       const [viewerGrid, viewerVGrid, statsDf, groupMapping] = await describe(
-        this.dataFrame, this.activityColumn, this.activityScaling,
-        this.sourceGrid, this.twoColorMode, this.initialBitset, this.grouping,
-      );
-      this.viewerGrid.next(viewerGrid);
-      this.viewerVGrid.next(viewerVGrid);
-      this.statsDf.next(statsDf);
-      this.groupMapping.next(groupMapping);
+        this.dataFrame, this.activityColumn, this.activityScaling, this.sourceGrid, this.twoColorMode,
+        this.initialBitset, this.grouping);
+      this.statsDataFrameSubject.next(statsDf);
+      this.groupMappingSubject.next(groupMapping);
+      this.sarGridSubject.next(viewerGrid);
+      this.sarVGridSubject.next(viewerVGrid);
+      this.substFlag = !this.substFlag;
+      this.substFlagSubject.next(this.substFlag);
+
+      this.sourceGrid.invalidate();
+
       this.isUpdating = false;
     }
+
+    await this.updateBarchart();
   }
-}
 
-export const model = new SARViewerModel();
+  async updateBarchart() {
+    const stackedBarchart = await this.dataFrame?.plot.fromType('StackedBarChartAA') as StackedBarChart;
+    if (stackedBarchart && this.sourceGrid)
+      addViewerToHeader(this.sourceGrid, stackedBarchart);
+  }
+
+  static get modelName() {
+    return PeptidesModel._modelName;
+  }
+
+  static getOrInit(dataFrame: DG.DataFrame): PeptidesModel {
+    dataFrame.temp[PeptidesModel.modelName] ??= new PeptidesModel(dataFrame);
+    return dataFrame.temp[PeptidesModel.modelName];
+  }
+}

package/src/monomer-library.ts

@@ -1,10 +1,8 @@
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-import * as grok from 'datagrok-api/grok';
-
 /** HELM associated sdf libraries with monomer processing*/
 export class MonomerLibrary {
-  private monomerFields: string[] = ['molecule', 'MonomerType', 'MonomerNaturalAnalogCode', 'MonomerName', 'MonomerCode', 'MonomerCaps', 'BranchMonomer'];
+  private monomerFields: string[] = [
+    'molecule', 'MonomerType', 'MonomerNaturalAnalogCode', 'MonomerName', 'MonomerCode', 'MonomerCaps', 'BranchMonomer',
+  ];
   private library: {
     [name: string]: {
       mol: string,
@@ -17,13 +15,13 @@ export class MonomerLibrary {
 
   constructor(sdf: string) {
     const sdfReader = new SDFReader();
-    const data = sdfReader.get_colls(sdf);
+    const data = sdfReader.getColls(sdf);
     this.monomerFields.forEach((f) => {
       if (!(f in data))
-        throw `Monomer library was not compiled: ${f} field is absent in provided file`;
+        throw new Error(`Monomer library was not compiled: ${f} field is absent in provided file`);
 
       if (data[f].length != data.molecule.length)
-        throw `Monomer library was not compiled: ${f} field is not presented for each monomer`;
+        throw new Error(`Monomer library was not compiled: ${f} field is not presented for each monomer`);
     });
 
     for (let i = 0; i < data.molecule.length; i++) {
@@ -45,7 +43,7 @@ export class MonomerLibrary {
   /** getting full monomer information from monomer library*/
   public getMonomerEntry(name: string) {
     if (!this.monomers.includes(name))
-      throw `Monomer library do not contain ${name} monomer`;
+      throw new Error(`Monomer library do not contain ${name} monomer`);
 
 
     return this.library[name];
@@ -54,7 +52,7 @@ export class MonomerLibrary {
   /** getting mol as string for monomer*/
   public getMonomerMol(name: string) {
     if (!this.monomers.includes(name))
-      throw `Monomer library do not contain ${name} monomer`;
+      throw new Error(`Monomer library do not contain ${name} monomer`);
 
 
     const entry = this.library[name];
@@ -77,7 +75,7 @@ export class MonomerLibrary {
   private getLinkData(mol: string, caps: string, name: string) {
     const rawData = mol.match(/M  RGP  .+/);
     if (rawData === null)
-      throw `Monomer library was not compiled: ${name} entry has no RGP`;
+      throw new Error(`Monomer library was not compiled: ${name} entry has no RGP`);
 
 
     const types: { [code: string]: string } = {};
@@ -118,7 +116,7 @@ class SDFReader {
     this.dataColls = {'molecule': []};
   }
 
-  get_colls(content: string) {
+  getColls(content: string) {
     this.read(content);
     return this.dataColls;
   }

package/src/package-test.ts

@@ -10,10 +10,10 @@ export const _package = new DG.Package();
 
 //name: test
 //input: string category {optional: true}
-//input: string test {optional: true}
+//input: string t {optional: true}
 //output: dataframe result
 //top-menu: Tools | Dev | JS API Tests
-export async function test(category: string, test: string): Promise<DG.DataFrame> {
-  const data = await runTests({category, test});
+export async function test(category: string, t: string): Promise<DG.DataFrame> {
+  const data = await runTests({category, test: t});
   return DG.DataFrame.fromObjects(data)!;
 }