@datagrok/bio 2.24.0 → 2.25.1

package/files/samples/HELM_CHEMS.csv

@@ -0,0 +1,11 @@
+HELM,Activity
+"PEPTIDE1{[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@@H](C(=O)*)C |$_R1;;;;;_R2;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@@H](C(=O)*)Cc1ccccc1 |$_R1;;;;;_R2;;;;;;;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@H](C(=O)*)C |$_R1;;;;;_R2;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@@H](C(=O)*)Cc1ccccc1 |$_R1;;;;;_R2;;;;;;;$|]}$PEPTIDE1,PEPTIDE1,8:R2-1:R1$$$",5.3075109739681280
+"PEPTIDE1{[ac].D.A.D.E.[*N[C@H](C(=O)*)Cc1ccc(cc1)OC(C(=O)O)C(=O)O |$_R1;;;;;_R2;;;;;;;;;;;;;;;$|].L.[am]}$$$$	CHEMBL8284
+PEPTIDE1{[N[C@](C)(C(=O)O)Cc1ccc(c(c1)O)O]}$$$$",5.7238768534315438
+"PEPTIDE1{[meL].[*O[C@@H](C(=O)*)C |$_R1;;;;;_R2;$|].[meL].[*O[C@@H](C(=O)*)Cc1ccccc1 |$_R1;;;;;_R2;;;;;;;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@H](C(=O)*)C |$_R1;;;;;_R2;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@@H](C(=O)*)Cc1ccccc1 |$_R1;;;;;_R2;;;;;;;$|]}|PEPTIDE2{E.[*O[C@@H](C(=O)*)C |$_R1;;;;;_R2;$|].E.[*O[C@@H](C(=O)*)Cc1ccccc1 |$_R1;;;;;_R2;;;;;;;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@H](C(=O)*)C |$_R1;;;;;_R2;$|].[*N(C)[C@H](C(=O)*)CCC |$_R1;;;;;;_R2;;;$|].[*O[C@@H](C(=O)*)Cc1ccccc1 |$_R1;;;;;_R2;;;;;;;$|]}$PEPTIDE2,PEPTIDE2,8:R2-1:R1|PEPTIDE1,PEPTIDE2,1:R1-3:R3|PEPTIDE2,PEPTIDE1,1:R3-8:R2$$$V2.0",5.1858112460224372
+"PEPTIDE1{[[C@H](C(=O)*)CS* |$;;;_R2;;;_R3$|].F.I.Q.N.[dC].S.R.G.[am]}$PEPTIDE1,PEPTIDE1,1:R3-6:R3$$$V2.0",6.2235023908043692
+"PEPTIDE1{A.[dP].D.[dW].F.[dF].N.[dY].Y.[dW].G.[dN].W.[dH].G.[*N[C@@H](C(=O)*)[C@@H](C)O |$_R1;;;;;_R2;;;$|]}$PEPTIDE1,PEPTIDE1,16:R2-1:R1$$$",3.8459123763832412
+PEPTIDE1{N.L.E.R.E.[*N[C@H](C(=O)*)CSCNC(=O)C |$_R1;;;;;_R2;;;;;;;$|].L.E.E.P.[*N[C@H](C(=O)*)CSCNC(=O)C |$_R1;;;;;_R2;;;;;;;$|].S.R.E.E.A.F}$$$$,3.2792043882465700
+"PEPTIDE1{[[C@H](C(=O)*)CS* |$;;;_R2;;;_R3$|].Y.[dF].G.[dN].[dC].[dP].R.G.[am]}$PEPTIDE1,PEPTIDE1,1:R3-6:R3$$$",2.1058521529925680
+PEPTIDE1{A.[[*]C(=O)[C@H](C)N([*])C |$_R2;;;;;;_R1;;;$|].A}$$$$V2.0,1.8036950016492720
+"CHEM1{[*N[C@H](C(=O)*)Cc1ccc(cc1)OP(=O)(O)O |$_R1;;;;;_R2;;;;;;;;;;;;$|]}|PEPTIDE1{[C[C@H](N[*])C(=O)C[*] |$;;;_R1;;;;_R2$|].G.G.G.C.C.K.K.K.K}$PEPTIDE1,CHEM1,10:R3-1:R1$$$V2.0",6.3880602836120888

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.24.0",
+  "version": "2.25.1",
   "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",
@@ -44,7 +44,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.60.0",
+    "@datagrok-libraries/bio": "^5.61.1",
     "@datagrok-libraries/chem-meta": "^1.2.9",
     "@datagrok-libraries/math": "^1.2.6",
     "@datagrok-libraries/ml": "^6.10.6",

package/src/analysis/sequence-space.ts

@@ -33,7 +33,7 @@ export async function getEncodedSeqSpaceCol(
   for (let rowIdx = 0; rowIdx < rowCount; rowIdx++) {
     const catI = seqColRawData[rowIdx];
     const seq = seqColCats[catI];
-    if (seq === null || seqCol.isNone(rowIdx)) {
+    if (seq == null || seqCol.isNone(rowIdx)) {
       //@ts-ignore
       encList[rowIdx] = null;
       continue;

package/src/demo/bio03-atomic-level.ts

@@ -18,7 +18,7 @@ export async function demoToAtomicLevel(): Promise<void> {
   adjustGridcolAfterRender(view.grid, 'molfile(HELM)', 500, 300, true);
   adjustGridcolAfterRender(view.grid, 'HELM', 500, undefined, true);
   grok.shell.info('Hover over monomers in HELM column to highlight them in molecular structure.', {timeout: 10});
-  grok.shell.windows.help.showHelp('/help/datagrok/solutions/domains/bio/bio.md#get-atomic-level-structure');
+  grok.shell.windows.help.showHelp('/help/datagrok/solutions/domains/bio/bio.md#convert-to-atomic-level');
 }
 
 export async function demoBio03UI(): Promise<void> {

package/src/package-types.ts

@@ -41,7 +41,7 @@ export class BioPackageProperties extends Map<string, any> {
   }
 
   public set maxMonomerLength(value: number | null) {
-    const vs = value === null ? 'long' : value.toString();
+    const vs = value == null ? 'long' : value.toString();
     super.set(BioPackagePropertiesNames.MaxMonomerLength, vs);
     this._onPropertyChanged.next(BioPackagePropertiesNames.MaxMonomerLength);
   }

package/src/package.ts

@@ -123,7 +123,7 @@ export class PackageFunctions {
 
   @grok.decorators.init({})
   static async initBio(): Promise<void> {
-    if (initBioPromise === null)
+    if (initBioPromise == null)
       initBioPromise = initBioInt();
 
     await initBioPromise;

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

@@ -83,7 +83,7 @@ category('monomerLibraries', () => {
     };
     const monomerLib = monomerLibHelper.getMonomerLib();
     const absentOverrideMonomer = monomerLib.getMonomer(overMon.polymerType, overMon.symbol);
-    expect(absentOverrideMonomer === null, true, `Unexpectedly found monomer '${overMon.symbol}' `);
+    expect(absentOverrideMonomer == null, true, `Unexpectedly found monomer '${overMon.symbol}' `);
 
     const overriddenMonomerLib = monomerLib.override({[overMon.polymerType]: {[overMon.symbol]: overMon}}, 'test');
     const resOverMon = overriddenMonomerLib.getMonomer(overMon.polymerType, overMon.symbol);

package/src/utils/get-region.ts

@@ -47,9 +47,9 @@ export function getRegionDo(
     if (sh.posList[posJ] == startPosName) startPosIdx = posJ;
     if (sh.posList[posJ] == endPosName) endPosIdx = posJ;
   }
-  if (startPosIdx === null && startPosName !== null)
+  if (startPosIdx == null && startPosName !== null)
     throw new Error(`Start position ${startPosName} not found.`);
-  if (endPosIdx === null && endPosName !== null)
+  if (endPosIdx == null && endPosName !== null)
     throw new Error(`End position ${endPosName} not found.`);
 
   if (sh.posList.length < endPosIdx!)

package/src/utils/helm-to-molfile/converter/const.ts

@@ -1,4 +1,3 @@
 export const HELM_ITEM_SEPARATOR = '|';
-export const HELM_SECTION_SEPARATOR = '$';
 
 export const HYDROGEN_SYMBOL = 'H';

package/src/utils/helm-to-molfile/converter/converter.ts

@@ -29,7 +29,7 @@ export class HelmToMolfileConverter implements IHelmToMolfileConverter {
     const smilesColName = `smiles(${helmCol.name})`;
     const smilesColNameU = df ? df.columns.getUnusedName(smilesColName) : smilesColName;
     return DG.Column.fromStrings(smilesColNameU, smiles.map((molecule) => {
-      if (molecule === null)
+      if (molecule == null)
         return '';
       return molecule;
     }));
@@ -57,7 +57,7 @@ export class HelmToMolfileConverter implements IHelmToMolfileConverter {
 
   public getMolV3000ViaOCL(beautifiedMols: (RDMol | null)[], columnName: string): DG.Column<string> {
     const beautifiedMolV2000 = beautifiedMols.map((mol) => {
-      if (mol === null)
+      if (mol == null)
         return '';
       const molBlock = mol.get_v3Kmolblock();
       mol!.delete();
@@ -97,7 +97,7 @@ export class HelmToMolfileConverter implements IHelmToMolfileConverter {
     if (chiralityEngine)
       return this.getMolV3000ViaOCL(beautifiedMols, molColNameU);
     return DG.Column.fromStrings(molColNameU, beautifiedMols.map((mol) => {
-      if (mol === null)
+      if (mol == null)
         return '';
       const molBlock = mol.get_v3Kmolblock();
       mol!.delete();

package/src/utils/helm-to-molfile/converter/helm.ts

@@ -1,16 +1,24 @@
 import {HELM_POLYMER_TYPE} from '@datagrok-libraries/bio/src/utils/const';
 import {ConnectionList} from './connection-list';
-import {HELM_ITEM_SEPARATOR, HELM_SECTION_SEPARATOR} from './const';
+import {HELM_ITEM_SEPARATOR} from './const';
 import {SimplePolymer} from './simple-polymer';
 import {Bond} from './types';
 
 export class Helm {
   constructor(private helmString: string) {
-    const helmSections = this.helmString.split(HELM_SECTION_SEPARATOR);
-    const simplePolymers = helmSections[0].split(HELM_ITEM_SEPARATOR);
-    this.simplePolymers = simplePolymers
+    const indexOfSequenceEnd = helmString.indexOf('}$');
+    const sequencePart = helmString.substring(0, indexOfSequenceEnd + 1);
+    const connectionsEndPart = helmString.indexOf('$', indexOfSequenceEnd + 2);
+    const connectionsPart = helmString.substring(indexOfSequenceEnd + 2, connectionsEndPart);
+    // const helmParts = seq.split('$');
+    const spList = sequencePart.split('}|');
+    // since we removed }|, need to add } to last part
+    for (let i = 0; i < spList.length - 1; i++)
+      spList[i] = spList[i] + '}';
+
+    this.simplePolymers = spList
       .map((item) => new SimplePolymer(item));
-    this.connectionList = new ConnectionList(helmSections[1]);
+    this.connectionList = new ConnectionList(connectionsPart);
     this.bondData = this.getBondData();
 
     this.bondedRGroupsMap = this.getBondedRGroupsMap();
@@ -58,7 +66,7 @@ export class Helm {
     const lowerBound = shiftValues.sort((a, b) => b - a).find( // find the largest shift not exceeding monomerGlobalIdx
       (shift) => monomerGlobalIdx >= shift
     );
-    if (lowerBound === undefined)
+    if (lowerBound == undefined)
       throw new Error(`Cannot find simple polymer for monomer ${monomerGlobalIdx}`);
     const simplePolymerId = Object.keys(shifts).find((simplePolymerId) => shifts[simplePolymerId] === lowerBound)!;
     const simplePolymer = this.simplePolymers.find((simplePolymer) => simplePolymer.id === simplePolymerId)!;

package/src/utils/helm-to-molfile/converter/mol-bonds.ts

@@ -31,7 +31,7 @@ export abstract class MolfileBonds {
   }
 
   replacePositionsInBondsByDummy(positions: PositionInBonds[], dummy?: number): void {
-    if (dummy === undefined)
+    if (dummy == undefined)
       dummy = -1;
     positions.forEach((position) => {
       const {bondLineIdx, nodeIdx} = position;

package/src/utils/helm-to-molfile/converter/mol-wrapper.ts

@@ -15,7 +15,7 @@ export abstract class MolfileWrapper {
 
   protected shiftR1GroupToOrigin(): void {
     const r1Idx = this.rGroups.getAtomicIdx(1);
-    if (r1Idx === null)
+    if (r1Idx == null)
       return; // R1 group is not present, nothing to shift
     const {x, y} = this.atoms.atomCoordinates[r1Idx];
     this.atoms.shift({x: -x, y: -y});
@@ -23,7 +23,7 @@ export abstract class MolfileWrapper {
 
   protected alignR2AlongX(): void {
     const r2Idx = this.rGroups.getAtomicIdx(2);
-    if (r2Idx === null)
+    if (r2Idx == null)
       throw new Error(`Cannot find R2 group for monomer ${this.monomerSymbol}`);
     const r2Coordinates = this.atoms.atomCoordinates[r2Idx];
     const tan = r2Coordinates.y / r2Coordinates.x;

package/src/utils/helm-to-molfile/converter/r-group-handler.ts

@@ -19,13 +19,13 @@ export class RGroupHandler {
 
   getAtomicIdx(rGroupId: number): number | null {
     const atomicIdx = this.rGroupIdToAtomicIndexMap.get(rGroupId);
-    return atomicIdx === undefined ? null : atomicIdx;
+    return atomicIdx == undefined ? null : atomicIdx;
   }
 
   private removeRGroupsFromAtomBlock(rGroupIds: number[]): void {
     rGroupIds.forEach((rgroupId) => {
       const atomicIdx = this.rGroupIdToAtomicIndexMap.get(rgroupId);
-      if (atomicIdx === undefined)
+      if (atomicIdx == undefined)
         throw new Error(`Cannot find atomic index for R group ${rgroupId}`);
     });
 

package/src/utils/monomer-lib/library-file-manager/file-validator.ts

@@ -22,7 +22,7 @@ export class MonomerLibFileValidator {
 
   validateFile(fileContent: string, fileName: string): boolean {
     const jsonContent = this.parseJson(fileContent, fileName);
-    if (jsonContent === null)
+    if (jsonContent == null)
       return false;
 
     if (!Array.isArray(jsonContent)) {

package/src/utils/monomer-lib/library-file-manager/ui.ts

@@ -5,7 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import $ from 'cash-dom';
-import {Subject} from 'rxjs';
+import {Subject, Subscription} from 'rxjs';
 
 import {
   getUserLibSettings, setUserLibSettings
@@ -50,7 +50,7 @@ class MonomerLibraryManagerWidget {
   private libHelper: IMonomerLibHelper;
 
   static async getInstance(): Promise<MonomerLibraryManagerWidget> {
-    if (MonomerLibraryManagerWidget.instancePromise === undefined) {
+    if (MonomerLibraryManagerWidget.instancePromise == undefined) {
       MonomerLibraryManagerWidget.instancePromise = (async () => {
         const instance = new MonomerLibraryManagerWidget();
         const libHelper = await getMonomerLibHelper();
@@ -67,10 +67,12 @@ class MonomerLibraryManagerWidget {
     instance._widget = await instance.createWidget();
   }
 
+  private _fileUploadSubscription: Subscription | null = null;
   private async createWidget() {
     const content = await this.getWidgetContent();
     const monomerLibHelper = await getMonomerLibHelper();
-    // eslint-disable-next-line rxjs/no-ignored-subscription
+    this._fileUploadSubscription?.unsubscribe();
+    this._fileUploadSubscription =
     monomerLibHelper.fileUploadRequested.subscribe(
       () => this.promptToAddLibraryFiles()
     );
@@ -92,14 +94,29 @@ class MonomerLibraryManagerWidget {
       accept: '.json',
       open: async (selectedFile) => {
         const doAdd = async (provider: IMonomerLibProvider) => {
-          const content = await selectedFile.text();
           const name = selectedFile.name;
+          const existingLibs = await provider.listLibraries();
+          // chech if library already exists
+          if (existingLibs.includes(name)) {
+            const confirm = await new Promise<boolean>((resolve) => {
+              ui.dialog('Confirm Library Update')
+                .add(ui.divText(`Library '${name}' already exists. Do you want to overwrite it?`))
+                .onOK(() => resolve(true))
+                .onCancel(() => resolve(false))
+                .show();
+            });
+            if (!confirm)
+              return;
+          }
+
+          const content = await selectedFile.text();
           const progressIndicator = DG.TaskBarProgressIndicator.create(`Adding ${name} as a monomer library`);
           try {
             await provider.addOrUpdateLibraryString(name, content);
           // this.eventManager.updateLibrarySelectionStatus(name, true);
           } catch (e) {
             grok.shell.error(`File ${name} is not a valid monomer library, verify it is aligned to HELM JSON schema.`);
+            console.error(e);
           } finally {
             progressIndicator.close();
           }
@@ -122,7 +139,7 @@ class MonomerLibraryManagerWidget {
           .onOK(async () => {
             const provider = providers.find((p) => p.name === providersInput.value)!; // should not be null
             await doAdd(provider);
-          });
+          }).show();
       },
     });
   }

package/src/utils/monomer-lib/monomer-lib-base.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 /* eslint-disable max-lines */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
@@ -18,12 +19,14 @@ import {GAP_SYMBOL, GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/ut
 import {Vector} from '@datagrok-libraries/utils/src/type-declarations';
 import {vectorAdd, vectorDotProduct, vectorLength} from '@datagrok-libraries/utils/src/vector-operations';
 
-import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, MissingWebEditorMonomer} from './web-editor-monomer-dummy';
+import {AmbiguousWebEditorMonomer, GapWebEditorMonomer, MissingWebEditorMonomer, SmilesWebEditorMonomer} from './web-editor-monomer-dummy';
 import {LibraryWebEditorMonomer} from './web-editor-monomer-of-library';
 import {naturalMonomerColors} from './monomer-colors';
 
 import {_package} from '../../package';
 import {MonomerLibData} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {smiles2Monomer} from './smiles2Monomer';
+import {polymerTypeToHelmType} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 
 const monomerRe = /[\w()]+/;
 //** Do not mess with monomer symbol with parenthesis enclosed in square brackets */
@@ -61,9 +64,15 @@ export class MonomerLibBase implements IMonomerLibBase {
   }
 
   getMonomerSymbolsByType(polymerType: PolymerType): string[] {
-    return Object.keys(this._monomers[polymerType]);
+    const res = Object.keys(this._monomers[polymerType]);
+    if (this._smilesMonomerCache[polymerType])
+      res.push(...Object.keys(this._smilesMonomerCache[polymerType]));
+    return res;
   }
 
+  // smiles to symbol Mapping cache
+  private _smilesMonomerCache: {[polymerType: string]: {[smiles: string]: string}} = {};
+
   /** Creates missing {@link Monomer} */
   addMissingMonomer(polymerType: PolymerType, monomerSymbol: string): Monomer {
     let mSet = this._monomers[polymerType];
@@ -78,6 +87,22 @@ export class MonomerLibBase implements IMonomerLibBase {
     else if (polymerType === PolymerTypes.RNA && monomerSymbol === 'N')
       monomerName = 'Any';
 
+    // test if it is smiles
+    // check if the missing monomer symbol is a valid SMILES string
+    const smilesMonomer = smiles2Monomer(monomerSymbol, polymerType);
+    if (smilesMonomer) {
+      this._smilesMonomerCache[polymerType] = this._smilesMonomerCache[polymerType] ?? {};
+      const smSet = this._smilesMonomerCache[polymerType];
+      const symbol = Object.keys(smSet).length + 1;
+      smSet[monomerSymbol] = `#${polymerType[0]}${symbol}`; // e.g. #P1, #R2, #C3, #B4
+      const m: Monomer = {...smilesMonomer, symbol: smSet[monomerSymbol]};
+      // note, the ID becomes #<index> for smiles based monomers, and as the smiles, original smiles is passed (which is in monomerSymbol), to avoid key duplication
+      const wem = new SmilesWebEditorMonomer(polymerTypeToHelmType(polymerType), m.symbol, monomerSymbol, `SMILES Monomer ${m.symbol}`, m.rgroups.map((rg) => rg[RGP.LABEL]));
+      m.wem = wem;
+      mSet[m.symbol] = m;
+      return m;
+    }
+
     const m = mSet[monomerSymbol] = {
       [REQ.SYMBOL]: monomerSymbol,
       [REQ.NAME]: monomerName,
@@ -124,8 +149,11 @@ export class MonomerLibBase implements IMonomerLibBase {
         if (res) break;
       }
     } else {
+      // Check smiles cache, modify with mapped symbol
+      if (this._smilesMonomerCache[polymerType]?.[monomerSymbol])
+        monomerSymbol = this._smilesMonomerCache[polymerType][monomerSymbol];
       const dict = this._monomers[polymerType];
-      res = dict ? dict[monomerSymbol] : null;
+      res = dict?.[monomerSymbol] ?? null;
     }
     return res;
   }

package/src/utils/monomer-lib/monomer-lib.ts

@@ -55,32 +55,6 @@ export class MonomerLib extends MonomerLibBase implements IMonomerLib {
     return resJSON;
   }
 
-  getMonomer(polymerType: PolymerType | null, argMonomerSymbol: string): Monomer | null {
-    const logPrefix = `Bio: MonomerLib.getMonomer()`;
-    // Adjust RNA's 'R' for ribose to 'r' and 'P' for phosphate to 'p' for case-sensitive monomer names.
-    // There are uppercase 'R' and 'P' at RNA samples in test data 'helm2.csv' but lowercase in HELMCoreLibrary.json
-    let monomerSymbol = argMonomerSymbol;
-    if (polymerType == 'RNA' && monomerSymbol == 'R')
-      monomerSymbol = 'r';
-    if (polymerType == 'RNA' && monomerSymbol == 'P')
-      monomerSymbol = 'p';
-
-    let res: Monomer | null = null;
-
-    if (!polymerType) {
-      _package.logger.warning(`${logPrefix} symbol '${argMonomerSymbol}', polymerType not specified.`);
-      // Assume any polymer type
-      for (const [_polymerType, dict] of Object.entries(this._monomers)) {
-        res = dict[monomerSymbol];
-        if (res) break;
-      }
-    } else {
-      const dict = this._monomers[polymerType];
-      res = dict?.[monomerSymbol] ?? null;
-    }
-    return res;
-  }
-
   private _monomerSets: { [biotype: string /*HelmType*/]: MonomerSetType } | null = null;
 
   getMonomerSet(biotype: HelmType): MonomerSetType | null {

package/src/utils/monomer-lib/monomer-manager/monomer-manager.ts

@@ -1178,7 +1178,7 @@ function getCorrectedSmiles(rgroups: RGroup[], smiles?: string, molBlock?: strin
   return isSmilesMalformed ? canonical : grok.chem.convert(canonical, DG.chem.Notation.Unknown, DG.chem.Notation.Smiles);
 }
 
-function getCorrectedMolBlock(molBlock: string) {
+export function getCorrectedMolBlock(molBlock: string) {
   // to correct molblock, we should make sure that
   // 1. RGP field is present at the end, before the M END line
   // 2. RGP field is present in the correct format

package/src/utils/monomer-lib/smiles2Monomer.ts

@@ -0,0 +1,128 @@
+/* eslint-disable camelcase */
+/* eslint-disable max-len */
+import {Monomer} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {_package} from '../../package';
+import {PolymerType} from '@datagrok-libraries/bio/src/helm/types';
+import {HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import * as grok from 'datagrok-api/grok';
+import {getCorrectedMolBlock} from './monomer-manager/monomer-manager';
+
+/**
+ *  Exaple r groups
+ * {
+        "capGroupSMILES": "[*:1][H]",
+        "alternateId": "R1-H",
+        "capGroupName": "H",
+        "label": "R1"
+      },
+      {
+        "capGroupSMILES": "O[*:2]",
+        "alternateId": "R2-OH",
+        "capGroupName": "OH",
+        "label": "R2"
+      }
+
+ */
+
+const cx_smiles_regexp = /.*\|\$.*R.*\$\|/;
+const rgroup_regexp = /\[R(\d+)\]/;
+const rgroup_regexpg = /\[R(\d+)\]/g;
+const ambig_regexp = /\[\*:(\d+)\]/g;
+
+export type MonomerWithoutSymbol = Omit<Monomer, 'symbol'>;
+
+export function getMonomerFromRSmiles(smiles: string, polymerType?: PolymerType): MonomerWithoutSymbol | null {
+  const rgroupNumbers = Array.from(smiles.matchAll(rgroup_regexpg)).map((m) => m[1]);
+  const res: MonomerWithoutSymbol = {
+    name: 'Explicit SMILES Monomer',
+    smiles: smiles,
+    polymerType: polymerType ?? 'CHEM',
+    molfile: '',
+    rgroups: rgroupNumbers.map((numString) => ({
+      [RGP.LABEL]: `R${numString}`,
+      [RGP.CAP_GROUP_NAME]: `H`,
+      [RGP.CAP_GROUP_SMILES]: `[*:${numString}][H]`,
+      [RGP.ALTERNATE_ID]: `R${numString}-H`,
+    })),
+    author: 'Datagrok auto-generated',
+    id: 0,
+    createDate: null,
+    monomerType: 'Backbone',
+  };
+
+  try {
+    //try to generate corrected molfile and smiles
+    let corSmiles = smiles;
+    res.rgroups.forEach((rg) => {
+      const labelNum = rg[RGP.LABEL].substring(1); // R1 -> 1
+      corSmiles = corSmiles.replace(`[R${labelNum}]`, `[*:${labelNum}]`);
+    });
+    const molFile = getCorrectedMolBlock(grok.chem.convert(corSmiles, grok.chem.Notation.Smiles, grok.chem.Notation.MolBlock));
+    res.molfile = molFile;
+    res.smiles = corSmiles;
+  } catch (e) {
+    _package.logger.error(`getMonomerFromRSmiles: cannot convert SMILES to Molfile: ${smiles}\n${e}`);
+  }
+
+  return res;
+}
+
+/** Generate Monomer Object directly from inline smiles
+ * Purely string based, no external calls
+ *
+ * Currently accepts (to be extended):
+ *
+ * cxsmiles written as *N[C@H](C(=O)*)Cc1ccc(cc1)OP(=O)(O)O |$_R1;;;;;_R2;;;;;;;;;;;;$| where * are connection points
+ *
+ * or * is square brackets like [*]N[C@H](C(=O)[*])Cc1ccc(cc1)OP(=O)(O)O |$_R1;;;;;_R2;;;;;;;;;;;;$|
+ *
+ * simple smiles with R notations like CCC[R1] or CCC(=O)[R2]
+ *
+ * simple smiles with ambiguety defined as [*:1] like CCC[*:1] or CCC(=O)[*:2]
+*/
+export function smiles2Monomer(smiles: string, polymerType?: PolymerType): MonomerWithoutSymbol | null {
+  try {
+    const isCxSmiles = cx_smiles_regexp.test(smiles);
+    if (isCxSmiles) {
+      // CXSMILES parsing
+      const parts = smiles.split('|$');
+      const molPart = parts[0].trim();
+      const rGroupPart = parts[1];
+      // make sure all R groups are captured
+      const rGroupMatches = Array.from(rGroupPart.matchAll(/R(\d+)/g));
+      const starsInMolecule = Array.from(molPart.matchAll(/(\*)/g));
+      if (rGroupMatches.length !== starsInMolecule.length)
+        return null; // make sure that number of R groups and stars are the same
+      // remove brackets from stars if any
+      let cleanMol = molPart.replaceAll(/\[\*\]/g, '*');
+      // speaking in terms of consecutiveness, R groups in definition and stars in Smiles will be in the same order
+      // so we can just iterate through them
+      const rGroupNumbers = rGroupMatches.map((m) => m[1]); // numbers as strings
+      for (let i = 0; i < rGroupNumbers.length; i++) {
+        const rNum = rGroupNumbers[i];
+        // replace first matched star with R group
+        cleanMol = cleanMol.replace('*', `[R${rNum}]`);
+      }
+      return getMonomerFromRSmiles(cleanMol, polymerType);
+    }
+
+    // simple smiles parsing
+    // to simplify, replace all ambigous [*:1] with R1, etc
+    let cleanSmiles = smiles;
+    const ambigMatches = Array.from(smiles.matchAll(ambig_regexp));
+    for (const match of ambigMatches) {
+      const fullMatch = match[0];
+      const rNum = match[1];
+      cleanSmiles = cleanSmiles.replace(fullMatch, `[R${rNum}]`);
+    }
+
+    // make sure monomer has at least one R group
+    if (rgroup_regexp.test(cleanSmiles))
+      return getMonomerFromRSmiles(cleanSmiles, polymerType);
+  } catch (e) {
+    _package.logger.error(`smiles2Monomer: cannot parse SMILES: ${smiles}\n${e}`);
+  }
+
+
+  return null;
+}

package/src/utils/monomer-lib/web-editor-monomer-dummy.ts

@@ -18,7 +18,7 @@ export abstract class WebEditorMonomerDummy implements IWebEditorMonomer {
   get issmiles(): boolean { return !!this.smiles; }
 
   /** R-Group index os single digit only is allowed in Pistoia code */
-  public readonly at: WebEditorRGroups = {
+  at: WebEditorRGroups = {
     R1: 'H', R2: 'H', R3: 'H', R4: 'H', R5: 'H', R6: 'H', R7: 'H', R8: 'H', R9: 'H'
   };
 
@@ -80,6 +80,20 @@ export abstract class WebEditorMonomerDummy implements IWebEditorMonomer {
   }
 }
 
+export class SmilesWebEditorMonomer extends WebEditorMonomerDummy {
+  public readonly backgroundcolor: string = '#808080';
+  public readonly linecolor: string = '#000000';
+  public readonly textcolor: string = '#000000';
+
+  constructor(biotype: string, id: string, smiles: string, name: string, rgpLabels: string[]) {
+    super(biotype, id, name, undefined, undefined, undefined, smiles);
+    this.at = {};
+    rgpLabels.forEach((label) => {
+      this.at[label] = 'H';
+    });
+  }
+}
+
 export class GapWebEditorMonomer extends WebEditorMonomerDummy {
   public readonly backgroundcolor: string = '#FFFFFF';
   public readonly linecolor: string = '#808080';

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

@@ -138,7 +138,7 @@ async function onDialogOk(
     colInput.fireChanged();
     if (colInput.value.semType !== DG.SEMTYPE.MACROMOLECULE)
       throw new Error('Chosen column has to be of Macromolecule semantic type');
-    if (performAlignment === undefined) // value can only be undefined when column can't be processed with either method
+    if (performAlignment == undefined) // value can only be undefined when column can't be processed with either method
       throw new Error('Invalid column format');
     msaCol = await performAlignment(); // progress
     if (msaCol == null)

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

@@ -149,7 +149,7 @@ function parseKalignError(out: string, limit?: number): string {
   const errLineList: string[] = [];
   const errLineRe = /^.+ERROR : (.+)$/gm;
   let ma: RegExpExecArray | null;
-  while ((ma = errLineRe.exec(out)) != null && (limit === undefined || errLineList.length < limit)) {
+  while ((ma = errLineRe.exec(out)) != null && (limit == undefined || errLineList.length < limit)) {
     //
     errLineList.push(ma[1]);
   }