@datagrok/sequence-translator 1.2.6 → 1.2.9

package/src/polytool/transformation.ts

@@ -0,0 +1,326 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {SeqHandler} from '@datagrok-libraries/bio/src/utils/seq-handler';
+import {ALIGNMENT, ALPHABET} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+//import {getMolColumnFromHelm} from '../helm-to-molfile/utils';
+
+export const RULES_PATH = 'System:AppData/Bio/polytool-rules/';
+export const RULES_STORAGE_NAME = 'Polytool';
+
+const enum HELM_WRAPPER {
+  LEFT = 'PEPTIDE1{',
+  RIGHT = '}$$$$',
+}
+
+type ConnectionData = {
+  allPos1: number[],
+  allPos2: number[],
+  allAttaches1: number[],
+  allAttaches2: number[],
+}
+
+type Rule = {
+  code: number,
+  firstMonomer: string,
+  secondMonomer: string,
+  firstModification: string,
+  secondModification: string,
+  firstR: number,
+  secondR: number
+}
+
+function addCommonTags(col: DG.Column): void {
+  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.setTag('aligned', ALIGNMENT.SEQ);
+  col.setTag('alphabet', ALPHABET.PT);
+}
+
+class TransformationCommon {
+  helmColumn: DG.Column;
+
+  constructor(helmColumn: DG.Column<string>) {
+    this.helmColumn = helmColumn;
+  }
+
+  protected getLinkedPositions(monomers: string[], rules: Rule[]): [number, number][] {
+    const monomersNames = monomers.map((m) => { return m.replace('[', '').replace(']', ''); });
+    const result: [number, number][] = new Array<[number, number]>(rules.length);
+
+    for (let i = 0; i < rules.length; i++) {
+      let firstFound = false;
+      let secondFound = false;
+      let firstIsFirst = false;
+      let firstEntryIndex = -1;
+      let secondEntryIndex = -1;
+      const add = `(${rules[i].code})`;
+      for (let j = 0; j < monomersNames.length; j++) {
+        if (monomersNames[j].includes(add)) {
+          if (firstFound) {
+            if (firstIsFirst && monomersNames[j] == rules[i].secondMonomer + add) {
+              secondFound = true;
+              secondEntryIndex = j;
+              break;
+            } else if (!firstIsFirst && monomersNames[j] == rules[i].firstMonomer + add) {
+              secondFound = true;
+              secondEntryIndex = j;
+              break;
+            } else {
+              continue;
+            }
+            //result[i][1] = j;
+            // secondFound = true;
+            // break;
+          } else {
+            if (monomersNames[j] == rules[i].firstMonomer + add) {
+              firstFound = true;
+              firstIsFirst = true;
+              firstEntryIndex = j;
+            } else if (monomersNames[j] == rules[i].secondMonomer + add) {
+              firstFound = true;
+              firstIsFirst = false;
+              firstEntryIndex = j;
+            } else {
+              continue;
+            }
+            //result[i] = [j, 0];
+          }
+        }
+      }
+
+      if (!(firstFound && secondFound))
+        result[i] = [-1, -1];
+      else if (firstIsFirst)
+        result[i] = [firstEntryIndex, secondEntryIndex];
+      else
+        result[i] = [secondEntryIndex, firstEntryIndex];
+    }
+
+
+    return result;
+  }
+
+  protected getRules(rulesTables: DG.DataFrame[]): Rule[] {
+    const ruleCount = rulesTables.map((df) => df.rowCount).reduce((a, b) => a + b);
+    const rules: Rule[] = new Array<Rule>(ruleCount);
+
+    let counter = 0;
+    for (let i = 0; i < rulesTables.length; i++) {
+      const codeCol = rulesTables[i].columns.byName('code');
+      const monomer1Col = rulesTables[i].columns.byName('monomer1');
+      const monomer2Col = rulesTables[i].columns.byName('monomer2');
+      const modification1Col = rulesTables[i].columns.byName('modification1');
+      const modification2Col = rulesTables[i].columns.byName('modification2');
+      const r1Col = rulesTables[i].columns.byName('R1');
+      const r2Col = rulesTables[i].columns.byName('R2');
+
+      for (let j = 0; j < rulesTables[i].rowCount; j++, counter++) {
+        rules[counter] = {
+          code: codeCol.get(j),
+          firstMonomer: monomer1Col.get(j),
+          secondMonomer: monomer2Col.get(j),
+          firstModification: modification1Col.get(j),
+          secondModification: modification2Col.get(j),
+          firstR: r1Col.get(j),
+          secondR: r2Col.get(j),
+        };
+      }
+    }
+
+    return rules;
+  }
+
+  protected getDimeric(helm: string): [string[], [number, number][]] {
+    const seq = helm.replace(HELM_WRAPPER.LEFT, '').replace(HELM_WRAPPER.RIGHT, '');
+    const monomers = seq.split('.');
+    const duplicates: [number, number][] = [];
+
+    for (let i = 0; i < monomers.length; i++) {
+      if (monomers[i].includes('(#2)')) {
+        monomers[i] = monomers[i].replace('(#2)', '');
+        const duplicateStart = i + 1;
+        let duplicateFinish = 0;
+        for (let j = duplicateStart + 1; j < monomers.length; j++) {
+          if (monomers[j].includes('}')) {
+            duplicateFinish = j; break;
+          }
+        }
+        monomers[duplicateStart] = monomers[duplicateStart].replace('{', '');
+        monomers[duplicateFinish] = monomers[duplicateFinish].replace('}', '');
+        duplicates.push([duplicateStart, duplicateFinish]);
+      }
+    }
+
+    return [monomers, duplicates];
+  }
+
+  protected getAllCycles(rules: Rule[], monomers: string [], positions: [number, number][]) :
+  [string [], number [], number [], number [], number []] {
+    const allPos1: number [] = [];
+    const allPos2: number [] = [];
+    const allAttaches1: number [] = [];
+    const allAttaches2: number [] = [];
+    const ruleCount = rules.length;
+
+    for (let i = 0; i < ruleCount; i++) {
+      if (positions[i][0] == -1)
+        continue;
+
+      const firstMonomer = monomers[positions[i][0]].replace('[', '').replace(']', '');
+      const secondMonomer = monomers[positions[i][1]].replace('[', '').replace(']', '');
+
+      monomers[positions[i][0]] = monomers[positions[i][0]].replace(firstMonomer, rules[i].firstModification);
+      monomers[positions[i][1]] = monomers[positions[i][1]].replace(secondMonomer, rules[i].secondModification);
+
+      allPos1.push(positions[i][0] + 1);
+      allPos2.push(positions[i][1] + 1);
+      allAttaches1.push(rules[i].firstR);
+      allAttaches2.push(rules[i].secondR);
+    }
+
+    return [monomers, allPos1, allPos2, allAttaches1, allAttaches2];
+  }
+
+  protected getHelmCycle(source: ConnectionData, polFirst: number, poSecond: number): string {
+    let cycled = '';
+
+    for (let i = 0; i < source.allPos1.length; i++) {
+      if (i == 0)
+        cycled += `PEPTIDE${polFirst},PEPTIDE${poSecond},`;
+      else
+        cycled += `|PEPTIDE${polFirst},PEPTIDE${poSecond},`;
+      cycled += `${source.allPos1[i]}:R${source.allAttaches1[i]}-${source.allPos2[i]}:R${source.allAttaches2[i]}`;
+    }
+    return cycled;
+  }
+
+  //"PEPTIDE1{[(#2)Succ].[{R].F.[Dab(2)].T.G.H.F.G.A.A.Y.P.[E(2)].[NH2}]}$$$$"
+  protected getTransformedHelm(helm: string, rules: Rule[]): string {
+    const [monomers, duplicates] = this.getDimeric(helm);
+    const positions = this.getLinkedPositions(monomers, rules);
+    const [monomersCycled, allPos1, allPos2, allAttaches1, allAttaches2] =
+      this.getAllCycles(rules, monomers, positions);
+
+    helm = 'PEPTIDE1{';
+    for (let i = 0; i < monomersCycled.length; i++)
+      helm += i != monomersCycled.length - 1 ? monomersCycled[i] + '.' : monomersCycled[i];
+
+    helm += '}';
+
+    const dimerCodes = new Array<string>(duplicates.length);
+    const cycleCodes = new Array<string>(duplicates.length);
+    for (let i = 0; i < duplicates.length; i++) {
+      let helmAdd = `|PEPTIDE${i + 2}{`;
+      const lengthAdd = duplicates[i][1] - duplicates[i][0];
+      //const monomersAdd = new Array<string>(lengthAdd);
+      const allPosAdd1: number [] = [];
+      const allPosAdd2: number [] = [];
+      const allAttachesAdd1: number [] = [];
+      const allAttachesAdd2: number [] = [];
+
+      for (let j = 0; j <= lengthAdd; j ++) {
+        const index = j + duplicates[i][0];
+        helmAdd += j != lengthAdd ? monomersCycled[index] + '.' : monomersCycled[index];
+      }
+
+      helmAdd += '}';
+
+      for (let j = 0; j < allPos1.length; j++) {
+        if (allPos1[j] - 1 >= duplicates[i][0] && allPos1[j] - 1 <= duplicates[i][1]) {
+          allPosAdd1.push(allPos1[j] - duplicates[i][0]);
+          allPosAdd2.push(allPos2[j] - duplicates[i][0]);
+          allAttachesAdd1.push(allAttaches1[j]);
+          allAttachesAdd2.push(allAttaches1[j]);
+        }
+      }
+
+      const addCyclysation = this.getHelmCycle({
+        allPos1: allPosAdd1,
+        allPos2: allPosAdd2,
+        allAttaches1: allAttachesAdd1,
+        allAttaches2: allAttachesAdd2}, i + 2, i + 2);
+
+      dimerCodes[i] = helmAdd;
+      cycleCodes[i] = this.getHelmCycle({
+        allPos1: [duplicates[i][0]],
+        allPos2: [1],
+        allAttaches1: [1],
+        allAttaches2: [1]}, 1, i + 2);
+      cycleCodes.push(addCyclysation);
+    }
+
+    for (let i = 0; i < dimerCodes.length; i++)
+      helm += dimerCodes[i];
+
+    helm += '$';
+    const mainCyclysation = this.getHelmCycle({allPos1, allPos2, allAttaches1, allAttaches2}, 1, 1);
+    helm += mainCyclysation;
+    for (let i = 0; i < cycleCodes.length; i++) {
+      helm += '|';
+      helm += cycleCodes[i];
+    }
+    helm += '$$$';
+    return helm;
+  }
+
+  transform(rulesTables: DG.DataFrame[]): string[] {
+    const rules = this.getRules(rulesTables);
+    const resultList = this.helmColumn.toList().map((helm: string) => {
+      return this.getTransformedHelm(helm, rules);
+    });
+    return resultList;
+  }
+}
+
+class PolymerTransformation {
+  private constructor() {}
+
+  static getInstance(molColumn: DG.Column<string>) {
+    return new TransformationCommon(molColumn);
+  }
+}
+
+export async function addTransformedColumn(
+  molColumn: DG.Column<string>, addHelm: boolean, ruleFiles: string[], chiralityEngine?: boolean
+): Promise<void> {
+  const df = molColumn.dataFrame;
+  const sh = SeqHandler.forColumn(molColumn);
+  const sourceHelmCol = sh.convert(NOTATION.HELM);
+  const pt = PolymerTransformation.getInstance(sourceHelmCol);
+  const fileSource = new DG.FileSource(RULES_PATH);
+
+  const rulesRawFrames: DG.DataFrame[] = new Array<DG.DataFrame>(ruleFiles.length);
+
+  for (let i = 0; i < ruleFiles.length; i++) {
+    const rulesRaw = await fileSource.readAsText(ruleFiles[i].replace(RULES_PATH, ''));
+    rulesRawFrames[i] = DG.DataFrame.fromCsv(rulesRaw);
+  }
+
+  const targetList = pt.transform(rulesRawFrames);
+  const helmColName = df.columns.getUnusedName('transformed(' + molColumn.name + ')');
+  const targetHelmCol = DG.Column.fromList('string', helmColName, targetList);
+
+  addCommonTags(targetHelmCol);
+  targetHelmCol.setTag('units', NOTATION.HELM);
+
+  //const molCol = await getMolColumnFromHelm(df, targetHelmCol, chiralityEngine);
+  const molCol = await grok.functions.call('Bio:getMolFromHelm', {
+    'df': df,
+    'helmCol': targetHelmCol,
+    'chiralityEngine': chiralityEngine
+  });
+
+
+  molCol.name = df.columns.getUnusedName('molfile(' + molColumn.name + ')');
+  molCol.semType = DG.SEMTYPE.MOLECULE;
+
+  if (addHelm) {
+    targetHelmCol.setTag('cell.renderer', 'helm');
+    //targetHelmCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    df.columns.add(targetHelmCol);
+  }
+  df.columns.add(molCol, true);
+  await grok.data.detectSemanticTypes(df);
+}

package/src/polytool/ui.ts

@@ -0,0 +1,59 @@
+/* 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 {addTransformedColumn} from './transformation';
+import {RULES_PATH, RULES_STORAGE_NAME} from './transformation';
+import {ActiveFiles} from '@datagrok-libraries/utils/src/settings/active-files-base';
+
+class RuleInputs extends ActiveFiles {
+  constructor(path: string, userStorageName: string, ext: string ) {
+    super(path, userStorageName, ext);
+  }
+}
+
+export async function getPolyToolDialog(): Promise<DG.Dialog> {
+  const targetColumns = grok.shell.t.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
+  if (!targetColumns)
+    throw new Error('No dataframe with macromolecule columns open');
+
+  const targetColumnInput = ui.columnInput(
+    'Column', grok.shell.t, targetColumns[0], null,
+    {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE}
+  );
+
+  const generateHelmChoiceInput = ui.boolInput('Get HELM', true);
+  ui.tooltip.bind(generateHelmChoiceInput.root, 'Add HELM column');
+
+  const chiralityEngineInput = ui.boolInput('Chirality engine', false);
+  const ruleInputs = new RuleInputs(RULES_PATH, RULES_STORAGE_NAME, '.csv');
+  const rulesForm = await ruleInputs.getForm();
+
+  const div = ui.div([
+    targetColumnInput,
+    generateHelmChoiceInput,
+    chiralityEngineInput,
+    'Rules used',
+    rulesForm
+  ]);
+
+  const dialog = ui.dialog('Poly Tool')
+    .add(div)
+    .onOK(async () => {
+      const molCol = targetColumnInput.value;
+      if (!molCol) {
+        grok.shell.warning('No marcomolecule column chosen!');
+        return;
+      }
+
+      const files = await ruleInputs.getActive();
+
+      addTransformedColumn(molCol!,
+        generateHelmChoiceInput.value!,
+        files,
+        chiralityEngineInput.value!);
+    });
+
+  return dialog;
+}

package/src/polytool/utils.ts

@@ -0,0 +1,20 @@
+/* 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 {ALPHABET, ALIGNMENT, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+
+export function _setPeptideColumn(col: DG.Column): void {
+  addCommonTags(col);
+  col.setTag('units', NOTATION.SEPARATOR);
+  col.setTag('separator', '-');
+  // col.setTag('cell.renderer', 'sequence');
+}
+
+function addCommonTags(col: DG.Column<any>) {
+  col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+  col.setTag('aligned', ALIGNMENT.SEQ);
+  col.setTag('alphabet', ALPHABET.PT);
+}
+

package/src/tests/const.ts

@@ -5,20 +5,20 @@ export const formatsToHelm: {[key: string]: Dict} = {
     'UfAfsCfsGfuacg': 'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'
   },
   'BioSpring': {
-    'AT*GC*123456789': 'RNA1{r(A)p.r(T)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$'
+    'A*GC*123456789': 'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$'
   },
   'Mermade12': {
     'hefglijkLIJKHEFG': 'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$'
   }
-}
+};
 
 export const helmToNucleotides: Dict = {
   'RNA1{[fR](U)p.[fR](A)[sp].[fR](C)[sp].[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACG',
 
-  'RNA1{r(A)p.r(T)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$': 'ATGCUACGUACGC',
+  'RNA1{r(A)[sp].r(G)p.r(C)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)p.d([m5C])}$$$$': 'AGCUACGUACGC',
 
   'RNA1{[25r](U)[sp].[25r](A)[sp].[25r](C)[sp].[25r](G)[sp].[fR](U)[sp].[fR](A)[sp].[fR](C)[sp].[fR](G)[sp].[fR](U)p.[fR](A)p.[fR](C)p.[fR](G)p.[25r](U)p.[25r](A)p.[25r](C)p.[25r](G)}$$$$': 'UACGUACGUACGUACG'
-}
+};
 
 export const helmToMolfile: Dict = {
-}
+};

package/src/tests/formats-support.ts

@@ -4,11 +4,11 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {DEFAULT_FORMATS} from '../model/const';
-import {getJsonData} from '../model/data-loading-utils/json-loader';
+import {DEFAULT_FORMATS} from '../apps/common/model/const';
+import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
 import {formatsToHelm} from './const';
-import {SequenceValidator} from '../model/parsing-validation/sequence-validator';
-import {getTranslatedSequences} from '../model/translator-app/conversion-utils';
+import {SequenceValidator} from '../apps/common/model/parsing-validation/sequence-validator';
+import {getTranslatedSequences} from '../apps/translator/model/conversion-utils';
 import {_package} from '../package';
 
 function getTranslationObject(sequence: string, format: string): {[format: string]: string} {
@@ -19,11 +19,11 @@ function getTranslationObject(sequence: string, format: string): {[format: strin
 const inputs = {
   [DEFAULT_FORMATS.AXOLABS]: 'Afcgacsu',
   [DEFAULT_FORMATS.HELM]: 'RNA1{[fR](A)p.[25r](C)p.[25r](G)p.[25r](A)p.[25r](C)[sp].[25r](U)}$$$$'
-}
+};
 
 category('Formats support', () => {
   before(async () => {
-    await getJsonData();
+    await loadJsonData();
     await _package.initMonomerLib();
   });
 

package/src/tests/formats-to-helm.ts

@@ -4,9 +4,9 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {DEFAULT_FORMATS} from '../model/const';
-import {FormatConverter} from '../model/translator-app/format-converter';
-import {getJsonData} from '../model/data-loading-utils/json-loader';
+import {DEFAULT_FORMATS} from '../apps/common/model/const';
+import {FormatConverter} from '../apps/translator/model/format-converter';
+import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
 import {formatsToHelm} from './const';
 import {_package} from '../package';
 
@@ -20,7 +20,7 @@ function getFromat(helm: string, format: string): string {
 
 category('Formats to HELM', () => {
   before(async () => {
-    await getJsonData();
+    await loadJsonData();
     await _package.initMonomerLib();
   });
 
@@ -37,7 +37,7 @@ category('Formats to HELM', () => {
 
 category('HELM to Formats', () => {
   before(async () => {
-    await getJsonData();
+    await loadJsonData();
     await _package.initMonomerLib();
   });
 

package/src/tests/helm-to-nucleotides.ts

@@ -4,15 +4,15 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {getNucleotidesSequence} from '../model/translator-app/conversion-utils';
-import {getJsonData} from '../model/data-loading-utils/json-loader';
+import {getNucleotidesSequence} from '../apps/translator/model/conversion-utils';
+import {loadJsonData} from '../apps/common/model/data-loader/json-loader';
 import {helmToNucleotides} from './const';
 import {_package} from '../package';
-import {MonomerLibWrapper} from '../model/monomer-lib/lib-wrapper';
+import {MonomerLibWrapper} from '../apps/common/model/monomer-lib/lib-wrapper';
 
 category('HELM to Nucleotides', () => {
   before(async () => {
-    await getJsonData();
+    await loadJsonData();
     await _package.initMonomerLib();
   });
 
@@ -22,5 +22,5 @@ category('HELM to Nucleotides', () => {
       const result = getNucleotidesSequence(helm, MonomerLibWrapper.getInstance());
       expect(result, expected);
     });
-  })
+  });
 });

package/tsconfig.json

@@ -4,15 +4,9 @@
 
     /* Basic Options */
     // "incremental": true,                         /* Enable incremental compilation */
-    "target": "es2022",
-    /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
-    "module": "es2022",
-    /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-    "lib": [
-      "ES2022",
-      "dom"
-    ],
-    /* Specify library files to be included in the compilation. */
+    "target": "es2020",                             /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "lib": ["ES2022", "ES2022.String", "dom"],      /* Specify library files to be included in the compilation. */
     // "allowJs": true,                             /* Allow javascript files to be compiled. */
     // "checkJs": true,                             /* Report errors in .js files. */
     // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
@@ -71,7 +65,7 @@
     // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
 
     /* Advanced Options */
-    "skipLibCheck": true,                           /* Skip type checking of declaration files. */
+    "skipLibCheck": false,                          /* Skip type checking of declaration files. */
     "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
   }
 }

package/webpack.config.js

@@ -2,6 +2,9 @@ const path = require('path');
 const packageName = path.parse(require('./package.json').name).name.toLowerCase().replace(/-/g, '');
 
 module.exports = {
+  cache: {
+    type: 'filesystem',
+  },
   mode: 'development',
   entry: {
     package: ['./src/package.ts'],

package/files/axolabs-style.json

@@ -1,97 +0,0 @@
-{
-  "RNA": {
-    "fullName": "RNA nucleotides",
-    "symbols": ["A", "C", "G", "U"],
-    "color": "rgb(255,230,153)"
-  },
-  "DNA": {
-    "fullName": "DNA nucleotides",
-    "symbols": ["dA", "dC", "dG", "dT"],
-    "color": "rgb(66, 120, 245)"
-  },
-  "2'-Fluoro": {
-    "fullName": "2'-Fluoro nucleotides",
-    "symbols": ["Af", "Cf", "Gf", "Uf"],
-    "color": "rgb(95, 212, 245)"
-  },
-  "2'-O-Methyl": {
-    "fullName": "2'-O-Methyl nucleotides",
-    "symbols": ["a", "c", "g", "u"],
-    "color": "rgb(150, 95, 245)"
-  },
-  "2'-O-MOE": {
-    "fullName": "2'-O-MOE nucleotides (including 5-Methyl C)",
-    "symbols": ["Am", "Cm", "Gm", "Tm"],
-    "color": "rgb(129, 199, 130)"
-  },
-  "GNA": {
-    "fullName": "Glycol nucleic acid",
-    "symbols": ["(GNA-A)", "(GNA-C)", "(GNA-G)", "(GNA-T)"],
-    "color": "rgb(199, 169, 129)"
-  },
-  "LNA": {
-    "fullName": "Locked nucleic acid (including 5-Methyl C)",
-    "symbols": ["Ab", "Cb", "Gb", "Tb"],
-    "color": "rgb(250, 185, 182)"
-  },
-  "UNA": {
-    "fullName": "Unlocked nucleotides",
-    "symbols": ["Ao", "Co", "Go", "Uo"],
-    "color": "rgb(237, 104, 184)"
-  },
-  "A": {
-    "fullName": "Adenosine",
-    "symbols": ["a"],
-    "color": "rgb(255,230,153)"
-  },
-  "C": {
-    "fullName": "Cytidine",
-    "symbols": ["c"],
-    "color": "rgb(255,230,153)"
-  },
-  "G": {
-    "fullName": "Guanosine",
-    "symbols": ["g"],
-    "color": "rgb(255,230,153)"
-  },
-  "U": {
-    "fullName": "Uridine",
-    "symbols": ["u"],
-    "color": "rgb(255,230,153)"
-  },
-  "X-New": {
-    "fullName": "",
-    "symbols": ["X"],
-    "color": "rgb(196, 91, 252)"
-  },
-  "Y-New": {
-    "fullName": "",
-    "symbols": ["Y"],
-    "color": "rgb(150, 177, 255)"
-  },
-  "Z-New": {
-    "fullName": "",
-    "symbols": ["Z"],
-    "color": "rgb(11, 222, 71)"
-  },
-  "invAb": {
-    "fullName": "Inverted abasic capped",
-    "symbols": ["(invAb)"],
-    "color": "rgb(243, 153, 247)"
-  },
-  "5'-vinylps": {
-    "fullName": "5'-vinylphosphonate-2'-OMe-uridine",
-    "symbols": ["(vinu)"],
-    "color": "rgb(99, 3, 40)"
-  },
-  "invAb(o)": {
-    "fullName": "Inverted abasic capped (overhang)",
-    "symbols": ["(invAb)"],
-    "color": "rgb(240, 224, 108)"
-  },
-  "2'-OMe-U(o)": {
-    "fullName": "Nucleotide Uridine with 2'O-Methyl protection (overhang)",
-    "symbols": ["mU"],
-    "color": "rgb(190, 237, 123)"
-  }
-}