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

package/lib/RcsbUtils/Helpers/SingletonMap.js

@@ -0,0 +1,11 @@
+export class SingletonMap {
+    static update(key, obj) {
+        if (SingletonMap.map.has(key)) {
+            Object.assign(SingletonMap.map.get(key), obj);
+        }
+        else {
+            SingletonMap.map.set(key, obj);
+        }
+    }
+}
+SingletonMap.map = new Map();

package/lib/RcsbUtils/Helpers/UrlTools.d.ts

@@ -0,0 +1,11 @@
+export declare namespace UrlTools {
+    function encodeUrlParameterList(paramList: {
+        key: string;
+        value: any;
+    }[]): void;
+    function encodeUrlParameter(key: string, value: any): void;
+    function decodeUrlParameters(): {
+        key: string;
+        value: any;
+    }[] | undefined;
+}

package/lib/RcsbUtils/Helpers/UrlTools.js

@@ -0,0 +1,31 @@
+export var UrlTools;
+(function (UrlTools) {
+    function encodeUrlParameterList(paramList) {
+        const urlParams = [];
+        paramList.filter(p => p.value).forEach(p => {
+            urlParams.push(`${p.key}=${encode(p.value)}`);
+        });
+        globalThis === null || globalThis === void 0 ? void 0 : globalThis.history.replaceState(null, "", "?" + urlParams.join("&"));
+    }
+    UrlTools.encodeUrlParameterList = encodeUrlParameterList;
+    function encodeUrlParameter(key, value) {
+        globalThis === null || globalThis === void 0 ? void 0 : globalThis.history.replaceState(null, "", "?" + (value ? `${key}=${encode(value)}` : ""));
+    }
+    UrlTools.encodeUrlParameter = encodeUrlParameter;
+    function decodeUrlParameters() {
+        var _a;
+        return (_a = parseUrlParameters()) === null || _a === void 0 ? void 0 : _a.map(param => ({ key: param.key, value: JSON.parse(decodeURIComponent(param.value)) }));
+    }
+    UrlTools.decodeUrlParameters = decodeUrlParameters;
+    function parseUrlParameters() {
+        if (globalThis.window.location.search.length === 0)
+            return;
+        return globalThis.window.location.search.substring(1)
+            .split("&")
+            .map((param) => (param.split("=")))
+            .map((param) => ({ key: param[0], value: param[1] }));
+    }
+    function encode(p) {
+        return encodeURIComponent(JSON.stringify(p));
+    }
+})(UrlTools || (UrlTools = {}));

package/lib/RcsbUtils/PairwiseAlignmentTools/AlignmentReference.d.ts

@@ -0,0 +1,17 @@
+import { AlignmentResponse } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+type AlignmentRefType = (number | undefined)[];
+export declare class AlignmentReference {
+    private readonly alignmentRefMap;
+    private readonly refId;
+    private readonly alignmentRefGaps;
+    private readonly memberRefList;
+    constructor(refId: string, targetId: string, alignment: AlignmentRefType, target: AlignmentRefType);
+    addAlignment(id: string, alignment: AlignmentRefType, target: AlignmentRefType): void;
+    buildAlignments(): AlignmentResponse;
+    private addRef;
+    private addEnd;
+    private addBeg;
+    private addGap;
+    private extendGap;
+}
+export {};

package/lib/RcsbUtils/PairwiseAlignmentTools/AlignmentReference.js

@@ -0,0 +1,165 @@
+import { cloneDeep } from "lodash";
+export class AlignmentReference {
+    constructor(refId, targetId, alignment, target) {
+        this.memberRefList = [];
+        this.alignmentRefMap = cloneDeep(alignment);
+        this.alignmentRefGaps = findGaps(alignment);
+        if (alignment.length != target.length)
+            throw new Error("Alignment and target length error");
+        this.refId = refId;
+        this.memberRefList.push({
+            id: targetId,
+            map: alignment.map((v, n) => n),
+            ref: cloneDeep(alignment),
+            target
+        });
+    }
+    addAlignment(id, alignment, target) {
+        const gaps = findGaps(alignment);
+        for (const gapBeg in gaps) {
+            if (this.alignmentRefGaps[gapBeg])
+                this.extendGap(parseInt(gapBeg), gaps[gapBeg]);
+            else
+                this.addGap(parseInt(gapBeg), gaps[gapBeg]);
+        }
+        const beg = alignment.filter(a => (a && this.alignmentRefMap[0] && a < this.alignmentRefMap[0]));
+        if (beg.length > 0)
+            this.addBeg(beg);
+        const n = this.alignmentRefMap[this.alignmentRefMap.length - 1];
+        const end = alignment.filter(a => (a && n && a > n));
+        if (end.length > 0)
+            this.addEnd(end);
+        this.addRef(id, alignment, target);
+    }
+    buildAlignments() {
+        return buildAlignments(this.refId, this.alignmentRefMap, this.memberRefList);
+    }
+    addRef(id, alignment, target) {
+        const map = Array(this.alignmentRefMap.length).fill(undefined);
+        alignment.forEach((v, n) => {
+            if (typeof v === "undefined")
+                return;
+            const index = this.alignmentRefMap.findIndex(e => e === v);
+            if (index >= 0)
+                map[index] = n;
+        });
+        const gaps = findGaps(alignment);
+        for (const gapBeg in gaps) {
+            const index = this.alignmentRefMap.findIndex(v => v === parseInt(gapBeg));
+            for (let i = 1; i <= gaps[gapBeg]; i++) {
+                map[index + i] = map[index] + i;
+            }
+        }
+        this.memberRefList.push({
+            id,
+            map,
+            ref: cloneDeep(alignment),
+            target: cloneDeep(target)
+        });
+    }
+    addEnd(indexList) {
+        const last = this.alignmentRefMap.length;
+        this.alignmentRefMap.splice(last, 0, ...indexList);
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(last, 0, ...Array(indexList.length).fill(undefined));
+        });
+    }
+    addBeg(indexList) {
+        this.alignmentRefMap.splice(0, 0, ...indexList);
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(0, 0, ...Array(indexList.length).fill(undefined));
+        });
+    }
+    addGap(gapBeg, gapLength) {
+        this.alignmentRefGaps[gapBeg] = gapLength;
+        const i = this.alignmentRefMap.findIndex((v) => v === gapBeg) + 1;
+        this.alignmentRefMap.splice(i, 0, ...Array(gapLength).fill(undefined));
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(i, 0, ...Array(gapLength).fill(undefined));
+        });
+    }
+    extendGap(gapBeg, gapLength) {
+        if (!this.alignmentRefGaps[gapBeg] || this.alignmentRefGaps[gapBeg] >= gapLength)
+            return;
+        const delta = gapLength - this.alignmentRefGaps[gapBeg];
+        this.alignmentRefGaps[gapBeg] += delta;
+        const i = this.alignmentRefMap.findIndex((v) => v === gapBeg) + 1;
+        this.alignmentRefMap.splice(i, 0, ...Array(delta).fill(undefined));
+        this.memberRefList.forEach(mr => {
+            mr.map.splice(i, 0, ...Array(delta).fill(undefined));
+        });
+    }
+}
+function buildAlignments(refId, alignmentRefMap, alignmentMembers) {
+    const out = {};
+    out.target_alignment = [];
+    out.target_alignment.push({
+        aligned_regions: buildRegions(alignmentRefMap),
+        target_id: refId
+    });
+    alignmentMembers.forEach(am => {
+        var _a;
+        (_a = out.target_alignment) === null || _a === void 0 ? void 0 : _a.push({
+            target_id: am.id,
+            aligned_regions: buildRegions(am.map.map((v, n) => typeof v === "number" ? am.target[v] : undefined))
+        });
+    });
+    return out;
+}
+function buildRegions(alignment) {
+    const out = [];
+    let begIndex = 0;
+    let begPos = 0;
+    alignment.forEach((v, n) => {
+        if (!v) {
+            if (begIndex > 0) {
+                out.push({
+                    query_begin: begIndex,
+                    target_begin: begPos,
+                    query_end: n,
+                    target_end: alignment[n - 1]
+                });
+                begIndex = 0;
+                begPos = 0;
+            }
+        }
+        else {
+            if (begIndex == 0) {
+                begIndex = n + 1;
+                begPos = v;
+            }
+        }
+    });
+    if (begPos > 0) {
+        const n = alignment.length;
+        out.push({
+            query_begin: begIndex,
+            target_begin: begPos,
+            query_end: n,
+            target_end: alignment[n - 1]
+        });
+    }
+    return out;
+}
+function findGaps(alignment) {
+    const out = {};
+    let gapBeg = 0;
+    let gapLength = 0;
+    alignment.forEach((v, n) => {
+        if (!v) {
+            if (gapBeg == 0)
+                gapBeg = alignment[n - 1];
+            gapLength++;
+        }
+        else {
+            if (gapLength > 0) {
+                out[gapBeg] = gapLength;
+                gapBeg = 0;
+                gapLength = 0;
+            }
+        }
+    });
+    if (gapLength > 0)
+        out[gapBeg] = gapLength;
+    return out;
+}

package/lib/RcsbUtils/PairwiseAlignmentTools/PairwiseAlignmentBuilder.d.ts

@@ -0,0 +1,37 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+export interface PairwiseAlignmentInterface {
+    querySequence: string;
+    targetSequence: string;
+    queryAlignment: string;
+    targetAlignment: string;
+    queryBegin: number;
+    queryEnd: number;
+    targetBegin: number;
+    targetEnd: number;
+    targetId: string;
+    queryId: string;
+    sequenceId: number;
+    isQueryExternal: boolean;
+    isTargetExternal: boolean;
+    pairwiseView?: boolean;
+}
+export declare class PairwiseAlignmentBuilder {
+    private querySequence;
+    private targetSequence;
+    private queryAlignment;
+    private targetAlignment;
+    private readonly queryBegin;
+    private readonly targetBegin;
+    private readonly alignmentLength;
+    private readonly targetId;
+    private readonly queryId;
+    private sequenceId;
+    private readonly isQueryExternal;
+    private readonly isTargetExternal;
+    private readonly pairwiseView;
+    constructor(paI: PairwiseAlignmentInterface);
+    getLength(): number;
+    buildReferenceAlignment(): Array<RcsbFvRowConfigInterface>;
+    buildPairwiseAlignment(): Array<RcsbFvRowConfigInterface>;
+    private addBlockTerminalTags;
+}

package/lib/RcsbUtils/PairwiseAlignmentTools/PairwiseAlignmentBuilder.js

@@ -0,0 +1,291 @@
+import { RcsbAnnotationConstants } from "../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { SequenceReference } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { FeatureTools } from "../../RcsbCollectTools/FeatureTools/FeatureTools";
+import { TrackUtils } from "../../RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/Helper/TrackUtils";
+const gradient = (color1, color2, weight) => {
+    const w1 = weight;
+    const w2 = 1 - w1;
+    return [Math.round(color1[0] * w1 + color2[0] * w2),
+        Math.round(color1[1] * w1 + color2[1] * w2),
+        Math.round(color1[2] * w1 + color2[2] * w2)];
+};
+//TODO This class is not using factories to build PFV row configurations
+export class PairwiseAlignmentBuilder {
+    constructor(paI) {
+        this.querySequence = paI.querySequence;
+        this.targetSequence = paI.targetSequence;
+        this.queryAlignment = paI.queryAlignment;
+        this.targetAlignment = paI.targetAlignment;
+        this.queryBegin = paI.queryBegin;
+        this.targetBegin = paI.targetBegin;
+        this.targetId = paI.targetId;
+        this.queryId = paI.queryId;
+        this.sequenceId = paI.sequenceId;
+        this.isQueryExternal = paI.isQueryExternal;
+        this.isTargetExternal = paI.isTargetExternal;
+        this.pairwiseView = paI.pairwiseView;
+        if (this.queryAlignment.length != this.targetAlignment.length)
+            throw "Sequence alignments length mismatch";
+        if (this.pairwiseView)
+            this.alignmentLength = this.queryAlignment.length;
+        else
+            this.alignmentLength = this.querySequence.length;
+    }
+    getLength() {
+        return this.alignmentLength;
+    }
+    buildReferenceAlignment() {
+        const qA = this.queryAlignment.split('');
+        const tA = this.targetAlignment.split('');
+        const alignedBlocks = [];
+        const mismatchData = [];
+        const targetSequence = [];
+        let currentQueryIndex = this.queryBegin;
+        let currentTargetIndex = this.targetBegin;
+        let blockQueryStart = this.queryBegin;
+        let blockTargetStart = this.targetBegin;
+        qA.forEach((q, i) => {
+            const t = tA[i];
+            if ((t === "-" || q === "-") && blockQueryStart > 0) {
+                alignedBlocks.push({
+                    begin: blockQueryStart,
+                    end: (currentQueryIndex - 1),
+                    oriBegin: blockTargetStart,
+                    oriEnd: (currentTargetIndex - 1),
+                    source: this.isTargetExternal ? RcsbAnnotationConstants.provenanceName.userInput : TrackUtils.transformSourceFromTarget(this.targetId, SequenceReference.PdbEntity),
+                    sourceId: this.targetId,
+                    provenanceName: RcsbAnnotationConstants.provenanceName.mmseqs,
+                    provenanceColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                    type: "ALIGNED_BLOCK",
+                    title: "ALIGNED REGION"
+                });
+                blockQueryStart = 0;
+            }
+            if (q != "-" && t != "-") {
+                targetSequence.push({
+                    begin: currentQueryIndex,
+                    oriBegin: currentTargetIndex,
+                    source: this.isTargetExternal ? RcsbAnnotationConstants.provenanceName.userInput : TrackUtils.transformSourceFromTarget(this.targetId, SequenceReference.PdbEntity),
+                    sourceId: this.targetId,
+                    provenanceName: TrackUtils.getProvenanceConfigFormTarget(this.targetId, this.targetId).name,
+                    provenanceColor: TrackUtils.getProvenanceConfigFormTarget(this.targetId, this.targetId).color,
+                    label: t,
+                    type: "RESIDUE",
+                    title: "RESIDUE"
+                });
+                if (q != t) {
+                    mismatchData.push({
+                        begin: currentQueryIndex,
+                        oriBegin: currentTargetIndex,
+                        source: this.isTargetExternal ? RcsbAnnotationConstants.provenanceName.userInput : TrackUtils.transformSourceFromTarget(this.targetId, SequenceReference.PdbEntity),
+                        sourceId: this.targetId,
+                        provenanceName: RcsbAnnotationConstants.provenanceName.mmseqs,
+                        provenanceColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                        type: "MISMATCH",
+                        title: "MISMATCH"
+                    });
+                }
+            }
+            if (t != "-" && q != "-" && blockQueryStart == 0) {
+                blockQueryStart = currentQueryIndex;
+                blockTargetStart = currentTargetIndex;
+            }
+            if (q != "-") {
+                currentQueryIndex++;
+            }
+            if (t != "-") {
+                currentTargetIndex++;
+            }
+        });
+        if (blockQueryStart > 0) {
+            alignedBlocks.push({
+                begin: blockQueryStart,
+                end: (currentQueryIndex - 1),
+                oriBegin: blockTargetStart,
+                oriEnd: (currentTargetIndex - 1),
+                source: this.isTargetExternal ? RcsbAnnotationConstants.provenanceName.userInput : TrackUtils.transformSourceFromTarget(this.targetId, SequenceReference.PdbEntity),
+                sourceId: this.targetId,
+                provenanceName: RcsbAnnotationConstants.provenanceName.mmseqs,
+                provenanceColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                type: "ALIGNED_BLOCK",
+                title: "ALIGNED REGION"
+            });
+        }
+        this.addBlockTerminalTags(alignedBlocks);
+        const queryTrack = {
+            trackId: "query_sequence",
+            displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+            trackColor: "#F9F9F9",
+            displayColor: "#000000",
+            titleFlagColor: TrackUtils.getProvenanceConfigFormTarget(this.queryId, SequenceReference.PdbEntity).color,
+            rowTitle: this.queryId,
+            nonEmptyDisplay: true,
+            trackData: this.querySequence.split('').map((s, n) => ({
+                source: this.isQueryExternal ? RcsbAnnotationConstants.provenanceName.userInput : TrackUtils.transformSourceFromTarget(this.queryId, SequenceReference.PdbEntity),
+                sourceId: this.queryId,
+                provenanceName: TrackUtils.getProvenanceConfigFormTarget(this.queryId, this.queryId).name,
+                provenanceColor: TrackUtils.getProvenanceConfigFormTarget(this.queryId, this.queryId).color,
+                label: s,
+                begin: n + 1
+            }))
+        };
+        const targetSequenceDisplay = {
+            displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+            displayColor: "#333333",
+            displayData: targetSequence
+        };
+        const mismatchDisplay = {
+            displayType: "pin" /* RcsbFvDisplayTypes.PIN */,
+            displayColor: "#FF9999",
+            displayData: mismatchData,
+            minRatio: 5
+        };
+        const blockColor = "rgb(" + gradient([153, 153, 255], [50, 50, 50], this.sequenceId).join(",") + ")";
+        const alignmentDisplay = {
+            displayType: "block" /* RcsbFvDisplayTypes.BLOCK */,
+            displayColor: blockColor,
+            displayData: alignedBlocks
+        };
+        const alignmentTrack = {
+            trackId: "targetSequenceTrack",
+            rowTitle: this.targetId,
+            displayType: "composite" /* RcsbFvDisplayTypes.COMPOSITE */,
+            trackColor: "#F9F9F9",
+            titleFlagColor: TrackUtils.getProvenanceConfigFormTarget(this.targetId, SequenceReference.PdbEntity).color,
+            displayConfig: [alignmentDisplay, mismatchDisplay, targetSequenceDisplay]
+        };
+        return [queryTrack, alignmentTrack];
+    }
+    buildPairwiseAlignment() {
+        const qA = this.queryAlignment.split('');
+        const tA = this.targetAlignment.split('');
+        const alignedBlocks = [];
+        const mismatchData = [];
+        const querySeq = [];
+        const targetSeq = [];
+        let currentQueryIndex = this.queryBegin;
+        let currentTargetIndex = this.targetBegin;
+        let start = 1;
+        qA.forEach((q, i) => {
+            const t = tA[i];
+            if (q === "-" || t === "-") {
+                if (start > 0 && i > start) {
+                    alignedBlocks.push({
+                        begin: start,
+                        end: i,
+                        provenanceName: RcsbAnnotationConstants.provenanceName.mmseqs,
+                        provenanceColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                        type: "ALIGNED_BLOCK",
+                        title: "ALIGNED REGION"
+                    });
+                    start = 0;
+                }
+            }
+            else if (q != "-" && t != "-" && start == 0) {
+                start = i + 1;
+            }
+            if (q != "-" && t != "-" && q != t && start > 0) {
+                mismatchData.push({
+                    begin: i + 1,
+                    provenanceName: RcsbAnnotationConstants.provenanceName.mmseqs,
+                    provenanceColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                    type: "MISMATCH",
+                    title: "MISMATCH"
+                });
+            }
+            querySeq.push({
+                begin: i + 1,
+                label: q,
+                source: RcsbAnnotationConstants.provenanceName.userInput,
+                sourceId: this.queryId,
+                provenanceName: this.queryId,
+                provenanceColor: RcsbAnnotationConstants.provenanceColorCode.external,
+                oriBegin: q != "-" ? currentQueryIndex : undefined
+            });
+            if (q != "-") {
+                currentQueryIndex++;
+            }
+            targetSeq.push({
+                begin: i + 1,
+                label: t,
+                source: TrackUtils.transformSourceFromTarget(this.targetId, SequenceReference.PdbEntity),
+                sourceId: this.targetId,
+                provenanceName: TrackUtils.getProvenanceConfigFormTarget(this.targetId, SequenceReference.PdbEntity).name,
+                provenanceColor: TrackUtils.getProvenanceConfigFormTarget(this.targetId, SequenceReference.PdbEntity).color,
+                oriBegin: t != "-" ? currentTargetIndex : undefined
+            });
+            if (t != "-") {
+                currentTargetIndex++;
+            }
+        });
+        if (start > 0) {
+            alignedBlocks.push({
+                begin: start,
+                end: this.alignmentLength,
+                provenanceName: RcsbAnnotationConstants.provenanceName.mmseqs,
+                provenanceColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                type: "ALIGNED_BLOCK",
+                title: "ALIGNED REGION"
+            });
+        }
+        const queryTrack = {
+            trackId: "query_sequence",
+            displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+            trackColor: "#F9F9F9",
+            displayColor: "#000000",
+            rowTitle: this.queryId,
+            titleFlagColor: TrackUtils.getProvenanceConfigFormTarget(this.queryId, SequenceReference.PdbEntity).color,
+            nonEmptyDisplay: true,
+            trackData: querySeq
+        };
+        const targetTrack = {
+            trackId: "target_sequence",
+            displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+            trackColor: "#F9F9F9",
+            displayColor: "#000000",
+            rowTitle: this.targetId,
+            titleFlagColor: TrackUtils.getProvenanceConfigFormTarget(this.targetId, SequenceReference.PdbEntity).color,
+            nonEmptyDisplay: true,
+            trackData: targetSeq
+        };
+        const mismatchDisplay = {
+            displayType: "pin" /* RcsbFvDisplayTypes.PIN */,
+            displayColor: "#FF9999",
+            displayData: mismatchData,
+            minRatio: 5
+        };
+        const blockColor = "rgb(" + gradient([153, 153, 255], [50, 50, 50], this.sequenceId).join(",") + ")";
+        const alignmentDisplay = {
+            displayType: "block" /* RcsbFvDisplayTypes.BLOCK */,
+            displayColor: blockColor,
+            displayData: alignedBlocks
+        };
+        const alignmentTrack = {
+            trackId: "targetSequenceTrack",
+            displayType: "composite" /* RcsbFvDisplayTypes.COMPOSITE */,
+            trackColor: "#F9F9F9",
+            rowTitle: " ",
+            titleFlagColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+            displayConfig: [alignmentDisplay, mismatchDisplay]
+        };
+        return [queryTrack, alignmentTrack, targetTrack];
+    }
+    addBlockTerminalTags(alignedBlocks) {
+        var _a;
+        if ((_a = alignedBlocks[0].oriBegin) !== null && _a !== void 0 ? _a : 0 > 1) {
+            alignedBlocks[0].openBegin = true;
+        }
+        for (let n = 0; n < (alignedBlocks.length - 1); n++) {
+            const oriEnd = alignedBlocks[n].oriEnd;
+            if (oriEnd && oriEnd + 1 != alignedBlocks[n + 1].oriBegin) {
+                alignedBlocks[n].openEnd = true;
+                alignedBlocks[n + 1].openBegin = true;
+            }
+        }
+        const oriEnd = alignedBlocks[alignedBlocks.length - 1].oriEnd;
+        if (oriEnd && oriEnd < this.targetSequence.length) {
+            alignedBlocks[alignedBlocks.length - 1].openEnd = true;
+        }
+        FeatureTools.mergeBlocks(alignedBlocks);
+    }
+}

package/lib/RcsbUtils/TrackGenerators/AlignmentGlobalBindingSite.d.ts

@@ -0,0 +1,2 @@
+import { ExternalTrackBuilderInterface } from "../../RcsbCollectTools/FeatureTools/ExternalTrackBuilderInterface";
+export declare function alignmentGlobalLigandBindingSite(): ExternalTrackBuilderInterface;

package/lib/RcsbUtils/TrackGenerators/AlignmentGlobalBindingSite.js

@@ -0,0 +1,99 @@
+import { __awaiter } from "tslib";
+import { RcsbAnnotationConstants } from "../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { groupExternalTrackBuilder } from "./GroupExternalTrackBuilder";
+import { Assertions } from "../Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+export function alignmentGlobalLigandBindingSite() {
+    const trackName = "GLOBAL BINDING";
+    const bindingSiteMap = new Map();
+    let max = 0;
+    const groupTrackBuilder = groupExternalTrackBuilder();
+    return {
+        addTo(tracks) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (Array.from(bindingSiteMap.values()).length > 0)
+                    tracks.annotationTracks.unshift({
+                        trackId: "annotationTrack_GLOBAL_BINDINGS",
+                        trackHeight: 40,
+                        displayType: "area" /* RcsbFvDisplayTypes.AREA */,
+                        overlap: true,
+                        trackColor: "#F9F9F9",
+                        displayColor: "#c4124b",
+                        titleFlagColor: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+                        rowTitle: trackName,
+                        displayDomain: [0, max],
+                        interpolationType: "step" /* InterpolationTypes.STEP */,
+                        trackData: Array.from(bindingSiteMap.values())
+                    });
+                yield ((_a = groupTrackBuilder.addTo) === null || _a === void 0 ? void 0 : _a.call(groupTrackBuilder, tracks));
+            });
+        },
+        processAlignmentAndFeatures(data) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                yield ((_a = groupTrackBuilder.processAlignmentAndFeatures) === null || _a === void 0 ? void 0 : _a.call(groupTrackBuilder, data));
+                processFeatures(data.annotations);
+            });
+        },
+        filterFeatures(data) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                const annotations = (_b = yield ((_a = groupTrackBuilder.filterFeatures) === null || _a === void 0 ? void 0 : _a.call(groupTrackBuilder, data))) !== null && _b !== void 0 ? _b : [];
+                annotations.forEach(ann => {
+                    var _a;
+                    ann.features = (_a = ann.features) === null || _a === void 0 ? void 0 : _a.filter(f => { var _a; return f ? (_a = f.name) === null || _a === void 0 ? void 0 : _a.includes("ligand") : false; });
+                });
+                return new Promise((resolve => {
+                    resolve(annotations);
+                }));
+            });
+        },
+        filterAlignments(data) {
+            assertDefined(groupTrackBuilder.filterAlignments);
+            return groupTrackBuilder.filterAlignments(data);
+        }
+    };
+    function processFeatures(annotations) {
+        // position > ligand name
+        const ligandMap = new Map();
+        annotations.forEach(ann => {
+            var _a;
+            (_a = ann.features) === null || _a === void 0 ? void 0 : _a.forEach(d => {
+                var _a;
+                if (d)
+                    (_a = d.feature_positions) === null || _a === void 0 ? void 0 : _a.forEach(p => {
+                        var _a;
+                        if (p === null || p === void 0 ? void 0 : p.beg_seq_id)
+                            (_a = p.values) === null || _a === void 0 ? void 0 : _a.forEach((v, n) => {
+                                var _a, _b;
+                                const key = (p.beg_seq_id + n).toString();
+                                if (!ligandMap.has(key))
+                                    ligandMap.set(key, new Set());
+                                else if (d.name && !((_a = ligandMap.get(key)) === null || _a === void 0 ? void 0 : _a.has(d.name)))
+                                    (_b = ligandMap.get(key)) === null || _b === void 0 ? void 0 : _b.add(d.name);
+                                else
+                                    return;
+                                const bs = bindingSiteMap.get(key);
+                                if (!bs) {
+                                    bindingSiteMap.set(key, {
+                                        begin: p.beg_seq_id + n,
+                                        type: trackName,
+                                        value: 1
+                                    });
+                                    if (max == 0)
+                                        max = 1;
+                                }
+                                else {
+                                    if (bs) {
+                                        bs.value += 1;
+                                        if (bs.value > max)
+                                            max = bs.value;
+                                    }
+                                }
+                            });
+                    });
+            });
+        });
+    }
+}

package/lib/RcsbUtils/TrackGenerators/BurialFraction.d.ts

@@ -0,0 +1,3 @@
+import { AnnotationFeatures } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+export declare function burialFraction(annotations: Array<AnnotationFeatures>): Array<AnnotationFeatures>;
+export declare function burialFractionFilter(annotations: Array<AnnotationFeatures>): Array<AnnotationFeatures>;