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

package/lib/RcsbUtils/TrackGenerators/GroupExternalTrackBuilder.js

@@ -0,0 +1,96 @@
+import { Logo } from "./Logo";
+import { RcsbAnnotationConstants } from "../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { Assertions } from "../Helpers/Assertions";
+var assertElementListDefined = Assertions.assertElementListDefined;
+import { GroupGapLessTransformer } from "../Groups/GroupGapLessTransformer";
+export function groupExternalTrackBuilder() {
+    const seqName = "CONSENSUS SEQUENCE";
+    const conservationName = "SEQUENCE VARIATION";
+    const querySequenceLogo = new Array();
+    const gapLessTransformer = new GroupGapLessTransformer();
+    let variationRowData;
+    return {
+        addTo(tracks) {
+            if (querySequenceLogo.length == 0)
+                return new Promise((resolve) => {
+                    resolve();
+                });
+            variationRowData.forEach(track => tracks.alignmentTracks.unshift(track));
+            return new Promise((resolve) => {
+                resolve();
+            });
+        },
+        processAlignmentAndFeatures(data) {
+            return new Promise((resolve) => {
+                resolve();
+            });
+        },
+        filterFeatures(data) {
+            gapLessTransformer.gapLessFeatures(data.annotations);
+            data.annotations.forEach(ann => {
+                var _a;
+                ann.features = (_a = ann.features) === null || _a === void 0 ? void 0 : _a.filter(f => ((f === null || f === void 0 ? void 0 : f.name) != "automated matches"));
+            });
+            return new Promise((resolve) => {
+                resolve(data.annotations);
+            });
+        },
+        filterAlignments(data) {
+            gapLessTransformer.gapLessAlignments(data.alignments);
+            processAlignments(data.alignments);
+            return new Promise((resolve) => {
+                resolve(data.alignments);
+            });
+        }
+    };
+    function processAlignments(alignment) {
+        var _a, _b;
+        if (querySequenceLogo.length > 0) {
+            return;
+        }
+        if (alignment.alignment_length && alignment.alignment_logo && alignment.alignment_length != ((_a = alignment.alignment_logo) === null || _a === void 0 ? void 0 : _a.length))
+            throw new Error("ERROR Alignment length and logo should match");
+        (_b = alignment.alignment_logo) === null || _b === void 0 ? void 0 : _b.forEach(al => {
+            assertElementListDefined(al);
+            querySequenceLogo.push(new Logo(al));
+        });
+        const sequenceRowData = querySequenceLogo.map((s, n) => {
+            const nFreq = 5;
+            const maxFreqList = s.frequency().filter(f => f.symbol != "-").slice(0, nFreq).map(f => Math.trunc(f.value * 100) / 100);
+            const gapFreq = Math.trunc(s.frequency().filter(f => f.symbol == "-")[0].value * 100) / 100;
+            return {
+                begin: n + 1,
+                values: maxFreqList.map((f, n) => maxFreqList.slice(0, (n + 1)).reduce((v, n) => v + n)).concat([1 - gapFreq, 1]),
+                value: s.frequency()[0].symbol != "-" ? Math.trunc(s.frequency()[0].value * 100) / 100 : 0
+            };
+        });
+        const logoRowData = querySequenceLogo.map((s, n) => ({
+            begin: n + 1,
+            label: s.mode(),
+            description: [s.frequency().filter(s => (s.value >= 0.01)).map(s => (s.symbol.replace("-", "gap") + ": " + Math.trunc(s.value * 100) / 100)).join(", ")]
+        }));
+        variationRowData = [{
+                trackId: "annotationTrack_ALIGNMENT_FREQ",
+                displayType: "multi-area" /* RcsbFvDisplayTypes.MULTI_AREA */,
+                overlap: true,
+                trackColor: "#F9F9F9",
+                displayColor: {
+                    thresholds: [],
+                    colors: ["#5289e9", "#76bbf6", "#91cef6", "#b9d9f8", "#d6eafd", "#e6f5fd", "#f9f9f9"]
+                },
+                trackHeight: 20,
+                titleFlagColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                rowTitle: conservationName,
+                trackData: sequenceRowData
+            }, {
+                trackId: "annotationTrack_ALIGNMENT_MODE",
+                displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+                overlap: true,
+                trackColor: "#F9F9F9",
+                titleFlagColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                rowTitle: seqName,
+                nonEmptyDisplay: true,
+                trackData: logoRowData
+            }];
+    }
+}

package/lib/RcsbUtils/TrackGenerators/Logo.js

@@ -0,0 +1,45 @@
+import { Assertions } from "../Helpers/Assertions";
+var assertElementListDefined = Assertions.assertElementListDefined;
+var assertDefined = Assertions.assertDefined;
+export class Logo {
+    constructor(logo) {
+        this.symbols = Object();
+        this.n = 0;
+        assertElementListDefined(logo);
+        logo.forEach(s => {
+            assertDefined(s.symbol);
+            assertDefined(s.value);
+            this.symbols[s.symbol] = s.value;
+            this.n += s.value;
+        });
+    }
+    aaTypes() {
+        return Object.keys(this.symbols);
+    }
+    /*add(aa: T): void{
+        this.symbols[aa] ++;
+        this.n ++;
+    }*/
+    get(aa) {
+        const n = this.symbols[aa];
+        assertDefined(n);
+        return n;
+    }
+    total() {
+        return this.n;
+    }
+    forEach(callback) {
+        this.aaTypes().forEach((aa, n) => {
+            callback(aa, n);
+        });
+    }
+    mode() {
+        return this.aaTypes().sort((a, b) => (this.symbols[b] - this.symbols[a]))[0];
+    }
+    frequency() {
+        return this.aaTypes().sort((a, b) => (this.symbols[b] - this.symbols[a])).map(a => ({ symbol: a, value: this.get(a) / this.n }));
+    }
+    entropy() {
+        return -this.aaTypes().map(aa => (this.get(aa) != 0 ? (this.get(aa) / this.n) * (Math.log(this.get(aa) / this.n) / Math.log(this.aaTypes().length)) : 0)).reduce((p, v) => (p + v));
+    }
+}

package/lib/RcsbUtils/Translators/AssemblyInterfacesTranslate.js

@@ -0,0 +1,15 @@
+export class AssemblyInterfacesTranslate {
+    constructor(data) {
+        this.interfaceMap = new Map();
+        this.rawData = data;
+        data.forEach(d => {
+            this.interfaceMap.set(d.rcsbId, d.interfaceIds);
+        });
+    }
+    getInterfaces(assemblyId) {
+        return this.interfaceMap.get(assemblyId);
+    }
+    getRawData() {
+        return this.rawData;
+    }
+}

package/lib/RcsbUtils/Translators/EntryAssemblyTranslate.js

@@ -0,0 +1,8 @@
+export class EntryAssemblyTranslate {
+    constructor(data) {
+        this.rawData = data;
+    }
+    getData() {
+        return this.rawData;
+    }
+}

package/lib/RcsbUtils/Translators/InterfaceInstanceTranslate.js

@@ -0,0 +1,20 @@
+export class InterfaceInstanceTranslate {
+    constructor(data) {
+        this.instances = new Map();
+        this.operatorsIds = new Map();
+        this.rawData = data;
+        data.forEach(d => {
+            this.instances.set(d.rcsbId, d.asymIds);
+            this.operatorsIds.set(d.rcsbId, d.operatorIds);
+        });
+    }
+    getInstances(rcsbId) {
+        return this.instances.get(rcsbId);
+    }
+    getOperatorIds(rcsbId) {
+        return this.operatorsIds.get(rcsbId);
+    }
+    getRawData() {
+        return this.rawData;
+    }
+}

package/lib/RcsbUtils/Translators/MultipleEntityInstanceTranslate.js

@@ -0,0 +1,33 @@
+import { PolymerEntityInstanceTranslate } from "./PolymerEntityInstanceTranslate";
+import { Operator } from "../Helpers/Operator";
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class MultipleEntityInstanceTranslate {
+    constructor() {
+        this.entityInstanceTranslateMap = new Map();
+    }
+    add(data) {
+        const entryEntityInstanceMapList = new Map();
+        data.forEach(d => {
+            var _a;
+            const entityId = d.entryId + TagDelimiter.entity + d.entityId;
+            if (!entryEntityInstanceMapList.has(entityId))
+                entryEntityInstanceMapList.set(entityId, new Array());
+            (_a = entryEntityInstanceMapList.get(entityId)) === null || _a === void 0 ? void 0 : _a.push(d);
+        });
+        entryEntityInstanceMapList.forEach((v, entityId) => {
+            this.entityInstanceTranslateMap.set(entityId, new PolymerEntityInstanceTranslate(v));
+        });
+    }
+    getEntity(entityId) {
+        return this.entityInstanceTranslateMap.get(entityId);
+    }
+    getEntities() {
+        return Array.from(this.entityInstanceTranslateMap.keys());
+    }
+    getEntries() {
+        return Operator.uniqueValues(Array.from(this.entityInstanceTranslateMap.keys()).map(entityId => TagDelimiter.parseEntity(entityId).entryId));
+    }
+    getInstances() {
+        return Operator.uniqueValues(Array.from(this.entityInstanceTranslateMap.values()).map(peit => peit.getData()).flat().map(e => e.asymId));
+    }
+}

package/lib/RcsbUtils/Translators/PolymerEntityChromosomeTranslate.js

@@ -0,0 +1,8 @@
+export class PolymerEntityChromosomeTranslate {
+    constructor(entityMap) {
+        this.rawData = entityMap;
+    }
+    getData() {
+        return this.rawData;
+    }
+}

package/{build/dist → lib}/RcsbUtils/Translators/PolymerEntityInstanceTranslate.d.ts

@@ -1,5 +1,5 @@
 import { PolymerEntityInstanceInterface } from "../../RcsbCollectTools/DataCollectors/PolymerEntityInstancesCollector";
-import { RcsbFvTrackDataElementInterface } from '@rcsb/rcsb-saguaro';
+import { RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
 import { SequenceReference, Source } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
 export interface AlignmentContextInterface {
     queryId: string;

package/lib/RcsbUtils/Translators/PolymerEntityInstanceTranslate.js

@@ -0,0 +1,92 @@
+import { SequenceReference, Source } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class PolymerEntityInstanceTranslate {
+    constructor(data) {
+        this.instanceAsymToAuth = new Map();
+        this.instanceAuthToAsym = new Map();
+        this.instanceAsymToEntity = new Map();
+        this.entityToAsym = new Map();
+        this.instanceAuthResIds = new Map();
+        this.INDEX_NAME = "auth";
+        this.rawData = data;
+        data.forEach(d => {
+            var _a;
+            this.instanceAsymToAuth.set(d.asymId, d.authId);
+            this.instanceAuthToAsym.set(d.authId, d.asymId);
+            this.instanceAuthResIds.set(d.asymId, d.authResId);
+            this.instanceAsymToEntity.set(d.asymId, d.entityId);
+            if (!this.entityToAsym.has(d.entityId))
+                this.entityToAsym.set(d.entityId, new Set());
+            (_a = this.entityToAsym.get(d.entityId)) === null || _a === void 0 ? void 0 : _a.add(d.asymId);
+        });
+    }
+    getData() {
+        return this.rawData;
+    }
+    translateEntityToAsym(id) {
+        const asymIds = this.entityToAsym.get(id);
+        if (asymIds)
+            return Array.from(asymIds);
+    }
+    translateAsymToEntity(id) {
+        return this.instanceAsymToEntity.get(id);
+    }
+    translateAsymToAuth(id) {
+        return this.instanceAsymToAuth.get(id);
+    }
+    translateAuthToAsym(id) {
+        return this.instanceAuthToAsym.get(id);
+    }
+    translateAuthResId(asymId, index) {
+        const autReaIds = this.instanceAuthResIds.get(asymId);
+        if (!autReaIds)
+            return undefined;
+        else if (index > autReaIds.length)
+            return undefined;
+        else if (autReaIds[index - 1])
+            return undefined;
+        else
+            return autReaIds[index - 1];
+    }
+    addAuthorResIds(e, alignmentContext) {
+        let o = e;
+        if (alignmentContext.from === SequenceReference.PdbInstance && alignmentContext.to) {
+            const asymId = alignmentContext.queryId.split(TagDelimiter.instance)[1];
+            this.helperAddAuthorResIds(o, alignmentContext.from, alignmentContext.to, asymId);
+            o.indexName = this.INDEX_NAME;
+        }
+        else if (alignmentContext.to === SequenceReference.PdbInstance && alignmentContext.from) {
+            const asymId = alignmentContext.targetId.split(TagDelimiter.instance)[1];
+            this.helperAddAuthorResIds(o, alignmentContext.from, alignmentContext.to, asymId);
+            o.indexName = this.INDEX_NAME;
+        }
+        return o;
+    }
+    helperAddAuthorResIds(e, reference, source, asymId) {
+        let out = e;
+        const authResIds = this.instanceAuthResIds.get(asymId);
+        if (!authResIds)
+            return out;
+        if (reference === SequenceReference.PdbInstance || (reference === SequenceReference.PdbEntity && source === Source.PdbInstance)) {
+            const x = authResIds[e.begin - 1];
+            if (typeof e.end === "number" && authResIds[e.end - 1] != x) {
+                out.beginName = x;
+                out.endName = authResIds[e.end - 1];
+            }
+            else if (typeof e.end != "number" || authResIds[e.end - 1] == x) {
+                out.beginName = x;
+            }
+        }
+        else if (source === Source.PdbInstance && e.oriBegin) {
+            const x = authResIds[e.oriBegin - 1];
+            if (typeof e.oriEnd === "number" && authResIds[e.oriEnd - 1] != x) {
+                out.oriBeginName = x;
+                out.oriEndName = authResIds[e.oriEnd - 1];
+            }
+            else if (typeof e.oriEnd != "number" || authResIds[e.oriEnd - 1] == x) {
+                out.oriBeginName = x;
+            }
+        }
+        return out;
+    }
+}

package/lib/app.js

@@ -0,0 +1,11 @@
+export { buildEntryChromosome, buildFullChromosome, buildEntityChromosome, buildChromosome, buildEntityFv, buildEntitySummaryFv, buildSingleEntitySummaryFv, buildInstanceFv, buildInstanceSequenceFv, buildMultipleInstanceSequenceFv, buildAssemblySequenceFv, buildPairwiseAlignment, buildPfv, buildMultipleAlignmentSequenceFv, buildUniprotEntityFv, buildUniprotEntityInstanceFv, buildUniprotFv, buildGroupFv, buildSequenceIdentityAlignmentFv, buildUniprotAlignmentFv, buildDataProviderFv, unmount } from "./RcsbFvWeb/RcsbFvBuilder";
+export { rcsbRequestCtxManager as RcsbRequestContextManager } from "./RcsbRequest/RcsbRequestContextManager";
+export { RcsbFvUI } from "./RcsbExport/RcsbFvUI";
+export { FeatureType } from "./RcsbExport/FeatureType";
+export { SequenceTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/SequenceTrackFactory";
+export { PositionalScoreAlignmentTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PositionalScoreAlignmentTrackFactory";
+export { PlainObservedAlignmentTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainObservedAlignmentTrackFactory";
+export { PlainAlignmentTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainAlignmentTrackFactory";
+export { MsaAlignmentTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/MsaAlignmentTrackFactory";
+export { AnnotationsTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/AnnotationsTrackFactory";
+export { AlignmentTrackFactory } from "./RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/AlignmentTrackFactory";

package/lib/commonjs/ExternalResources/NcbiData/NcbiGenomeSequenceData.d.ts

@@ -0,0 +1,7 @@
+import { RcsbFvTrackData } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+import { LocationViewInterface } from "@rcsb/rcsb-saguaro/lib/RcsbBoard/RcsbBoard";
+export declare class NcbiGenomeSequenceData {
+    private static readonly urlPrefix;
+    private static readonly urlSuffix;
+    static update(ncbiId: string, strand: number, reverse: boolean, trackWidth?: number): ((where: LocationViewInterface) => Promise<RcsbFvTrackData>);
+}

package/lib/commonjs/ExternalResources/NcbiData/NcbiGenomeSequenceData.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NcbiGenomeSequenceData = void 0;
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const web_resources_json_1 = tslib_1.__importDefault(require("../../RcsbServerConfig/web.resources.json"));
+class NcbiGenomeSequenceData {
+    static update(ncbiId, strand, reverse, trackWidth) {
+        let process = null;
+        return (where) => {
+            if (process)
+                process.unsubscribe();
+            return new Promise((resolve, reject) => {
+                const delta = trackWidth ? trackWidth / (where.to - where.from) : 1000 / (where.to - where.from);
+                if (delta > 4) {
+                    let N = 0;
+                    const timeout = 5000;
+                    const getGenomeSequence = () => {
+                        const Http = new XMLHttpRequest();
+                        Http.timeout = timeout;
+                        const url = NcbiGenomeSequenceData.urlPrefix + 'id=' + ncbiId + '&from=' + where.from + '&to=' + where.to + '&strand=' + strand + NcbiGenomeSequenceData.urlSuffix;
+                        Http.open("GET", url);
+                        Http.send();
+                        Http.onloadend = (e) => {
+                            const sequence = Http.responseText.split("\n").slice(1).join("");
+                            if (sequence.length < 1) {
+                                N++;
+                                console.warn("HTTP error while access URL: " + url + " - empty sequence - " + N);
+                                if (N < 4) {
+                                    process = rxjs_1.asyncScheduler.schedule(() => {
+                                        getGenomeSequence();
+                                    }, timeout);
+                                }
+                                else {
+                                    reject("HTTP error while access URL: " + url + " - No more attempts after " + N);
+                                }
+                            }
+                            else {
+                                const selectedOption = [{
+                                        begin: where.from,
+                                        label: reverse ? sequence.split("").reverse().join("") : sequence
+                                    }];
+                                resolve(selectedOption);
+                            }
+                        };
+                        Http.onerror = (e) => {
+                            N++;
+                            console.warn("HTTP error while access URL: " + url + " - " + N);
+                            if (N < 4) {
+                                process = rxjs_1.asyncScheduler.schedule(() => {
+                                    getGenomeSequence();
+                                }, timeout);
+                            }
+                            else {
+                                reject("HTTP error while access URL: " + url + " - No more attempts after " + N);
+                            }
+                        };
+                    };
+                    getGenomeSequence();
+                }
+                else {
+                    resolve([]);
+                }
+            });
+        };
+    }
+}
+exports.NcbiGenomeSequenceData = NcbiGenomeSequenceData;
+NcbiGenomeSequenceData.urlPrefix = web_resources_json_1.default.ncbi_genome_sequence.url;
+NcbiGenomeSequenceData.urlSuffix = web_resources_json_1.default.ncbi_genome_sequence.url_suffix;

package/lib/commonjs/ExternalResources/NcbiData/NcbiSummary.d.ts

@@ -0,0 +1,24 @@
+export interface ChromosomeMetadataInterface {
+    ncbiId: string;
+    title: string;
+    organism: string;
+    extra: string;
+    taxid: number;
+    length: number;
+    subtype: string;
+    subname: string;
+    uid: number;
+}
+export interface TaxonomyMetadataInterface {
+    scientificname: string;
+    commonname: string;
+    taxid: number;
+    uid: number;
+}
+export declare class NcbiSummary {
+    private static timeout;
+    private static httpTimeout;
+    private static jobTask;
+    static requestChromosomeData(chrId: string): Promise<ChromosomeMetadataInterface>;
+    static requestTaxonomyData(taxId: string): Promise<TaxonomyMetadataInterface>;
+}

package/lib/commonjs/ExternalResources/NcbiData/NcbiSummary.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NcbiSummary = void 0;
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const web_resources_json_1 = tslib_1.__importDefault(require("../../RcsbServerConfig/web.resources.json"));
+//TODO are static attributes/methods safe in this case ?
+//TODO change `XMLHttpRequest` to `fetch`
+class NcbiSummary {
+    static requestChromosomeData(chrId) {
+        if (NcbiSummary.jobTask)
+            NcbiSummary.jobTask.unsubscribe();
+        const urlPrefix = web_resources_json_1.default.ncbi_summary_nuccore.url;
+        const urlSuffix = web_resources_json_1.default.ncbi_summary_nuccore.url_suffix;
+        return new Promise((resolve, reject) => {
+            const recursiveRequest = () => {
+                const url = urlPrefix + chrId + urlSuffix;
+                const Http = new XMLHttpRequest();
+                Http.timeout = NcbiSummary.httpTimeout;
+                Http.open("GET", url);
+                Http.send();
+                Http.onloadend = (e) => {
+                    var _a;
+                    if (Http.responseText.length == 0) {
+                        NcbiSummary.jobTask = rxjs_1.asyncScheduler.schedule(() => {
+                            recursiveRequest();
+                        }, NcbiSummary.timeout);
+                    }
+                    else {
+                        const jsonResult = JSON.parse(Http.responseText);
+                        const uid = (_a = jsonResult === null || jsonResult === void 0 ? void 0 : jsonResult.result) === null || _a === void 0 ? void 0 : _a.uids[0];
+                        const out = jsonResult.result[uid];
+                        out.ncbiId = chrId;
+                        resolve(out);
+                    }
+                };
+                Http.onerror = (e) => {
+                    if (NcbiSummary.jobTask)
+                        NcbiSummary.jobTask.unsubscribe();
+                    NcbiSummary.jobTask = rxjs_1.asyncScheduler.schedule(() => {
+                        recursiveRequest();
+                    }, NcbiSummary.timeout);
+                };
+            };
+            recursiveRequest();
+        });
+    }
+    static requestTaxonomyData(taxId) {
+        if (NcbiSummary.jobTask)
+            NcbiSummary.jobTask.unsubscribe();
+        const urlPrefix = web_resources_json_1.default.ncbi_summary_taxonomy.url;
+        const urlSuffix = web_resources_json_1.default.ncbi_summary_taxonomy.url_suffix;
+        return new Promise((resolve, reject) => {
+            const recursiveRequest = () => {
+                const url = urlPrefix + taxId + urlSuffix;
+                const Http = new XMLHttpRequest();
+                Http.timeout = NcbiSummary.httpTimeout;
+                Http.open("GET", url);
+                Http.send();
+                Http.onloadend = (e) => {
+                    var _a;
+                    if (Http.responseText.length == 0) {
+                        NcbiSummary.jobTask = rxjs_1.asyncScheduler.schedule(() => {
+                            recursiveRequest();
+                        }, NcbiSummary.timeout);
+                    }
+                    else {
+                        const jsonResult = JSON.parse(Http.responseText);
+                        const uid = (_a = jsonResult === null || jsonResult === void 0 ? void 0 : jsonResult.result) === null || _a === void 0 ? void 0 : _a.uids[0];
+                        resolve(jsonResult.result[uid]);
+                    }
+                };
+                Http.onerror = (e) => {
+                    NcbiSummary.jobTask = rxjs_1.asyncScheduler.schedule(() => {
+                        recursiveRequest();
+                    }, NcbiSummary.timeout);
+                };
+            };
+            recursiveRequest();
+        });
+    }
+}
+exports.NcbiSummary = NcbiSummary;
+NcbiSummary.timeout = 3000;
+NcbiSummary.httpTimeout = 10000;
+NcbiSummary.jobTask = null;

package/lib/commonjs/RcsbAnnotationConfig/AnnotationConfigInterface.d.ts

@@ -0,0 +1,66 @@
+import { RcsbFvDisplayTypes } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvDefaultConfigValues";
+import { RcsbFvColorGradient } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+export interface AnnotationConfigInterface {
+    provenance_color_code: {
+        external: string;
+        rcsb_pdb: string;
+        rcsb_link: string;
+        csm: string;
+    };
+    merge?: Array<{
+        merged_types: Array<string>;
+        type: string;
+        title: string;
+        display: RcsbFvDisplayTypes;
+    }>;
+    external_data_order?: Array<string>;
+    instance_order?: Array<string>;
+    entity_order?: Array<string>;
+    config: Array<RcsbAnnotationConfigInterface>;
+}
+export interface RcsbAnnotationConfigInterface {
+    type: string;
+    display: RcsbFvDisplayTypes;
+    color?: string | RcsbFvColorGradient;
+    title: string;
+    prefix?: string;
+    provenanceList: Set<string>;
+    height?: number;
+    key?: string;
+    addToType?: string[];
+    transformToNumerical?: boolean;
+    domain?: [number, number];
+    displayCooccurrence?: boolean;
+    ignore?: boolean;
+    fitTitleWidth?: boolean;
+}
+export interface RcsbDistributionConfigInterface {
+    blockConfig: RcsbTrackBlockConfigInterface[];
+    trackConfig: RcsbTrackConfigInterface[];
+}
+export interface RcsbTrackBlockConfigInterface {
+    type: string;
+    title: string;
+    trackType: string[];
+    sort: string[];
+    contentType: "binary" | "numerical";
+    undefTrack?: {
+        label: string;
+        color: string;
+        id: string;
+    };
+    axisLabel?: string;
+}
+export interface RcsbTrackConfigInterface {
+    type: string;
+    color?: string;
+    label?: string;
+    numericalCategories?: {
+        thresholds: number[];
+        categories: {
+            label: string;
+            color: string;
+            id: string;
+        }[];
+    };
+}

package/lib/commonjs/RcsbAnnotationConfig/AnnotationConfigInterface.js

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