@datagrok/sequence-translator 1.4.8 → 1.5.0

package/src/utils/cyclized.ts

@@ -13,11 +13,12 @@ import {CellRendererBackBase} from '@datagrok-libraries/bio/src/utils/cell-rende
 import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-monomer-placer';
 import {monomerToShort, StringListSeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
-import {getHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
+import {getHelmHelper, IHelmHelper} from '@datagrok-libraries/bio/src/helm/helm-helper';
 
-import {Chain} from '../polytool/pt-conversion';
+import {Chain} from '../polytool/conversion/pt-chain';
 
 import {_package} from '../package';
+import {CyclizedCellRendererBack} from './cell-renderer-cyclized';
 
 /* eslint-enable max-len */
 
@@ -25,14 +26,18 @@ export class CyclizedNotationProvider implements INotationProvider {
   private readonly separatorSplitter: SplitterFunc;
   public readonly splitter: SplitterFunc;
 
+  get defaultGapOriginal(): string { return ''; }
+
   constructor(
     public readonly separator: string,
-    protected readonly seqHelper: ISeqHelper
+    protected readonly helmHelper: IHelmHelper
   ) {
     this.separatorSplitter = getSplitterWithSeparator(this.separator);
     this.splitter = this._splitter.bind(this);
   }
 
+  setUnits(): void {}
+
   private _splitter(seq: string): ISeqSplitted {
     const baseSS: ISeqSplitted = this.separatorSplitter(seq);
     return new CyclizedSeqSplitted(
@@ -40,25 +45,17 @@ export class CyclizedNotationProvider implements INotationProvider {
       GapOriginals[NOTATION.SEPARATOR]);
   }
 
-  public async getHelm(seq: string, options?: any): Promise<string> {
-    const helmHelper = await getHelmHelper();
-    const seqChain = await Chain.parseNotation(seq, helmHelper);
+  public getHelm(seq: string, options?: any): string {
+    const seqChain = Chain.parseNotation(seq, this.helmHelper);
     const resPseudoHelm = seqChain.getNotationHelm();
     return resPseudoHelm;
   }
 
   public createCellRendererBack(gridCol: DG.GridColumn | null, tableCol: DG.Column<string>): CellRendererBackBase<string> {
     let maxLengthOfMonomer: number = 4; // (_package.bioProperties ? _package.bioProperties.maxMonomerLength : 4) ?? 50;
-    const back = new MonomerPlacer(gridCol, tableCol, _package.logger, maxLengthOfMonomer,
-      () => {
-        const sh = this.seqHelper.getSeqHandler(tableCol);
-        return {
-          seqHandler: sh,
-          monomerCharWidth: 7,
-          separatorWidth: 11,
-          monomerToShort: monomerToShort,
-        };
-      });
+    const back = new CyclizedCellRendererBack(gridCol, tableCol,
+      maxLengthOfMonomer, this.helmHelper.seqHelper);
+
     back.init().then(() => {});
     return back;
   }
@@ -66,23 +63,23 @@ export class CyclizedNotationProvider implements INotationProvider {
 
 /** Gets canonical monomers for original ones with cyclization marks */
 export class CyclizedSeqSplitted extends StringListSeqSplitted {
-  private readonly seqCList: (string | null)[];
-
   override getCanonical(posIdx: number): string {
     if (this.isGap(posIdx)) return GAP_SYMBOL;
 
-    let cmRes: string | null = this.seqCList[posIdx];
-    if (cmRes === null) {
-      const om = this.getOriginal(posIdx);
-      cmRes = om;
-      if (om[om.length - 1] === ')')
-        cmRes = this.seqCList[posIdx] = om.replace(/\(\d+\)$/, '');
-    }
+    const om = this.getOriginal(posIdx);
+    let cmRes = om;
+    if (om.startsWith('{'))
+      cmRes = om.slice(1);
+    else if (om.endsWith('}'))
+      cmRes = om.slice(0, -1);
+    else if (om.startsWith('('))
+      cmRes = om.replace(/^\(.\d+\)/, '');
+    else if (om.endsWith(')'))
+      cmRes = om.replace(/\(\d+\)$/, '');
     return cmRes;
   }
 
   constructor(seqOList: SeqSplittedBase, gapOriginalMonomer: string) {
     super(seqOList, gapOriginalMonomer);
-    this.seqCList = new Array<string | null>(this.length).fill(null);
   }
 }

package/src/polytool/pt-rules.ts

@@ -1,93 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import * as grok from 'datagrok-api/grok';
-import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
-
-export const RULES_PATH = 'System:AppData/SequenceTranslator/polytool-rules/';
-export const RULES_STORAGE_NAME = 'Polytool';
-export const RULES_TYPE_LINK = 'link';
-export const RULES_TYPE_REACTION = 'reaction';
-export const RULES_TYPE_HOMODIMER = 'fragmentDuplication';
-export const RULES_TYPE_HETERODIMER = 'differentFragments';
-
-export class RuleInputs extends ActiveFiles {
-  constructor(
-    path: string, userStorageName: string, ext: string,
-    options?: { onValueChanged: (value: string[]) => void }
-  ) {
-    super(path, userStorageName, ext, options);
-  }
-}
-
-export type Rules = {
-  homodimerCode: string | null,
-  heterodimerCode: string | null,
-  linkRules: RuleLink[],
-  reactionRules: RuleReaction[]
-}
-
-export type RuleLink = {
-  code: number,
-  firstMonomer: string,
-  secondMonomer: string,
-  firstSubstitution: string,
-  secondSubstitution: string,
-  firstLinkingGroup: number,
-  secondLinkingGroup: number
-}
-
-export type RuleReaction = {
-  code: number,
-  firstMonomer: string,
-  secondMonomer: string,
-  reaction: string,
-  name: string
-}
-
-export async function getRules(ruleFiles: string[]): Promise<Rules> {
-  const fileSource = new DG.FileSource(RULES_PATH);
-  const linkRules: RuleLink[] = [];
-  const reactionRules: RuleReaction[] = [];
-  const rules: Rules = {homodimerCode: null, heterodimerCode: null, linkRules: linkRules, reactionRules: reactionRules};
-
-  for (let i = 0; i < ruleFiles.length; i++) {
-    const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
-    const ruleSingle = JSON.parse(rulesRaw);
-    for (let j = 0; j < ruleSingle.length; j++) {
-      if (ruleSingle[j].type !== undefined && ruleSingle[j].code !== undefined) {
-        switch (ruleSingle[j].type) {
-        case RULES_TYPE_LINK: {
-          const rule = ruleSingle[j].monomericSubstitution;
-          rule['code'] = ruleSingle[j].code;
-          linkRules.push(rule);
-          break;
-        }
-        case RULES_TYPE_REACTION: {
-          const rule = ruleSingle[j].monomericSubstitution;
-          rule['code'] = ruleSingle[j].code;
-          reactionRules.push(rule);
-          break;
-        }
-        case RULES_TYPE_HOMODIMER: {
-          if (rules.homodimerCode)
-            grok.shell.warning(`PolyTool: homodimer code is duplicated in rules.`);
-          rules.homodimerCode = ruleSingle[j].code;
-          break;
-        }
-        case RULES_TYPE_HETERODIMER: {
-          if (rules.heterodimerCode)
-            grok.shell.warning(`PolyTool: heterodimer code is duplicated in rules.`);
-          rules.heterodimerCode = ruleSingle[j].code;
-          break;
-        }
-        default:
-          grok.shell.warning(`PolyTool: Unexpected type - '${ruleSingle[j]}'.`);
-          break;
-        }
-      } else {
-        grok.shell.warning('Polytool: rules contain invalid rule');
-      }
-    }
-  }
-
-  return rules;
-}