@datagrok/sequence-translator 1.4.4 → 1.4.6

package/src/polytool/pt-conversion.ts

@@ -2,98 +2,149 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
-import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import wu from 'wu';
+
+import {cleanupHelmSymbol} from '@datagrok-libraries/bio/src/helm/utils';
+import {HelmTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {IMonomerLib, IMonomerLibBase, Monomer, MonomerLibData, RGroup} from '@datagrok-libraries/bio/src/types';
 import {RDModule, RDMol, RDReaction, MolList, RDReactionResult} from '@datagrok-libraries/chem-meta/src/rdkit-api';
-import {HELM_REQUIRED_FIELD, HELM_RGROUP_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
+import {HELM_REQUIRED_FIELD as REQ, HELM_OPTIONAL_FIELDS as OPT, HELM_RGROUP_FIELDS, HELM_OPTIONAL_FIELDS} from '@datagrok-libraries/bio/src/utils/const';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+import {HelmAtom, HelmBio, HelmMol, HelmType, JSDraw2ModuleType, OrgType} from '@datagrok-libraries/bio/src/helm/types';
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {Rules, RuleLink, RuleReaction} from './pt-rules';
 import {InvalidReactionError, MonomerNotFoundError} from './types';
-import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
+
 import {_package} from '../package';
 
-export const RULES_DIMER = '(#2)';
-export const RULES_HETERODIMER = '($2)';
+declare const JSDraw2: JSDraw2ModuleType;
+declare const org: OrgType;
+
+type Linkage = {
+  fChain: number,
+  sChain: number,
+  /** Continuous 1-based numbering */ fMonomer: number,
+  /** Continuous 1-based numbering */ sMonomer: number,
+  fR: number,
+  sR: number
+}
 
-// function addCommonTags(col: DG.Column): void {
-//   col.semType = DG.SEMTYPE.MACROMOLECULE;
-//   col.setTag('aligned', ALIGNMENT.SEQ);
-//   col.setTag('alphabet', ALPHABET.PT);
-// }
+type PolyToolBio = HelmBio & { i: number, j: number };
 
 export class Chain {
-  linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[];
+  linkages: Linkage[];
   monomers: string[][];
+  mol: HelmMol;
 
   constructor(
     monomers: string[][],
-    linkages: { fChain: number, sChain: number, fMonomer: number, sMonomer: number, fR: number, sR: number }[]) {
+    linkages: Linkage[],
+    mol: HelmMol) {
     this.linkages = linkages;
     this.monomers = monomers;
+    this.mol = mol;
   }
 
-  static fromHelm(helm: string) {
-    const fragmentation = helm.split('$');
+  /** Parse harmonized sequence (template) from pseudo helm */
+  static parseHelm(helm: string, helmHelper: IHelmHelper) {
+    const ea = /(\w+\{.*\})\$(.*)\$(.*)\$(.*)\$/g.exec(helm)!;
+    // const fragmentation = helm.split('$');
+    const fragmentation = [ea[1], ea[2], ea[3], ea[4]];
+
     const rawFragments = fragmentation[0].split('|');
     const rawLinkages = fragmentation[1].split('|');
 
     const monomers = new Array<Array<string>>(rawFragments.length);
-    const linkages: {
-      fChain: number,
-      sChain: number,
-      fMonomer: number,
-      sMonomer: number,
-      fR: number,
-      sR: number
-    }[] = [];
+    const linkages: Linkage[] = [];
+
+    const resHwe = helmHelper.createHelmWebEditor();
+    const resMol = resHwe.editor.m;
 
+    let counter = 0;
+    const p = new JSDraw2.Point(0, 0);
     //HELM parsing
     for (let i = 0; i < rawFragments.length; i++) {
       const idxStart = rawFragments[i].indexOf('{');
       const idxEnd = rawFragments[i].indexOf('}');
 
-      monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.');
+      monomers[i] = rawFragments[i].slice(idxStart + 1, idxEnd).split('.').map((s) => cleanupHelmSymbol(s));
+      for (let j = 0; j < monomers[i].length; j++) {
+        const elem = monomers[i][j];
+        const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+        const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+        resMol.addAtom(atom);
+
+        if (j !== 0) {
+          const atom1 = resMol.atoms[counter - 1];
+          const atom2 = resMol.atoms[counter];
+          const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+          bond.r1 = 2;
+          bond.r2 = 1;
+          resMol.addBond(bond);
+        }
+
+        counter++;
+        p.x += JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
+      }
+      p.y += 4 * JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
     }
 
     //HELM parsing
     for (let i = 0; i < rawLinkages.length; i++) {
       if (rawLinkages[i] !== '' && rawLinkages[i] !== 'V2.0') {
         const rawData = rawLinkages[i].split(',');
-        const seq1 = (rawData[0].replace('PEPTIDE', '') as unknown as number) - 1;
-        const seq2 = (rawData[1].replace('PEPTIDE', '') as unknown as number) - 1;
-        const rawDataConnctions = rawData[2].split('-');
-        const rawDataConnction1 = rawDataConnctions[0].split(':');
-        const rawDataConnction2 = rawDataConnctions[1].split(':');
+        const fChainIdx = parseInt(rawData[0].replace('PEPTIDE', '')) - 1;
+        const sChainIdx = parseInt(rawData[1].replace('PEPTIDE', '')) - 1;
+        const rawDataConnections = rawData[2].split('-');
+        const rawDataConnection1 = rawDataConnections[0].split(':');
+        const rawDataConnection2 = rawDataConnections[1].split(':');
 
         linkages.push({
-          fChain: seq1,
-          sChain: seq2,
-          fMonomer: rawDataConnction1[0] as unknown as number,
-          sMonomer: rawDataConnction2[0] as unknown as number,
-          fR: rawDataConnction1[1].replace('R', '') as unknown as number,
-          sR: rawDataConnction2[1].replace('R', '') as unknown as number,
+          fChain: fChainIdx,
+          sChain: sChainIdx,
+          fMonomer: getOuterIdx(parseInt(rawDataConnection1[0]), fChainIdx, monomers),
+          sMonomer: getOuterIdx(parseInt(rawDataConnection2[0]), sChainIdx, monomers),
+          fR: parseInt(rawDataConnection1[1].replace('R', '')),
+          sR: parseInt(rawDataConnection2[1].replace('R', '')),
         });
       }
     }
 
-    return new Chain(monomers, linkages);
+    for (let i = 0; i < linkages.length; i++) {
+      const atom1 = resMol.atoms[linkages[i].fMonomer - 1];
+      const atom2 = resMol.atoms[linkages[i].sMonomer - 1];
+      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      bond.r1 = linkages[i].fR;
+      bond.r2 = linkages[i].sR;
+      resMol.addBond(bond);
+    }
+
+    return new Chain(monomers, linkages, resMol);
+  }
+
+  /** Get macromolecule from harmonized sequence (template) */
+  applyRules(rules: Rules): Chain {
+    // Clone this
+    const resMonomers: string[][] = this.monomers.map((mL) => [...mL]);
+    const resLinkages: Linkage[] = [...this.linkages];
+    const resMol: HelmMol = this.mol.clone();
+
+    throw new Error('not implemented');
+
+    const chain = new Chain(resMonomers, resLinkages, resMol);
+    return chain;
   }
 
-  static fromNotation(sequence: string, rules: Rules): Chain {
+  /** @deprecated Use {@link parseNotation} and {@link applyRules} instead. */
+  static fromNotation(sequence: string, rules: Rules, helmHelper: IHelmHelper): Chain {
     const heterodimerCode = rules.heterodimerCode;
     const homodimerCode = rules.homodimerCode;
-    const mainFragments: string[] = [];
 
-    const linkages: {
-      fChain: number,
-      sChain: number,
-      fMonomer: number,
-      sMonomer: number,
-      fR: number,
-      sR: number
-    }[] = [];
+    const mainFragments: string[] = [];
+    const linkages: Linkage[] = [];
 
     //NOTICE: this works only with simple single heterodimers
     const heterodimeric = heterodimerCode !== null ? sequence.split(`(${rules.heterodimerCode!})`) : '';
@@ -164,6 +215,11 @@ export class Chain {
 
     const monomersAll: string[][] = [];
 
+    const resHwe = helmHelper.createHelmWebEditor();
+    const resMol = resHwe.editor.m;
+
+    let counter = 0;
+    const p = new JSDraw2.Point(0, 0);
     for (let i = 0; i < monomers.length; i++) {
       const linkedPositions = this.getLinkedPositions(monomers[i], rules.reactionRules);
       const [monomersCycled, allPos1, allPos2, ruleN] =
@@ -172,14 +228,41 @@ export class Chain {
       if (allPos1.length >= 1) {
         const ch1 = new Array<string>(allPos2[0] - 1);
         const ch2 = new Array<string>(monomersCycled.length - allPos2[0]);
-        for (let j = 0; j < allPos2[0] - 1; j++)
-          ch1[j] = monomersCycled[j];
-
-        for (let j = allPos2[0]; j < monomersCycled.length; j++)
-          ch2[j - allPos2[0]] = monomersCycled[j];
+        for (let j = 0; j < allPos2[0] - 1; j++) {
+          const elem = ch1[j] = monomersCycled[j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
+
+          if (j > 0) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+          counter++;
+        }
 
+        for (let j = allPos2[0]; j < monomersCycled.length; j++) {
+          const elem = ch2[j - allPos2[0]] = monomersCycled[j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
+
+          if (j > allPos2[0]) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+          counter++;
+        }
 
-        ch1[allPos1[0] - 1] = rules.reactionRules[ruleN[0]].name;
+        resMol.atoms[allPos1[0] - 1].elem = ch1[allPos1[0] - 1] = rules.reactionRules[ruleN[0]].name;
 
         for (let j = 0; j < linkages.length; j++) {
           if (linkages[j].fMonomer > allPos2[0]) {
@@ -219,11 +302,116 @@ export class Chain {
         monomersAll.push(ch1);
         monomersAll.push(ch2);
       } else {
+        for (let j = 0; j < monomers[i].length; j++) {
+          const elem = monomers[i][j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom: HelmAtom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
+
+          if (j > 0) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+          counter++;
+        }
         monomersAll.push(monomers[i]);
       }
     }
 
-    const chain = new Chain(monomersAll, linkages);
+    for (const l of linkages) {
+      const atom1 = resMol.atoms[l.fMonomer - 1];
+      const atom2 = resMol.atoms[l.sMonomer - 1];
+      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      bond.r1 = l.fR;
+      bond.r2 = l.sR;
+      resMol.addBond(bond);
+    }
+
+    const chain = new Chain(monomersAll, linkages, resMol);
+    return chain;
+  }
+
+  /** Parse harmonized sequence notation (template)  */
+  static parseNotation(sequence: string, helmHelper: IHelmHelper): Chain {
+    const mainFragments: string[][] = [];
+
+    const linkages: Linkage[] = [];
+
+    const resHwe = helmHelper.createHelmWebEditor();
+    const resMol = resHwe.editor.m;
+
+    const rxp = /(\(.\d+\))?\{[^\}]*\}/g;
+    const seqs: string [] = [];
+    seqs.push(sequence.replaceAll(rxp, ''));
+
+    //const l = (rxpRes?.length) ?? -1;
+
+    const matches = sequence.matchAll(rxp);
+    //const rxpRes = rxp.exec(sequence);
+    for (const m of matches) {
+      const str = m![0];
+      if (str)
+        seqs.push(str);
+    }
+
+    let counter = 0;
+    for (let i = 0; i < seqs.length; i++) {
+      const splMonomers = seqs[i].split('-');
+      const monomers: string [] = new Array<string>(splMonomers.length);
+      let spmCount: number = 0;
+      for (let j = 0; j < splMonomers.length; j++) {
+        const monomer = splMonomers[j].replace('{', '').replace('}', '');
+        if (monomer !== '') {
+          monomers[j] = monomer;
+          counter++;
+          spmCount++;
+        } else {
+          linkages.push({fChain: i, sChain: i + 1, fMonomer: counter, sMonomer: counter + 1, fR: 1, sR: 1});
+        }
+      }
+      mainFragments.push(monomers.slice(0, spmCount));
+    }
+
+    counter = 0;
+    const p = new JSDraw2.Point(0, 0);
+    for (let i = 0; i < mainFragments.length; i++) {
+      for (let j = 0; j < mainFragments[i].length; j++) {
+        if (!!mainFragments[i][j]) {
+          const elem = mainFragments[i][j];
+          const bio: PolyToolBio = {type: HelmTypes.AA, i: i, j: j, continuousId: counter};
+          const atom = new JSDraw2.Atom<HelmType>(p, elem, bio);
+          resMol.addAtom(atom);
+
+          if (j !== 0) {
+            const atom1 = resMol.atoms[counter - 1];
+            const atom2 = resMol.atoms[counter];
+            const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+            bond.r1 = 2;
+            bond.r2 = 1;
+            resMol.addBond(bond);
+          }
+
+          counter++;
+          p.x += JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
+        }
+        p.y += 4 * JSDraw2.Editor.BONDLENGTH; // Inspired by HELMWebEditor
+      }
+    }
+
+    for (let i = 0; i < linkages.length; i++) {
+      const atom1 = resMol.atoms[linkages[i].fMonomer - 1];
+      const atom2 = resMol.atoms[linkages[i].sMonomer - 1];
+      const bond = new JSDraw2.Bond<HelmType>(atom1, atom2);
+      bond.r1 = linkages[i].fR;
+      bond.r2 = linkages[i].sR;
+      resMol.addBond(bond);
+    }
+
+    const chain = new Chain(mainFragments, linkages, resMol);
     return chain;
   }
 
@@ -233,17 +421,17 @@ export class Chain {
     let idx1 = 0;
     let idx2 = 0;
     loop1:
-      for (let i = 0; i < this.monomers.length; i++) {
-        loop2:
-          for (let j = 0; j < this.monomers[i].length; j++) {
-            if (counter == changeNumber) {
-              idx1 = i;
-              idx2 = j;
-              break loop1;
-            }
-            counter++;
-          }
+    for (let i = 0; i < this.monomers.length; i++) {
+      loop2:
+      for (let j = 0; j < this.monomers[i].length; j++) {
+        if (counter == changeNumber) {
+          idx1 = i;
+          idx2 = j;
+          break loop1;
+        }
+        counter++;
       }
+    }
 
     const previous = this.monomers[idx1][idx2];
 
@@ -254,6 +442,12 @@ export class Chain {
     return res;
   }
 
+  /** Gets harmonized sequence (template) pseudo helm */
+  getNotationHelm(): string {
+    return this.getHelm();
+  }
+
+  /** Gets harmonized sequence (template) pseudo helm */
   getHelm(): string {
     let helm = '';
     for (let i = 0; i < this.monomers.length; i++) {
@@ -277,16 +471,75 @@ export class Chain {
       if (i > 0)
         helm += '|';
       helm += `PEPTIDE${this.linkages[i].fChain + 1},PEPTIDE${this.linkages[i].sChain + 1},`;
-      helm += `${this.linkages[i].fMonomer}:R${this.linkages[i].fR}-`;
-      helm += `${this.linkages[i].sMonomer}:R${this.linkages[i].sR}`;
+
+      helm += `${getInnerIdx(this.linkages[i].fMonomer - 1, this.monomers)[0] + 1}:R${this.linkages[i].fR}-`;
+      helm += `${getInnerIdx(this.linkages[i].sMonomer - 1, this.monomers)[0] + 1}:R${this.linkages[i].sR}`;
     }
 
-    helm += '$$$';
+    helm += '$$$' + 'V2.0';
     return helm;
   }
 
-  getNotation(rules: Rules): string {
-    return 'not implemented';
+  getNotation(): string {
+    const atoms = this.mol.atoms;
+    const bonds = this.mol.bonds;
+    const chains: number[] = [];
+    const specialBonds: number[] = [];
+    for (let i = 0; i < bonds.length!; i++) {
+      //@ts-ignore
+      if (bonds[i].a1.bio.i !== bonds[i].a2.bio.i)
+        specialBonds.push(i);
+    }
+
+    for (let i = 0; i < atoms.length!; i++) {
+      //@ts-ignore
+      const atomChain = atoms[i].bio?.i;
+      if (atomChain + 1 > chains.length)
+        chains.push(1);
+      else
+        chains[atomChain]++;
+    }
+
+    const simpleChains: string[][] = new Array(chains.length);
+    let counter = 0;
+    for (let i = 0; i < chains.length!; i++) {
+      const simpleChain: string[] = new Array(chains[i]);
+      for (let j = 0; j < chains[i]; j++) {
+        simpleChain[j] = atoms[counter].elem;
+        counter++;
+      }
+
+      simpleChains[i] = simpleChain;
+    }
+
+    let res = '';
+    for (let i = 0; i < simpleChains.length; i++) {
+      let chainAdd = '';
+
+      for (let j = 0; j < simpleChains[i].length; j++)
+        chainAdd += `${j == 0 ? '' : '-'}${simpleChains[i][j]}`;
+
+      if (i !== 0) {
+        const rxp = /(\(.\d+\))/;
+        const match = chainAdd.match(rxp);
+        chainAdd = chainAdd.replace(match?.[0]!, '');
+        const group = match ? match?.[0]! : '';
+        chainAdd = `${group}{${chainAdd}}`;
+      } else {
+        if (simpleChains.length > 1) {
+          //@ts-ignore
+          const firstAtomLinks = bonds[specialBonds[0]].a1.bio.i == 0 && bonds[specialBonds[0]].a1.bio.j == 0;
+          //@ts-ignore
+          const secondAtomLinks = bonds[specialBonds[0]].a2.bio.i == 1 && bonds[specialBonds[0]].a1.bio.j == 0;
+          if (firstAtomLinks && secondAtomLinks)
+            chainAdd += '-';
+        }
+      }
+
+      res += chainAdd;
+    }
+
+    return res;
   }
 
   protected static getLinkedPositions(monomers: string[], rules: RuleLink[] | RuleReaction []):
@@ -390,15 +643,48 @@ export class Chain {
 
     return [monomers, allPos1, allPos2, rule];
   }
+
+  public check(throwError: boolean = false): string[] {
+    const errors: string[] = [];
+
+    const chainsMonomerCount = this.monomers.map((ch) => ch.length).reduce((acc, curr) => acc + curr, 0);
+    if (this.mol.atoms.length !== chainsMonomerCount)
+      errors.push(`The mol atoms count ${this.mol.atoms.length} does not match ` +
+        `the total number ${chainsMonomerCount} of chains' monomers.`);
+
+    const internalBondsCount = this.monomers.map((ch) => ch.length - 1).reduce((acc, curr) => acc + curr, 0);
+    const chainsBondCount = internalBondsCount + this.linkages.length;
+    if (this.mol.bonds.length !== chainsBondCount)
+      errors.push(`The mol bonds count ${this.mol.bonds.length} does not match ` +
+        `the total number ${chainsBondCount} in- and inter-chain linkages.`);
+
+    let counter: number = 0;
+    for (let spIdx = 0; spIdx < this.monomers.length; ++spIdx) {
+      const chain = this.monomers[spIdx];
+      for (let mIntIdx = 0; mIntIdx < chain.length; ++mIntIdx) {
+        try {
+          const m = chain[mIntIdx];
+          const a = this.mol.atoms[counter];
+          if (a.bio!.continuousId !== counter)
+            errors.push(`Atom #${counter} has incorrect .bio.continuousId: ${a.bio!.continuousId}.`);
+          if (a.elem !== m)
+            errors.push(`Atom #${counter} elem: '${a.elem}' does not match chain monomer: '${m}'.`);
+        } finally { counter++; }
+      }
+    }
+    if (throwError && errors.length > 0)
+      throw new Error(`Chain errors:\n${errors.map((e) => `  ${e}`).join('\n')}`);
+    return errors;
+  }
 }
 
 /** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
-export function doPolyToolConvert(sequences: string[], rules: Rules): string[] {
+export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
   const helms = new Array<string>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
     try {
       if (sequences[i] == null) { helms[i] = ''; } else {
-        const chain = Chain.fromNotation(sequences[i], rules);
+        const chain = Chain.fromNotation(sequences[i], rules, helmHelper);
         helms[i] = chain.getHelm();
       }
     } catch (err: any) {
@@ -517,18 +803,24 @@ export function getNewMonomer(rdkit: RDModule, mLib: IMonomerLib, rule: RuleReac
   const groups: RGroup[] = getNewGroups(monomer1!, monomer2!);
 
   const resMonomer: Monomer = {
-    [HELM_REQUIRED_FIELD.SYMBOL]: monomerName,
-    [HELM_REQUIRED_FIELD.NAME]: monomerName,
-    [HELM_REQUIRED_FIELD.MOLFILE]: molBlock,
-    [HELM_REQUIRED_FIELD.AUTHOR]: '',
-    [HELM_REQUIRED_FIELD.ID]: 0,
-    [HELM_REQUIRED_FIELD.RGROUPS]: groups,
-    [HELM_REQUIRED_FIELD.SMILES]: '',
-    [HELM_REQUIRED_FIELD.POLYMER_TYPE]: 'PEPTIDE',
-    [HELM_REQUIRED_FIELD.MONOMER_TYPE]: 'Backbone',
-    [HELM_REQUIRED_FIELD.CREATE_DATE]: null,
+    [REQ.SYMBOL]: monomerName,
+    [REQ.NAME]: monomerName,
+    [REQ.MOLFILE]: molBlock,
+    [REQ.AUTHOR]: '',
+    [REQ.ID]: 0,
+    [REQ.RGROUPS]: groups,
+    [REQ.SMILES]: '',
+    [REQ.POLYMER_TYPE]: 'PEPTIDE',
+    [REQ.MONOMER_TYPE]: 'Backbone',
+    [REQ.CREATE_DATE]: null,
+
+    // // @ts-ignore
+    // lib: {source: 'Reaction'},
   };
 
+  resMonomer[OPT.META] = Object.assign(resMonomer[OPT.META] ?? {},
+    {'colors': {'default': {line: '#2083D5', text: '#2083D5', background: '#F2F2F5'}}});
+
   return [monomerName, resMonomer];
 }
 
@@ -545,6 +837,28 @@ export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBas
   }
 
   const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};
-  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData);
+  const overriddenMonomerLib = systemMonomerLib.override(overrideMonomerLibData,
+    'ST-PT-reactions.' + wu.repeat(1).map(() => Math.floor((Math.random() * 36)).toString(36)).take(4).toArray().join(''));
   return overriddenMonomerLib;
 }
+
+/** Gets 0-based in-index (simple polymer) of out-index (continuous) {@link idx} */
+export function getInnerIdx(outIdx: number, monomers: string[][]): [number, number] {
+  // let prevSpCount = 0;
+  // for (let spI = 0; spI < monomers.length && idx >= (prevSpCount + monomers[spI].length); ++spI)
+  //   prevSpCount += monomers[spI].length;
+  // return idx - prevSpCount;
+  let inIdx = outIdx;
+  let spIdx: number;
+  for (spIdx = 0; spIdx < monomers.length && inIdx >= monomers[spIdx].length; ++spIdx)
+    inIdx -= monomers[spIdx].length;
+  return [inIdx, spIdx];
+}
+
+/** Gets 0-based out-index of 0-based in-index {@link inIdx} monomer of simple polymer {@link spIdx} */
+export function getOuterIdx(inIdx: number, spIdx: number, monomers: string[][]): number {
+  let outIdx = 0;
+  for (let i = 0; i < spIdx; ++i)
+    outIdx += monomers[i].length;
+  return outIdx + inIdx;
+}