@rcsb/rcsb-saguaro-app 6.0.0-development.1 → 6.0.0-development.2

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryImpl/TrackDistributionFactory.js

@@ -0,0 +1,21 @@
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+import { MultipleTrackDistributionFactory } from "./MultipleTrackDistributionFactory";
+import { NumericalTrackDistributionFactory } from "./NumericalTrackDistributionFactory";
+export class TrackDistributionFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig();
+        this.multipleTrackDistributionFactory = new MultipleTrackDistributionFactory(distributionConfig);
+        this.numericalTrackDistributionFactory = new NumericalTrackDistributionFactory(distributionConfig);
+    }
+    getDistribution(tracks, blockType, numberResidues) {
+        var _a;
+        switch ((_a = this.distributionConfig.getBlockConfig(blockType)) === null || _a === void 0 ? void 0 : _a.contentType) {
+            case "binary":
+                return this.multipleTrackDistributionFactory.getDistribution(tracks, blockType, numberResidues);
+            case "numerical":
+                return this.numericalTrackDistributionFactory.getDistribution([tracks[0]], blockType, numberResidues);
+            default:
+                return undefined;
+        }
+    }
+}

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryInterface.d.ts

@@ -0,0 +1,24 @@
+import { TrackManagerInterface } from "../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
+import { RcsbChartInterface } from "../../../../RcsbSeacrh/FacetTools";
+export interface ResidueDistributionInterface {
+    attribute: string;
+    title: string;
+    buckets: ResidueBucket[];
+}
+export interface ResidueBucket {
+    label: string;
+    id: string;
+    color: string;
+    residueSet: Set<number>;
+}
+export interface TrackBlockFactoryInterface<S = {}> {
+    getTrackBlocks(tracks: TrackManagerInterface[]): ({
+        tracks: TrackManagerInterface[];
+    } & S)[];
+}
+export interface ResidueDistributionFactoryInterface<T extends any[] = []> {
+    getDistribution(tracks: TrackManagerInterface[], ...args: T): ResidueDistributionInterface | undefined;
+}
+export interface DistributionChartFactoryInterface {
+    getChart(residueDistribution: ResidueDistributionInterface): RcsbChartInterface;
+}

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryInterface.js

@@ -0,0 +1 @@
+export {};

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/TrackBlockFactoryImpl/TrackBlockFactory.d.ts

@@ -0,0 +1,14 @@
+import { TrackBlockFactoryInterface } from "../ResidueDistributionFactoryInterface";
+import { TrackManagerInterface } from "../../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+export declare class TrackBlockFactory implements TrackBlockFactoryInterface<{
+    blockType: string;
+}> {
+    private readonly distributionConfig;
+    constructor(distributionConfig?: RcsbDistributionConfig);
+    getTrackBlocks(tracks: TrackManagerInterface[]): ({
+        tracks: TrackManagerInterface[];
+    } & {
+        blockType: string;
+    })[];
+}

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/TrackBlockFactoryImpl/TrackBlockFactory.js

@@ -0,0 +1,19 @@
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+export class TrackBlockFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig();
+    }
+    getTrackBlocks(tracks) {
+        const trackMap = new Map();
+        tracks.forEach(t => {
+            var _a;
+            const blockType = this.distributionConfig.getBlockType(t.getId());
+            if (!blockType)
+                return;
+            if (!trackMap.has(blockType))
+                trackMap.set(blockType, []);
+            (_a = trackMap.get(blockType)) === null || _a === void 0 ? void 0 : _a.push(t);
+        });
+        return Array.from(trackMap.entries()).map(e => ({ blockType: e[0], tracks: e[1] }));
+    }
+}

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartTools/Helper.d.ts

@@ -0,0 +1,4 @@
+import { RcsbChartInterface } from "../../../../RcsbSeacrh/FacetTools";
+export declare namespace Helper {
+    function mergeCharts(charts: RcsbChartInterface[]): RcsbChartInterface[];
+}

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartTools/Helper.js

@@ -0,0 +1,22 @@
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+export var Helper;
+(function (Helper) {
+    var assertDefined = Assertions.assertDefined;
+    function mergeCharts(charts) {
+        const attributes = Array.from(new Set(charts.map(ch => ch.attribute)));
+        return attributes.map(attr => (mergeChartData(charts.filter(ch => ch.attribute == attr))));
+    }
+    Helper.mergeCharts = mergeCharts;
+    function mergeChartData(charts) {
+        return Object.assign(Object.assign({}, charts[0]), { data: mergeData(charts.map(ch => ch.data).flat()) });
+    }
+    function mergeData(data) {
+        const labels = Array.from(new Set(data.map(d => d.label)));
+        return labels.map(label => {
+            var _a, _b;
+            const d = data.find(d => d.label === label);
+            assertDefined(d);
+            return Object.assign(Object.assign({}, d), { population: (_b = (_a = data.filter(d => d.label === label)) === null || _a === void 0 ? void 0 : _a.reduce((prev, curr) => (prev + curr.population), 0)) !== null && _b !== void 0 ? _b : 0 });
+        });
+    }
+})(Helper || (Helper = {}));

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartTools/ResidueChartTools.d.ts

@@ -0,0 +1,8 @@
+import { RcsbChartInterface } from "../../../../RcsbSeacrh/FacetTools";
+export interface ResidueChartInterface {
+    granularity: "entry" | "assembly" | "instance" | "entity";
+    rcsbId: string;
+}
+export declare namespace ResidueChartTools {
+    function getResidueDistribution(residueChart: ResidueChartInterface): Promise<Promise<RcsbChartInterface[]>>;
+}

package/lib/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartTools/ResidueChartTools.js

@@ -0,0 +1,87 @@
+import { __awaiter } from "tslib";
+import { AnnotationCollector } from "../../../../RcsbCollectTools/AnnotationCollector/AnnotationCollector";
+import { SequenceReference, Source } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { filter, interfaceAnnotations } from "../../../../RcsbFvWeb/RcsbFvModule/RcsbFvInterface";
+import * as rcm from "../../../../RcsbAnnotationConfig/RcsbResidueConfig.ac.json";
+import { AnnotationBlockManager } from "../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationBlockManager";
+import { AnnotationTrackManagerFactory } from "../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationTrackManager";
+import { RcsbAnnotationConfig } from "../../../../RcsbAnnotationConfig/RcsbAnnotationConfig";
+import { TrackBlockFactory } from "../ResidueChartFactories/TrackBlockFactoryImpl/TrackBlockFactory";
+import { TrackDistributionFactory } from "../ResidueChartFactories/ResidueDistributionFactoryImpl/TrackDistributionFactory";
+import { DistributionChartFactory } from "../ResidueChartFactories/DistributionChartFactoryImpl/DistributionChartFactory";
+import { AlignmentCollector } from "../../../../RcsbCollectTools/AlignmentCollector/AlignmentCollector";
+import { rcsbRequestCtxManager } from "../../../../RcsbRequest/RcsbRequestContextManager";
+import { Helper } from "./Helper";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+export var ResidueChartTools;
+(function (ResidueChartTools) {
+    var assertDefined = Assertions.assertDefined;
+    function getResidueDistribution(residueChart) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (residueChart.granularity) {
+                case "entry":
+                    return yield getEntryCharts(residueChart.rcsbId);
+                case "assembly":
+                    return [];
+                case "instance":
+                    return yield getInstanceCharts(residueChart.rcsbId);
+                case "entity":
+                    return [];
+            }
+        });
+    }
+    ResidueChartTools.getResidueDistribution = getResidueDistribution;
+    function getEntryCharts(entryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instanceIds = (yield rcsbRequestCtxManager.getEntryProperties(entryId)).map(e => Array.from(e.entityToInstance.values()).flat()).flat();
+            let charts = [];
+            for (const id of instanceIds) {
+                charts = charts.concat(yield getInstanceCharts(id));
+            }
+            return Helper.mergeCharts(charts);
+        });
+    }
+    function getInstanceCharts(instanceId) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const alignmentRequestContext = {
+                queryId: instanceId,
+                from: SequenceReference.PdbInstance,
+                to: SequenceReference.PdbInstance
+            };
+            const alignmentResponse = yield alignmentCollector.collect(alignmentRequestContext);
+            const annotationsRequestContext = {
+                queryId: instanceId,
+                reference: SequenceReference.PdbInstance,
+                sources: [Source.PdbEntity, Source.PdbInstance, Source.Uniprot, Source.PdbInterface],
+                annotationGenerator: interfaceAnnotations,
+                annotationFilter: filter
+            };
+            return yield getCharts(annotationsRequestContext, yield annotationCollector.collect(annotationsRequestContext), (_b = (_a = alignmentResponse.query_sequence) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : -1);
+        });
+    }
+    function getCharts(annotationRequestContext, annotations, numberResidues) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return processAnnotations({
+                annotations,
+                annotationBlockManager: new AnnotationBlockManager(new AnnotationTrackManagerFactory(), new RcsbAnnotationConfig(rcm)),
+                annotationRequestContext,
+                trackBlockFactory: new TrackBlockFactory(),
+                residueDistributionFactory: new TrackDistributionFactory(),
+                distributionChartFactory: new DistributionChartFactory(),
+                numberResidues
+            });
+        });
+    }
+    function processAnnotations(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield config.annotationBlockManager.setData(config.annotationRequestContext, config.annotations);
+            return config.trackBlockFactory.getTrackBlocks(config.annotationBlockManager.getTracks()).map(block => (config.residueDistributionFactory.getDistribution(block.tracks, block.blockType, config.numberResidues))).map(distribution => {
+                assertDefined(distribution);
+                return config.distributionChartFactory.getChart(distribution);
+            });
+        });
+    }
+    const annotationCollector = new AnnotationCollector();
+    const alignmentCollector = new AlignmentCollector();
+})(ResidueChartTools || (ResidueChartTools = {}));

package/lib/RcsbQueries/Borrego/.graphqlconfig

@@ -0,0 +1,15 @@
+{
+  "name": "Untitled GraphQL Schema",
+  "schemaPath": "schema.graphql",
+  "extensions": {
+    "endpoints": {
+      "Default GraphQL Endpoint": {
+        "url": "https://1d-coordinates.rcsb.org/graphql",
+        "headers": {
+          "user-agent": "JS GraphQL"
+        },
+        "introspect": false
+      }
+    }
+  }
+}

package/lib/RcsbQueries/Borrego/QueryAlignments.graphql

@@ -0,0 +1,29 @@
+query QueryAlignment($queryId: String!, $from: SequenceReference, $to:SequenceReference, $range:[Int]){
+    alignment(
+        queryId:$queryId
+        from:$from
+        to:$to
+        range:$range
+    ){
+        query_sequence
+        target_alignment {
+            target_id
+            orientation
+            target_sequence
+            coverage {
+                query_coverage
+                query_length
+                target_coverage
+                target_length
+            }
+            aligned_regions {
+                query_begin
+                query_end
+                target_begin
+                target_end
+                exon_shift
+            }
+        }
+
+    }
+}

package/lib/RcsbQueries/Borrego/QueryAnnotations.graphql

@@ -0,0 +1,40 @@
+query QueryAnnotations($queryId: String!, $reference: SequenceReference, $sources:[Source], $range:[Int], $filters: [FilterInput]){
+    annotations(
+        queryId:$queryId
+        reference:$reference
+        sources:$sources
+        range:$range
+        filters:$filters
+    ){
+        source
+        target_id
+        target_identifiers{
+            target_id
+            entry_id
+            assembly_id
+            entity_id
+            asym_id
+            interface_id
+            interface_partner_index
+        }
+        features {
+            type
+            provenance_source
+            description
+            feature_id
+            name
+            value
+            feature_positions {
+                beg_seq_id
+                end_seq_id
+                beg_ori_id
+                end_ori_id
+                range_id
+                open_begin
+                open_end
+                value
+                values
+            }
+        }
+    }
+}

package/lib/RcsbQueries/Borrego/QueryGroupAlignments.graphql

@@ -0,0 +1,43 @@
+query QueryGroupAlignment($group: GroupReference!, $groupId: String!, $filter: [String], $first: Int!, $after: String){
+    group_alignment(
+        group: $group
+        groupId: $groupId
+        filter: $filter
+    ){
+        alignment_length
+        alignment_logo{
+            symbol
+            value
+        }
+        query_sequence
+        target_alignment_subset(first: $first, after: $after) {
+            pageInfo{
+                startCursor
+                endCursor
+                hasNextPage
+                hasPreviousPage
+            }
+            edges{
+                node{
+                    target_id
+                    orientation
+                    target_sequence
+                    coverage {
+                        query_coverage
+                        query_length
+                        target_coverage
+                        target_length
+                    }
+                    aligned_regions {
+                        query_begin
+                        query_end
+                        target_begin
+                        target_end
+                        exon_shift
+                    }
+                }
+                cursor
+            }
+        }
+    }
+}

package/lib/RcsbQueries/Borrego/QueryGroupAlignmentsNoLogo.graphql

@@ -0,0 +1,39 @@
+query QueryGroupAlignmentNoLogo($group: GroupReference!, $groupId: String!, $filter: [String], $first: Int!, $after: String){
+    group_alignment(
+        group: $group
+        groupId: $groupId
+        filter: $filter
+    ){
+        alignment_length
+        query_sequence
+        target_alignment_subset(first: $first, after: $after) {
+            pageInfo{
+                startCursor
+                endCursor
+                hasNextPage
+                hasPreviousPage
+            }
+            edges{
+                node{
+                    target_id
+                    orientation
+                    target_sequence
+                    coverage {
+                        query_coverage
+                        query_length
+                        target_coverage
+                        target_length
+                    }
+                    aligned_regions {
+                        query_begin
+                        query_end
+                        target_begin
+                        target_end
+                        exon_shift
+                    }
+                }
+                cursor
+            }
+        }
+    }
+}

package/lib/RcsbQueries/Borrego/QueryGroupAnnotations.graphql

@@ -0,0 +1,31 @@
+query QueryGroupAnnotations($group: GroupReference!, $groupId: String!, $sources:[Source], $filters: [FilterInput], $histogram:Boolean){
+    group_annotations(
+        group:$group
+        groupId:$groupId
+        sources:$sources
+        filters:$filters
+        histogram:$histogram
+    ){
+        source
+        target_id
+        features {
+            type
+            provenance_source
+            description
+            feature_id
+            name
+            value
+            feature_positions {
+                beg_seq_id
+                end_seq_id
+                beg_ori_id
+                end_ori_id
+                range_id
+                open_begin
+                open_end
+                value
+                values
+            }
+        }
+    }
+}