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

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/DistributionChartFactoryImpl/DistributionChartFactory.d.ts

@@ -0,0 +1,8 @@
+import { DistributionChartFactoryInterface, ResidueDistributionInterface } from "../ResidueDistributionFactoryInterface";
+import { RcsbChartInterface } from "../../../../../RcsbSeacrh/FacetTools";
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+export declare class DistributionChartFactory implements DistributionChartFactoryInterface {
+    private readonly distributionConfig;
+    constructor(distributionConfig?: RcsbDistributionConfig);
+    getChart(residueDistribution: ResidueDistributionInterface): RcsbChartInterface;
+}

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/DistributionChartFactoryImpl/DistributionChartFactory.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributionChartFactory = void 0;
+const RcsbDistributionConfig_1 = require("../../../../../RcsbAnnotationConfig/RcsbDistributionConfig");
+const Operator_1 = require("../../../../../RcsbUtils/Helpers/Operator");
+const ChartConfigInterface_1 = require("@rcsb/rcsb-charts/lib/RcsbChartComponent/ChartConfigInterface");
+class DistributionChartFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig_1.RcsbDistributionConfig();
+    }
+    getChart(residueDistribution) {
+        var _a, _b;
+        const sort = (_a = this.distributionConfig.getBlockConfig(residueDistribution.attribute)) === null || _a === void 0 ? void 0 : _a.sort;
+        const axisLabel = (_b = this.distributionConfig.getBlockConfig(residueDistribution.attribute)) === null || _b === void 0 ? void 0 : _b.axisLabel;
+        return {
+            chartType: ChartConfigInterface_1.ChartType.barplot,
+            attribute: residueDistribution.attribute,
+            attributeName: residueDistribution.attribute,
+            contentType: "number",
+            data: residueDistribution.buckets.map(b => ({
+                label: b.label,
+                population: b.residueSet.size,
+                objectConfig: {
+                    color: b.color,
+                    objectId: b.id
+                }
+            })),
+            title: residueDistribution.title,
+            chartConfig: {
+                sort: sort ? (a, b) => (sort.findIndex(x => x === a.x) - sort.findIndex(x => x === b.x)) : undefined,
+                tooltipText: (d) => (`${Operator_1.Operator.digitGrouping(d.y)} residues`),
+                axisLabel,
+                domainEmptyBins: true
+            }
+        };
+    }
+}
+exports.DistributionChartFactory = DistributionChartFactory;

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryImpl/MultipleTrackDistributionFactory.d.ts

@@ -0,0 +1,8 @@
+import { ResidueDistributionFactoryInterface, ResidueDistributionInterface } from "../ResidueDistributionFactoryInterface";
+import { TrackManagerInterface } from "../../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+export declare class MultipleTrackDistributionFactory implements ResidueDistributionFactoryInterface<[string, number]> {
+    private readonly distributionConfig;
+    constructor(distributionConfig?: RcsbDistributionConfig);
+    getDistribution(tracks: TrackManagerInterface[], blockType: string, numberResidues: number): ResidueDistributionInterface;
+}

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryImpl/MultipleTrackDistributionFactory.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipleTrackDistributionFactory = void 0;
+const RcsbDistributionConfig_1 = require("../../../../../RcsbAnnotationConfig/RcsbDistributionConfig");
+const lodash_1 = require("lodash");
+const Assertions_1 = require("../../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+class MultipleTrackDistributionFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig_1.RcsbDistributionConfig();
+    }
+    getDistribution(tracks, blockType, numberResidues) {
+        const undefResidues = new Set((0, lodash_1.range)(1, numberResidues + 1));
+        const blockConfig = this.distributionConfig.getBlockConfig(blockType);
+        assertDefined(blockConfig);
+        const undefTrack = blockConfig.undefTrack;
+        return {
+            attribute: blockConfig.type,
+            title: blockConfig.title,
+            buckets: tracks.map(track => {
+                const trackConfig = this.distributionConfig.getTrackConfig(track.getId());
+                assertDefined(trackConfig), assertDefined(trackConfig.label), assertDefined(trackConfig === null || trackConfig === void 0 ? void 0 : trackConfig.color);
+                return {
+                    label: trackConfig.label,
+                    color: trackConfig.color,
+                    id: trackConfig.type,
+                    residueSet: new Set(track.values().reduce((prev, curr) => { var _a; return (prev.concat((0, lodash_1.range)(curr.begin, ((_a = curr.end) !== null && _a !== void 0 ? _a : curr.begin) + 1))); }, []).map(n => {
+                        undefResidues.delete(n);
+                        return n;
+                    }))
+                };
+            }).concat(undefTrack && undefResidues.size > 0 ? [Object.assign(Object.assign({}, undefTrack), { residueSet: undefResidues })] : [])
+        };
+    }
+}
+exports.MultipleTrackDistributionFactory = MultipleTrackDistributionFactory;

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryImpl/NumericalTrackDistributionFactory.d.ts

@@ -0,0 +1,8 @@
+import { ResidueDistributionFactoryInterface, ResidueDistributionInterface } from "../ResidueDistributionFactoryInterface";
+import { TrackManagerInterface } from "../../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+export declare class NumericalTrackDistributionFactory implements ResidueDistributionFactoryInterface<[string, number]> {
+    private readonly distributionConfig;
+    constructor(distributionConfig?: RcsbDistributionConfig);
+    getDistribution(tracks: [TrackManagerInterface], blockType: string, numberResidues: number): ResidueDistributionInterface;
+}

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryImpl/NumericalTrackDistributionFactory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericalTrackDistributionFactory = void 0;
+const RcsbDistributionConfig_1 = require("../../../../../RcsbAnnotationConfig/RcsbDistributionConfig");
+const lodash_1 = require("lodash");
+const Assertions_1 = require("../../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+class NumericalTrackDistributionFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig_1.RcsbDistributionConfig();
+    }
+    getDistribution(tracks, blockType, numberResidues) {
+        var _a;
+        const track = tracks[0];
+        const numericalCategories = (_a = this.distributionConfig.getTrackConfig(track.getId())) === null || _a === void 0 ? void 0 : _a.numericalCategories;
+        assertDefined(numericalCategories);
+        const bucketMap = new Map();
+        const undefResidues = new Set((0, lodash_1.range)(1, numberResidues + 1));
+        numericalCategories.categories.forEach(category => {
+            const label = category.label;
+            bucketMap.set(label, Object.assign(Object.assign({}, category), { residueSet: new Set() }));
+        });
+        track.forEach(ann => {
+            var _a;
+            let index = numericalCategories.thresholds.findIndex((x) => { var _a; return x >= ((_a = ann.value) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER); });
+            if (index < 0)
+                index = numericalCategories.thresholds.length;
+            const label = numericalCategories.categories[index].label;
+            (_a = bucketMap.get(label)) === null || _a === void 0 ? void 0 : _a.residueSet.add(ann.begin);
+            undefResidues.delete(ann.begin);
+        });
+        const bc = this.distributionConfig.getBlockConfig(blockType);
+        assertDefined(bc);
+        return {
+            attribute: bc.type,
+            title: bc.title,
+            buckets: Array.from(bucketMap.values()).concat(bc.undefTrack && undefResidues.size > 0 ? [Object.assign(Object.assign({}, bc.undefTrack), { residueSet: undefResidues })] : [])
+        };
+    }
+}
+exports.NumericalTrackDistributionFactory = NumericalTrackDistributionFactory;

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryImpl/TrackDistributionFactory.d.ts

@@ -0,0 +1,10 @@
+import { ResidueDistributionFactoryInterface, ResidueDistributionInterface } from "../ResidueDistributionFactoryInterface";
+import { RcsbDistributionConfig } from "../../../../../RcsbAnnotationConfig/RcsbDistributionConfig";
+import { TrackManagerInterface } from "../../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
+export declare class TrackDistributionFactory implements ResidueDistributionFactoryInterface<[string, number]> {
+    private readonly distributionConfig;
+    private readonly multipleTrackDistributionFactory;
+    private readonly numericalTrackDistributionFactory;
+    constructor(distributionConfig?: RcsbDistributionConfig);
+    getDistribution(tracks: TrackManagerInterface[], blockType: string, numberResidues: number): ResidueDistributionInterface | undefined;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackDistributionFactory = void 0;
+const RcsbDistributionConfig_1 = require("../../../../../RcsbAnnotationConfig/RcsbDistributionConfig");
+const MultipleTrackDistributionFactory_1 = require("./MultipleTrackDistributionFactory");
+const NumericalTrackDistributionFactory_1 = require("./NumericalTrackDistributionFactory");
+class TrackDistributionFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig_1.RcsbDistributionConfig();
+        this.multipleTrackDistributionFactory = new MultipleTrackDistributionFactory_1.MultipleTrackDistributionFactory(distributionConfig);
+        this.numericalTrackDistributionFactory = new NumericalTrackDistributionFactory_1.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;
+        }
+    }
+}
+exports.TrackDistributionFactory = TrackDistributionFactory;

package/lib/commonjs/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/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/ResidueDistributionFactoryInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/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/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartFactories/TrackBlockFactoryImpl/TrackBlockFactory.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackBlockFactory = void 0;
+const RcsbDistributionConfig_1 = require("../../../../../RcsbAnnotationConfig/RcsbDistributionConfig");
+class TrackBlockFactory {
+    constructor(distributionConfig) {
+        this.distributionConfig = distributionConfig !== null && distributionConfig !== void 0 ? distributionConfig : new RcsbDistributionConfig_1.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] }));
+    }
+}
+exports.TrackBlockFactory = TrackBlockFactory;

package/lib/commonjs/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/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartTools/Helper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helper = void 0;
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var Helper;
+(function (Helper) {
+    var assertDefined = Assertions_1.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 || (exports.Helper = Helper = {}));

package/lib/commonjs/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/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbResidueChart/ResidueChartTools/ResidueChartTools.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResidueChartTools = void 0;
+const tslib_1 = require("tslib");
+const AnnotationCollector_1 = require("../../../../RcsbCollectTools/AnnotationCollector/AnnotationCollector");
+const GqlTypes_1 = require("@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes");
+const RcsbFvInterface_1 = require("../../../../RcsbFvWeb/RcsbFvModule/RcsbFvInterface");
+const rcm = tslib_1.__importStar(require("../../../../RcsbAnnotationConfig/RcsbResidueConfig.ac.json"));
+const AnnotationBlockManager_1 = require("../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationBlockManager");
+const AnnotationTrackManager_1 = require("../../../../RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationTrackManager");
+const RcsbAnnotationConfig_1 = require("../../../../RcsbAnnotationConfig/RcsbAnnotationConfig");
+const TrackBlockFactory_1 = require("../ResidueChartFactories/TrackBlockFactoryImpl/TrackBlockFactory");
+const TrackDistributionFactory_1 = require("../ResidueChartFactories/ResidueDistributionFactoryImpl/TrackDistributionFactory");
+const DistributionChartFactory_1 = require("../ResidueChartFactories/DistributionChartFactoryImpl/DistributionChartFactory");
+const AlignmentCollector_1 = require("../../../../RcsbCollectTools/AlignmentCollector/AlignmentCollector");
+const RcsbRequestContextManager_1 = require("../../../../RcsbRequest/RcsbRequestContextManager");
+const Helper_1 = require("./Helper");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var ResidueChartTools;
+(function (ResidueChartTools) {
+    var assertDefined = Assertions_1.Assertions.assertDefined;
+    function getResidueDistribution(residueChart) {
+        return tslib_1.__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 tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const instanceIds = (yield RcsbRequestContextManager_1.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_1.Helper.mergeCharts(charts);
+        });
+    }
+    function getInstanceCharts(instanceId) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const alignmentRequestContext = {
+                queryId: instanceId,
+                from: GqlTypes_1.SequenceReference.PdbInstance,
+                to: GqlTypes_1.SequenceReference.PdbInstance
+            };
+            const alignmentResponse = yield alignmentCollector.collect(alignmentRequestContext);
+            const annotationsRequestContext = {
+                queryId: instanceId,
+                reference: GqlTypes_1.SequenceReference.PdbInstance,
+                sources: [GqlTypes_1.Source.PdbEntity, GqlTypes_1.Source.PdbInstance, GqlTypes_1.Source.Uniprot, GqlTypes_1.Source.PdbInterface],
+                annotationGenerator: RcsbFvInterface_1.interfaceAnnotations,
+                annotationFilter: RcsbFvInterface_1.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 tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return processAnnotations({
+                annotations,
+                annotationBlockManager: new AnnotationBlockManager_1.AnnotationBlockManager(new AnnotationTrackManager_1.AnnotationTrackManagerFactory(), new RcsbAnnotationConfig_1.RcsbAnnotationConfig(rcm)),
+                annotationRequestContext,
+                trackBlockFactory: new TrackBlockFactory_1.TrackBlockFactory(),
+                residueDistributionFactory: new TrackDistributionFactory_1.TrackDistributionFactory(),
+                distributionChartFactory: new DistributionChartFactory_1.DistributionChartFactory(),
+                numberResidues
+            });
+        });
+    }
+    function processAnnotations(config) {
+        return tslib_1.__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_1.AnnotationCollector();
+    const alignmentCollector = new AlignmentCollector_1.AlignmentCollector();
+})(ResidueChartTools || (exports.ResidueChartTools = ResidueChartTools = {}));

package/lib/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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/commonjs/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
+            }
+        }
+    }
+}