@datagrok/sequence-translator 1.2.7 → 1.3.0

package/src/apps/pattern/model/event-bus.ts

@@ -0,0 +1,487 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as DG from 'datagrok-api/dg';
+import * as rxjs from 'rxjs';
+import {debounceTime, throttleTime, map, skip, switchMap} from 'rxjs/operators';
+
+import {
+  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R, STRAND, STRANDS, TERMINI, TERMINUS
+} from './const';
+import {DataManager} from './data-manager';
+import {
+  NucleotideSequences, PatternConfigRecord, PatternConfiguration,
+  PhosphorothioateLinkageFlags, StrandTerminusModifications, StrandType
+} from './types';
+import {
+  getMostFrequentNucleotide, getUniqueNucleotides, getUniqueNucleotidesWithNumericLabels, StrandEditingUtils
+} from './utils';
+
+import _ from 'lodash';
+
+/** Manager of all events in the application, *the* central state manager.
+ * Use for communication between app's components to avoid tight coupling. */
+export class EventBus {
+  private _patternAuthorSelection$: rxjs.BehaviorSubject<string>;
+
+  private _patternName$: rxjs.BehaviorSubject<string>;
+
+  private _isAntisenseStrandActive$: rxjs.BehaviorSubject<boolean>;
+
+  private _nucleotideSequences$: rxjs.BehaviorSubject<NucleotideSequences>;
+  private _phosphorothioateLinkageFlags: rxjs.BehaviorSubject<PhosphorothioateLinkageFlags>;
+  private _terminalModifications: rxjs.BehaviorSubject<StrandTerminusModifications>;
+  private _comment$: rxjs.BehaviorSubject<string>;
+  private _modificationsWithNumericLabels$: rxjs.BehaviorSubject<string[]>;
+  private _sequenceBase$: rxjs.BehaviorSubject<string>;
+
+  private _patternListUpdated$ = new rxjs.Subject<void>();
+
+  private _patternLoadRequested$ = new rxjs.Subject<string>();
+  private _patternLoaded$ = new rxjs.Subject<string>();
+  private _uniqueNucleotides$ = new rxjs.BehaviorSubject<string[]>([]);
+
+  private _patternDeletionRequested$ = new rxjs.Subject<string>();
+  private _tableSelection$ = new rxjs.BehaviorSubject<DG.DataFrame | null>(null);
+
+  private _svgSaveRequested$ = new rxjs.Subject<void>();
+  private _loadPatternInNewTabRequested$ = new rxjs.Subject<string>();
+  private _urlStateUpdated$ = new rxjs.Subject<string>();
+
+  private _patternHasUnsavedChanges$ = new rxjs.BehaviorSubject<boolean>(false);
+  private _lastLoadedPatternConfig: rxjs.BehaviorSubject<PatternConfiguration >;
+
+  private _selectedStrandColumn = new rxjs.BehaviorSubject<{[strand: string]: string | null} | null>(null);
+  private _selectedIdColumn = new rxjs.BehaviorSubject<string | null>(null);
+
+
+  constructor(
+    private dataManager: DataManager,
+    initialPaternConfigRecord: PatternConfigRecord
+  ) {
+    this.initializeAuthorSelection(initialPaternConfigRecord);
+    this.initializePatternState(initialPaternConfigRecord);
+    this._lastLoadedPatternConfig = new rxjs.BehaviorSubject(
+      _.cloneDeep(this.getPatternConfig())
+    );
+    this.setupSubscriptions();
+  }
+
+  private setupSubscriptions(): void {
+    this._nucleotideSequences$.subscribe(() => {
+      this.updateUniqueNucleotides();
+      this.updateSequenceBase();
+    });
+
+    this._isAntisenseStrandActive$.subscribe((isActive) => {
+      if (isActive)
+        return;
+
+      TERMINI.forEach((terminus) => {
+        this.updateTerminusModification(STRAND.ANTISENSE, terminus, '');
+      });
+    });
+
+    this.patternStateChanged$.pipe(
+      debounceTime(20)
+    ).subscribe(() => {
+      const lastLoadedConfig = this._lastLoadedPatternConfig.getValue();
+      const currentConfig = this.getPatternConfig();
+      const hasUnsavedChanges = !_.isEqual(currentConfig, lastLoadedConfig);
+      this._patternHasUnsavedChanges$.next(hasUnsavedChanges);
+    });
+  }
+
+  private updateUniqueNucleotides(): void {
+    const sequences = this._nucleotideSequences$.getValue();
+    const uniqueNucleotides = getUniqueNucleotides(sequences);
+    this._uniqueNucleotides$.next(uniqueNucleotides);
+  }
+
+  private updateSequenceBase(): void {
+    const nucleotideSequences = this._nucleotideSequences$.getValue();
+    const mostFrequentNucleotide = getMostFrequentNucleotide(nucleotideSequences);
+    this._sequenceBase$.next(mostFrequentNucleotide);
+  }
+
+  get nucleotideSequencesChanged$(): rxjs.Observable<NucleotideSequences> {
+    return this._nucleotideSequences$.asObservable();
+  }
+
+  private initializeAuthorSelection(
+    initialConfigRecord: PatternConfigRecord
+  ) {
+    const patternAuthorId = initialConfigRecord[R.AUTHOR_ID];
+    if (this.dataManager.isCurrentUserId(patternAuthorId))
+      this._patternAuthorSelection$ = new rxjs.BehaviorSubject(this.dataManager.getCurrentUserAuthorshipCategory());
+    else
+      this._patternAuthorSelection$ = new rxjs.BehaviorSubject(this.dataManager.getOtherUsersAuthorshipCategory());
+  }
+
+  private initializePatternState(
+    initialConfigRecord: PatternConfigRecord
+  ) {
+    const initialPattern = initialConfigRecord[R.PATTERN_CONFIG];
+    this._patternName$ = new rxjs.BehaviorSubject(initialPattern[L.PATTERN_NAME]);
+    this._isAntisenseStrandActive$ = new rxjs.BehaviorSubject(
+      initialPattern[G.IS_ANTISENSE_STRAND_INCLUDED]
+    );
+    this._nucleotideSequences$ = new rxjs.BehaviorSubject(
+      initialPattern[G.NUCLEOTIDE_SEQUENCES]
+    );
+    this._phosphorothioateLinkageFlags = new rxjs.BehaviorSubject(
+      initialPattern[G.PHOSPHOROTHIOATE_LINKAGE_FLAGS]
+    );
+    this._terminalModifications = new rxjs.BehaviorSubject(
+      initialPattern[G.STRAND_TERMINUS_MODIFICATIONS]
+    );
+    this._comment$ = new rxjs.BehaviorSubject(
+      initialPattern[L.PATTERN_COMMENT]
+    );
+    this._modificationsWithNumericLabels$ = new rxjs.BehaviorSubject(
+      initialPattern[L.NUCLEOTIDES_WITH_NUMERIC_LABELS]
+    );
+    this._sequenceBase$ = new rxjs.BehaviorSubject(
+      getMostFrequentNucleotide(initialPattern[G.NUCLEOTIDE_SEQUENCES])
+    );
+  }
+
+  getPatternName(): string {
+    return this._patternName$.getValue();
+  }
+
+  updatePatternName(patternName: string) {
+    this._patternName$.next(patternName);
+  }
+
+  get antisenseStrandToggled$(): rxjs.Observable<boolean> {
+    return this._isAntisenseStrandActive$.asObservable();
+  }
+
+  isAntisenseStrandActive(): boolean {
+    return this._isAntisenseStrandActive$.getValue();
+  }
+
+  toggleAntisenseStrand(isActive: boolean) {
+    if (!isActive)
+      this.updateStrandLength(STRAND.ANTISENSE, 0);
+    else
+      this.updateStrandLength(STRAND.ANTISENSE, this.getNucleotideSequences()[STRAND.SENSE].length);
+
+    this._isAntisenseStrandActive$.next(isActive);
+  }
+
+  getNucleotideSequences(): NucleotideSequences {
+    return this._nucleotideSequences$.getValue();
+  }
+
+  updateNucleotideSequences(nucleotideSequences: NucleotideSequences) {
+    this._nucleotideSequences$.next(nucleotideSequences);
+  }
+
+  updateStrandLength(strand: StrandType, newStrandLength: number): void {
+    const originalNucleotides = this.getNucleotideSequences()[strand];
+    if (originalNucleotides.length === newStrandLength) return;
+
+    const originalPTOFlags = this.getPhosphorothioateLinkageFlags()[strand];
+
+    if (newStrandLength === 0) {
+      this.setNewStrandData([], [], strand);
+      return;
+    }
+
+    if (originalNucleotides.length > newStrandLength) {
+      const {nucleotides, ptoFlags} = StrandEditingUtils.getTruncatedStrandData(
+        originalNucleotides, originalPTOFlags, newStrandLength
+      );
+      this.setNewStrandData(nucleotides, ptoFlags, strand);
+      return;
+    }
+
+    const sequenceBase = this.getSequenceBase();
+    const {nucleotides, ptoFlags} = StrandEditingUtils.getExtendedStrandData(
+      originalNucleotides, originalPTOFlags, newStrandLength, sequenceBase
+    );
+    this.setNewStrandData(nucleotides, ptoFlags, strand);
+  }
+
+  private setNewStrandData(
+    newNucleotides: string[],
+    newPTOFlags: boolean[],
+    strand: StrandType
+  ): void {
+    this.updateNucleotideSequences({
+      ...this.getNucleotideSequences(),
+      [strand]: newNucleotides
+    });
+    this.updatePhosphorothioateLinkageFlags({
+      ...this.getPhosphorothioateLinkageFlags(),
+      [strand]: newPTOFlags
+    });
+  }
+
+  getPhosphorothioateLinkageFlags(): PhosphorothioateLinkageFlags {
+    return this._phosphorothioateLinkageFlags.getValue();
+  }
+
+  updatePhosphorothioateLinkageFlags(phosphorothioateLinkageFlags: PhosphorothioateLinkageFlags) {
+    this._phosphorothioateLinkageFlags.next(phosphorothioateLinkageFlags);
+  }
+
+  get phosphorothioateLingeFlagsChanged$(): rxjs.Observable<PhosphorothioateLinkageFlags> {
+    return this._phosphorothioateLinkageFlags.asObservable();
+  }
+
+  getTerminalModifications(): StrandTerminusModifications {
+    return this._terminalModifications.getValue();
+  }
+
+  updateTerminalModifications(terminalModifications: StrandTerminusModifications) {
+    this._terminalModifications.next(terminalModifications);
+  }
+
+  updateTerminusModification(strand: StrandType, terminus: TERMINUS, modification: string) {
+    const terminalModifications = this.getTerminalModifications();
+    terminalModifications[strand][terminus] = modification;
+    this.updateTerminalModifications(terminalModifications);
+  }
+
+  terminalModificationsUpdated$(): rxjs.Observable<StrandTerminusModifications> {
+    return this._terminalModifications.asObservable();
+  }
+
+  getComment(): string {
+    return this._comment$.getValue();
+  }
+
+  updateComment(comment: string) {
+    this._comment$.next(comment);
+  }
+
+  getModificationsWithNumericLabels(): string[] {
+    return this._modificationsWithNumericLabels$.getValue();
+  }
+
+  updateModificationsWithNumericLabels(modificationsWithNumericLabels: string[]) {
+    const newValue = getUniqueNucleotidesWithNumericLabels(modificationsWithNumericLabels);
+    this._modificationsWithNumericLabels$.next(newValue);
+  }
+
+  get patternLoadRequested$(): rxjs.Observable<string> {
+    return this._patternLoadRequested$.asObservable();
+  }
+
+  requestPatternLoad(patternHash: string) {
+    this._patternLoadRequested$.next(patternHash);
+  }
+
+  get patternListUpdated$(): rxjs.Observable<void> {
+    return this._patternListUpdated$.asObservable();
+  }
+
+  updatePatternList() {
+    this._patternListUpdated$.next();
+  }
+
+  get tableSelectionChanged$(): rxjs.Observable<DG.DataFrame | null> {
+    return this._tableSelection$.asObservable();
+  }
+
+  selectTable(table: DG.DataFrame | null) {
+    this._tableSelection$.next(table);
+  }
+
+  getTableSelection(): DG.DataFrame | null {
+    return this._tableSelection$.getValue();
+  }
+
+  requestPatternDeletion(patternName: string) {
+    this._patternDeletionRequested$.next(patternName);
+  }
+
+  get patternDeletionRequested$(): rxjs.Observable<string> {
+    return this._patternDeletionRequested$.asObservable();
+  }
+
+  replaceSequenceBase(newNucleobase: string) {
+    const oldNucleotideSequences = this._nucleotideSequences$.getValue();
+    const newNucleotideSequences = {} as NucleotideSequences;
+    STRANDS.forEach((strand) => {
+      newNucleotideSequences[strand] = oldNucleotideSequences[strand].map(() => newNucleobase);
+    });
+    this._nucleotideSequences$.next(newNucleotideSequences);
+
+    const labelledNucleotides = this._modificationsWithNumericLabels$.getValue();
+    if (!labelledNucleotides.includes(newNucleobase))
+      this.updateModificationsWithNumericLabels(labelledNucleotides.concat(newNucleobase));
+  }
+
+  get patternStateChanged$(): rxjs.Observable<void> {
+    const observable = rxjs.merge(
+      this._patternName$.pipe(debounceTime(300), map(() => {})),
+      this._isAntisenseStrandActive$,
+      this._nucleotideSequences$,
+      this._phosphorothioateLinkageFlags,
+      this._terminalModifications,
+      this._comment$.pipe(debounceTime(300)),
+      this._modificationsWithNumericLabels$
+    ) as rxjs.Observable<void>;
+
+    return observable;
+  }
+
+  getSequenceBase(): string {
+    return this._sequenceBase$.getValue();
+  }
+
+  uniqueNucleotidesChanged$(): rxjs.Observable<string[]> {
+    // WARNING: switchMap is necessary to preserve order of events
+    const observable = this.patternStateChanged$.pipe(
+      switchMap(() => this._uniqueNucleotides$)
+    );
+
+    return observable;
+  }
+
+  getUniqueNucleotides(): string[] {
+    return this._uniqueNucleotides$.getValue();
+  }
+
+  get svgSaveRequested$(): rxjs.Observable<void> {
+    return this._svgSaveRequested$.asObservable();
+  }
+
+  requestSvgSave() {
+    this._svgSaveRequested$.next();
+  }
+
+  setAllPTOLinkages(value: boolean) {
+    const flags = this.getPhosphorothioateLinkageFlags();
+    STRANDS.forEach((strand) => {
+      flags[strand] = flags[strand].map(() => value);
+    });
+    this.updatePhosphorothioateLinkageFlags(flags);
+  }
+
+  setPatternConfig(patternConfiguration: PatternConfiguration) {
+    this._patternName$.next(patternConfiguration[L.PATTERN_NAME]);
+    this._isAntisenseStrandActive$.next(patternConfiguration[G.IS_ANTISENSE_STRAND_INCLUDED]);
+    this._nucleotideSequences$.next(patternConfiguration[G.NUCLEOTIDE_SEQUENCES]);
+    this._phosphorothioateLinkageFlags.next(patternConfiguration[G.PHOSPHOROTHIOATE_LINKAGE_FLAGS]);
+    this._terminalModifications.next(patternConfiguration[G.STRAND_TERMINUS_MODIFICATIONS]);
+    this._comment$.next(patternConfiguration[L.PATTERN_COMMENT]);
+    this._modificationsWithNumericLabels$.next(patternConfiguration[L.NUCLEOTIDES_WITH_NUMERIC_LABELS]);
+  }
+
+  setLastLoadedPatternConfig(patternConfiguration: PatternConfiguration) {
+    this._lastLoadedPatternConfig.next(
+      _.cloneDeep(patternConfiguration)
+    );
+  }
+
+  getPatternConfig(): PatternConfiguration {
+    return {
+      [L.PATTERN_NAME]: this.getPatternName(),
+      [G.IS_ANTISENSE_STRAND_INCLUDED]: this.isAntisenseStrandActive(),
+      [G.NUCLEOTIDE_SEQUENCES]: this.getNucleotideSequences(),
+      [G.PHOSPHOROTHIOATE_LINKAGE_FLAGS]: this.getPhosphorothioateLinkageFlags(),
+      [G.STRAND_TERMINUS_MODIFICATIONS]: this.getTerminalModifications(),
+      [L.PATTERN_COMMENT]: this.getComment(),
+      [L.NUCLEOTIDES_WITH_NUMERIC_LABELS]: this.getModificationsWithNumericLabels(),
+    };
+  }
+
+  setPhosphorothioateLinkageFlag(strand: StrandType, index: number, newValue: boolean) {
+    const flags = this.getPhosphorothioateLinkageFlags();
+    flags[strand][index] = newValue;
+    this.updatePhosphorothioateLinkageFlags(flags);
+  }
+
+  setNucleotide(strand: StrandType, index: number, value: string) {
+    const sequences = this.getNucleotideSequences();
+    sequences[strand][index] = value;
+    const labelledModifications = this.getModificationsWithNumericLabels();
+    this.updateModificationsWithNumericLabels(labelledModifications.concat(value));
+    this.updateNucleotideSequences(sequences);
+  }
+
+  get strandsUpdated$(): rxjs.Observable<void> {
+    return rxjs.merge(
+      this._isAntisenseStrandActive$.asObservable().pipe(map(() => {})),
+      this._nucleotideSequences$.asObservable().pipe(map(() => {})),
+      this._patternLoaded$.asObservable().pipe(map(() => {}))
+    ).pipe(
+      debounceTime(10)
+    ) as rxjs.Observable<void>;
+  }
+
+  get strandsLinkagesAndTerminalsUpdated$(): rxjs.Observable<void> {
+    return rxjs.merge(
+      this.strandsUpdated$,
+      this._phosphorothioateLinkageFlags.asObservable().pipe(map(() => {})),
+      this._terminalModifications.asObservable().pipe(map(() => {}))
+    );
+  }
+
+  updateControlsUponPatternLoaded(patternHash: string) {
+    this._patternLoaded$.next(patternHash);
+  }
+
+  get patternLoaded$(): rxjs.Observable<string> {
+    return this._patternLoaded$.asObservable();
+  }
+
+  get userSelection$(): rxjs.Observable<string> {
+    return this._patternAuthorSelection$.asObservable().pipe(skip(1));
+  }
+
+  selectAuthor(username: string) {
+    this._patternAuthorSelection$.next(username);
+  }
+
+  getSelectedAuthor(): string {
+    return this._patternAuthorSelection$.getValue();
+  }
+
+  get loadPatternInNewTabRequested$(): rxjs.Observable<string> {
+    return this._loadPatternInNewTabRequested$.asObservable();
+  }
+
+  requestLoadPatternInNewTab(patternHash: string) {
+    this._loadPatternInNewTabRequested$.next(patternHash);
+  }
+
+  updateUrlState(patternHash: string) {
+    this._urlStateUpdated$.next(patternHash);
+  }
+
+  get urlStateUpdated$(): rxjs.Observable<string> {
+    return this._urlStateUpdated$.asObservable();
+  }
+
+  get patternHasUnsavedChanges$(): rxjs.Observable<boolean> {
+    return this._patternHasUnsavedChanges$.asObservable();
+  }
+
+  selectStrandColumn(strand: StrandType, colName: string | null) {
+    this._selectedStrandColumn.next({...this._selectedStrandColumn.getValue(), [strand]: colName});
+  }
+
+  getSelectedStrandColumn(strand: StrandType): string | null {
+    const value = this._selectedStrandColumn.getValue();
+    return value ? value[strand] : null;
+  }
+
+  selectIdColumn(colName: string) {
+    this._selectedIdColumn.next(colName);
+  }
+
+  getSelectedIdColumn(): string | null {
+    return this._selectedIdColumn.getValue();
+  }
+
+  get updateSvgContainer$(): rxjs.Observable<void> {
+    return this.patternStateChanged$.pipe(
+      debounceTime(100)
+    );
+  }
+}
+

package/src/apps/pattern/model/router.ts

@@ -0,0 +1,46 @@
+import {EventBus} from '../model/event-bus';
+
+const PATTERN_KEY = 'pattern';
+
+export class URLRouter {
+  private urlSearchParams: URLSearchParams;
+  constructor() {
+    this.urlSearchParams = new URLSearchParams(window.location.search);
+  }
+
+  subscribeToObservables(eventBus: EventBus): void {
+    eventBus.urlStateUpdated$.subscribe((hash) => this.setPatternURL(hash));
+    eventBus.loadPatternInNewTabRequested$.subscribe((hash) => {
+      const url = `${window.location.origin}${window.location.pathname}?${PATTERN_KEY}=${hash}`;
+      window.open(url, '_blank');
+    });
+
+    window.addEventListener('popstate', () => {
+      this.urlSearchParams = new URLSearchParams(window.location.search);
+      const patternHash = this.getPatternHash();
+      if (patternHash === null)
+        return;
+
+      eventBus.requestPatternLoad(patternHash);
+    });
+  }
+
+  getPatternHash(): string | null {
+    return this.urlSearchParams.get(PATTERN_KEY);
+  }
+
+  private setPatternURL(patternHash: string): void {
+    if (patternHash === null || patternHash === '') {
+      this.clearPatternURL();
+      return;
+    }
+
+    this.urlSearchParams.set(PATTERN_KEY, patternHash);
+    window.history.pushState({}, '', `${window.location.pathname}?${this.urlSearchParams}`);
+  }
+
+  clearPatternURL(): void {
+    this.urlSearchParams.delete(PATTERN_KEY);
+    window.history.pushState({}, '', `${window.location.pathname}`);
+  }
+}

package/src/apps/pattern/model/subscription-manager.ts

@@ -0,0 +1,21 @@
+import * as DG from 'datagrok-api/dg';
+import {Subscription} from 'rxjs';
+
+export class SubscriptionManager {
+  private rxjsSubscriptions = [] as Subscription[];
+  private dgSubscriptions = [] as DG.StreamSubscription[];
+
+  add(subscription: Subscription | DG.StreamSubscription) {
+    if (subscription instanceof Subscription)
+      this.rxjsSubscriptions.push(subscription);
+    else
+      this.dgSubscriptions.push(subscription);
+  }
+
+  unsubscribeAll() {
+    for (const subs of [this.rxjsSubscriptions, this.dgSubscriptions]) {
+      subs.forEach((sub) => sub.unsubscribe());
+      subs.length = 0;
+    }
+  }
+}

package/src/apps/pattern/model/translator.ts

@@ -0,0 +1,94 @@
+import * as grok from 'datagrok-api/grok';
+import {STRAND, STRANDS, TERMINI, TERMINUS} from './const';
+import {PATTERN_APP_DATA} from '../../common/model/data-loader/json-loader';
+import {EventBus} from './event-bus';
+
+export function bulkTranslate(eventBus: EventBus): void {
+  const df = eventBus.getTableSelection();
+  if (!df) {
+    grok.shell.warning('Please select a table');
+    return;
+  }
+  const strandColNames = STRANDS.filter(
+    (strand) => !(strand === STRAND.ANTISENSE && !eventBus.isAntisenseStrandActive())
+  ).map((strand) => eventBus.getSelectedStrandColumn(strand))
+    .filter((colName) => colName) as string[];
+
+  if (strandColNames.length === 0) {
+    grok.shell.warning('Please column for sense strand');
+    return;
+  }
+
+  const idColumnName = eventBus.getSelectedIdColumn();
+  if (!idColumnName) throw new Error('No ID column selected');
+
+  const idColumn = df.getCol(idColumnName);
+
+  const strandCols = strandColNames.map((colName) => df.getCol(colName));
+}
+
+export function applyPatternToRawSequence(
+  rawNucleotideSequence: string,
+  modifications: string[],
+  ptoFlags: boolean[],
+  terminalModifications: Record<TERMINUS, string>
+): string {
+  const rawNucleotides = rawNucleotideSequence.split('');
+
+  const modifiedNucleotides = rawNucleotides.map((nucleotide, i) => {
+    const modifiedNucleotide = getModifiedNucleotide(
+      nucleotide,
+      modifications[i]
+
+    );
+    return modifiedNucleotide;
+  });
+
+  const modificationsWithPTOLinkages = getModificationsWithPTOLinkages(
+    modifiedNucleotides, ptoFlags, terminalModifications
+  );
+
+  return modificationsWithPTOLinkages.join('');
+}
+
+function getModifiedNucleotide(nucleotide: string, modification: string): string {
+  const format = Object.keys(PATTERN_APP_DATA)[0];
+  const substitution = PATTERN_APP_DATA[format][modification].substitution;
+  return nucleotide.replace(/([AGCTU])/, substitution);
+}
+
+function getPhosphorothioateLinkageSymbol(): string {
+  return 'ps';
+}
+
+function getModificationsWithPTOLinkages(
+  modifiedNucleotides: string[],
+  ptoFlags: boolean[],
+  terminalModifications: Record<TERMINUS, string>
+): string[] {
+  const modificationsWithPTOLinkages = new Array<string>(
+    modifiedNucleotides.length + ptoFlags.filter((flag) => flag).length + TERMINI.length
+  );
+
+  const ptoLinkage = getPhosphorothioateLinkageSymbol();
+
+  modificationsWithPTOLinkages[0] = terminalModifications[TERMINUS.FIVE_PRIME];
+  modificationsWithPTOLinkages[modificationsWithPTOLinkages.length - 1] = terminalModifications[TERMINUS.THREE_PRIME];
+
+  let idxShift = 1;
+
+  if (ptoFlags[0]) {
+    modificationsWithPTOLinkages[idxShift] = ptoLinkage;
+    idxShift++;
+  }
+
+  modifiedNucleotides.forEach((nucleotide, i) => {
+    modificationsWithPTOLinkages[i + idxShift] = nucleotide;
+    if (ptoFlags[i + 1]) {
+      modificationsWithPTOLinkages[i + idxShift + 1] = ptoLinkage;
+      idxShift++;
+    }
+  });
+
+  return modificationsWithPTOLinkages;
+}

package/src/apps/pattern/model/types.ts

@@ -0,0 +1,52 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {
+  TERMINI, STRANDS,
+  GRAPH_SETTINGS_KEYS as G, LEGEND_SETTINGS_KEYS as L, PATTERN_RECORD_KEYS as R
+} from './const';
+
+export type StrandType = typeof STRANDS[number];
+export type TerminalType = typeof TERMINI[number];
+
+export type NucleotideSequences = Record<StrandType, string[]>;
+export type PhosphorothioateLinkageFlags = Record<StrandType, boolean[]>;
+export type StrandTerminusModifications = Record<StrandType, Record<TerminalType, string>>;
+
+export type PatternGraphSettings = {
+  [G.IS_ANTISENSE_STRAND_INCLUDED]: boolean,
+  [G.NUCLEOTIDE_SEQUENCES]: NucleotideSequences,
+  [G.PHOSPHOROTHIOATE_LINKAGE_FLAGS]: PhosphorothioateLinkageFlags,
+  [G.STRAND_TERMINUS_MODIFICATIONS]: StrandTerminusModifications,
+}
+
+export type PatternLegendSettings = {
+  [L.PATTERN_NAME]: string,
+  [L.PATTERN_COMMENT]: string,
+  [L.NUCLEOTIDES_WITH_NUMERIC_LABELS]: string[],
+}
+
+export type PatternConfiguration = PatternGraphSettings & PatternLegendSettings;
+
+export type PatternConfigRecord = {
+  [R.PATTERN_CONFIG]: PatternConfiguration,
+  [R.AUTHOR_ID]: string,
+}
+
+export class PatternNameExistsError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PatternNameExistsError';
+  }
+}
+
+export class PatternExistsError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PatternExistsError';
+  }
+}
+
+export type RawPatternRecords = {[patternName: string]: string};