@datagrok/sequence-translator 1.4.0 → 1.4.2

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

@@ -10,7 +10,7 @@ import {
 
 import {Chain} from './pt-conversion';
 import {getAvailableMonomers} from './utils';
-import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholders} from './types';
+import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes, PolyToolPlaceholders, PolyToolPlaceholdersBreadth} 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]}$$$$';
@@ -19,17 +19,21 @@ export const PT_HELM_EXAMPLE = 'PEPTIDE1{R.[Aca].T.G.H.F.G.A.A.Y.P.E.[meI]}$$$$'
 declare const JSDraw2: JSDraw2ModuleType;
 declare const org: OrgType;
 
-function polyToolEnumeratorCore(m: HelmMol, position: number, monomerList: string[]): HelmMol[] {
-  const resMolList: HelmMol[] = new Array<HelmMol>(monomerList.length);
-  for (let i = 0; i < monomerList.length; i++) {
-    const newSymbol = monomerList[i];
-    const resM = resMolList[i] = m.clone() as HelmMol;
-    const oldSymbol = resM.atoms[position].elem;
-    resM.atoms[position].elem = newSymbol;
+function polyToolEnumeratorCore(m: HelmMol, start: number, end: number, monomerList: string[]): HelmMol[] {
+  const resMolList: HelmMol[] = new Array<HelmMol>(monomerList.length * (end - start + 1));
+  for (let monI: number = 0; monI < monomerList.length; ++monI) {
+    const posCount = end - start + 1;
+    for (let posI: number = 0; posI < posCount; ++posI) {
+      const pos = start + posI;
+      const newSymbol = monomerList[monI];
+      const resM = resMolList[monI * posCount + posI] = m.clone() as HelmMol;
+      const oldSymbol = resM.atoms[pos].elem;
+      resM.atoms[pos].elem = newSymbol;
 
-    const idOldSymbol = oldSymbol?.length > 1 ? `[${oldSymbol}]` : oldSymbol;
-    const idNewSymbol = newSymbol?.length > 1 ? `[${newSymbol}]` : newSymbol;
-    resM.name = `${m.name}-${idOldSymbol}${position + 1}${idNewSymbol}`;
+      const idOldSymbol = oldSymbol?.length > 1 ? `[${oldSymbol}]` : oldSymbol;
+      const idNewSymbol = newSymbol?.length > 1 ? `[${newSymbol}]` : newSymbol;
+      resM.name = `${m.name}-${idOldSymbol}${pos + 1}${idNewSymbol}`;
+    }
   }
   return resMolList;
 }
@@ -40,18 +44,26 @@ function polyToolEnumeratorCore(m: HelmMol, position: number, monomerList: strin
  * @returns {string[]} List of enumerated molecules in Helm format
  */
 function getPtEnumeratorSingle(m: HelmMol, placeholders: PolyToolPlaceholders): HelmMol[] {
-  const coreResList: HelmMol[][] = Object.entries(placeholders)
-    .map(([p, monomerList]: [string, string[]]) => polyToolEnumeratorCore(m, parseInt(p), monomerList));
+  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[] {
   let resMolList = [m];
-  for (const [p, monomerList] of Object.entries(placeholders)) {
-    const pos: number = parseInt(p);
-    const posResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, pos, monomerList));
-    resMolList = posResMolList.reduce((acc, l) => acc.concat(l), []);
+  for (const ph of placeholders) {
+    const phResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, ph.position, ph.position, ph.monomers));
+    resMolList = phResMolList.reduce((acc, l) => acc.concat(l), []);
+  }
+  return resMolList;
+}
+
+function getPtEnumeratorBreadth(m: HelmMol, placeholdersBreadth: PolyToolPlaceholdersBreadth): HelmMol[] {
+  let resMolList = [m];
+  for (const phb of placeholdersBreadth) {
+    const phResMolList: HelmMol[][] = resMolList.map((m: HelmMol) => polyToolEnumeratorCore(m, phb.start, phb.end, phb.monomers));
+    resMolList = phResMolList.reduce((acc, l) => acc.concat(l), []);
   }
   return resMolList;
 }
@@ -66,17 +78,25 @@ export function doPolyToolEnumerateHelm(
   const m = molHandler.m;
   m.name = id;
 
-  let resMolList: HelmMol[];
-  switch (params.type) {
-  case PolyToolEnumeratorTypes.Single: {
-    resMolList = getPtEnumeratorSingle(molHandler.m, params.placeholders);
-    break;
-  }
-  case PolyToolEnumeratorTypes.Matrix: {
-    resMolList = getPtEnumeratorMatrix(molHandler.m, params.placeholders);
-    break;
+  let resMolList: HelmMol[] = [];
+  if (params.placeholders) {
+    switch (params.type) {
+    case PolyToolEnumeratorTypes.Single: {
+      resMolList = getPtEnumeratorSingle(molHandler.m, params.placeholders);
+      break;
+    }
+    case PolyToolEnumeratorTypes.Matrix: {
+      resMolList = getPtEnumeratorMatrix(molHandler.m, params.placeholders);
+      break;
+    }
+    }
   }
+
+  let resBreadthMolList: HelmMol[] = [];
+  if (params.placeholdersBreadth) {
+    resBreadthMolList = getPtEnumeratorBreadth(molHandler.m, params.placeholdersBreadth);
   }
+  resMolList = resMolList.concat(resBreadthMolList);
 
   if (params.keepOriginal)
     resMolList = [m, ...resMolList];

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

@@ -0,0 +1,111 @@
+import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {Unsubscribable} from 'rxjs';
+import {PolyToolPlaceholders, PolyToolPlaceholdersBreadth} from './types';
+import {parseMonomerSymbolList} from './pt-placeholders-input';
+
+export class PolyToolPlaceholdersBreadthInput extends DG.JsInputBase<DG.DataFrame> {
+  get inputType(): string { return 'Breadth'; }
+
+  get dataType(): string { return DG.TYPE.DATA_FRAME; }
+
+  getInput(): HTMLElement { return this.gridHost; }
+
+  getValue(): DG.DataFrame { return this.grid.dataFrame; }
+
+  setValue(value: DG.DataFrame): void { this.grid.dataFrame = value; }
+
+  getStringValue(): string { return this.grid.dataFrame.toCsv(); }
+
+  setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
+
+  get placeholdersBreadthValue(): PolyToolPlaceholdersBreadth {
+    return dfToPlaceholdersBreadth(this.grid.dataFrame);
+  }
+
+  private readonly gridHost: HTMLDivElement;
+  public readonly grid: DG.Grid;
+
+  private subs: Unsubscribable[] = [];
+
+  protected constructor(name: string | undefined, grid: DG.Grid, heightRowCount?: number) {
+    super();
+
+    if (name) this.captionLabel.innerText = name;
+
+    this.gridHost = ui.div([], {
+      classes: 'ui-input-editor',
+      style: {width: '100%', height: '100%', marginTop: '-8px', marginBottom: '8px', paddingBottom: '4px'},
+    });
+
+    this.grid = grid;
+    this.gridHost.append(this.grid.root);
+
+    if (heightRowCount != null) {
+      this.updateGridHeight(heightRowCount + 0.7);
+    } else {
+      this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6);
+      this.subs.push(this.grid.dataFrame.onRowsAdded
+        .subscribe(() => { this.updateGridHeight(this.grid.dataFrame.rowCount + 0.6); }));
+    }
+    this.grid.root.style.width = `100%`;
+
+    this.subs.push(this.grid.dataFrame.onDataChanged.subscribe(() => {
+      this.fireChanged();
+    }));
+
+    this.subs.push(ui.onSizeChanged(this.grid.root).subscribe(() => {
+      this.grid.columns.byIndex(3)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
+        this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - this.grid.columns.byIndex(2)!.width - 10;
+    }));
+
+    this.root.classList.add('ui-input-polytool-pos-grid');
+    this.root.append(this.gridHost);
+  }
+
+  detach(): void {
+    for (const sub of this.subs) sub.unsubscribe();
+  }
+
+  public static async create(
+    name?: string, options?: {}, heightRowCount?: number
+  ): Promise<PolyToolPlaceholdersBreadthInput> {
+    const df: DG.DataFrame = DG.DataFrame.fromColumns([
+      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'Start', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'End', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Monomers', 0),
+    ])!;
+    const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
+    grid.sort(['Start', 'End']);
+    return new PolyToolPlaceholdersBreadthInput(name, grid, heightRowCount);
+  }
+
+  // -- Update view --
+
+  private updateGridHeight(visibleRowCount: number): void {
+    const gridHeight = this.grid.colHeaderHeight + visibleRowCount * this.grid.props.rowHeight + 6 + 2;
+    this.grid.root.style.height = `${gridHeight}px`;
+  }
+
+  // -- Handle events --
+
+  private gridRootOnSizeChanged(): void {
+    this.grid.columns.byIndex(3)!.width = this.grid.root.clientWidth - this.grid.horzScroll.root.offsetWidth -
+      this.grid.columns.byIndex(0)!.width - this.grid.columns.byIndex(1)!.width - this.grid.columns.byIndex(2)!.width - 10;
+  }
+}
+
+export function dfToPlaceholdersBreadth(df: DG.DataFrame): PolyToolPlaceholdersBreadth {
+  const res: PolyToolPlaceholdersBreadth = [];
+  for (let rowI = 0; rowI < df.rowCount; rowI++) {
+    const startPos = parseInt(df.get('Start', rowI));
+    const endPos = parseInt(df.get('End', rowI));
+    if (!isNaN(startPos) && !isNaN(endPos)) {
+      const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
+      res.push({start: startPos, end: endPos, monomers: monomerSymbolList});
+    }
+  }
+  return res;
+}

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

@@ -13,23 +13,15 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 
   getInput(): HTMLElement { return this.gridHost; }
 
-  getValue(): DG.DataFrame {
-    return this.grid.dataFrame;
-  }
+  getValue(): DG.DataFrame { return this.grid.dataFrame; }
 
-  setValue(value: DG.DataFrame): void {
-    this.grid.dataFrame = value;
-  }
+  setValue(value: DG.DataFrame): void { this.grid.dataFrame = value; }
 
-  getStringValue(): string {
-    return this.grid.dataFrame.toCsv();
-  }
+  getStringValue(): string { return this.grid.dataFrame.toCsv(); }
 
-  setStringValue(str: string): void {
-    this.grid.dataFrame = DG.DataFrame.fromCsv(str);
-  }
+  setStringValue(str: string): void { this.grid.dataFrame = DG.DataFrame.fromCsv(str); }
 
-  get placeholdersValue() {
+  get placeholdersValue(): PolyToolPlaceholders {
     return dfToPlaceholders(this.grid.dataFrame);
   }
 
@@ -80,7 +72,9 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
   public static async create(
     name?: string, options?: {}, heightRowCount?: number
   ): Promise<PolyToolPlaceholdersInput> {
-    const df: DG.DataFrame = DG.DataFrame.fromObjects([{Position: '', Monomers: ''}])!;
+    const df: DG.DataFrame = DG.DataFrame.fromColumns([
+      DG.Column.fromType(DG.COLUMN_TYPE.INT, 'Position', 0),
+      DG.Column.fromType(DG.COLUMN_TYPE.STRING, 'Monomers', 0),])!;
     const grid = (await df.plot.fromType(DG.VIEWER.GRID, options)) as DG.Grid;
     grid.sort(['Position']);
     return new PolyToolPlaceholdersInput(name, grid, heightRowCount);
@@ -102,26 +96,25 @@ export class PolyToolPlaceholdersInput extends DG.JsInputBase<DG.DataFrame> {
 }
 
 export function getPlaceholdersFromText(src: string): PolyToolPlaceholders {
-  const res: PolyToolPlaceholders = {};
+  const res: PolyToolPlaceholders = [];
   for (const line of src.split('\n')) {
     const lineM = /^\s*(?<pos>\d+)\s*:\s*(?<monomers>.+)$/.exec(line);
     if (lineM) {
       const pos: number = parseInt(lineM.groups!['pos']) - 1;
-      const monomerList: string[] = lineM.groups!['monomers'].split(',').map(m => m.trim());
-      if (!(pos in res)) res[pos] = [];
-      res[pos].push(...monomerList);
+      const monomerList: string[] = lineM.groups!['monomers'].split(',').map((m) => m.trim());
+      res.push({position: pos, monomers: monomerList});
     }
   }
   return res;
 }
 
 export function dfToPlaceholders(df: DG.DataFrame): PolyToolPlaceholders {
-  const res: PolyToolPlaceholders = {};
+  const res: PolyToolPlaceholders = [];
   for (let rowI = 0; rowI < df.rowCount; rowI++) {
     const pos = parseInt(df.get('Position', rowI));
     if (!isNaN(pos)) {
       const monomerSymbolList = parseMonomerSymbolList(df.get('Monomers', rowI));
-      res[pos - 1] = monomerSymbolList;
+      res.push({position: pos, monomers: monomerSymbolList});
     }
   }
   return res;

package/src/polytool/types.ts

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

package/src/tests/polytool-enumerate-breadth-tests.ts

@@ -0,0 +1,118 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {before, after, category, expect, test, expectArray} from '@datagrok-libraries/utils/src/test';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {UserLibSettings} from '@datagrok-libraries/bio/src/monomer-works/types';
+import {
+  getUserLibSettings, setUserLibSettings, setUserLibSettingsForTests
+} from '@datagrok-libraries/bio/src/monomer-works/lib-settings';
+
+import {PolyToolEnumeratorParams, PolyToolEnumeratorTypes} from '../polytool/types';
+import {doPolyToolEnumerateHelm} from '../polytool/pt-enumeration-helm';
+
+import {_package} from '../package-test';
+
+category('PolyTool: Enumerate', () => {
+  let helmHelper: IHelmHelper;
+  let monomerLibHelper: IMonomerLibHelper;
+  let userLibSettings: UserLibSettings; //backup
+
+  before(async () => {
+    helmHelper = await getHelmHelper(); // initialize JSDraw2 and org
+
+    monomerLibHelper = await getMonomerLibHelper();
+    userLibSettings = await getUserLibSettings();
+    // Clear settings to test default
+    await setUserLibSettingsForTests();
+    await monomerLibHelper.awaitLoaded();
+    await monomerLibHelper.loadMonomerLib(true);
+  });
+
+  after(async () => {
+    await setUserLibSettings(userLibSettings);
+    await monomerLibHelper.loadMonomerLib(true);
+  });
+
+  const tests: {
+    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: { seq: string, name: string }[] }
+  } = {
+    'breadth1': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+      params: {
+        type: PolyToolEnumeratorTypes.Single,
+        placeholdersBreadth: [
+          {start: 2, end: 4, monomers: ['K']},
+        ],
+      },
+      tgt: [
+        {seq: 'PEPTIDE1{[Ac(1)].F.K.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-W3K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.K.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-G4K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5K'},
+      ],
+    },
+    'breadth1-with-original': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+      params: {
+        type: PolyToolEnumeratorTypes.Single,
+        placeholdersBreadth: [
+          {start: 2, end: 4, monomers: ['K']},
+        ],
+        keepOriginal: true,
+      },
+      tgt: [
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: ''},
+        {seq: 'PEPTIDE1{[Ac(1)].F.K.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-W3K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.K.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-G4K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5K'},
+      ],
+    },
+    'breadth2': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+      params: {
+        type: PolyToolEnumeratorTypes.Single,
+        placeholdersBreadth: [
+          {start: 2, end: 4, monomers: ['K', 'Y']},
+        ],
+      },
+      tgt: [
+        {seq: 'PEPTIDE1{[Ac(1)].F.K.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-W3K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.K.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-G4K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.Y.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-W3Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.Y.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-G4Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.Y.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5Y'},
+      ],
+    },
+    'breadth-double': {
+      src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
+      params: {
+        type: PolyToolEnumeratorTypes.Single,
+        placeholdersBreadth: [
+          {start: 2, end: 4, monomers: ['K']},
+          {start: 2, end: 4, monomers: ['Y']},
+        ],
+      },
+      tgt: [
+        {seq: "PEPTIDE1{[Ac(1)].F.Y.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-W3K-K3Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.K.Y.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-W3K-G4Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.K.G.Y.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-W3K-P5Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.Y.K.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-G4K-W3Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.W.Y.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-G4K-K4Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.W.K.Y.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-G4K-P5Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.Y.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-P5K-W3Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.W.Y.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-P5K-G4Y"},
+        {seq: "PEPTIDE1{[Ac(1)].F.W.G.Y.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0", name: "-P5K-K5Y"}
+      ]
+    }
+  };
+
+  for (const [testName, testData] of Object.entries(tests)) {
+    test(`${testName}`, async () => {
+      const res = doPolyToolEnumerateHelm(testData.src, '', testData.params);
+      expectArray(res, testData.tgt.map((r) => [r.seq, r.name]));
+    });
+  }
+});

package/src/tests/polytool-enumerate-tests.ts

@@ -27,6 +27,7 @@ category('PolyTool: Enumerate', () => {
     userLibSettings = await getUserLibSettings();
     // Clear settings to test default
     await setUserLibSettingsForTests();
+    await monomerLibHelper.awaitLoaded();
     await monomerLibHelper.loadMonomerLib(true);
   });
 
@@ -36,42 +37,42 @@ category('PolyTool: Enumerate', () => {
   });
 
   const tests: {
-    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: [string, string][] }
+    [testName: string]: { src: string, params: PolyToolEnumeratorParams, tgt: { seq: string, name: string }[] }
   } = {
     'single1': {
       src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
-        placeholders: {
-          [4]: ['K', 'P', 'F4COO'],
-          [6]: ['Y', 'T'],
-        },
+        placeholders: [
+          {position: 4, monomers: ['K', 'P', 'F4COO']},
+          {position: 6, monomers: ['Y', 'T']},
+        ],
       },
       tgt: [
-        ['PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5K'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5P'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5[F4COO]'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7Y'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7T'],
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5P'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5[F4COO]'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-[Tic]7T'},
       ]
     },
     'single-with-original': {
       src: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0',
       params: {
         type: PolyToolEnumeratorTypes.Single,
-        placeholders: {
-          [4]: ['K', 'P', 'F4COO'],
-          [6]: ['Y', 'T'],
-        },
+        placeholders: [
+          {position: 4, monomers: ['K', 'P', 'F4COO']},
+          {position: 6, monomers: ['Y', 'T']},
+        ],
         keepOriginal: true,
       },
       tgt: [
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', ''],
-        ['PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5K'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5P'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', '-P5[F4COO]'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7Y'],
-        ['PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', '-[Tic]7T'],
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: ''},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.K.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5K'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5P'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.[F4COO].L.[Tic].[C(1)].G.[NH2]}$$$$V2.0', name: '-P5[F4COO]'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].F.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-[Tic]7T'},
       ]
     },
     'matrix1': {
@@ -79,25 +80,25 @@ category('PolyTool: Enumerate', () => {
       params:
         {
           type: PolyToolEnumeratorTypes.Matrix,
-          placeholders: {
-            [1]: ['D', 'L'],
-            [4]: ['K', 'P', 'F4COO'],
-            [6]: ['Y', 'T'],
-          }
+          placeholders: [
+            {position: 1, monomers: ['D', 'L']},
+            {position: 4, monomers: ['K', 'P', 'F4COO']},
+            {position: 6, monomers: ['Y', 'T']},
+          ]
         },
       tgt: [
-        ["PEPTIDE1{[Ac(1)].D.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5K-[Tic]7Y"],
-        ["PEPTIDE1{[Ac(1)].D.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5K-[Tic]7T"],
-        ["PEPTIDE1{[Ac(1)].D.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5P-[Tic]7Y"],
-        ["PEPTIDE1{[Ac(1)].D.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5P-[Tic]7T"],
-        ["PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5[F4COO]-[Tic]7Y"],
-        ["PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2D-P5[F4COO]-[Tic]7T"],
-        ["PEPTIDE1{[Ac(1)].L.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5K-[Tic]7Y"],
-        ["PEPTIDE1{[Ac(1)].L.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5K-[Tic]7T"],
-        ["PEPTIDE1{[Ac(1)].L.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5P-[Tic]7Y"],
-        ["PEPTIDE1{[Ac(1)].L.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5P-[Tic]7T"],
-        ["PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5[F4COO]-[Tic]7Y"],
-        ["PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0", "-F2L-P5[F4COO]-[Tic]7T"],
+        {seq: 'PEPTIDE1{[Ac(1)].D.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2D-P5K-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].D.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2D-P5K-[Tic]7T'},
+        {seq: 'PEPTIDE1{[Ac(1)].D.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2D-P5P-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].D.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2D-P5P-[Tic]7T'},
+        {seq: 'PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2D-P5[F4COO]-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].D.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2D-P5[F4COO]-[Tic]7T'},
+        {seq: 'PEPTIDE1{[Ac(1)].L.W.G.K.L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2L-P5K-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].L.W.G.K.L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2L-P5K-[Tic]7T'},
+        {seq: 'PEPTIDE1{[Ac(1)].L.W.G.P.L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2L-P5P-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].L.W.G.P.L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2L-P5P-[Tic]7T'},
+        {seq: 'PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.Y.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2L-P5[F4COO]-[Tic]7Y'},
+        {seq: 'PEPTIDE1{[Ac(1)].L.W.G.[F4COO].L.T.[C(1)].G.[NH2]}$$$$V2.0', name: '-F2L-P5[F4COO]-[Tic]7T'},
       ],
     }
   };
@@ -105,7 +106,7 @@ category('PolyTool: Enumerate', () => {
   for (const [testName, testData] of Object.entries(tests)) {
     test(`${testName}`, async () => {
       const res = doPolyToolEnumerateHelm(testData.src, '', testData.params);
-      expectArray(res, testData.tgt);
+      expectArray(res, testData.tgt.map((r) => [r.seq, r.name]));
     });
   }
 });