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

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/AnnotationsTrackFactory.js

@@ -0,0 +1,145 @@
+import { __awaiter } from "tslib";
+import { RcsbAnnotationConfig } from "../../../../RcsbAnnotationConfig/RcsbAnnotationConfig";
+import { AnnotationsTrackTitleFactory } from "../TrackTitleFactoryImpl/AnnotationsTrackTitleFactory";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+export class AnnotationsTrackFactory {
+    constructor(trackTitleFactory) {
+        this.trackTitleFactory = trackTitleFactory !== null && trackTitleFactory !== void 0 ? trackTitleFactory : new AnnotationsTrackTitleFactory();
+    }
+    getTrack(annotations) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let out;
+            const type = annotations.getId();
+            const rcsbAnnotationConfig = annotations.getConfig();
+            let displayType;
+            const annConfig = rcsbAnnotationConfig;
+            if (annConfig != null) {
+                displayType = annConfig === null || annConfig === void 0 ? void 0 : annConfig.display;
+            }
+            switch (displayType) {
+                case "composite" /* RcsbFvDisplayTypes.COMPOSITE */:
+                case "bond" /* RcsbFvDisplayTypes.BOND */:
+                case "pin" /* RcsbFvDisplayTypes.PIN */:
+                    assertDefined(rcsbAnnotationConfig);
+                    out = buildRcsbFvRowConfigComposite(annotations, type, rcsbAnnotationConfig);
+                    break;
+                case "area" /* RcsbFvDisplayTypes.AREA */:
+                case "line" /* RcsbFvDisplayTypes.LINE */:
+                    assertDefined(rcsbAnnotationConfig);
+                    out = buildRcsbFvRowConfigArea(annotations, type, rcsbAnnotationConfig);
+                    break;
+                case "block-area" /* RcsbFvDisplayTypes.BLOCK_AREA */:
+                    assertDefined(rcsbAnnotationConfig);
+                    out = buildRcsbFvRowConfigBlockArea(annotations, type, rcsbAnnotationConfig);
+                    break;
+                default:
+                    out = buildRcsbFvRowConfigTrack(annotations, type, rcsbAnnotationConfig);
+                    break;
+            }
+            if (annConfig != null && typeof annConfig.height === "number") {
+                out.trackHeight = annConfig.height;
+            }
+            return Object.assign(Object.assign({}, out), { titleFlagColor: yield this.trackTitleFactory.getTrackTitleFlagColor(annotations), rowTitle: yield this.trackTitleFactory.getTrackTitle(annotations), rowPrefix: yield this.trackTitleFactory.getTrackTitlePrefix(annotations) });
+        });
+    }
+}
+function buildRcsbFvRowConfigArea(annotationTrack, type, rcsbAnnotationConfig) {
+    var _a;
+    const data = annotationTrack.values();
+    const annConfig = rcsbAnnotationConfig;
+    const displayType = annConfig === null || annConfig === void 0 ? void 0 : annConfig.display;
+    const displayColor = annConfig === null || annConfig === void 0 ? void 0 : annConfig.color;
+    let min = annotationTrack.getRange().min;
+    let max = annotationTrack.getRange().max;
+    if (min >= 0)
+        min = 0;
+    else if (Math.abs(min) > Math.abs(max))
+        max = -min;
+    else
+        min = -max;
+    const domain = (_a = annConfig === null || annConfig === void 0 ? void 0 : annConfig.domain) !== null && _a !== void 0 ? _a : [min, max];
+    return Object.assign(Object.assign({}, rcsbAnnotationConfig), { trackId: "annotationTrack_" + type, displayType: displayType, overlap: true, trackColor: "#F9F9F9", displayColor: displayColor, displayDomain: domain, interpolationType: "step" /* InterpolationTypes.STEP */, trackData: data });
+}
+function buildRcsbFvRowConfigBlockArea(annotationTrack, type, rcsbAnnotationConfig) {
+    var _a;
+    const data = annotationTrack.values();
+    const annConfig = rcsbAnnotationConfig;
+    const displayType = annConfig.display;
+    const displayColor = (_a = annConfig.color) !== null && _a !== void 0 ? _a : RcsbAnnotationConfig.randomRgba();
+    return Object.assign(Object.assign({}, rcsbAnnotationConfig), { trackId: "annotationTrack_" + type, displayType: displayType, overlap: true, trackColor: "#F9F9F9", displayColor: displayColor, displayDomain: [0, 1], interpolationType: "step" /* InterpolationTypes.STEP */, trackData: data });
+}
+function buildRcsbFvRowConfigComposite(annotationTrack, type, rcsbAnnotationConfig) {
+    var _a;
+    const data = annotationTrack.values();
+    let out = undefined;
+    const annConfig = rcsbAnnotationConfig;
+    let altDisplayType = "block" /* RcsbFvDisplayTypes.BLOCK */;
+    if (annConfig.display === "bond" /* RcsbFvDisplayTypes.BOND */.toString()) {
+        altDisplayType = "bond" /* RcsbFvDisplayTypes.BOND */;
+        data.forEach(d => {
+            d.isEmpty = true;
+        });
+    }
+    const displayColor = (_a = annConfig.color) !== null && _a !== void 0 ? _a : RcsbAnnotationConfig.randomRgba();
+    const pin = new Array();
+    const nonPin = new Array();
+    data.forEach(d => {
+        if (d.end !== null && d.end !== d.begin) {
+            nonPin.push(d);
+        }
+        else {
+            pin.push(d);
+        }
+    });
+    if (pin.length > 0 && nonPin.length > 0) {
+        const displayConfig = new Array();
+        displayConfig.push({
+            displayData: nonPin,
+            displayType: altDisplayType,
+            displayColor: displayColor
+        });
+        displayConfig.push({
+            displayData: pin,
+            displayType: "pin" /* RcsbFvDisplayTypes.PIN */,
+            displayColor: displayColor
+        });
+        out = {
+            displayType: "composite" /* RcsbFvDisplayTypes.COMPOSITE */,
+            trackColor: "#F9F9F9",
+            trackId: "annotationTrack_" + type,
+            displayConfig: displayConfig
+        };
+    }
+    else if (pin.length > 0) {
+        altDisplayType = "pin" /* RcsbFvDisplayTypes.PIN */;
+    }
+    if (out == undefined) {
+        out = {
+            trackId: "annotationTrack_" + type,
+            displayType: altDisplayType,
+            trackColor: "#F9F9F9",
+            displayColor: displayColor,
+            trackData: data
+        };
+    }
+    return out;
+}
+function buildRcsbFvRowConfigTrack(annotationTrack, type, rcsbAnnotationConfig) {
+    const data = annotationTrack.values();
+    let displayType = "block" /* RcsbFvDisplayTypes.BLOCK */;
+    if (data.length > 0 && data[0].end == null) {
+        displayType = "pin" /* RcsbFvDisplayTypes.PIN */;
+    }
+    let displayColor = RcsbAnnotationConfig.randomRgba();
+    const annConfig = rcsbAnnotationConfig;
+    if (annConfig != null) {
+        displayType = annConfig.display;
+        if (annConfig.color)
+            displayColor = annConfig.color;
+    }
+    else {
+        console.warn("Annotation config type " + type + " not found. Using random config");
+    }
+    return Object.assign(Object.assign({}, rcsbAnnotationConfig), { trackId: "annotationTrack_" + type, displayType: displayType, trackColor: "#F9F9F9", displayColor: displayColor, trackData: data });
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/Helper/TrackUtils.d.ts

@@ -0,0 +1,9 @@
+import { SequenceReference, Source } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+export declare namespace TrackUtils {
+    function getProvenanceConfigFormTarget(targetId: string, targetSource: SequenceReference | Source): {
+        name: string;
+        color: string;
+    };
+    function transformSourceFromTarget(targetId: string, source: SequenceReference | Source): string;
+    function getProvenanceColorFromProvenance(provenance?: string): string;
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/Helper/TrackUtils.js

@@ -0,0 +1,36 @@
+import { RcsbAnnotationConstants } from "../../../../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export var TrackUtils;
+(function (TrackUtils) {
+    function getProvenanceConfigFormTarget(targetId, targetSource) {
+        if (TagDelimiter.isRcsbId(targetId))
+            return {
+                name: RcsbAnnotationConstants.provenanceName.pdb,
+                color: RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+            };
+        else if (TagDelimiter.isModel(targetId))
+            return {
+                name: RcsbAnnotationConstants.provenanceName.csm,
+                color: RcsbAnnotationConstants.provenanceColorCode.csm,
+            };
+        else
+            return {
+                name: targetSource,
+                color: RcsbAnnotationConstants.provenanceColorCode.external,
+            };
+    }
+    TrackUtils.getProvenanceConfigFormTarget = getProvenanceConfigFormTarget;
+    function transformSourceFromTarget(targetId, source) {
+        if (TagDelimiter.isModel(targetId) && source.includes("PDB_"))
+            return source.replace("PDB_", "CSM ");
+        else
+            return source;
+    }
+    TrackUtils.transformSourceFromTarget = transformSourceFromTarget;
+    function getProvenanceColorFromProvenance(provenance) {
+        if (provenance === RcsbAnnotationConstants.provenanceName.pdb || provenance === RcsbAnnotationConstants.provenanceName.promotif)
+            return RcsbAnnotationConstants.provenanceColorCode.rcsbPdb;
+        return RcsbAnnotationConstants.provenanceColorCode.external;
+    }
+    TrackUtils.getProvenanceColorFromProvenance = getProvenanceColorFromProvenance;
+})(TrackUtils || (TrackUtils = {}));

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/MsaAlignmentTrackFactory.d.ts

@@ -0,0 +1,12 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { TrackFactoryInterface } from "../TrackFactoryInterface";
+import { AlignmentRequestContextType } from "./AlignmentTrackFactory";
+import { AnnotationFeatures, TargetAlignment } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+export declare class MsaAlignmentTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
+    private observedAlignmentTrackFactory;
+    private positionalScoreAlignmentTrackFactory;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate);
+    getTrack(alignmentQueryContext: AlignmentRequestContextType, targetAlignment: TargetAlignment): Promise<RcsbFvRowConfigInterface>;
+    prepareFeatures(unObservedRegions: Array<AnnotationFeatures>, positionalScores: Array<AnnotationFeatures>): Promise<void>;
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/MsaAlignmentTrackFactory.js

@@ -0,0 +1,24 @@
+import { __awaiter } from "tslib";
+import { PositionalScoreAlignmentTrackFactory } from "./PositionalScoreAlignmentTrackFactory";
+import { PlainObservedAlignmentTrackFactory } from "./PlainObservedAlignmentTrackFactory";
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class MsaAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.observedAlignmentTrackFactory = new PlainObservedAlignmentTrackFactory(entityInstanceTranslator);
+        this.positionalScoreAlignmentTrackFactory = new PositionalScoreAlignmentTrackFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (targetAlignment.target_id && TagDelimiter.isEntityOrInstanceId(targetAlignment.target_id))
+                return this.observedAlignmentTrackFactory.getTrack(alignmentQueryContext, targetAlignment);
+            else
+                return this.positionalScoreAlignmentTrackFactory.getTrack(alignmentQueryContext, targetAlignment);
+        });
+    }
+    prepareFeatures(unObservedRegions, positionalScores) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.observedAlignmentTrackFactory.prepareFeatures(unObservedRegions);
+            yield this.positionalScoreAlignmentTrackFactory.prepareFeatures(positionalScores);
+        });
+    }
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainAlignmentTrackFactory.d.ts

@@ -0,0 +1,23 @@
+import { RcsbFvColorGradient, RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { AlignedRegion, TargetAlignment } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { PolymerEntityInstanceTranslate, AlignmentContextInterface } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { TrackFactoryInterface } from "../TrackFactoryInterface";
+import { AlignmentCollectConfig } from "../../../../RcsbCollectTools/AlignmentCollector/AlignmentCollectorInterface";
+import { RcsbFvTrackDataAnnotationInterface } from "../RcsbFvTrackDataAnnotationInterface";
+export type AlignmentRequestContextType = AlignmentCollectConfig & {
+    querySequence?: string;
+};
+export declare class PlainAlignmentTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
+    private readonly sequenceTrackFactory;
+    private readonly trackTitleFactory;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate);
+    getTrack(alignmentRequestContext: AlignmentRequestContextType, targetAlignment: TargetAlignment, alignedRegionToTrackElementList?: (region: AlignedRegion, alignmentContext: AlignmentContextInterface) => Array<RcsbFvTrackDataElementInterface>, alignmentColor?: RcsbFvColorGradient): Promise<RcsbFvRowConfigInterface>;
+    getAlignmentTrackConfiguration(alignmentQueryContext: AlignmentRequestContextType, targetAlignment: TargetAlignment, alignedRegionToTrackElementList: (region: AlignedRegion, alignmentContext: AlignmentContextInterface) => Array<RcsbFvTrackDataElementInterface>): {
+        alignedBlocks: Array<RcsbFvTrackDataElementInterface>;
+        mismatchData: Array<RcsbFvTrackDataElementInterface>;
+        sequenceData: Array<RcsbFvTrackDataElementInterface>;
+    };
+    alignedRegionToTrackElementList(region: AlignedRegion, alignmentContext: AlignmentContextInterface): Array<RcsbFvTrackDataElementInterface>;
+    addAuthorResIds(e: RcsbFvTrackDataAnnotationInterface, alignmentContext: AlignmentContextInterface): RcsbFvTrackDataElementInterface;
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainAlignmentTrackFactory.js

@@ -0,0 +1,128 @@
+import { __awaiter } from "tslib";
+import { SequenceTrackFactory } from "./SequenceTrackFactory";
+import { range } from "lodash";
+import { AlignmentTrackTitleFactory } from "../TrackTitleFactoryImpl/AlignmentTrackTitleFactory";
+import { TrackUtils } from "./Helper/TrackUtils";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+export class PlainAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.sequenceTrackFactory = new SequenceTrackFactory(entityInstanceTranslator);
+        this.trackTitleFactory = new AlignmentTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList, alignmentColor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { alignedBlocks, mismatchData, sequenceData } = this.getAlignmentTrackConfiguration(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList !== null && alignedRegionToTrackElementList !== void 0 ? alignedRegionToTrackElementList : this.alignedRegionToTrackElementList.bind(this));
+            const sequenceDisplay = {
+                displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+                displayColor: "#000000",
+                displayData: sequenceData
+            };
+            const mismatchDisplay = {
+                displayType: "pin" /* RcsbFvDisplayTypes.PIN */,
+                displayColor: "#FF9999",
+                displayData: mismatchData
+            };
+            const alignmentDisplay = {
+                displayType: "block-area" /* RcsbFvDisplayTypes.BLOCK_AREA */,
+                displayColor: alignmentColor !== null && alignmentColor !== void 0 ? alignmentColor : {
+                    colors: ["#dcdcdc", "#c7c7ff"],
+                    thresholds: [50]
+                },
+                displayData: alignedBlocks
+            };
+            return {
+                trackId: "targetSequenceTrack_" + targetAlignment.target_id,
+                displayType: "composite" /* RcsbFvDisplayTypes.COMPOSITE */,
+                overlap: true,
+                trackColor: "#F9F9F9",
+                rowTitle: yield this.trackTitleFactory.getTrackTitle(alignmentRequestContext, targetAlignment),
+                fitTitleWidth: alignmentRequestContext.fitTitleWidth,
+                titleFlagColor: yield this.trackTitleFactory.getTrackTitleFlagColor(alignmentRequestContext, targetAlignment),
+                displayConfig: [alignmentDisplay, mismatchDisplay, sequenceDisplay]
+            };
+        });
+    }
+    getAlignmentTrackConfiguration(alignmentQueryContext, targetAlignment, alignedRegionToTrackElementList) {
+        var _a, _b, _c, _d;
+        const alignedBlocks = [];
+        const mismatchData = [];
+        const targetSequence = targetAlignment.target_sequence;
+        const sequenceData = [];
+        const queryId = (_a = alignmentQueryContext.queryId) !== null && _a !== void 0 ? _a : alignmentQueryContext.groupId;
+        assertDefined(queryId), assertDefined(targetAlignment.target_id);
+        const alignmentContext = {
+            queryId,
+            targetId: targetAlignment.target_id,
+            from: alignmentQueryContext.from,
+            to: alignmentQueryContext.to,
+            targetSequenceLength: (_b = targetAlignment.target_sequence) === null || _b === void 0 ? void 0 : _b.length,
+            querySequenceLength: (_c = alignmentQueryContext.querySequence) === null || _c === void 0 ? void 0 : _c.length
+        };
+        (_d = targetAlignment.aligned_regions) === null || _d === void 0 ? void 0 : _d.forEach(region => {
+            if (!(region === null || region === void 0 ? void 0 : region.target_begin) || !(region === null || region === void 0 ? void 0 : region.target_end))
+                return;
+            const regionSequence = targetSequence === null || targetSequence === void 0 ? void 0 : targetSequence.substring(region.target_begin - 1, region.target_end);
+            if (regionSequence)
+                this.sequenceTrackFactory.buildSequenceData(Object.assign(Object.assign({}, alignmentContext), { sequence: regionSequence, begin: region.query_begin, oriBegin: region.target_begin }), "to").forEach(sd => {
+                    sequenceData.push(sd);
+                });
+            alignedRegionToTrackElementList(region, alignmentContext).forEach(r => {
+                alignedBlocks.push(r);
+            });
+            if (regionSequence && alignmentQueryContext.querySequence)
+                findMismatch(regionSequence, alignmentQueryContext.querySequence.substring(region.query_begin - 1, region.query_end)).forEach(m => {
+                    if (alignmentQueryContext.querySequence && targetAlignment.target_id && alignmentContext.to)
+                        mismatchData.push(this.sequenceTrackFactory.addAuthorResIds({
+                            begin: (m + region.query_begin),
+                            oriBegin: (m + region.target_begin),
+                            sourceId: targetAlignment.target_id,
+                            source: TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                            provenanceName: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                            provenanceColor: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).color,
+                            type: "MISMATCH",
+                            title: "MISMATCH"
+                        }, alignmentContext));
+                });
+        });
+        return { alignedBlocks, mismatchData, sequenceData };
+    }
+    alignedRegionToTrackElementList(region, alignmentContext) {
+        let openBegin = false;
+        if (region.target_begin != 1)
+            openBegin = true;
+        let openEnd = false;
+        if (region.target_end != alignmentContext.targetSequenceLength && alignmentContext.querySequenceLength)
+            openEnd = true;
+        return range(region.query_begin, region.query_end + 1).map((p, n) => {
+            assertDefined(alignmentContext.to);
+            return this.addAuthorResIds({
+                begin: p,
+                oriBegin: region.target_begin + n,
+                sourceId: alignmentContext.targetId,
+                source: TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                provenanceName: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                provenanceColor: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).color,
+                openBegin: openBegin,
+                openEnd: openEnd,
+                type: "ALIGNED_BLOCK",
+                title: "ALIGNED REGION",
+                value: 100
+            }, alignmentContext);
+        });
+    }
+    addAuthorResIds(e, alignmentContext) {
+        return this.sequenceTrackFactory.addAuthorResIds(e, alignmentContext);
+    }
+}
+function findMismatch(seqA, seqB) {
+    const out = [];
+    if (seqA.length === seqB.length) {
+        for (let i = 0; i < seqA.length; i++) {
+            if (seqA.charAt(i) !== seqB.charAt(i)) {
+                out.push(i);
+            }
+        }
+    }
+    return out;
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainObservedAlignmentTrackFactory.d.ts

@@ -0,0 +1,17 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { AnnotationFeatures, TargetAlignment } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { TrackFactoryInterface } from "../TrackFactoryInterface";
+import { AlignmentRequestContextType } from "./AlignmentTrackFactory";
+export declare class PlainObservedAlignmentTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
+    private alignmentTrackFactory;
+    private unObservedResidues;
+    private readonly instanceEntityMap;
+    private readonly entityInstanceNumberMap;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate);
+    getTrack(alignmentRequestContext: AlignmentRequestContextType, targetAlignment: TargetAlignment): Promise<RcsbFvRowConfigInterface>;
+    prepareFeatures(unObservedRegions: Array<AnnotationFeatures>): Promise<void>;
+    private collectFeatureEntryProperties;
+    private prepareFeaturesAlignmentMap;
+    private alignedRegionToTrackElementList;
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainObservedAlignmentTrackFactory.js

@@ -0,0 +1,110 @@
+import { __awaiter } from "tslib";
+import { Operator } from "../../../../RcsbUtils/Helpers/Operator";
+import { range } from "lodash";
+import { PlainAlignmentTrackFactory } from "./PlainAlignmentTrackFactory";
+import { TrackUtils } from "./Helper/TrackUtils";
+import { rcsbRequestCtxManager } from "../../../../RcsbRequest/RcsbRequestContextManager";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class PlainObservedAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.unObservedResidues = new Map();
+        this.instanceEntityMap = new Map();
+        this.entityInstanceNumberMap = new Map();
+        this.alignmentTrackFactory = new PlainAlignmentTrackFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.alignmentTrackFactory.getTrack(alignmentRequestContext, targetAlignment, this.alignedRegionToTrackElementList.bind(this));
+        });
+    }
+    prepareFeatures(unObservedRegions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.collectFeatureEntryProperties(unObservedRegions);
+            this.prepareFeaturesAlignmentMap(unObservedRegions);
+        });
+    }
+    collectFeatureEntryProperties(unObservedRegions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryIds = Operator.uniqueValues(unObservedRegions.map(uor => {
+                assertDefined(uor.target_id);
+                return uor.target_id.split(TagDelimiter.instance)[0];
+            }));
+            //TODO define a Translator class for multiple entry entry data
+            const entryProperties = (yield Promise.all(Operator.arrayChunk(entryIds, 100).map(ids => rcsbRequestCtxManager.getEntryProperties(ids)))).flat();
+            entryProperties.forEach(ep => {
+                ep.entityToInstance.forEach((instanceList, entityId) => {
+                    this.entityInstanceNumberMap.set(entityId, instanceList.length);
+                    instanceList.forEach(instanceId => {
+                        this.instanceEntityMap.set(instanceId, entityId);
+                    });
+                });
+            });
+        });
+    }
+    prepareFeaturesAlignmentMap(unObservedRegions) {
+        const uoInstanceFeatureMap = new Map();
+        unObservedRegions.forEach(ur => {
+            var _a;
+            if (!ur.target_id)
+                return;
+            const instanceId = ur.target_id;
+            if (!uoInstanceFeatureMap.has(instanceId))
+                uoInstanceFeatureMap.set(instanceId, new Set());
+            (_a = ur.features) === null || _a === void 0 ? void 0 : _a.forEach(feature => {
+                var _a;
+                (_a = feature === null || feature === void 0 ? void 0 : feature.feature_positions) === null || _a === void 0 ? void 0 : _a.forEach(fp => {
+                    var _a;
+                    if ((fp === null || fp === void 0 ? void 0 : fp.beg_seq_id) && (fp === null || fp === void 0 ? void 0 : fp.end_seq_id))
+                        for (let i = fp.beg_seq_id; i <= fp.end_seq_id; i++) {
+                            (_a = uoInstanceFeatureMap.get(instanceId)) === null || _a === void 0 ? void 0 : _a.add(i);
+                        }
+                });
+            });
+        });
+        const uoEntityFeatureMap = new Map();
+        uoInstanceFeatureMap.forEach((uoSet, instanceId) => {
+            const entityId = this.instanceEntityMap.get(instanceId);
+            if (!entityId)
+                return;
+            if (!uoEntityFeatureMap.has(entityId))
+                uoEntityFeatureMap.set(entityId, new Map());
+            uoSet.forEach(i => {
+                var _a, _b, _c, _d;
+                if ((_a = uoEntityFeatureMap.get(entityId)) === null || _a === void 0 ? void 0 : _a.has(i)) {
+                    const v = (_b = uoEntityFeatureMap.get(entityId)) === null || _b === void 0 ? void 0 : _b.get(i);
+                    if (v)
+                        (_c = uoEntityFeatureMap.get(entityId)) === null || _c === void 0 ? void 0 : _c.set(i, v + 1);
+                }
+                else {
+                    (_d = uoEntityFeatureMap.get(entityId)) === null || _d === void 0 ? void 0 : _d.set(i, 1);
+                }
+            });
+        });
+        uoEntityFeatureMap.forEach((unObservedMap, entityId) => {
+            this.unObservedResidues.set(entityId, Array.from(unObservedMap.entries()).filter(e => (e[1] == this.entityInstanceNumberMap.get(entityId))).map(e => e[0]).sort((a, b) => a - b));
+        });
+    }
+    alignedRegionToTrackElementList(region, alignmentContext) {
+        var _a;
+        if (!this.unObservedResidues.has(alignmentContext.targetId) || ((_a = this.unObservedResidues.get(alignmentContext.targetId)) === null || _a === void 0 ? void 0 : _a.length) == 0)
+            return this.alignmentTrackFactory.alignedRegionToTrackElementList(region, alignmentContext);
+        const unModelledSet = new Set(this.unObservedResidues.get(alignmentContext.targetId));
+        const delta = region.target_begin - region.query_begin;
+        return range(region.query_begin, region.query_end + 1).map((i) => {
+            assertDefined(alignmentContext.to);
+            return this.alignmentTrackFactory.addAuthorResIds({
+                begin: i,
+                oriBegin: i + delta,
+                sourceId: alignmentContext.targetId,
+                source: TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                provenanceName: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                provenanceColor: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).color,
+                type: "ALIGNED_BLOCK",
+                title: unModelledSet.has(i) ? "UNMODELED REGION" : "ALIGNED REGION",
+                value: unModelledSet.has(i) ? 0 : 100
+            }, alignmentContext);
+        });
+    }
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PositionalScoreAlignmentTrackFactory.d.ts

@@ -0,0 +1,17 @@
+import { RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { AlignedRegion, AnnotationFeatures, TargetAlignment } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { AlignmentContextInterface, PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { TrackFactoryInterface } from "../TrackFactoryInterface";
+import { AlignmentRequestContextType } from "./AlignmentTrackFactory";
+export declare class PositionalScoreAlignmentTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
+    private alignmentTrackFactory;
+    private positionalScores;
+    private readonly instanceEntityMap;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate);
+    getTrack(alignmentRequestContext: AlignmentRequestContextType, targetAlignment: TargetAlignment, alignedRegionToTrackElementList?: (region: AlignedRegion, alignmentContext: AlignmentContextInterface) => Array<RcsbFvTrackDataElementInterface>): Promise<RcsbFvRowConfigInterface>;
+    prepareFeatures(positionalScores: Array<AnnotationFeatures>): Promise<void>;
+    private collectFeatureEntryProperties;
+    private prepareFeaturesAlignmentMap;
+    private alignedRegionToTrackElementList;
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PositionalScoreAlignmentTrackFactory.js

@@ -0,0 +1,114 @@
+import { __awaiter } from "tslib";
+import { Type } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { Operator } from "../../../../RcsbUtils/Helpers/Operator";
+import { range } from "lodash";
+import { PlainAlignmentTrackFactory } from "./PlainAlignmentTrackFactory";
+import { TrackUtils } from "./Helper/TrackUtils";
+import { rcsbRequestCtxManager } from "../../../../RcsbRequest/RcsbRequestContextManager";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class PositionalScoreAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.positionalScores = new Map();
+        this.instanceEntityMap = new Map();
+        this.alignmentTrackFactory = new PlainAlignmentTrackFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.alignmentTrackFactory.getTrack(alignmentRequestContext, targetAlignment, this.alignedRegionToTrackElementList.bind(this), {
+                colors: ["#ff7d45", "#ffdb13", "#65cbf3", "#0053d6"],
+                thresholds: [50, 70, 90]
+            });
+        });
+    }
+    prepareFeatures(positionalScores) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.collectFeatureEntryProperties(positionalScores);
+            this.prepareFeaturesAlignmentMap(positionalScores);
+        });
+    }
+    collectFeatureEntryProperties(unObservedRegions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entryIds = Operator.uniqueValues(unObservedRegions.map(uor => {
+                assertDefined(uor.target_id);
+                return uor.target_id.split(TagDelimiter.instance)[0];
+            }));
+            //TODO define a Translator class for multiple entry entry data
+            const entryProperties = (yield Promise.all(Operator.arrayChunk(entryIds, 100).map(ids => rcsbRequestCtxManager.getEntryProperties(ids)))).flat();
+            entryProperties.forEach(ep => {
+                ep.entityToInstance.forEach((instanceList, entityId) => {
+                    instanceList.forEach(instanceId => {
+                        this.instanceEntityMap.set(instanceId, entityId);
+                    });
+                });
+            });
+        });
+    }
+    prepareFeaturesAlignmentMap(positionalScores) {
+        const instancePositionalScores = new Map();
+        positionalScores.forEach(ps => {
+            var _a;
+            if (!ps.target_id)
+                return;
+            const instanceId = ps.target_id;
+            if (!instancePositionalScores.has(instanceId))
+                instancePositionalScores.set(instanceId, new Map());
+            (_a = ps.features) === null || _a === void 0 ? void 0 : _a.forEach(feature => {
+                var _a;
+                (_a = feature === null || feature === void 0 ? void 0 : feature.feature_positions) === null || _a === void 0 ? void 0 : _a.forEach(fp => {
+                    var _a;
+                    (_a = fp === null || fp === void 0 ? void 0 : fp.values) === null || _a === void 0 ? void 0 : _a.forEach((v, n) => {
+                        var _a;
+                        if (fp.beg_seq_id && v)
+                            (_a = instancePositionalScores.get(instanceId)) === null || _a === void 0 ? void 0 : _a.set(fp.beg_seq_id + n, v);
+                    });
+                });
+            });
+        });
+        const entityPositionalScore = new Map();
+        instancePositionalScores.forEach((ips, instanceId) => {
+            const entityId = this.instanceEntityMap.get(instanceId);
+            if (!entityId)
+                return;
+            if (!entityPositionalScore.has(entityId))
+                entityPositionalScore.set(entityId, new Map());
+            const o = entityPositionalScore.get(entityId);
+            assertDefined(o);
+            ips.forEach((score, position) => {
+                var _a;
+                if (!o.has(position)) {
+                    o.set(position, score);
+                }
+                else if (score < ((_a = o.get(position)) !== null && _a !== void 0 ? _a : Number.MIN_SAFE_INTEGER)) {
+                    o.set(position, score);
+                }
+            });
+        });
+        this.positionalScores = entityPositionalScore;
+    }
+    alignedRegionToTrackElementList(region, alignmentContext) {
+        var _a;
+        if (!this.positionalScores.has(alignmentContext.targetId) || ((_a = this.positionalScores.get(alignmentContext.targetId)) === null || _a === void 0 ? void 0 : _a.size) == 0)
+            return this.alignmentTrackFactory.alignedRegionToTrackElementList(region, alignmentContext);
+        const outRegions = [];
+        const entityPositionalScores = this.positionalScores.get(alignmentContext.targetId);
+        if (entityPositionalScores && entityPositionalScores.size > 0) {
+            range(region.query_begin, region.query_end + 1).forEach((p, n) => {
+                if (!alignmentContext.to)
+                    return;
+                outRegions.push(this.alignmentTrackFactory.addAuthorResIds({
+                    begin: p,
+                    oriBegin: region.target_begin + n,
+                    value: entityPositionalScores.get(p),
+                    sourceId: alignmentContext.targetId,
+                    source: TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                    provenanceName: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                    provenanceColor: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).color,
+                    type: Type.MaQaMetricLocalTypeOther,
+                }, alignmentContext));
+            });
+        }
+        return outRegions;
+    }
+}