@datagrok/sequence-translator 1.9.11 → 1.9.13

package/files/polytool-rules/rules_example.json

@@ -3,26 +3,71 @@
   "heterodimerCode": "$2",
   "linkRules": [
     {
+      "code": 2,
       "firstMonomers": [
         "D"
       ],
       "secondMonomers": [
         "NH2"
       ],
-      "firstLinkingGroup": "3",
-      "secondLinkingGroup": "2",
-      "code": "2"
+      "firstLinkingGroup": 3,
+      "secondLinkingGroup": 2
     },
     {
+      "code": 1,
       "firstMonomers": [
-        "C"
+        "C",
+        "dC"
       ],
       "secondMonomers": [
-        "C"
+        "C",
+        "dC"
       ],
-      "firstLinkingGroup": "3",
-      "secondLinkingGroup": "3",
-      "code": "1"
+      "firstLinkingGroup": 3,
+      "secondLinkingGroup": 3
+    },
+    {
+      "code": 10,
+      "firstMonomers": [
+        "C",
+        "D",
+        "E",
+        "K"
+      ],
+      "secondMonomers": [
+        "C",
+        "D",
+        "E",
+        "K"
+      ],
+      "firstLinkingGroup": 3,
+      "secondLinkingGroup": 2
+    },
+    {
+      "code": 11,
+      "firstMonomers": [
+        "C",
+        "E",
+        "K"
+      ],
+      "secondMonomers": [
+        "NH2"
+      ],
+      "firstLinkingGroup": 3,
+      "secondLinkingGroup": 2
+    },
+    {
+      "code": 1,
+      "firstMonomers": [
+        "C",
+        "dC"
+      ],
+      "secondMonomers": [
+        "THA",
+        "MG3"
+      ],
+      "firstLinkingGroup": 3,
+      "secondLinkingGroup": 3
     }
   ],
   "reactionRules": [
@@ -36,6 +81,50 @@
       ],
       "reaction": "[C:1]N=[N+]=[N-].[C:2]C#C>>[C:1]N1-N=NC=C1[C:2]",
       "name": "GGaz"
+    },
+    {
+      "code": 8,
+      "firstMonomers": [
+        "DRR1"
+      ],
+      "secondMonomers": [
+        "DRR2"
+      ],
+      "reaction": "C=C[C:1].C=C/C=C/[C:2]>>C1=CC([C:2])C([C:1])CC1",
+      "name": "DARR"
+    },
+    {
+      "code": 8,
+      "firstMonomers": [
+        "ODAR1"
+      ],
+      "secondMonomers": [
+        "ODAR2"
+      ],
+      "reaction": "C=CC(=O)[C:1].C=C[C:2]>>C1CC([C:1])OC([C:2])C1",
+      "name": "ODARR"
+    },
+    {
+      "code": 7,
+      "firstMonomers": [
+        "PHAR1"
+      ],
+      "secondMonomers": [
+        "PHAR2"
+      ],
+      "reaction": "C=C[C:1].C=C[C:2]>>C1CC([C:2])C1[C:1]",
+      "name": "PHAR_CIS"
+    },
+    {
+      "code": 6,
+      "firstMonomers": [
+        "PHAR1"
+      ],
+      "secondMonomers": [
+        "PHAR2"
+      ],
+      "reaction": "C=C[C:1].C=C[C:2]>>C1C([C:1])CC1[C:2]",
+      "name": "PHAR_TRANS"
     }
   ]
-}
+}

package/files/samples/cyclized.csv

@@ -7,3 +7,9 @@ n,seqs
 6,D(2)-T-G-H-F-Y-P-NH2(2)
 7,R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI
 8,R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI
+9,R-F-R-I-F-D-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-THA(1)-meI-G-T
+10,R-F-R-I-F-D-C(1)-T-G-H-F-Y-G-H-F-Y-G-H-F-Y-P-MG3(1)-meI-G-T
+11,R-F-DRR1(8)-T-G-H-F-Y-P-DRR2(8)-C-C
+12,R-F-ODAR1(8)-T-G-H-F-Y-P-ODAR2(8)-meI-R-P-NH2
+13,R-F-PHAR1(7)-T-G-H-F-Y-P-PHAR2(7)-meI-F-K-NH2
+14,R-F-PHAR1(6)-T-G-H-F-Y-P-PHAR2(6)-C-C

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.9.11",
+  "version": "1.9.13",
   "author": {
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"

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

@@ -7,8 +7,10 @@ import {RulesManager} from './rule-manager';
 import {RuleCards} from './pt-rule-cards';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {
+  _package,
   PackageFunctions} from '../../package';
 import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {ReactionEditorProps} from './rule-reaction-editor';
 
 export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
 export const RULES_STORAGE_NAME = 'Polytool';
@@ -25,6 +27,7 @@ const NAME_FIRST_LINK = 'firstLinkingGroup';
 const NAME_SECOND_LINK = 'secondLinkingGroup';
 
 export class RuleInputs extends ActiveFiles {
+  static ruleDescriptions: Record<string, Promise<HTMLElement>> = {};
   constructor(
     path: string, userStorageName: string, ext: string,
     options?: { onValueChanged: (value: string[]) => void }
@@ -47,8 +50,70 @@ export class RuleInputs extends ActiveFiles {
 
     return res;
   }
+
+  override async getForm(): Promise<HTMLDivElement> {
+    const form = await super.getForm();
+    this.processRulesForm(form);
+    return form;
+  }
+
+  private async processRulesForm(rulesForm: HTMLElement) {
+    const ruleNameLabels = Array.from(rulesForm.getElementsByTagName('label') ?? [])
+      .filter((l) => l.textContent?.endsWith('.json') && l.parentElement != null);
+    for (const label of ruleNameLabels) {
+      const ruleName = label.textContent!.trim();
+      const inputRoot = label.parentElement!.getElementsByTagName('input')[0]!;
+      ui.tooltip.bind(inputRoot, ui.wait(async () => {
+        RuleInputs.ruleDescriptions[ruleName] ??= (async () => {
+          try {
+            const rule = JSON.parse(await grok.dapi.files.readAsText(`${RULES_PATH}/${ruleName}`));
+            const descDiv = ui.divV([ui.h1(ruleName)]);
+            const linkRules: RuleLink[] = rule.linkRules ?? [];
+            // link rules
+            if (linkRules.length > 0) {
+              descDiv.appendChild(ui.h3('Linkage Rules'));
+              const table = ui.table(linkRules, (item) => [
+                item.code?.toString() ?? '',
+                shortenToMaxLen((item.firstMonomers ?? []).join(', ')),
+                shortenToMaxLen((item.secondMonomers ?? []).join(', ')),
+                item.firstLinkingGroup?.toString() ?? '',
+                item.secondLinkingGroup?.toString() ?? ''
+              ], ['Code', 'M1', 'M2', 'L1', 'L2']);
+              descDiv.appendChild(table);
+            }
+            // reaction rules
+            const reactionRules: RuleReaction[] = rule.reactionRules ?? [];
+            if (reactionRules.length > 0) {
+              descDiv.appendChild(ui.h3('Synthesis Rules'));
+              const table = ui.table(reactionRules, (item) => [
+                item.code?.toString() ?? '',
+                shortenToMaxLen((item.firstMonomers ?? []).join(', ')),
+                shortenToMaxLen((item.secondMonomers ?? []).join(', ')),
+                shortenToMaxLen(item.name ?? ''),
+                grok.chem.drawMolecule(item.reaction?.split('>>')[1] ?? '', 70, 70)
+              ], ['Code', 'M1', 'M2', 'Name', 'Product']);
+              descDiv.appendChild(table);
+            }
+            return descDiv;
+          } catch (e: any) {
+            _package.logger.error(`Failed to load rule ${ruleName}: ${e?.toString?.()}`);
+            console.error(e);
+            return ui.divText(`Failed to load rule ${ruleName}`);
+          }
+        })();
+        return await RuleInputs.ruleDescriptions[ruleName];
+      }));
+    }
+  }
 }
 
+
+function shortenToMaxLen(s: string, maxLen: number = 30): string {
+  if (s.length <= maxLen) return s;
+  return `${s.substring(0, maxLen)}...`;
+}
+
+
 export type RuleLink = {
   code: number,
   firstMonomers: string[],
@@ -170,7 +235,7 @@ export class Rules {
     return cards;
   }
 
-  getSynthesisRulesDf(): DG.DataFrame {
+  getSynthesisRulesDf() {
     const length = this.reactionRules.length;
     const codeCol = DG.Column.int(NAME_CODE, length);
     codeCol.setTag('friendlyName', 'Code');
@@ -178,6 +243,15 @@ export class Rules {
     firstMonomerCol.setTag('friendlyName', 'First monomers');
     const secondMonomerCol = DG.Column.string(NAME_SECOND_MONOMERS, length);
     secondMonomerCol.setTag('friendlyName', 'Second monomers');
+    // set these columns as macromolecule for better visualization
+    firstMonomerCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    firstMonomerCol.temp[MmcrTemps.fontSize] = 16;
+    PackageFunctions.applyNotationProviderForCyclized(firstMonomerCol, ',');
+    secondMonomerCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    secondMonomerCol.temp[MmcrTemps.fontSize] = 16;
+    PackageFunctions.applyNotationProviderForCyclized(secondMonomerCol, ',');
+    secondMonomerCol.setTag(DG.TAGS.CELL_RENDERER, 'Sequence');
+    firstMonomerCol.setTag(DG.TAGS.CELL_RENDERER, 'Sequence');
     const name = DG.Column.string(NAME_REACTION_NAME, length);
     name.setTag('friendlyName', 'Name');
     const firstReactant = DG.Column.string('firstReactant', length);
@@ -205,9 +279,27 @@ export class Rules {
     product.semType = DG.SEMTYPE.MOLECULE;
 
 
-    return DG.DataFrame.fromColumns([
+    const df = DG.DataFrame.fromColumns([
       name, firstReactant, secondReactant, product, codeCol, firstMonomerCol, secondMonomerCol
     ]);
+
+    const addNewRow = (rowObj: ReactionEditorProps) => {
+      if (rowObj.rowIndex != undefined && rowObj.rowIndex < df.rowCount && rowObj.rowIndex >= 0) {
+        name.set(rowObj.rowIndex, rowObj.resultMonomerName);
+        codeCol.set(rowObj.rowIndex, rowObj.code);
+        firstMonomerCol.set(rowObj.rowIndex, rowObj.firstMonomers.join(','));
+        secondMonomerCol.set(rowObj.rowIndex, rowObj.secondMonomers.join(','));
+        firstReactant.set(rowObj.rowIndex, rowObj.firstReactantSmiles);
+        secondReactant.set(rowObj.rowIndex, rowObj.secondReactantSmiles);
+        product.set(rowObj.rowIndex, rowObj.productSmiles);
+      } else {
+        const {resultMonomerName, code, firstMonomers, secondMonomers,
+          firstReactantSmiles, secondReactantSmiles, productSmiles} = rowObj;
+        df.rows.addNew([resultMonomerName, firstReactantSmiles, secondReactantSmiles,
+          productSmiles, code, firstMonomers.join(','), secondMonomers.join(',')]);
+      }
+    };
+    return {df, addNewRow};
   }
 
   setLinkRules(df: DG.DataFrame) : void {

package/src/polytool/conversion/rule-manager.ts

@@ -8,6 +8,12 @@ import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {doPolyToolConvert} from './pt-conversion';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
 import {RuleCards} from './pt-rule-cards';
+import {getOverriddenLibrary} from './pt-synthetic';
+import {MmcrTemps} from '@datagrok-libraries/bio/src/utils/cell-renderer-consts';
+import {helmToMol} from './pt-atomic';
+import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
+import {getSeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import {getReactionEditor, ReactionEditorProps} from './rule-reaction-editor';
 
 
 const TAB_LINKS = 'Links';
@@ -26,6 +32,7 @@ export class RulesManager {
 
   linkCards: RuleCards[];
   addLinkRulesFunc: (rowObj: LinkRuleRowArgs) => void;
+  addSynthRulesFunc: (rowObj: ReactionEditorProps) => void;
 
   // every rule set will have its editor instance
   private static instances: Record<string, RulesManager> = {};
@@ -36,7 +43,15 @@ export class RulesManager {
     this.linkRuleDataFrame = linksRes.res;
     this.addLinkRulesFunc = linksRes.addNewRow;
 
-    this.synthRuleDataFrame = this.rules.getSynthesisRulesDf();
+    const synthRes = this.rules.getSynthesisRulesDf();
+    this.addSynthRulesFunc = (r) => {
+      synthRes.addNewRow(r);
+      this.rules.setSynthesisRules(synthRes.df);
+      this.synthRuleDataFrame = synthRes.df;
+      this.substituteReactionGridDataFrame?.();
+      this.save();
+    };
+    this.synthRuleDataFrame = synthRes.df;
     this.fileName = fileName;
 
     const homoValue = this.rules.homodimerCode ? this.rules.homodimerCode : '';
@@ -170,18 +185,36 @@ export class RulesManager {
 
     const initCol = DG.Column.fromStrings('Monomers', seqs);
     const helmCol = DG.Column.fromStrings('Helm', helms);
-
+    const df = DG.DataFrame.fromColumns([
+      initCol, helmCol
+    ]);
     initCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    const rdKitModule = await getRdKitModule();
+    const seqHelper = await getSeqHelper();
+    // initialize seqHandler for this column
     PackageFunctions.applyNotationProviderForCyclized(initCol, '-');
+    initCol.tags[DG.TAGS.CELL_RENDERER] = 'Sequence';
 
     helmCol.semType = DG.SEMTYPE.MACROMOLECULE;
     helmCol.meta.units = NOTATION.HELM;
     helmCol.setTag(DG.TAGS.CELL_RENDERER, 'helm');
-    return DG.DataFrame.fromColumns([
-      initCol, helmCol
-    ]).plot.grid();
+
+    const lib = await getOverriddenLibrary(this.rules);
+    const resHelmColTemp = helmCol.temp;
+    resHelmColTemp[MmcrTemps.overriddenLibrary] = lib;
+    helmCol.temp = resHelmColTemp;
+
+    const resMolCol = await helmToMol(helmCol, seqs,
+      isLinear, true, false, false, lib, rdKitModule, seqHelper);
+    resMolCol.name = `molfile(sequence)`;
+    resMolCol.semType = DG.SEMTYPE.MOLECULE;
+    df.columns.add(resMolCol);
+
+    return df.plot.grid();
   }
 
+  private substituteReactionGridDataFrame: (() => void) | null = null;
+
   async getForm() {
     const gridOptions: Partial<DG.IGridSettings> = {showAddNewRowIcon: false, allowEdit: false, rowHeight: 60};
 
@@ -240,10 +273,31 @@ export class RulesManager {
     });
 
     const links = ui.splitH([linksGridDiv, gridDiv], null, true);
+    const synthesisGrid = this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: false, allowEdit: false, rowHeight: 130});
+    synthesisGrid.onCellDoubleClick.subscribe(() => {
+      if (!synthesisGrid.dataFrame || synthesisGrid.dataFrame.currentRowIdx == -1 || synthesisGrid.dataFrame.currentRowIdx == undefined)
+        return;
+      const idx = synthesisGrid.dataFrame.currentRowIdx;
+      const editArgs: ReactionEditorProps = {
+        rowIndex: idx,
+        code: this.synthRuleDataFrame.get('code', idx),
+        firstMonomers: this.synthRuleDataFrame.get('firstMonomers', idx).split(',').map((s: string) => s.trim()).filter((s: string) => s),
+        secondMonomers: this.synthRuleDataFrame.get('secondMonomers', idx).split(',').map((s: string) => s.trim()).filter((s: string) => s),
+        resultMonomerName: this.synthRuleDataFrame.get('name', idx),
+        firstReactantSmiles: this.synthRuleDataFrame.get('firstReactant', idx),
+        secondReactantSmiles: this.synthRuleDataFrame.get('secondReactant', idx),
+        productSmiles: this.synthRuleDataFrame.get('product', idx),
+      };
+      getReactionEditor((props: ReactionEditorProps) => this.addSynthRulesFunc(props), editArgs);
+    });
+    const reactionsGridDiv = this.createGridDiv('Rules', synthesisGrid);
 
-    const reactionsGridDiv = this.createGridDiv('Rules',
-      this.synthRuleDataFrame.plot.grid({showAddNewRowIcon: true}));
-    const reactionExamples = this.createGridDiv('Examples', await this.getReactionExamplesGrid());
+    const reactionExamplesGrid = await this.getReactionExamplesGrid();
+    const reactionExamples = this.createGridDiv('Examples', reactionExamplesGrid);
+    this.substituteReactionGridDataFrame = async () => {
+      const newGrid = await this.getReactionExamplesGrid();
+      reactionExamplesGrid.dataFrame = newGrid.dataFrame;
+    };
     reactionsGridDiv.style.width = '50%';
     reactionExamples.style.width = '50%';
     const reactions = ui.divH([reactionsGridDiv, reactionExamples]);
@@ -281,9 +335,37 @@ export class RulesManager {
       if (currentTab == TAB_LINKS)
         this.getAddNewLinkRuleDialog();
       else if (currentTab == TAB_REACTIONS)
-        this.synthRuleDataFrame.rows.addNew();
+        getReactionEditor((props: ReactionEditorProps) => this.addSynthRulesFunc(props));
     });
-    const topPanel = [saveButton, addButton];
+    const removeButton = ui.button('Remove rule', () => {
+      const currentTab = inputsTabControl.currentPane.name;
+      if (currentTab == TAB_LINKS) {
+        if (this.linkRuleDataFrame == null || this.linkRuleDataFrame.currentRowIdx == -1 || this.linkRuleDataFrame.currentRowIdx == undefined)
+          return;
+        const idx = linksGrid.dataFrame.currentRowIdx;
+        ui.dialog('Are you sure you want to remove the rule?')
+          .add(ui.divText('This action is irreversible!'))
+          .onOK(() => {
+            this.linkRuleDataFrame.rows.removeAt(idx);
+            this.rules.setLinkRules(this.linkRuleDataFrame);
+            this.save();
+          }).show();
+      } else if (currentTab == TAB_REACTIONS) {
+        if (this.synthRuleDataFrame == null || this.synthRuleDataFrame.currentRowIdx == -1 || this.synthRuleDataFrame.currentRowIdx == undefined)
+          return;
+        const idx = synthesisGrid.dataFrame.currentRowIdx;
+        ui.dialog('Are you sure you want to remove the rule?')
+          .add(ui.divText('This action is irreversible!'))
+          .onOK(() => {
+            this.synthRuleDataFrame.rows.removeAt(idx);
+            this.rules.setSynthesisRules(this.synthRuleDataFrame);
+            this.substituteReactionGridDataFrame?.();
+            this.save();
+          }).show();
+      }
+    });
+
+    const topPanel = [saveButton, addButton, removeButton];
     this.v!.setRibbonPanels([topPanel]);
 
     panel.style.height = '100%';

package/src/polytool/conversion/rule-reaction-editor.ts

@@ -0,0 +1,125 @@
+/* eslint-disable max-len */
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+
+function correctRGroups(smiles: string): string {
+  const elementRGroupRegex = /\[R[1-9]\]/g;
+  // replace all [R1] with [*:1]
+  let correctedSmiles = smiles.replaceAll(elementRGroupRegex, (match) => {
+    const rGroupNum = match[2];
+    return `[*:${rGroupNum}]`;
+  });
+
+  // in some scenarios, rgroups can be written as [2*]
+  const elementRGroupRegex2 = /\[\d\*\]/g;
+  correctedSmiles = correctedSmiles.replaceAll(elementRGroupRegex2, (match) => {
+    const rGroupNum = match[1];
+    return `[*:${rGroupNum}]`;
+  });
+
+  // in some other scenarios, rgroups can be written as [1*:1] or [1*:0]
+  const elementRGroupRegex3 = /\[\d\*\:\d\]/g;
+  return correctedSmiles.replaceAll(elementRGroupRegex3, (match) => {
+    const rGroupNum = match[1];
+    return `[*:${rGroupNum}]`;
+  });
+}
+
+function rgroupToRadicalForm(smiles: string): string {
+  // here we are sure that all rgroups are in the form [*:1], [*:2], ..., [*:9]
+  // replace all [*:1] with [C:1] to mark carbons
+  return smiles.replaceAll(/\[\*\:\d\]/g, (match) => {
+    const rGroupNum = match[3];
+    return `[C:${rGroupNum}]`;
+  });
+}
+
+function radicalToRgroupForm(smiles: string): string {
+  // here we are sure that all marked carbons are in the form [C:1], [C:2], ..., [C:9]
+  // replace all [C:1] with [*:1]
+  return smiles.replaceAll(/\[C\:\d\]/g, (match) => {
+    const rGroupNum = match[3];
+    return `[*:${rGroupNum}]`;
+  });
+}
+
+export type ReactionEditorProps = {
+    resultMonomerName: string,
+    firstReactantSmiles: string,
+    secondReactantSmiles: string,
+    productSmiles: string,
+    firstMonomers: string[],
+    secondMonomers: string[],
+    code: number,
+    rowIndex?: number,
+}
+
+export function getReactionEditor(onOk: (props: ReactionEditorProps) => void, preset?: ReactionEditorProps) {
+  // preset smiles are in radical form, need to convert to rgroup form
+  const firstReactant = preset?.firstReactantSmiles ? radicalToRgroupForm(preset.firstReactantSmiles) : '[*:1]C';
+  const secondReactant = preset?.secondReactantSmiles ? radicalToRgroupForm(preset.secondReactantSmiles) : '[*:2]C';
+  const product = preset?.productSmiles ? radicalToRgroupForm(preset.productSmiles) : '[*:1]CC[*:2]';
+  const code = preset?.code;
+  const firstMonomers = preset?.firstMonomers ?? [];
+  const secondMonomers = preset?.secondMonomers ?? [];
+  const resultMonomerName = preset?.resultMonomerName ?? '';
+
+  const codeInput = ui.input.int('Code', {value: code, nullable: false, showPlusMinus: false, showSlider: false, tooltipText: 'Reaction code'});
+  const firstMonomersInput = ui.input.string('First monomers', {value: firstMonomers.join(','), nullable: false, tooltipText: 'Comma-separated list of monomers for the first reactant'});
+  const secondMonomersInput = ui.input.string('Second monomers', {value: secondMonomers.join(','), nullable: false, tooltipText: 'Comma-separated list of monomers for the second reactant'});
+  const resultMonomerNameInput = ui.input.string('Result monomer name', {value: resultMonomerName, nullable: false, tooltipText: 'Name of the resulting pseudo-monomer generated by the reaction of the two reactants'});
+
+  const firstReactantInput = ui.input.molecule('First reactant', {value: firstReactant, nullable: false, tooltipText: 'Reactant fragment of first monomer(s). Use numbered R groups in correspondence with the rest of the molecule.'});
+  const secondReactantInput = ui.input.molecule('Second reactant', {value: secondReactant, nullable: false, tooltipText: 'Reactant fragment of second monomer(s). Use numbered R groups in correspondence with the rest of the molecule.'});
+  const productInput = ui.input.molecule('Product', {value: product, nullable: false, tooltipText: 'Product fragment of the resulting monomer from the reaction of the two reactants. Use numbered R groups in correspondence with the reactants.'});
+
+  const validate = () => {
+    if (!firstReactantInput || !secondReactantInput || !productInput)
+      return 'Inputs not initialized yet';
+    const firstSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(firstReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const secondSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(secondReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const productSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(productInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    if (!firstSmiles || !secondSmiles || !productSmiles)
+      return 'First/Second Reactants and Product must all be set';
+    if (firstSmiles.indexOf('[C:1]') == -1)
+      return 'First Reactant must contain R1-group';
+    if (secondSmiles.indexOf('[C:2]') == -1)
+      return 'Second Reactant must contain R2-group';
+    if (productSmiles.indexOf('[C:1]') == -1 || productSmiles.indexOf('[C:2]') == -1)
+      return 'Product must contain R1- and R2-groups';
+    return null;
+  };
+  firstReactantInput.addValidator(validate);
+  secondReactantInput.addValidator(validate);
+  productInput.addValidator(validate);
+  const dialog = ui.dialog(preset ? 'Edit Reaction Rule' : 'Add Reaction Rule')
+    .add(codeInput)
+    .add(resultMonomerNameInput)
+    .add(firstMonomersInput)
+    .add(secondMonomersInput)
+    .add(firstReactantInput)
+    .add(secondReactantInput)
+    .add(productInput);
+  dialog.addButton('Save', () => {
+    const validationError = validate();
+    if (validationError != null) {
+      grok.shell.warning(validationError);
+      return;
+    }
+    const firstSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(firstReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const secondSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(secondReactantInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    const productSmiles = rgroupToRadicalForm(correctRGroups(grok.chem.convert(productInput.value ?? '', grok.chem.Notation.Unknown, grok.chem.Notation.Smiles)));
+    onOk({
+      code: codeInput.value!,
+      resultMonomerName: resultMonomerNameInput.value,
+      firstMonomers: firstMonomersInput.value.split(',').map((s) => s.trim()).filter((s) => s.length > 0),
+      secondMonomers: secondMonomersInput.value.split(',').map((s) => s.trim()).filter((s) => s.length > 0),
+      firstReactantSmiles: firstSmiles,
+      secondReactantSmiles: secondSmiles,
+      productSmiles: productSmiles,
+      rowIndex: preset?.rowIndex});
+    dialog.close();
+  });
+  dialog.show();
+}

package/src/polytool/pt-convert-editor.ts

@@ -35,7 +35,7 @@ export class PolyToolConvertFuncEditor {
 
   private async initInputs(): Promise<void> {
     const getParam = (pName: string) => this.call.inputParams[pName];
-
+    const rulesForm = await this.ruleInputs.getForm();
     this.inputs = {
       table: (() => {
         const p = getParam(P.table);
@@ -49,7 +49,7 @@ export class PolyToolConvertFuncEditor {
       chiralityEngine: ui.input.forProperty(getParam(P.chiralityEngine).property),
       rules: {
         header: ui.inlineText([PT_UI_RULES_USED]),
-        form: await this.ruleInputs.getForm(),
+        form: rulesForm,
       }
     };
   }