protvista-uniprot 2.13.2 → 3.0.0

package/src/adapters/feature-adapter.ts

@@ -0,0 +1,19 @@
+import { renameProperties } from '../utils';
+import formatTooltip from '../tooltips/featureTooltip';
+
+const transformData = (data) => {
+  let transformedData = [];
+  const { features } = data;
+  if (features && features.length > 0) {
+    transformedData = features.map((feature) => {
+      return {
+        ...feature,
+        tooltipContent: formatTooltip(feature),
+      };
+    });
+    transformedData = renameProperties(transformedData);
+  }
+  return transformedData;
+};
+
+export default transformData;

package/src/adapters/interpro-adapter.ts

@@ -0,0 +1,71 @@
+import ColorHash from 'color-hash';
+
+// Copied from InterPro to replicate the same colours for the representative domains
+/* eslint-disable no-magic-numbers */
+const colorHash = new ColorHash({
+  hash: 'bkdr',
+  saturation: [0.65, 0.35, 0.5],
+  lightness: [0.65, 0.35, 0.5],
+});
+/* eslint-enable no-magic-numbers */
+
+const transformData = (data) => {
+  try {
+    return data?.results?.map(({ metadata, proteins }) => ({
+      ...metadata,
+      locations: proteins[0].entry_protein_locations,
+      start: proteins[0].entry_protein_locations
+        ? Math.min(
+            ...proteins[0].entry_protein_locations.map((location) =>
+              Math.min(...location.fragments.map((fragment) => fragment.start))
+            )
+          )
+        : '',
+      end: proteins[0].entry_protein_locations
+        ? Math.max(
+            ...proteins[0].entry_protein_locations?.map((location) =>
+              Math.max(...location.fragments.map((fragment) => fragment.end))
+            )
+          )
+        : '',
+      color: colorHash.hex(
+        metadata.accession.toLowerCase().split('').reverse().join('')
+      ),
+      tooltipContent: `
+        <h5>Accession</h5>
+        <p>
+        <a
+          target="_blank"
+          rel="noopener"
+          href="https://www.ebi.ac.uk/interpro/entry/${
+            metadata.source_database
+          }/${metadata.accession}/"
+        >
+        ${metadata.accession}
+        </a>
+        </p>
+        <h5>Name</h5>
+        <p>${metadata.name}</p>
+        ${
+          metadata.integrated
+            ? `<h5>Integrated into </h5>
+        <p>
+        <a
+          target="_blank"
+          rel="noopener"
+          href="https://www.ebi.ac.uk/interpro/entry/InterPro/${metadata.integrated}/"
+        >
+          ${metadata.integrated}
+        </a>
+        </p>`
+            : ''
+        }
+      `,
+      length: proteins[0].protein_length,
+    }));
+  } catch (error) {
+    throw new Error('Failed transforming the data');
+  }
+};
+
+export default transformData;

package/src/adapters/proteomics-adapter.ts

@@ -0,0 +1,76 @@
+import { renameProperties } from '../utils';
+import formatTooltip from '../tooltips/featureTooltip';
+
+const proteomicsTrackProperties = (feature) => {
+  return {
+    category: 'PROTEOMICS',
+    type: feature.unique ? 'unique' : 'non_unique',
+    tooltipContent: formatTooltip(feature),
+  };
+};
+
+const transformData = (data) => {
+  let adaptedData = [];
+
+  if (data && data.length !== 0) {
+    /* Important: The PTM map is a temporary patch until multiple modifications are shown in the peptide. At this point, only 'phospho' sites are of interest. 
+      Once they are available in the data, there is no need for the below merging */
+
+    // To merge PTM data present in same residue in a same length peptide, have a map [key: start-end-phospho site 1-... phosphosite n, value: corresponding feature elements]
+    const ptmMap: Record<string, any> = {};
+    data.features.forEach((feature) => {
+      let ft = `${feature.begin}-${feature.end}`;
+      if (feature.ptms) {
+        feature.ptms.forEach((ptm) => {
+          ft += `-${ptm.position}`;
+        });
+        ptmMap[ft] = ft in ptmMap ? [...ptmMap[ft], feature] : [feature];
+      }
+    });
+
+    // The else part alone is enough if the PTM information need not be merged.
+    if (Object.keys(ptmMap).length) {
+      adaptedData = Object.values(ptmMap).map((features) => {
+        // Only the dbReferences have to be merged as the rest is all the same
+        const mergedDbReferences = [];
+        features.forEach((feature) => {
+          feature.ptms.forEach((ptm) => {
+            ptm.dbReferences.forEach((dbReference) => {
+              mergedDbReferences.push(dbReference);
+            });
+          });
+        });
+
+        const mergedFeatures = {
+          type: features[0].type,
+          begin: features[0].begin,
+          end: features[0].end,
+          xrefs: features[0].xrefs,
+          evidences: features[0].evidences,
+          peptide: features[0].peptide,
+          unique: features[0].unique,
+          ptms: features[0].ptms.map((ptm) => ({
+            name: ptm.name,
+            position: ptm.position,
+            sources: ptm.sources,
+            dbReferences: mergedDbReferences,
+          })),
+        };
+
+        return Object.assign(
+          mergedFeatures,
+          proteomicsTrackProperties(mergedFeatures)
+        );
+      }, []);
+    } else {
+      adaptedData = data.features.map((feature) => {
+        return Object.assign(feature, proteomicsTrackProperties(feature));
+      });
+    }
+
+    adaptedData = renameProperties(adaptedData);
+  }
+  return adaptedData;
+};
+
+export default transformData;

package/src/{protvista-ptm-exchange.ts → adapters/ptm-exchange-adapter.ts}

@@ -135,7 +135,7 @@ const convertPtmExchangePtms = (
   };
 };
 
-export const transformData = (data: ProteomicsPtm) => {
+const transformData = (data: ProteomicsPtm) => {
   if (data) {
     const { features } = data;
 
@@ -178,3 +178,5 @@ export const transformData = (data: ProteomicsPtm) => {
   }
   return [];
 };
+
+export default transformData;

package/src/adapters/structure-adapter.ts

@@ -0,0 +1,105 @@
+import formatTooltip from '../tooltips/structureTooltip';
+
+const featureType = 'PDBE_COVER';
+const featureCategory = 'STRUCTURE_COVERAGE';
+
+const capitalizeFirstLetter = (word) => {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+};
+
+const getDescription = (properties) => {
+  return Object.keys(properties).reduce(
+    (accumulator, propertyKey) =>
+      `${accumulator}${capitalizeFirstLetter(propertyKey)}: ${
+        properties[propertyKey]
+      }. `,
+    ''
+  );
+};
+
+const parseChainString = (value) => {
+  const posEqual = value.indexOf('=');
+  const posDash = value.indexOf('-');
+  if (posEqual === -1 || posDash === -1) {
+    return { start: 0, end: 0 };
+  }
+  return {
+    start: +value.slice(posEqual + 1, posDash),
+    end: +value.slice(posDash + 1),
+  };
+};
+
+// Iterate over references and extract chain start and end
+export const getAllFeatureStructures = (data) => {
+  return data.dbReferences
+    .filter((reference) => {
+      return reference.type === 'PDB';
+    })
+    .map((structureReference) => {
+      const parsedChain = structureReference.properties.chains
+        ? parseChainString(structureReference.properties.chains)
+        : { start: 0, end: 0 };
+      return {
+        type: featureType,
+        category: featureCategory,
+        structures: [
+          {
+            description: getDescription(structureReference.properties),
+            start: parsedChain.start,
+            end: parsedChain.end,
+            source: {
+              id: structureReference.id,
+              url: `http://www.ebi.ac.uk/pdbe-srv/view/entry/${structureReference.id}`,
+            },
+          },
+        ],
+        start: parsedChain.start,
+        end: parsedChain.end,
+      };
+    });
+};
+
+export const mergeOverlappingIntervals = (structures) => {
+  if (!structures || structures.length <= 0) {
+    return [];
+  }
+  // Sort by start position
+  const sortedStructures = structures.sort((a, b) => a.start - b.start);
+  const mergedIntervals = [];
+  sortedStructures.forEach((structure) => {
+    const lastItem = mergedIntervals[mergedIntervals.length - 1];
+    if (
+      !lastItem ||
+      // If item doesn't overlap, push it
+      lastItem.end < structure.start
+    ) {
+      mergedIntervals.push(structure);
+    }
+    // If the end is bigger update the last one
+    else if (lastItem.end < structure.end) {
+      lastItem.end = structure.end;
+      lastItem.structures.push(structure.structures[0]);
+    }
+    // Otherwise just add to last item
+    else {
+      lastItem.structures.push(structure.structures[0]);
+    }
+  });
+  return mergedIntervals;
+};
+
+const transformData = (data) => {
+  let transformedData = [];
+  if (data && data.length !== 0) {
+    const allFeatureStructures = getAllFeatureStructures(data);
+    transformedData = mergeOverlappingIntervals(allFeatureStructures);
+
+    transformedData.forEach((feature) => {
+      /* eslint-disable no-param-reassign */
+      feature.tooltipContent = formatTooltip(feature);
+    });
+  }
+  return transformedData;
+};
+
+export default transformData;

package/src/adapters/variation-adapter.ts

@@ -0,0 +1,44 @@
+import {
+  ProteinsAPIVariation,
+  AminoAcid,
+  SourceType,
+  Variant,
+  Xref,
+  VariationDatum,
+} from '@nightingale-elements/nightingale-variation';
+
+import formatTooltip from '../tooltips/variationTooltip';
+
+export type TransformedVariant = VariationDatum & Variant;
+
+const getSourceType = (xrefs: Xref[], sourceType: SourceType) => {
+  const xrefNames = xrefs ? xrefs.map((ref) => ref.name) : [];
+  if (sourceType === 'uniprot' || sourceType === 'mixed') {
+    xrefNames.push('uniprot');
+  }
+  return xrefNames;
+};
+
+const transformData = (
+  data: ProteinsAPIVariation
+): {
+  sequence: string;
+  variants: TransformedVariant[];
+} => {
+  const { sequence, features } = data;
+  const variants = features.map((variant) => ({
+    ...variant,
+    accession: variant.genomicLocation?.join(', '),
+    variant: variant.alternativeSequence
+      ? variant.alternativeSequence
+      : AminoAcid.Empty,
+    start: +variant.begin,
+    xrefNames: getSourceType(variant.xrefs, variant.sourceType),
+    hasPredictions: variant.predictions && variant.predictions.length > 0,
+    tooltipContent: formatTooltip(variant),
+  }));
+  if (!variants) return null;
+  return { sequence, variants };
+};
+
+export default transformData;

package/src/{protvista-variation-graph-adapter.ts → adapters/variation-graph-adapter.ts}

@@ -1,10 +1,10 @@
-export const transformData = (data) => {
+const transformData = (data) => {
   if (data.sequence && data.features.length) {
     const variants = data.features.map((variant) => ({
-        ...variant,
-        accession: variant.genomicLocation?.join(", "),
-        start: variant.begin,
-      }));
+      ...variant,
+      accession: variant.genomicLocation?.join(', '),
+      start: variant.begin,
+    }));
 
     const total = new Uint8ClampedArray(data.sequence.length);
     const diseaseTotal = new Uint8ClampedArray(data.sequence.length);
@@ -28,20 +28,27 @@ export const transformData = (data) => {
     }
 
     const graphData = [
-        {
-          name: 'variant',
-          range: [0, Math.max(Math.max(...total), Math.max(...diseaseTotal))],
-          color: 'darkgrey',
-          values: [...total].map((value, index) => ({ position: index, value: value })),
-        },
-        {
-          name: 'disease causing variant',
-          range: [0, Math.max(Math.max(...total), Math.max(...diseaseTotal))],
-          color: 'red',
-          values: [...diseaseTotal].map((value, index) => ({ position: index, value: value })),
-        },
-      ];
+      {
+        name: 'variant',
+        range: [0, Math.max(Math.max(...total), Math.max(...diseaseTotal))],
+        color: 'darkgrey',
+        values: [...total].map((value, index) => ({
+          position: index,
+          value: value,
+        })),
+      },
+      {
+        name: 'disease causing variant',
+        range: [0, Math.max(Math.max(...total), Math.max(...diseaseTotal))],
+        color: 'red',
+        values: [...diseaseTotal].map((value, index) => ({
+          position: index,
+          value: value,
+        })),
+      },
+    ];
     return graphData;
   }
 };
 
+export default transformData;