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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackUtils = void 0;
+const RcsbAnnotationConstants_1 = require("../../../../../RcsbAnnotationConfig/RcsbAnnotationConstants");
+const TagDelimiter_1 = require("@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter");
+var TrackUtils;
+(function (TrackUtils) {
+    function getProvenanceConfigFormTarget(targetId, targetSource) {
+        if (TagDelimiter_1.TagDelimiter.isRcsbId(targetId))
+            return {
+                name: RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceName.pdb,
+                color: RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceColorCode.rcsbPdb,
+            };
+        else if (TagDelimiter_1.TagDelimiter.isModel(targetId))
+            return {
+                name: RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceName.csm,
+                color: RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceColorCode.csm,
+            };
+        else
+            return {
+                name: targetSource,
+                color: RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceColorCode.external,
+            };
+    }
+    TrackUtils.getProvenanceConfigFormTarget = getProvenanceConfigFormTarget;
+    function transformSourceFromTarget(targetId, source) {
+        if (TagDelimiter_1.TagDelimiter.isModel(targetId) && source.includes("PDB_"))
+            return source.replace("PDB_", "CSM ");
+        else
+            return source;
+    }
+    TrackUtils.transformSourceFromTarget = transformSourceFromTarget;
+    function getProvenanceColorFromProvenance(provenance) {
+        if (provenance === RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceName.pdb || provenance === RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceName.promotif)
+            return RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceColorCode.rcsbPdb;
+        return RcsbAnnotationConstants_1.RcsbAnnotationConstants.provenanceColorCode.external;
+    }
+    TrackUtils.getProvenanceColorFromProvenance = getProvenanceColorFromProvenance;
+})(TrackUtils || (exports.TrackUtils = TrackUtils = {}));

package/lib/commonjs/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/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/MsaAlignmentTrackFactory.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsaAlignmentTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const PositionalScoreAlignmentTrackFactory_1 = require("./PositionalScoreAlignmentTrackFactory");
+const PlainObservedAlignmentTrackFactory_1 = require("./PlainObservedAlignmentTrackFactory");
+const TagDelimiter_1 = require("@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter");
+class MsaAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.observedAlignmentTrackFactory = new PlainObservedAlignmentTrackFactory_1.PlainObservedAlignmentTrackFactory(entityInstanceTranslator);
+        this.positionalScoreAlignmentTrackFactory = new PositionalScoreAlignmentTrackFactory_1.PositionalScoreAlignmentTrackFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentQueryContext, targetAlignment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (targetAlignment.target_id && TagDelimiter_1.TagDelimiter.isEntityOrInstanceId(targetAlignment.target_id))
+                return this.observedAlignmentTrackFactory.getTrack(alignmentQueryContext, targetAlignment);
+            else
+                return this.positionalScoreAlignmentTrackFactory.getTrack(alignmentQueryContext, targetAlignment);
+        });
+    }
+    prepareFeatures(unObservedRegions, positionalScores) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.observedAlignmentTrackFactory.prepareFeatures(unObservedRegions);
+            yield this.positionalScoreAlignmentTrackFactory.prepareFeatures(positionalScores);
+        });
+    }
+}
+exports.MsaAlignmentTrackFactory = MsaAlignmentTrackFactory;

package/lib/commonjs/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/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainAlignmentTrackFactory.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainAlignmentTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const SequenceTrackFactory_1 = require("./SequenceTrackFactory");
+const lodash_1 = require("lodash");
+const AlignmentTrackTitleFactory_1 = require("../TrackTitleFactoryImpl/AlignmentTrackTitleFactory");
+const TrackUtils_1 = require("./Helper/TrackUtils");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+class PlainAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.sequenceTrackFactory = new SequenceTrackFactory_1.SequenceTrackFactory(entityInstanceTranslator);
+        this.trackTitleFactory = new AlignmentTrackTitleFactory_1.AlignmentTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList, alignmentColor) {
+        return tslib_1.__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_1.TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                            provenanceName: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                            provenanceColor: TrackUtils_1.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 (0, lodash_1.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_1.TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                provenanceName: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                provenanceColor: TrackUtils_1.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);
+    }
+}
+exports.PlainAlignmentTrackFactory = PlainAlignmentTrackFactory;
+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/commonjs/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/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PlainObservedAlignmentTrackFactory.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainObservedAlignmentTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const Operator_1 = require("../../../../RcsbUtils/Helpers/Operator");
+const lodash_1 = require("lodash");
+const PlainAlignmentTrackFactory_1 = require("./PlainAlignmentTrackFactory");
+const TrackUtils_1 = require("./Helper/TrackUtils");
+const RcsbRequestContextManager_1 = require("../../../../RcsbRequest/RcsbRequestContextManager");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+const TagDelimiter_1 = require("@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter");
+class PlainObservedAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.unObservedResidues = new Map();
+        this.instanceEntityMap = new Map();
+        this.entityInstanceNumberMap = new Map();
+        this.alignmentTrackFactory = new PlainAlignmentTrackFactory_1.PlainAlignmentTrackFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.alignmentTrackFactory.getTrack(alignmentRequestContext, targetAlignment, this.alignedRegionToTrackElementList.bind(this));
+        });
+    }
+    prepareFeatures(unObservedRegions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.collectFeatureEntryProperties(unObservedRegions);
+            this.prepareFeaturesAlignmentMap(unObservedRegions);
+        });
+    }
+    collectFeatureEntryProperties(unObservedRegions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const entryIds = Operator_1.Operator.uniqueValues(unObservedRegions.map(uor => {
+                assertDefined(uor.target_id);
+                return uor.target_id.split(TagDelimiter_1.TagDelimiter.instance)[0];
+            }));
+            //TODO define a Translator class for multiple entry entry data
+            const entryProperties = (yield Promise.all(Operator_1.Operator.arrayChunk(entryIds, 100).map(ids => RcsbRequestContextManager_1.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 (0, lodash_1.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_1.TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                provenanceName: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                provenanceColor: TrackUtils_1.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);
+        });
+    }
+}
+exports.PlainObservedAlignmentTrackFactory = PlainObservedAlignmentTrackFactory;

package/lib/commonjs/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/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PositionalScoreAlignmentTrackFactory.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionalScoreAlignmentTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const GqlTypes_1 = require("@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes");
+const Operator_1 = require("../../../../RcsbUtils/Helpers/Operator");
+const lodash_1 = require("lodash");
+const PlainAlignmentTrackFactory_1 = require("./PlainAlignmentTrackFactory");
+const TrackUtils_1 = require("./Helper/TrackUtils");
+const RcsbRequestContextManager_1 = require("../../../../RcsbRequest/RcsbRequestContextManager");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+const TagDelimiter_1 = require("@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter");
+class PositionalScoreAlignmentTrackFactory {
+    constructor(entityInstanceTranslator) {
+        this.positionalScores = new Map();
+        this.instanceEntityMap = new Map();
+        this.alignmentTrackFactory = new PlainAlignmentTrackFactory_1.PlainAlignmentTrackFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList) {
+        return tslib_1.__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 tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.collectFeatureEntryProperties(positionalScores);
+            this.prepareFeaturesAlignmentMap(positionalScores);
+        });
+    }
+    collectFeatureEntryProperties(unObservedRegions) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const entryIds = Operator_1.Operator.uniqueValues(unObservedRegions.map(uor => {
+                assertDefined(uor.target_id);
+                return uor.target_id.split(TagDelimiter_1.TagDelimiter.instance)[0];
+            }));
+            //TODO define a Translator class for multiple entry entry data
+            const entryProperties = (yield Promise.all(Operator_1.Operator.arrayChunk(entryIds, 100).map(ids => RcsbRequestContextManager_1.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) {
+            (0, lodash_1.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_1.TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                    provenanceName: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                    provenanceColor: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).color,
+                    type: GqlTypes_1.Type.MaQaMetricLocalTypeOther,
+                }, alignmentContext));
+            });
+        }
+        return outRegions;
+    }
+}
+exports.PositionalScoreAlignmentTrackFactory = PositionalScoreAlignmentTrackFactory;

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/SequenceTrackFactory.d.ts

@@ -0,0 +1,21 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+import { AlignmentContextInterface, PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { TrackFactoryInterface } from "../TrackFactoryInterface";
+import { AlignmentRequestContextType } from "./AlignmentTrackFactory";
+import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
+import { RcsbFvTrackDataAnnotationInterface } from "../RcsbFvTrackDataAnnotationInterface";
+interface BuildSequenceDataInterface extends AlignmentContextInterface {
+    sequence: string;
+    begin: number;
+    oriBegin?: number;
+}
+export declare class SequenceTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, string]> {
+    private readonly entityInstanceTranslator;
+    private readonly trackTitleFactory;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate, trackTitleFactory?: TrackTitleFactoryInterface<[AlignmentRequestContextType]>);
+    getTrack(alignmentQueryContext: AlignmentRequestContextType, querySequence: string): Promise<RcsbFvRowConfigInterface>;
+    buildSequenceData(config: BuildSequenceDataInterface, source: "from" | "to"): Array<RcsbFvTrackDataElementInterface>;
+    addAuthorResIds(e: RcsbFvTrackDataAnnotationInterface, alignmentContext: AlignmentContextInterface): RcsbFvTrackDataElementInterface;
+}
+export {};

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/SequenceTrackFactory.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequenceTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const GqlTypes_1 = require("@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes");
+const SequenceTrackTitleFactory_1 = require("../TrackTitleFactoryImpl/SequenceTrackTitleFactory");
+const TrackUtils_1 = require("./Helper/TrackUtils");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+const TagDelimiter_1 = require("@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter");
+class SequenceTrackFactory {
+    constructor(entityInstanceTranslator, trackTitleFactory) {
+        this.entityInstanceTranslator = undefined;
+        this.entityInstanceTranslator = entityInstanceTranslator;
+        this.trackTitleFactory = trackTitleFactory !== null && trackTitleFactory !== void 0 ? trackTitleFactory : new SequenceTrackTitleFactory_1.SequenceTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentQueryContext, querySequence) {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const queryId = (_a = alignmentQueryContext.queryId) !== null && _a !== void 0 ? _a : alignmentQueryContext.groupId;
+            assertDefined(queryId);
+            return {
+                trackId: (_b = "mainSequenceTrack_" + alignmentQueryContext.queryId) !== null && _b !== void 0 ? _b : alignmentQueryContext.groupId,
+                displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+                trackColor: "#F9F9F9",
+                displayColor: "#000000",
+                rowTitle: yield this.trackTitleFactory.getTrackTitle(alignmentQueryContext),
+                rowPrefix: yield this.trackTitleFactory.getTrackTitlePrefix(alignmentQueryContext),
+                titleFlagColor: yield this.trackTitleFactory.getTrackTitleFlagColor(alignmentQueryContext),
+                nonEmptyDisplay: true,
+                overlap: true,
+                trackData: this.buildSequenceData({
+                    sequence: querySequence,
+                    begin: 1,
+                    oriBegin: undefined,
+                    queryId,
+                    targetId: "",
+                    from: alignmentQueryContext.from,
+                    to: undefined
+                }, "from")
+            };
+        });
+    }
+    buildSequenceData(config, source) {
+        const sequenceData = new Array();
+        const id = source === "from" ? config.queryId : config.targetId;
+        config.sequence.split("").forEach((s, i) => {
+            const c = config[source];
+            if (!c)
+                return;
+            const o = {
+                begin: (config.begin + i),
+                oriBegin: typeof config.oriBegin === "number" ? config.oriBegin + i : undefined,
+                sourceId: id,
+                source: TrackUtils_1.TrackUtils.transformSourceFromTarget(id, c),
+                provenanceName: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(id, c).name,
+                provenanceColor: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(id, c).color,
+                label: s
+            };
+            sequenceData.push(this.addAuthorResIds(o, {
+                from: config.from,
+                to: config.to,
+                queryId: config.queryId,
+                targetId: config.targetId
+            }));
+        });
+        return sequenceData;
+    }
+    //TODO this method can be defined in a helper
+    addAuthorResIds(e, alignmentContext) {
+        let o = e;
+        if (this.entityInstanceTranslator != null) {
+            this.entityInstanceTranslator.addAuthorResIds(o, alignmentContext);
+        }
+        if (alignmentContext.to == GqlTypes_1.SequenceReference.PdbInstance && o.sourceId != null && this.entityInstanceTranslator != null)
+            o.sourceId = o.sourceId.split(TagDelimiter_1.TagDelimiter.instance)[0] + TagDelimiter_1.TagDelimiter.instance + this.entityInstanceTranslator.translateAsymToAuth(o.sourceId.split(TagDelimiter_1.TagDelimiter.instance)[1]);
+        return o;
+    }
+}
+exports.SequenceTrackFactory = SequenceTrackFactory;

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryInterface.d.ts

@@ -0,0 +1,4 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+export interface TrackFactoryInterface<T extends any[]> {
+    getTrack(...args: T): Promise<RcsbFvRowConfigInterface>;
+}

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryInterface.js

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

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/AlignmentTrackTitleFactory.d.ts

@@ -0,0 +1,13 @@
+import { RcsbFvLink } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
+import { TargetAlignment } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { AlignmentRequestContextType } from "../TrackFactoryImpl/AlignmentTrackFactory";
+import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+export declare class AlignmentTrackTitleFactory implements TrackTitleFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
+    private readonly experimentalTrackTitleFactory;
+    private readonly modelTrackTitleFactory;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate);
+    getTrackTitle(alignmentQueryContext: AlignmentRequestContextType, targetAlignment: TargetAlignment): Promise<string | RcsbFvLink>;
+    getTrackTitlePrefix(alignmentQueryContext: AlignmentRequestContextType, targetAlignment: TargetAlignment): Promise<string>;
+    getTrackTitleFlagColor(alignmentQueryContext: AlignmentRequestContextType, targetAlignment: TargetAlignment): Promise<string>;
+}