@datagrok/sequence-translator 1.4.5 → 1.4.6

package/src/polytool/pt-dialog.ts

@@ -38,17 +38,18 @@ type PolyToolEnumerateChemSerialized = {
   screenLibrary: string | null;
 }
 
-export function polyToolEnumerateChemUI(cell?: DG.Cell): void {
-  getPolyToolEnumerationChemDialog(cell)
-    .then((dialog) => {
-      dialog.show({resizable: true});
-    })
-    .catch((_err: any) => {
-      grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
-    });
+export async function polyToolEnumerateChemUI(cell?: DG.Cell): Promise<void> {
+  await _package.initPromise;
+  try {
+    const dialog = await getPolyToolEnumerationChemDialog(cell);
+    dialog.show({resizable: true});
+  } catch (_err: any) {
+    grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
+  }
 }
 
 export async function polyToolConvertUI(): Promise<void> {
+  await _package.initPromise;
   let dialog: DG.Dialog;
   try {
     dialog = await getPolyToolConvertDialog();
@@ -234,6 +235,11 @@ async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dial
   }
 }
 
+function dealGroups(col: DG.Column<string>): void {
+  for (let i = 0; i < col.length; i++)
+    col.set(i, col.get(i)!.replaceAll('undefined', 'H'));
+}
+
 /** Returns Helm and molfile columns.  */
 export async function polyToolConvert(
   seqCol: DG.Column<string>, generateHelm: boolean, chiralityEngine: boolean, ruleFiles: string[]
@@ -244,11 +250,11 @@ export async function polyToolConvert(
       if (!df) return colName;
       return df.columns.getUnusedName(colName);
     };
-    await getHelmHelper(); // initializes JSDraw and org
+    const helmHelper = await getHelmHelper(); // initializes JSDraw and org
 
     const table = seqCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const resList = doPolyToolConvert(seqCol.toList(), rules);
+    const resList = doPolyToolConvert(seqCol.toList(), rules, helmHelper);
 
     const resHelmColName = getUnusedName(table, `transformed(${seqCol.name})`);
     const resHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, resHelmColName, resList.length)
@@ -267,7 +273,7 @@ export async function polyToolConvert(
     const toAtomicLevelRes =
       await seqHelper.helmToAtomicLevel(resHelmCol, chiralityEngine, /* highlight */ generateHelm, lib);
     const resMolCol = toAtomicLevelRes.molCol!;
-
+    dealGroups(resMolCol);
     resMolCol.name = getUnusedName(table, `molfile(${seqCol.name})`);
     resMolCol.semType = DG.SEMTYPE.MOLECULE;
     if (table) {

package/src/polytool/pt-enumeration-helm-dialog.ts

@@ -5,10 +5,8 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 import wu from 'wu';
 import {fromEvent, Unsubscribable} from 'rxjs';
-
-import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
-import {HelmAtom, HelmMol} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
-import {getHelmHelper, HelmInputBase} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {HelmAtom} from '@datagrok-libraries/helm-web-editor/src/types/org-helm';
+import {getHelmHelper, HelmInputBase, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {getMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {HelmType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
 import {helmTypeToPolymerType} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
@@ -17,17 +15,17 @@ import '@datagrok-libraries/bio/src/types/input';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {InputColumnBase} from '@datagrok-libraries/bio/src/types/input';
 
-import {
-  PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes
-} from './types';
+import {PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes} from './types';
 import {getLibrariesList} from './utils';
 import {doPolyToolEnumerateHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
 import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
 import {defaultErrorHandler} from '../utils/err-info';
 import {PolyToolPlaceholdersBreadthInput} from './pt-placeholders-breadth-input';
 import {PT_UI_DIALOG_ENUMERATION} from './const';
+import {PolyToolDataRole, PolyToolTags} from '../consts';
+import {Chain} from './pt-conversion';
 
-import {_package} from '../package';
+import {_package, applyNotationProviderForCyclized} from '../package';
 
 type PolyToolEnumerateInputs = {
   macromolecule: HelmInputBase;
@@ -52,6 +50,8 @@ type PolyToolEnumerateHelmSerialized = {
 };
 
 export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
+  await _package.initPromise;
+
   const maxWidth = window.innerWidth;
   const maxHeight = window.innerHeight;
 
@@ -118,7 +118,6 @@ export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
   }
 }
 
-
 async function getPolyToolEnumerateDialog(
   cell?: DG.Cell, resizeInputs?: () => void
 ): Promise<DG.Dialog> {
@@ -312,11 +311,12 @@ async function getPolyToolEnumerateDialog(
     inputs.macromolecule.root.style.setProperty('min-width', '250px', 'important');
     // inputs.macromolecule.root.style.setProperty('max-height', '300px', 'important');
 
+    const phPosSet = new Set<number>(inputs.placeholders.placeholdersValue.map((ph) => ph.position));
     const updateMolView = () => {
       const mol = inputs.macromolecule.molValue;
       for (let aI = 0; aI < mol.atoms.length; aI++) {
         const a = mol.atoms[aI];
-        a.highlighted = aI in inputs.placeholders.placeholdersValue;
+        a.highlighted = phPosSet.has(aI);
       }
       inputs.macromolecule.redraw();
     };
@@ -363,23 +363,33 @@ async function getPolyToolEnumerateDialog(
       if (resizeInputs) resizeInputs();
     };
 
-    const fillForCurrentCell = async (cell?: DG.Cell): Promise<void> => {
+    const fillForCurrentCell = async (cell?: DG.Cell): Promise<PolyToolDataRole> => {
+      let resDataRole;
       let helmValue: string;
       let table: DG.DataFrame | undefined = undefined;
       if (cell && cell.rowIndex >= 0 && cell?.column.semType == DG.SEMTYPE.MACROMOLECULE) {
         const sh = _package.seqHelper.getSeqHandler(cell.column);
-        const helmSemValue = await sh.getHelm(cell.rowIndex);
-        helmValue = helmSemValue.value;
+        const mValue = await sh.getValue(cell.rowIndex);
+        helmValue = mValue.value;
         table = cell.dataFrame;
+        resDataRole = (mValue.tags[PolyToolTags.dataRole] as PolyToolDataRole.template) ?? PolyToolDataRole.macromolecule;
       } else {
         helmValue = PT_HELM_EXAMPLE;
+        resDataRole = PolyToolDataRole.macromolecule;
       }
-
       inputs.macromolecule.stringValue = helmValue;
+
+      if (resDataRole === PolyToolDataRole.template) {
+        inputs.toAtomicLevel.root.style.display = 'none';
+      } else {
+        inputs.toAtomicLevel.root.style.removeProperty('display');
+      }
+
       fillTrivialNameList(table);
+      return resDataRole;
     };
 
-    await fillForCurrentCell(cell);
+    let dataRole: PolyToolDataRole = await fillForCurrentCell(cell);
 
     const exec = async (): Promise<void> => {
       try {
@@ -402,10 +412,12 @@ async function getPolyToolEnumerateDialog(
           const params: PolyToolEnumeratorParams = {
             placeholders: inputs.placeholders.placeholdersValue,
             type: inputs.enumeratorType.value!,
-            placeholdersBreadth: inputs.placeholdersBreadth.placeholdersBreadthValue,
+            breadthPlaceholders: inputs.placeholdersBreadth.placeholdersBreadthValue,
             keepOriginal: inputs.keepOriginal.value,
           };
-          const enumeratorResDf = await polyToolEnumerateHelm(srcHelm, srcId, params, inputs.toAtomicLevel.value, seqHelper);
+          const toAtomicLevelV = inputs.toAtomicLevel.value && dataRole == PolyToolDataRole.macromolecule;
+          const enumeratorResDf = await polyToolEnumerateHelm(srcHelm, dataRole, srcId, params,
+            toAtomicLevelV, seqHelper, helmHelper);
           grok.shell.addTableView(enumeratorResDf);
         }
       } catch (err: any) {
@@ -460,23 +472,49 @@ async function getPolyToolEnumerateDialog(
   }
 }
 
+/**
+ * @param {DG.SemanticValue} srcValue Source value to enumerate, either of data role
+ *                                    {@link PolyToolDataRole.template} or {@link PolyToolDataRole.macromolecule}
+ * */
 async function polyToolEnumerateHelm(
-  srcHelm: string, srcId: { value: string, colName: string } | null, params: PolyToolEnumeratorParams,
-  toAtomicLevel: boolean, seqHelper: ISeqHelper,
+  srcHelm: string, dataRole: PolyToolDataRole, srcId: { value: string, colName: string } | null,
+  params: PolyToolEnumeratorParams, toAtomicLevel: boolean, seqHelper: ISeqHelper, helmHelper: IHelmHelper
 ): Promise<DG.DataFrame> {
   const pi = DG.TaskBarProgressIndicator.create('PolyTool enumerating...');
   try {
     await getHelmHelper(); // initializes JSDraw and org
 
     const resList = doPolyToolEnumerateHelm(srcHelm, srcId?.value ?? '', params);
-    const enumHelmCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Enumerated', resList.length)
-      .init((rowIdx: number) => resList[rowIdx][0]);
-    const enumeratorResDf = DG.DataFrame.fromColumns([enumHelmCol]);
+    let enumCol: DG.Column<string>;
+    switch (dataRole) {
+    case PolyToolDataRole.macromolecule: {
+      enumCol = DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Enumerated', resList.length)
+        .init((rowIdx: number) => resList[rowIdx][0]);
+      break;
+    }
+    case PolyToolDataRole.template: {
+      const templateList: string[] = new Array<string>(resList.length);
+      for (let rowIdx = 0; rowIdx < resList.length; rowIdx++) {
+        const pseudoHelm = resList[rowIdx][0];
+        const chain = Chain.parseHelm(pseudoHelm, helmHelper);
+        templateList[rowIdx] = chain.getNotation();
+      }
+      enumCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'Enumerated', templateList);
+      // enumCol.semType = DG.SEMTYPE.MACROMOLECULE;
+      // enumCol.setTag(PolyToolTags.dataRole, PolyToolDataRole.template);
+      // applyNotationProviderForCyclized(enumCol, '-');
+      break;
+    }
+    }
+    const enumeratorResDf = DG.DataFrame.fromColumns([enumCol]);
+    await grok.data.detectSemanticTypes(enumeratorResDf);
+    if (dataRole == PolyToolDataRole.template) {
+      applyNotationProviderForCyclized(enumCol, '-');
+    }
 
-    if (toAtomicLevel) {
+    if (toAtomicLevel && dataRole != PolyToolDataRole.template) {
       const seqHelper: ISeqHelper = await getSeqHelper();
-      const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(enumHelmCol, true, true);
-      toAtomicLevelRes.molCol!.semType = DG.SEMTYPE.MOLECULE;
+      const toAtomicLevelRes = await seqHelper.helmToAtomicLevel(enumCol, true, true);
       enumeratorResDf.columns.add(toAtomicLevelRes.molCol!, false);
     }
 

package/src/polytool/pt-enumeration-helm.ts

@@ -11,7 +11,7 @@ import {
 
 import {Chain} from './pt-conversion';
 import {getAvailableMonomers} from './utils';
-import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholders, PolyToolPlaceholdersBreadth} from './types';
+import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholder, PolyToolBreadthPlaceholder} from './types';
 
 // For example keep monomers presented in HELMCoreLibrary.json only (not [NH2])
 export const PT_HELM_EXAMPLE = 'PEPTIDE1{R.[Aca].T.G.H.F.G.A.A.Y.P.E.[meI]}$$$$';
@@ -44,14 +44,14 @@ function polyToolEnumeratorCore(m: HelmMol, start: number, end: number, monomerL
  * @param  placeholders Placeholders by zero-based position key
  * @returns {string[]} List of enumerated molecules in Helm format
  */
-function getPtEnumeratorSingle(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
+function getPtEnumeratorSingle(m: HelmMol, placeholders: PolyToolPlaceholder[]): HelmMol[] {
   const coreResList: HelmMol[][] = placeholders
     .map((ph) => polyToolEnumeratorCore(m, ph.position, ph.position, ph.monomers));
   const resMolList = coreResList.reduce((acc, posList) => acc.concat(posList), []);
   return resMolList;
 }
 
-function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
+function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholder[]): HelmMol[] {
   let resMolList = [m];
   for (const ph of placeholders) {
     const phResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, ph.position, ph.position, ph.monomers));
@@ -60,7 +60,10 @@ function getPtEnumeratorMatrix(m: HelmMol, placeholders: PolyToolPlaceholders):
   return resMolList;
 }
 
-function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolPlaceholdersBreadth): HelmMol[] {
+function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolBreadthPlaceholder[]): HelmMol[] {
+  if (placeholdersBreadth.length == 0)
+    return [];
+
   let resMolList = [m];
   for (const phb of placeholdersBreadth) {
     const phResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, phb.start, phb.end, phb.monomers));
@@ -94,8 +97,8 @@ export function doPolyToolEnumerateHelm(
   }
 
   let resBreadthMolList: HelmMol[] = [];
-  if (params.placeholdersBreadth) {
-    resBreadthMolList = getPtEnumeratorBreadth(molHandler.m, params.placeholdersBreadth);
+  if (params.breadthPlaceholders) {
+    resBreadthMolList = getPtEnumeratorBreadth(molHandler.m, params.breadthPlaceholders);
   }
   resMolList = resMolList.concat(resBreadthMolList);
 

package/src/polytool/pt-placeholders-breadth-input.ts

@@ -3,7 +3,7 @@ import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
 import {Unsubscribable} from 'rxjs';
-import {PolyToolPlaceholders, PolyToolPlaceholdersBreadth} from './types';
+import {PolyToolBreadthPlaceholder} from './types';
 import {parseMonomerSymbolList} from './pt-placeholders-input';
 
 export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFrame> {
@@ -21,7 +21,7 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
 
   setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
 
-  get placeholdersBreadthValue(): PolyToolPlaceholdersBreadth {
+  get placeholdersBreadthValue(): PolyToolBreadthPlaceholder[] {
     return dfToPlaceholdersBreadth(this.grid.dataFrame);
   }
 
@@ -97,8 +97,8 @@ export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFram
   }
 }
 
-export function dfToPlaceholdersBreadth(df: DG.DataFrame): PolyToolPlaceholdersBreadth {
-  const res: PolyToolPlaceholdersBreadth = [];
+export function dfToPlaceholdersBreadth(df: DG.DataFrame): PolyToolBreadthPlaceholder[] {
+  const res: PolyToolBreadthPlaceholder[] = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
     const startPos = parseInt(df.get('Start', rowI)) - 1;
     const endPos = parseInt(df.get('End', rowI)) - 1;

package/src/polytool/pt-placeholders-input.ts

@@ -4,7 +4,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {Unsubscribable} from 'rxjs';
 
-import {PolyToolPlaceholders} from './types';
+import {PolyToolPlaceholder} from './types';
 
 export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   get inputType(): string { return 'Positions'; }
@@ -21,7 +21,7 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 
   setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
 
-  get placeholdersValue(): PolyToolPlaceholders {
+  get placeholdersValue(): PolyToolPlaceholder[] {
     return dfToPlaceholders(this.grid.dataFrame);
   }
 
@@ -95,8 +95,8 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   }
 }
 
-export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
-  const res: PolyToolPlaceholders = [];
+export function getPlaceholdersFromText(src: string): PolyToolPlaceholder[] {
+  const res: PolyToolPlaceholder[] = [];
   for (const line of src.split('\n')) {
     const lineM = /^\s*(?<pos>\d+)\s*:\s*(?<monomers>.+)$/.exec(line);
     if (lineM) {
@@ -108,8 +108,8 @@ export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
   return res;
 }
 
-export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
-  const res: PolyToolPlaceholders = [];
+export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholder[] {
+  const res: PolyToolPlaceholder[] = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
     const pos = parseInt(df.get('Position', rowI)) - 1;
     if (!isNaN(pos)) {

package/src/polytool/pt-unrule-dialog.ts

@@ -6,11 +6,13 @@ import {Unsubscribable} from 'rxjs';
 
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {getUnusedColName} from '@datagrok-libraries/bio/src/monomer-works/utils';
+import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 import {defaultErrorHandler} from '../utils/err-info';
 import {doPolyToolUnrule} from './pt-unrule';
 import {getRules, RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './pt-rules';
 import {PT_ERROR_DATAFRAME, PT_UI_DIALOG_UNRULE, PT_UI_RULES_USED} from './const';
+
 import {_package} from '../package';
 
 type PolyToolUnruleSerialized = {
@@ -87,9 +89,11 @@ export async function polyToolUnrule(
 ): Promise<DG.Column> {
   const pi = DG.TaskBarProgressIndicator.create('PolyTool unrule...');
   try {
+    const helmHelper = await getHelmHelper();
+
     const table = srcCol.dataFrame;
     const rules = await getRules(ruleFiles);
-    const resHelmList = doPolyToolUnrule(srcCol.toList(), rules);
+    const resHelmList = doPolyToolUnrule(srcCol.toList(), rules, helmHelper);
     const resHelmColName = `harmonized(srcCol.name)`;
     const resHelmCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, resHelmColName, resHelmList,);
     resHelmCol.semType = DG.SEMTYPE.MACROMOLECULE;

package/src/polytool/pt-unrule.ts

@@ -9,6 +9,7 @@ import {getPolyToolUnruleDialog} from './pt-unrule-dialog';
 import {Rules} from './pt-rules';
 
 import {_package} from '../package';
+import {IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
 export async function polyToolUnruleUI(): Promise<void> {
   let dialog: DG.Dialog;
@@ -23,13 +24,13 @@ export async function polyToolUnruleUI(): Promise<void> {
 }
 
 /** Returns list of harmonized sequences. Covered with tests. */
-export function doPolyToolUnrule(helms: string[], rules: Rules): string[] {
+export function doPolyToolUnrule(helms: string[], rules: Rules, helmHelper: IHelmHelper): string[] {
   const resHrzSeqList = new Array<string>(helms.length);
   for (let i = 0; i < helms.length; ++i) {
     if (!helms[i])
       resHrzSeqList[i] = '';
     else {
-      const chain = Chain.fromHelm(helms[i]);
+      const chain = Chain.parseHelm(helms[i], helmHelper);
       resHrzSeqList[i] = chain.getNotation();
     }
   }

package/src/polytool/types.ts

@@ -11,15 +11,15 @@ export enum PolyToolEnumeratorTypes {
 
 export type PolyToolEnumeratorType = typeof PolyToolEnumeratorTypes[keyof typeof PolyToolEnumeratorTypes];
 
-export type PolyToolPlaceholders = { position: number, monomers: string[] } [];
+export type PolyToolPlaceholder = { position: number, monomers: string[] };
 
-export type PolyToolPlaceholdersBreadth = { start: number, end: number, monomers: string[] }[];
+export type PolyToolBreadthPlaceholder = { start: number, end: number, monomers: string[] };
 
 export type PolyToolEnumeratorParams = {
   type: PolyToolEnumeratorType;
   /** position key is zero-based */
-  placeholders?: PolyToolPlaceholders;
-  placeholdersBreadth?: PolyToolPlaceholdersBreadth;
+  placeholders?: PolyToolPlaceholder[];
+  breadthPlaceholders?: PolyToolBreadthPlaceholder[];
   keepOriginal?: boolean;
   trivialName?: boolean;
 }

package/src/tests/polytool-chain-from-notation-tests.ts

@@ -5,41 +5,131 @@ import * as DG from 'datagrok-api/dg';
 import {before, after, category, expect, test, expectArray, testEvent, delay} from '@datagrok-libraries/utils/src/test';
 import {Chain} from '../polytool/pt-conversion';
 import {getRules} from '../polytool/pt-rules';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+
+category('PolyTool: Chain', () => {
+  let helmHelper: IHelmHelper;
+
+  before(async () => {
+    helmHelper = await getHelmHelper();
+  });
 
-category('PolyTool: Chain: fromNotation', () => {
   const tests = {
     'cyclized': {
-      src: {seq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI'},
+      data: {
+        templateSeq: 'R-F-C(1)-T-G-H-F-Y-P-C(1)-meI',
+        templateHelm: 'PEPTIDE1{R.F.[C(1)].T.G.H.F.Y.P.[C(1)].[meI]}$$$$V2.0',
+        mmHelm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$V2.0',
+      },
       tgt: {
-        monomerCount: [11], linkageCount: 1,
-        helm: 'PEPTIDE1{R.F.C.T.G.H.F.Y.P.C.[meI]}$PEPTIDE1,PEPTIDE1,3:R3-10:R3$$$',
+        templateChain: {monomerCount: [11], linkageCount: 0},
+        mmChain: {monomerCount: [11], linkageCount: 1,}
       },
     },
     'reaction1': {
-      src: {seq: 'R-F-azG(3)-T-G-H-F-Y-P-aG(3)-meI'},
+      data: {
+        templateSeq: 'R-F-azG(4)-T-G-H-F-Y-P-aG(4)-meI',
+        templateHelm: 'PEPTIDE1{R.F.[azG(4)].T.G.H.F.Y.P.[aG(4)].[meI]}$$$$V2.0',
+        mmHelm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$V2.0',
+      },
       tgt: {
-        monomerCount: [9, 1], linkageCount: 2,
-        helm: 'PEPTIDE1{R.F.[GGaz].T.G.H.F.Y.P}|PEPTIDE2{[meI]}$PEPTIDE1,PEPTIDE1,3:R3-9:R2|PEPTIDE1,PEPTIDE2,3:R4-1:R1$$$',
+        templateChain: {monomerCount: [11], linkageCount: 0,},
+        mmChain: {monomerCount: [9, 1], linkageCount: 2,}
       }
     },
     'reaction2': {
-      src: {seq: 'R-F-aG(3)-T-G-H-F-Y-P-azG(3)-meI'},
+      data: {
+        templateSeq: 'R-F-aG(4)-T-G-H-F-Y-P-azG(4)-meI',
+        templateHelm: 'PEPTIDE1{R.F.[aG(4)].T.G.H.F.Y.P.[azG(4)].[meI]}$$$$V2.0',
+        mmHelm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$V2.0',
+      },
+      tgt: {
+        templateChain: {monomerCount: [11], linkageCount: 0,},
+        mmChain: {monomerCount: [2, 8], linkageCount: 2,}
+      }
+    },
+    'dimerized1': {
+      data: {
+        templateSeq: '(#3)Succ-{A(CHOL)-F-C(1)-T-G-H-Y-P-C(1)-NH2}',
+        templateHelm: 'PEPTIDE1{[(#3)Succ]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.[C(1)].T.G.H.Y.P.[C(1)].[NH2]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
+        mmHelm: 'PEPTIDE1{[Succ].[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.C.T.G.H.Y.P.C.[NH2]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
+          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
+          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+      },
+      tgt: {
+        templateChain: {monomerCount: [1, 10], linkageCount: 1},
+        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
+      }
+    },
+    'dimerized2': {
+      data: {
+        templateSeq: '($3)Succ-{R-F-C(1)-T-G-H-F-P-C(1)-NH2}($3){A(CHOL)-F-C(1)-Y-H-G-D-N-C(1)-meI}',
+        templateHelm: 'PEPTIDE1{[($3)Succ]}' + '|' +
+          'PEPTIDE2{R.F.[C(1)].T.G.H.F.P.[C(1)].[NH2]}' + '|' +
+          'PEPTIDE3{[($3)A(CHOL)].F.[C(1)].Y.H.G.D.N.[C(1)].[meI]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '$$$' + 'V2.0',
+        mmHelm: 'PEPTIDE1{[Succ].R.F.C.T.G.H.F.P.C.[NH2]}' + '|' +
+          'PEPTIDE2{[A(CHOL)].F.C.Y.H.G.D.N.C.[meI]}' + '$' +
+          'PEPTIDE1,PEPTIDE2,1:R1-1:R1' + '|' +
+          'PEPTIDE1,PEPTIDE1,4:R3-10:R3' + '|' +
+          'PEPTIDE2,PEPTIDE2,3:R3-9:R3' + '$$$V2.0',
+      },
       tgt: {
-        // TODO: Target test data requires clarification
-        monomerCount: [2, 8], linkageCount: 0,
-        helm: 'PEPTIDE1{R.F}|PEPTIDE2{T.G.H.F.Y.P.[GGaz].[meI]}$PEPTIDE1,PEPTIDE2,2:R2-7:R3|PEPTIDE2,PEPTIDE2,1:R1-7:R4,$$$',
+        templateChain: {monomerCount: [1, 10, 10], linkageCount: 1,},
+        mmChain: {monomerCount: [11, 10], linkageCount: 3,}
       }
     }
-
   };
 
-  for (const [testName, testData] of Object.entries(tests)) {
-    test(`${testName}`, async () => {
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`fromNotation-${testName}`, async () => {
       const rules = await getRules(['rules_example.json']);
-      const resChain = Chain.fromNotation(testData.src.seq, rules);
-      expectArray(resChain.monomers.map((mL) => mL.length), testData.tgt.monomerCount);
-      expect(resChain.linkages.length, testData.tgt.linkageCount);
-      expect(resChain.getHelm(), testData.tgt.helm);
+      const resMmChain = Chain.fromNotation(data.templateSeq, rules, helmHelper);
+      resMmChain.check(true);
+      expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
+      expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
+      expect(resMmChain.getHelm(), data.mmHelm);
     }, testName == 'reaction2' ? {skipReason: 'reverse reaction'} : undefined);
   }
+
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`parseNotation-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
+      resTemplateChain.check(true);
+      expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.templateChain.monomerCount);
+      expect(resTemplateChain.linkages.length, tgt.templateChain.linkageCount);
+      expect(resTemplateChain.getHelm(), data.templateHelm);
+      expect(resTemplateChain.getNotation(), data.templateSeq);
+    });
+  }
+
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`parseHelm-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resTemplateChain = Chain.parseHelm(data.templateHelm, helmHelper);
+      resTemplateChain.check(true);
+      expectArray(resTemplateChain.monomers.map((mL) => mL.length), tgt.templateChain.monomerCount);
+      expect(resTemplateChain.linkages.length, tgt.templateChain.linkageCount);
+      expect(resTemplateChain.getHelm(), data.templateHelm);
+      expect(resTemplateChain.getNotation(), data.templateSeq);
+    });
+  }
+
+  for (const [testName, {data, tgt}] of Object.entries(tests)) {
+    test(`applyRules-${testName}`, async () => {
+      const rules = await getRules(['rules_example.json']);
+      const resTemplateChain = Chain.parseNotation(data.templateSeq, helmHelper);
+      const resMmChain = resTemplateChain.applyRules(rules);
+      resMmChain.check(true);
+      expectArray(resMmChain.monomers.map((mL) => mL.length), tgt.mmChain.monomerCount);
+      expect(resMmChain.linkages.length, tgt.mmChain.linkageCount);
+      expect(resMmChain.getHelm(), data.mmHelm);
+    }, {skipReason: 'applyRules is not implemented'});
+  }
+
 });