@datagrok/sequence-translator 1.6.3 → 1.7.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.6.3",
+  "version": "1.7.0",
   "author": {
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"
@@ -23,7 +23,7 @@
   ],
   "dependencies": {
     "@datagrok-libraries/bio": "^5.46.0",
-    "@datagrok-libraries/chem-meta": "^1.2.7",
+    "@datagrok-libraries/chem-meta": "^1.2.8",
     "@datagrok-libraries/tutorials": "^1.4.3",
     "@datagrok-libraries/utils": "^4.3.7",
     "@types/react": "^18.0.15",
@@ -41,9 +41,9 @@
   "devDependencies": {
     "@datagrok-libraries/helm-web-editor": "^1.1.13",
     "@datagrok-libraries/js-draw-lite": "^0.0.10",
-    "@datagrok/bio": "^2.17.2",
-    "@datagrok/helm": "^2.5.8",
-    "@datagrok/chem": "^1.12.4",
+    "@datagrok/bio": "^2.18.0",
+    "@datagrok/helm": "^2.7.0",
+    "@datagrok/chem": "^1.13.0",
     "@types/jquery": "^3.5.14",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.202",

package/src/package.ts

@@ -49,7 +49,7 @@ async function initSequenceTranslatorInt(): Promise<void> {
 
 //name: Oligo Toolkit
 //meta.icon: img/icons/toolkit.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoToolkitApp(): Promise<DG.ViewBase> {
@@ -64,7 +64,7 @@ export async function oligoToolkitApp(): Promise<DG.ViewBase> {
 
 //name: Oligo Translator
 //meta.icon: img/icons/translator.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoTranslatorApp(): Promise<DG.ViewBase> {
@@ -74,7 +74,7 @@ export async function oligoTranslatorApp(): Promise<DG.ViewBase> {
 
 //name: Oligo Pattern
 //meta.icon: img/icons/pattern.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoPatternApp(): Promise<DG.ViewBase> {
@@ -84,7 +84,7 @@ export async function oligoPatternApp(): Promise<DG.ViewBase> {
 
 //name: Oligo Structure
 //meta.icon: img/icons/structure.png
-//meta.browsePath: Oligo
+//meta.browsePath: Peptides | Oligo Toolkit
 //tags: app
 //output: view v
 export async function oligoStructureApp(): Promise<DG.ViewBase> {
@@ -209,7 +209,7 @@ export async function getPolyToolConvertEditor(call: DG.FuncCall): Promise<DG.Co
 export async function polyToolConvert2(table: DG.DataFrame,
   seqCol: DG.Column, generateHelm: boolean, chiralityEngine: boolean, rules: string[]
 ): Promise<DG.Column<string>> {
-  const ptConvertRes = await polyToolConvert(seqCol, generateHelm, chiralityEngine, rules);
+  const ptConvertRes = await polyToolConvert(seqCol, generateHelm, false, chiralityEngine, false, rules);
   return ptConvertRes[0];
 }
 
@@ -273,17 +273,17 @@ export async function createMonomerLibraryForPolyTool(file: DG.FileInfo) {
 //   }
 // }
 
-//name: PolyTool Enumerator Helm
+//name: HELM Enumerator
 //meta.icon: img/icons/structure.png
-//meta.browsePath: PolyTool
+//meta.browsePath: Peptides | PolyTool
 //tags: app
 export async function ptEnumeratorHelmApp(): Promise<void> {
   await polyToolEnumerateHelmUI();
 }
 
-//name: PolyTool Enumerator Chem
+//name: Chem Enumerator
 //meta.icon: img/icons/structure.png
-//meta.browsePath: PolyTool
+//meta.browsePath: Peptides | PolyTool
 //tags: app
 export async function ptEnumeratorChemApp(): Promise<void> {
   polyToolEnumerateChemUI();

package/src/polytool/const.ts

@@ -32,6 +32,8 @@ export const PT_WARNING_COLUMN = 'No marcomolecule column chosen!';
 
 export const PT_UI_GET_HELM = 'Get HELM';
 export const PT_UI_ADD_HELM = 'Add HELM column';
+export const PT_UI_LINEARIZE = 'Linearize';
+export const PT_UI_LINEARIZE_TT = 'Make representation linear if possible';
 export const PT_UI_USE_CHIRALITY = 'Chirality engine';
 export const PT_UI_HIGHLIGHT_MONOMERS = 'Highlight monomers';
 export const PT_UI_DIALOG_CONVERSION = 'Poly Tool Conversion';

package/src/polytool/conversion/pt-atomic.ts

@@ -0,0 +1,70 @@
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomic-level';
+import {ALPHABET, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {IMonomerLibBase} from '@datagrok-libraries/bio/src/types';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+
+export function dealGroups(col: DG.Column<string>): void {
+  for (let i = 0; i < col.length; i++) {
+    col.set(i, col.get(i)!.replaceAll('undefined', 'H'));
+    col.set(i, col.get(i)!.replaceAll('Oh', 'O'));
+    col.set(i, col.get(i)!.replaceAll('0.000000 3', '0.000000 0'));
+    col.set(i, col.get(i)!.replaceAll('?', 'O'));
+    col.set(i, col.get(i)!.replaceAll('0 3\n', '0 0\n'));
+    col.set(i, col.get(i)!.replaceAll('RGROUPS=(1 1)', ''));
+  }
+}
+
+export async function helmToMol(resHelmCol: DG.Column, resList: string[],
+  isLinear: boolean[], chiralityEngine: boolean, highlight: boolean, linearize: boolean,
+  lib: IMonomerLibBase, rdkit: RDModule, seqHelper: ISeqHelper) {
+  const getUnusedName = (df: DG.DataFrame | undefined, colName: string): string => {
+    if (!df) return colName;
+    return df.columns.getUnusedName(colName);
+  };
+
+  const toAtomicLevelRes =
+    await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, highlight, lib);
+
+  const resMolCol = toAtomicLevelRes.molCol!;
+
+  const allLinear = isLinear.filter((l) => l).length;
+  if (linearize && allLinear > 0) {
+    const lin = new Array<string>(allLinear);
+    let counter = 0;
+    for (let i = 0; i < isLinear.length; i++) {
+      if (isLinear[i]) {
+        lin[counter] = resList[i];
+        counter++;
+      }
+    }
+
+    const linCol = DG.Column.fromStrings('helm', lin);
+    linCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    linCol.meta.units = NOTATION.HELM;
+    linCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
+
+    const monomerLibHelper = await getMonomerLibHelper();
+    const systemMonomerLib = monomerLibHelper.getMonomerLib();
+    try {
+      const linear = await _toAtomicLevel(DG.DataFrame.create(0), linCol, systemMonomerLib, seqHelper, rdkit);
+      counter = 0;
+      for (let i = 0; i < isLinear.length; i++) {
+        if (isLinear[i]) {
+          resMolCol.set(i, linear!.molCol!.get(counter));
+          counter++;
+        }
+      }
+    } catch (e: any) {
+      grok.shell.warning('PolyTool was not able to linearize sequences');
+    }
+  }
+
+  dealGroups(resMolCol);
+
+  return resMolCol;
+}

package/src/polytool/conversion/pt-chain.ts

@@ -16,6 +16,7 @@ export class Chain {
   linkagesUnderRules: Linkage[];
   monomersUnderRules: string[][];
   molUnderRules: HelmMol;
+  posToPosUnderRules: number[][] = [];
 
   constructor(monomers: string[][], linkages: Linkage[], protected helmHelper: IHelmHelper) {
     this.linkages = linkages;
@@ -52,9 +53,28 @@ export class Chain {
   applyRules(rules: Rules): void {
     const sequence = this.getNotation();
 
-    const [linkages, mainFragments] = handleDuplicated(sequence, rules);
+    const [linkages, mainFragments, isDuplicated] = handleDuplicated(sequence, rules);
     const monomers = new Array<Array<string>>(mainFragments.length);
-    handleLinkRules(mainFragments, monomers, linkages, rules);
+
+    let counter = 0;
+    for (let i = 0; i < mainFragments.length; i++) {
+      monomers[i] = mainFragments[i].split('-');
+      if (!isDuplicated[i]) {
+        for (let j = 0; j < monomers[i].length; j++) {
+          this.posToPosUnderRules.push([counter]);
+          counter++;
+        }
+      } else {
+        const start = this.posToPosUnderRules.length - monomers[i].length;
+        for (let j = 0; j < monomers[i].length; j++) {
+          this.posToPosUnderRules[start + j].push(counter);
+          counter++;
+        }
+      }
+    }
+
+    //his.posToPosUnderRules
+    handleLinkRules(monomers, linkages, rules);
     handleReactionRules(monomers, linkages, rules);
 
     this.underRules = true;

package/src/polytool/conversion/pt-conversion.ts

@@ -6,14 +6,19 @@ import {Chain} from './pt-chain';
 import {_package} from '../../package';
 
 /** The main PolyTool convert engine. Returns list of Helms. Covered with tests. */
-export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
+export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper: IHelmHelper):
+[string[], boolean[], number[][][]] {
   const helms = new Array<string>(sequences.length);
+  const isLinear = new Array<boolean>(sequences.length);
+  const positionMaps = new Array<number[][]>(sequences.length);
   for (let i = 0; i < sequences.length; i++) {
     try {
       if (sequences[i] == null) { helms[i] = ''; } else {
         const chain = Chain.fromSeparator(sequences[i], helmHelper);
         chain.applyRules(rules);
+        isLinear[i] = chain.monomersUnderRules.length > 1 || chain.linkagesUnderRules.length > 0 ? false : true;
         helms[i] = chain.getHelm();
+        positionMaps[i] = chain.posToPosUnderRules;
       }
     } catch (err: any) {
       const [errMsg, errStack] = errInfo(err);
@@ -21,5 +26,5 @@ export function doPolyToolConvert(sequences: string[], rules: Rules, helmHelper:
       helms[i] = '';
     }
   }
-  return helms;
+  return [helms, isLinear, positionMaps];
 }

package/src/polytool/conversion/pt-rule-cards.ts

@@ -0,0 +1,160 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import './style.css';
+
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types';
+import {Rules} from './pt-rules';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {doPolyToolConvert} from './pt-conversion';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {getSeqHelper, ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
+import {getOverriddenLibrary} from './pt-synthetic';
+import {helmToMol} from './pt-atomic';
+
+class MonomerCard {
+  root: HTMLElement = ui.divV([], {classes: 'monomer-card-rule-root'});
+
+  private _selected: boolean = false;
+  get selected(): boolean { return this._selected; }
+  set selected(value: boolean) {
+    this._selected = value;
+    this.root.style.border = value ? '2px solid var(--green-2)' : '2px solid var(--grey-2)';
+  }
+
+  constructor(public monomer: Monomer | null) {}
+
+  render() {
+    if (this.monomer) {
+      ui.empty(this.root);
+      const monomerMolSvg = this.monomer.smiles && grok.chem.checkSmiles(this.monomer.smiles) ?
+        grok.chem.drawMolecule(this.monomer.smiles, 150, 120) :
+        grok.chem.drawMolecule(this.monomer.molfile ?? '', 150, 120);
+      this.root.appendChild(monomerMolSvg);
+      const monomerName =
+        ui.divH([ui.divText('Monomer Name: '), ui.divText(this.monomer.name)], {classes: 'monomer-card-info-rules'});
+
+      this.root.appendChild(monomerName);
+      ui.tooltip.bind(monomerName, this.monomer.name);
+      if (this.monomer.lib?.source) {
+        const monomerSource =
+          ui.divH([ui.divText('Source: '), ui.divText(this.monomer.lib.source)], {classes: 'monomer-card-info-rules'});
+        this.root.appendChild(monomerSource);
+        ui.tooltip.bind(monomerSource, this.monomer.lib.source);
+      }
+      const monomerType = ui.divH([
+        ui.divText('Polymer Type: '),
+        ui.divText(this.monomer.polymerType)
+      ], {classes: 'monomer-card-info-rules'});
+      this.root.appendChild(monomerType);
+      ui.tooltip.bind(monomerType, this.monomer.polymerType);
+
+      ui.tooltip.bind(this.root, 'Select Monomer');
+    }
+  }
+}
+
+export class RuleCards {
+  root: HTMLElement = ui.divH([],
+    {style: {
+      alignItems: 'center',
+      width: '100%',
+      overflow: 'hidden',
+      visibility: 'visible',
+    }, classes: 'monomer-cards'}
+  );
+  cardsFirst: MonomerCard[];
+  cardsSecond: MonomerCard[];
+  firstCard: MonomerCard;
+  secondCard: MonomerCard;
+  resulting: HTMLElement;
+  actionable: boolean;
+
+  constructor(public firstMonomers: string[], public secondMonomers: string[],
+    lib: IMonomerLib, public code: number, public rules: Rules) {
+    if (firstMonomers.length > 0) {
+      this.actionable = true;
+      const monomerGalleryFirst = ui.divH([], {style: {overflowX: 'auto', width: '100%'}});
+      const monomerGallerySecond = ui.divH([], {style: {overflowX: 'auto', width: '100%'}});
+      this.resulting = ui.divH([], {style: {overflowX: 'auto', width: '100%', minHeight: '150px'}});
+      const galleries = ui.divV([monomerGalleryFirst, monomerGallerySecond, this.resulting]);
+      this.cardsFirst = firstMonomers.map((symbol) => new MonomerCard(lib.getMonomer('PEPTIDE', symbol)));
+      this.cardsSecond = secondMonomers.map((symbol) => new MonomerCard(lib.getMonomer('PEPTIDE', symbol)));
+
+      this.cardsFirst.forEach((card) => {
+        card.root.onclick = () => {
+          this.cardsFirst.forEach((c) => c.selected = false);
+          card.selected = true;
+          this.firstCard = card;
+          this.reset();
+          //onMonomerSelected(card.monomer);
+        };
+        monomerGalleryFirst.appendChild(card.root);
+      });
+
+      this.cardsSecond.forEach((card) => {
+        card.root.onclick = () => {
+          this.cardsSecond.forEach((c) => c.selected = false);
+          card.selected = true;
+          this.secondCard = card;
+          this.reset();
+          //onMonomerSelected(card.monomer);
+        };
+        monomerGallerySecond.appendChild(card.root);
+      });
+
+      this.cardsFirst[0].selected = true;
+      this.cardsSecond[0].selected = true;
+      this.firstCard = this.cardsFirst[0];
+      this.secondCard = this.cardsSecond[0];
+      this.root.appendChild(galleries);
+    } else {
+      const es = ui.divV(['Rule is active for all monomers, no examples to show']);
+      this.root.appendChild(es);
+      this.actionable = false;
+    }
+  }
+
+  async reset() {
+    if (this.actionable) {
+      const seqs: string[] = [
+        `${this.firstCard.monomer?.symbol}(${this.code})-A-A-A-A-${this.secondCard.monomer?.symbol}(${this.code})`
+      ];
+
+      const helmHelper = await getHelmHelper();
+      const [helms, isLinear, positionMaps] = doPolyToolConvert(seqs, this.rules, helmHelper);
+
+      const resHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'helm', helms.length)
+        .init((rowIdx: number) => { return helms[rowIdx]; });
+      resHelmCol.semType = DG.SEMTYPE.MACROMOLECULE;
+      resHelmCol.meta.units = NOTATION.HELM;
+      resHelmCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
+
+      const rdKitModule: RDModule = await getRdKitModule();
+      const seqHelper: ISeqHelper = await getSeqHelper();
+
+      const lib = await getOverriddenLibrary(this.rules);
+      const resHelmColTemp = resHelmCol.temp;
+      resHelmCol.temp = resHelmColTemp;
+      const resMolCol = await helmToMol(resHelmCol, helms,
+        isLinear, true, false, false, lib, rdKitModule, seqHelper);
+
+      const mol = resMolCol.get(0);
+      const monomerMolSvg = mol && grok.chem.checkSmiles(mol) ?
+        grok.chem.drawMolecule(mol, 150, 120) :
+        grok.chem.drawMolecule(mol ?? '', 150, 120);
+
+      ui.empty(this.resulting);
+      this.resulting.append(ui.divH([monomerMolSvg], {style: {overflowX: 'auto', width: '100%', minHeight: '150px'}}));
+    }
+  }
+
+  render() {
+    if (this.actionable) {
+      this.cardsFirst.forEach((card) => card.render());
+      this.cardsSecond.forEach((card) => card.render());
+    }
+  }
+}

package/src/polytool/conversion/pt-rules.ts

@@ -1,7 +1,11 @@
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
 import {RulesManager} from './rule-manager';
+import {RuleCards} from './pt-rule-cards';
+import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {applyNotationProviderForCyclized} from '../../package';
 
 export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
 export const RULES_STORAGE_NAME = 'Polytool';
@@ -93,10 +97,22 @@ export class Rules {
   getLinkRulesDf(): DG.DataFrame {
     const length = this.linkRules.length;
     const codeCol = DG.Column.int(NAME_CODE, length);
+    codeCol.setTag('friendlyName', 'Code');
+    //ui.tooltip.bind(codeCol.root, 'Click to zoom');
     const firstMonomerCol = DG.Column.string(NAME_FIRST_MONOMERS, length);
+    firstMonomerCol.setTag('friendlyName', 'First monomers');
+    firstMonomerCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    applyNotationProviderForCyclized(firstMonomerCol, ',');
+
     const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
+    secondMonomerCol.setTag('friendlyName', 'Second monomers');
+    secondMonomerCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    applyNotationProviderForCyclized(secondMonomerCol, ',');
+
     const firstLinkingGroup = DG.Column.int(NAME_FIRST_LINK, length);
+    firstLinkingGroup.setTag('friendlyName', 'First group');
     const secondLinkingGroup = DG.Column.int(NAME_SECOND_LINK, length);
+    secondLinkingGroup.setTag('friendlyName', 'Second group');
 
     for (let i = 0; i < length; i++) {
       codeCol.set(i, this.linkRules[i].code);
@@ -106,20 +122,43 @@ export class Rules {
       secondLinkingGroup.set(i, this.linkRules[i].secondLinkingGroup);
     }
 
-    return DG.DataFrame.fromColumns([
+    const res = DG.DataFrame.fromColumns([
       codeCol, firstMonomerCol, secondMonomerCol, firstLinkingGroup, secondLinkingGroup
     ]);
+
+    return res;
+  }
+
+  async getLinkCards(): Promise<RuleCards[]> {
+    const length = this.linkRules.length;
+    const cards: RuleCards[] = new Array<RuleCards>(length);
+    const monomerLibHelper = await getMonomerLibHelper();
+    const systemMonomerLib = monomerLibHelper.getMonomerLib();
+
+    for (let i = 0; i < length; i++) {
+      cards[i] = new RuleCards(this.linkRules[i].firstMonomers, this.linkRules[i].secondMonomers,
+        systemMonomerLib, this.linkRules[i].code, this);
+    }
+
+    return cards;
   }
 
   getSynthesisRulesDf(): DG.DataFrame {
     const length = this.reactionRules.length;
     const codeCol = DG.Column.int(NAME_CODE, length);
+    codeCol.setTag('friendlyName', 'Code');
     const firstMonomerCol = DG.Column.string(NAME_FIRST_MONOMERS, length);
+    firstMonomerCol.setTag('friendlyName', 'First monomers');
     const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
+    secondMonomerCol.setTag('friendlyName', 'Second monomers');
     const name = DG.Column.string(NAME_REACTION_NAME, length);
+    name.setTag('friendlyName', 'Name');
     const firstReactant = DG.Column.string('firstReactant', length);
+    firstReactant.setTag('friendlyName', 'First reactant');
     const secondReactant = DG.Column.string('secondReactant', length);
+    secondReactant.setTag('friendlyName', 'Second reactant');
     const product = DG.Column.string('product', length);
+    product.setTag('friendlyName', 'Product');
 
     for (let i = 0; i < length; i++) {
       codeCol.set(i, this.reactionRules[i].code);

package/src/polytool/conversion/pt-tools-parse.ts

@@ -121,9 +121,10 @@ export function fromObjectsToHelm(linkages: Linkage[], monomers: string[][]): st
   return helm;
 }
 
-//homo and hetero dimers
-export function handleDuplicated(sequence: string, rules: Rules): [Linkage[], string[]] {
+//homo and hetero dimers/ also fills map from initial positions to positions arrays
+export function handleDuplicated(sequence: string, rules: Rules): [Linkage[], string[], boolean[]] {
   const mainFragments: string[] = [];
+  const isDuplicated: boolean[] = [];
   const linkages: Linkage[] = [];
   const heterodimerCode = rules.heterodimerCode;
   const homodimerCode = rules.homodimerCode;
@@ -134,8 +135,11 @@ export function handleDuplicated(sequence: string, rules: Rules): [Linkage[], st
     linkages.push({fChain: 0, sChain: 1, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
     mainFragments.push(heterodimeric[1].replaceAll('{', '').replaceAll('}', ''));
     mainFragments.push(heterodimeric[2].replaceAll('{', '').replaceAll('}', ''));
+    isDuplicated.push(false);
+    isDuplicated.push(false);
   } else {
     mainFragments.push(sequence);
+    isDuplicated.push(false);
   }
 
   //NOTICE: this works only with simple single dimers
@@ -151,30 +155,16 @@ export function handleDuplicated(sequence: string, rules: Rules): [Linkage[], st
 
       mainFragments[i] = linker + body;
       mainFragments.push(body);
+      isDuplicated.push(true);
     }
   }
 
-  for (let i = 0; i < mainFragments.length; i++) {
-    if (homodimerCode !== null && mainFragments[i].includes(`(${homodimerCode!})`)) {
-      const idxSequence = mainFragments.length;
-
-      linkages.push({fChain: i, sChain: idxSequence, fMonomer: 1, sMonomer: 1, fR: 1, sR: 1});
-      const rawDimer = mainFragments[i].replace(`(${homodimerCode!})`, '');
-      const idx = rawDimer.indexOf('{');
-      const linker = rawDimer.slice(0, idx);
-      const body = rawDimer.replace(linker, '').replaceAll('{', '').replaceAll('}', '');
-
-      mainFragments[i] = linker + body;
-      mainFragments.push(body);
-    }
-  }
-
-  return [linkages, mainFragments];
+  return [linkages, mainFragments, isDuplicated];
 }
 
-export function handleLinkRules(mf: string[], monomers: string[][], linkages: Linkage[], rules: Rules): void {
-  for (let i = 0; i < mf.length; i++) {
-    const rawMonomers = mf[i].split('-');
+export function handleLinkRules(monomers: string[][], linkages: Linkage[], rules: Rules): void {
+  for (let i = 0; i < monomers.length; i++) {
+    const rawMonomers = monomers[i];
     const linkedPositions = getLinkedPositions(rawMonomers, rules.linkRules);
     const [allPos1, allPos2, allAttaches1, allAttaches2] =
       getAllCycles(rules.linkRules, rawMonomers, linkedPositions);