protvista-uniprot 2.11.2 → 2.12.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "protvista-uniprot",
   "description": "ProtVista tool for the UniProt website",
-  "version": "2.11.2",
+  "version": "2.12.0",
   "files": [
     "dist",
     "src"

package/src/commonTypes.ts

@@ -0,0 +1,25 @@
+export type AlphafoldPayload = Array<{
+  entryId: string;
+  gene: string;
+  uniprotAccession: string;
+  uniprotId: string;
+  uniprotDescription: string;
+  taxId: number;
+  organismScientificName: string;
+  uniprotStart: number;
+  uniprotEnd: number;
+  uniprotSequence: string;
+  modelCreatedDate: string;
+  latestVersion: number;
+  allVersions: number[];
+  isReviewed: boolean;
+  isReferenceProteome: boolean;
+  cifUrl?: string;
+  bcifUrl?: string;
+  amAnnotationsUrl?: string;
+  amAnnotationsHg19Url?: string;
+  amAnnotationsHg38Url?: string;
+  pdbUrl: string;
+  paeImageUrl: string;
+  paeDocUrl: string;
+}>;

package/src/config.json

@@ -216,7 +216,7 @@
           "tooltip": "Extent of a region located in a membrane without crossing it"
         }
       ]
-    },  
+    },
     {
       "name": "DOMAINS",
       "label": "Domains",
@@ -332,7 +332,6 @@
           ],
           "tooltip": "Any interesting single amino acid site on the sequence"
         },
-        
         {
           "name": "ca_bind",
           "label": "Calcium binding",
@@ -639,13 +638,41 @@
           "data": [
             {
               "adapter": "protvista-alphafold-confidence-adapter",
-              "url": "https://alphafold.ebi.ac.uk/api/prediction/{accession}"
+              "url": [
+                "https://alphafold.ebi.ac.uk/api/prediction/{accession}",
+                "https://www.ebi.ac.uk/proteins/api/proteins/{accession}"
+              ]
             }
           ],
           "tooltip": "AlphaFold prediction confidence"
         }
       ]
     },
+    {
+      "name": "ALPHAMISSENSE_PATHOGENICITY",
+      "label": "AlphaMissense",
+      "trackType": "protvista-coloured-sequence",
+      "scale": "P:100,A:50,B:0",
+      "color-range": "#9a131a:100,#a8a9ad:50,#3d5493:0",
+      "tracks": [
+        {
+          "name": "alphamissense_pathogenicity",
+          "label": "AlphaMissense Pathogenicity",
+          "labelUrl": "https://alphafold.ebi.ac.uk/entry/{accession}",
+          "trackType": "protvista-coloured-sequence",
+          "data": [
+            {
+              "adapter": "protvista-alphamissense-pathogenicity-adapter",
+              "url": [
+                "https://alphafold.ebi.ac.uk/api/prediction/{accession}",
+                "https://www.ebi.ac.uk/proteins/api/proteins/{accession}"
+              ]
+            }
+          ],
+          "tooltip": "AlphaMissense prediction pathogenicity"
+        }
+      ]
+    },
     {
       "name": "STRUCTURAL",
       "label": "Structural features",

package/src/protvista-alphafold-confidence.ts

@@ -1,23 +1,4 @@
-type AlphafoldPayload = Array<{
-  entryId: string;
-  gene: string;
-  uniprotAccession: string;
-  uniprotId: string;
-  uniprotDescription: string;
-  taxId: number;
-  organismScientificName: string;
-  uniprotStart: number;
-  uniprotEnd: number;
-  uniprotSequence: string;
-  modelCreatedDate: string;
-  latestVersion: number;
-  allVersions: number[];
-  cifUrl: string;
-  bcifUrl: string;
-  pdbUrl: string;
-  paeImageUrl: string;
-  paeDocUrl: string;
-}>;
+import { AlphafoldPayload } from './commonTypes';
 
 type AlphafoldConfidencePayload = {
   residueNumber: Array<number>;
@@ -43,9 +24,19 @@ const loadConfidence = async (
   }
 };
 
-export const transformData = async (data: AlphafoldPayload) => {
+type PartialProtein = {
+  sequence: {
+    sequence: string;
+  };
+};
+
+export const transformData = async (
+  data: AlphafoldPayload,
+  protein: PartialProtein
+) => {
   const confidenceUrl = getConfidenceURLFromPayload(data);
-  if (confidenceUrl) {
+  const { uniprotSequence } = data?.[0] || {};
+  if (confidenceUrl && uniprotSequence === protein.sequence.sequence) {
     const confidenceData = await loadConfidence(confidenceUrl);
     return confidenceData?.confidenceCategory.join('');
   }

package/src/protvista-alphamissense-pathogenicity.ts

@@ -0,0 +1,100 @@
+import { AlphafoldPayload } from './commonTypes';
+
+// from example data
+// benign: [0.0448,0.3397]: x < 0.34
+// ambiguous: [0.34,0.564]: 0.34 <= x <= 0.564
+// pathogenic: [0.5646,0.9999]: 0.564 < x
+const benign = 0.34;
+const pathogenic = 0.564;
+
+const rowSplitter = /\s*\n\s*/;
+const cellSplitter = /^(.)(\d+)(.),(.+),(\w+)$/;
+
+type Row = {
+  wildType: string;
+  position: number;
+  mutated: string;
+  pathogenicityScore: number;
+  pathogenicityLabel: string;
+};
+
+const parseCSV = (rawText: string): string => {
+  const positions: Array<Array<Row>> = [];
+  for (const [i, row] of rawText.split(rowSplitter).entries()) {
+    if (i === 0 || !row) {
+      continue;
+    }
+    const [
+      ,
+      wildType,
+      positionString,
+      mutated,
+      pathogenicityScore,
+      pathogenicityLabel,
+    ] = row.match(cellSplitter);
+    const position = +positionString;
+    const index = position - 1;
+    if (!positions[index]) {
+      positions[index] = [];
+    }
+    positions[index].push({
+      wildType,
+      position,
+      mutated,
+      pathogenicityScore: +pathogenicityScore,
+      pathogenicityLabel,
+    });
+  }
+
+  const out = [];
+  for (const position of positions) {
+    let letter = 'A';
+    // maximum
+    // const value = Math.max(
+    //   ...position.map((variation) => variation.pathogenicityScore)
+    // );
+    // average
+    const value =
+      position.reduce(
+        (acc, variation) => acc + +variation.pathogenicityScore,
+        0
+      ) / position.length;
+    if (value > pathogenic) {
+      letter = 'P';
+    } else if (value < benign) {
+      letter = 'B';
+    }
+    out.push(letter);
+  }
+
+  return out.join('');
+};
+
+// Load and parse
+const loadAndParseAnnotations = async (url: string): Promise<string> => {
+  try {
+    const payload = await fetch(url);
+    const rawCSV = await payload.text();
+    return parseCSV(rawCSV);
+  } catch (e) {
+    console.error('Could not load AlphaMissense pathogenicity', e);
+  }
+};
+
+type PartialProtein = {
+  sequence: {
+    sequence: string;
+  };
+};
+
+export const transformData = async (
+  data: AlphafoldPayload,
+  protein: PartialProtein
+) => {
+  const { amAnnotationsUrl, uniprotSequence } = data?.[0] || {};
+  if (amAnnotationsUrl && uniprotSequence === protein.sequence.sequence) {
+    const variationData = await loadAndParseAnnotations(amAnnotationsUrl);
+    // return confidenceData?.confidenceCategory.join('');
+    return variationData;
+  }
+};

package/src/protvista-uniprot.ts

@@ -22,6 +22,7 @@ import { transformData as _transformDataVariationAdapter } from 'protvista-varia
 import { transformData as _transformDataInterproAdapter } from 'protvista-interpro-adapter';
 import { transformData as _transformDataProteomicsPTMApdapter } from './protvista-ptm-exchange';
 import { transformData as _transformDataAlphaFoldConfidenceAdapter } from './protvista-alphafold-confidence';
+import { transformData as _transformDataAlphaMissensePathogenicityAdapter } from './protvista-alphamissense-pathogenicity';
 
 import defaultConfig from './config.json';
 import _ProtvistaUniprotStructure from './protvista-uniprot-structure';
@@ -44,6 +45,9 @@ export const transformDataProteomicsPTMApdapter =
 export const transformDataAlphaFoldConfidenceAdapter =
   _transformDataAlphaFoldConfidenceAdapter;
 
+export const transformDataAlphaMissensePathogenicityAdapter =
+  _transformDataAlphaMissensePathogenicityAdapter;
+
 export const filterConfig = _filterConfig;
 export const colorConfig = _colorConfig;
 export const ProtvistaUniprotStructure = _ProtvistaUniprotStructure;
@@ -58,6 +62,8 @@ const adapters = {
   'protvista-proteomics-ptm-adapter': transformDataProteomicsPTMApdapter,
   'protvista-alphafold-confidence-adapter':
     transformDataAlphaFoldConfidenceAdapter,
+  'protvista-alphamissense-pathogenicity-adapter':
+    transformDataAlphaMissensePathogenicityAdapter,
 };
 
 type TrackType =
@@ -74,7 +80,7 @@ type ProtvistaTrackConfig = {
   filter: string;
   trackType: TrackType;
   data: {
-    url: string;
+    url: string | string[];
     adapter?:
       | 'protvista-feature-adapter'
       | 'protvista-structure-adapter'
@@ -181,9 +187,9 @@ class ProtvistaUniprot extends LitElement {
     const accession = this.accession;
     if (accession && this.config) {
       // Get the list of unique urls
-      const urls = this.config.categories
-        .map(({ tracks }) => tracks.map(({ data }) => data[0].url))
-        .flat();
+      const urls = this.config.categories.flatMap(({ tracks }) =>
+        tracks.flatMap(({ data }) => data[0].url)
+      );
       const uniqueUrls = [...new Set(urls)];
       // Get the data for all urls and store it
       await Promise.all(
@@ -213,26 +219,28 @@ class ProtvistaUniprot extends LitElement {
         const categoryData = await Promise.all(
           tracks.map(async ({ data: dataConfig, name: trackName, filter }) => {
             const { url, adapter } = dataConfig[0]; // TODO handle array
-            const trackData = this.rawData[url] || [];
+            const trackData = (Array.isArray(url) ? url : [url]).map(
+              (url) => this.rawData[url] || []
+            );
 
             if (
               !trackData ||
               (adapter === 'protvista-variation-adapter' &&
-                trackData.length === 0)
+                trackData[0].length === 0)
             ) {
               return;
             }
 
             // 1. Convert data
             let transformedData = adapter
-              ? await adapters[adapter](trackData)
+              ? await adapters[adapter](...trackData)
               : trackData;
 
             if (adapter === 'protvista-interpro-adapter') {
               const representativeDomains = [];
-              transformedData?.forEach(feature => {
-                feature.locations?.forEach(location => {
-                  location.fragments?.forEach(fragment => {
+              transformedData?.forEach((feature) => {
+                feature.locations?.forEach((location) => {
+                  location.fragments?.forEach((fragment) => {
                     if (fragment.representative) {
                       representativeDomains.push({
                         ...feature,