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

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/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/PositionalScoreAlignmentTrackFactory.d.ts

@@ -1,7 +1,8 @@
+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 { RcsbFvRowConfigInterface, RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro";
 import { AlignmentRequestContextType } from "./AlignmentTrackFactory";
 export declare class PositionalScoreAlignmentTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
     private alignmentTrackFactory;

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;
+    }
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryImpl/SequenceTrackFactory.d.ts

@@ -1,8 +1,10 @@
-import { RcsbFvRowConfigInterface, RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro";
+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;
@@ -14,6 +16,6 @@ export declare class SequenceTrackFactory implements TrackFactoryInterface<[Alig
     constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate, trackTitleFactory?: TrackTitleFactoryInterface<[AlignmentRequestContextType]>);
     getTrack(alignmentQueryContext: AlignmentRequestContextType, querySequence: string): Promise<RcsbFvRowConfigInterface>;
     buildSequenceData(config: BuildSequenceDataInterface, source: "from" | "to"): Array<RcsbFvTrackDataElementInterface>;
-    addAuthorResIds(e: RcsbFvTrackDataElementInterface, alignmentContext: AlignmentContextInterface): RcsbFvTrackDataElementInterface;
+    addAuthorResIds(e: RcsbFvTrackDataAnnotationInterface, alignmentContext: AlignmentContextInterface): RcsbFvTrackDataElementInterface;
 }
 export {};

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

@@ -0,0 +1,76 @@
+import { __awaiter } from "tslib";
+import { SequenceReference } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { SequenceTrackTitleFactory } from "../TrackTitleFactoryImpl/SequenceTrackTitleFactory";
+import { TrackUtils } from "./Helper/TrackUtils";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class SequenceTrackFactory {
+    constructor(entityInstanceTranslator, trackTitleFactory) {
+        this.entityInstanceTranslator = undefined;
+        this.entityInstanceTranslator = entityInstanceTranslator;
+        this.trackTitleFactory = trackTitleFactory !== null && trackTitleFactory !== void 0 ? trackTitleFactory : new SequenceTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentQueryContext, querySequence) {
+        var _a, _b;
+        return __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.transformSourceFromTarget(id, c),
+                provenanceName: TrackUtils.getProvenanceConfigFormTarget(id, c).name,
+                provenanceColor: 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 == SequenceReference.PdbInstance && o.sourceId != null && this.entityInstanceTranslator != null)
+            o.sourceId = o.sourceId.split(TagDelimiter.instance)[0] + TagDelimiter.instance + this.entityInstanceTranslator.translateAsymToAuth(o.sourceId.split(TagDelimiter.instance)[1]);
+        return o;
+    }
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackFactoryInterface.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/AlignmentTrackTitleFactory.d.ts

@@ -1,7 +1,7 @@
+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 { RcsbFvLink } from "@rcsb/rcsb-saguaro";
 import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
 export declare class AlignmentTrackTitleFactory implements TrackTitleFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
     private readonly experimentalTrackTitleFactory;

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/AlignmentTrackTitleFactory.js

@@ -0,0 +1,34 @@
+import { __awaiter } from "tslib";
+import { ExperimentalAlignmentTrackTitleFactory } from "./ExperimentalAlignmentTrackTitleFactory";
+import { ModelAlignmentTrackTitleFactory } from "./ModelAlignmentTrackTitleFactory";
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class AlignmentTrackTitleFactory {
+    constructor(entityInstanceTranslator) {
+        this.experimentalTrackTitleFactory = new ExperimentalAlignmentTrackTitleFactory(entityInstanceTranslator);
+        this.modelTrackTitleFactory = new ModelAlignmentTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrackTitle(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (targetAlignment.target_id && TagDelimiter.isModel(targetAlignment.target_id))
+                return this.modelTrackTitleFactory.getTrackTitle(alignmentQueryContext, targetAlignment);
+            else
+                return this.experimentalTrackTitleFactory.getTrackTitle(alignmentQueryContext, targetAlignment);
+        });
+    }
+    getTrackTitlePrefix(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (targetAlignment.target_id && TagDelimiter.isModel(targetAlignment.target_id))
+                return this.modelTrackTitleFactory.getTrackTitlePrefix(alignmentQueryContext, targetAlignment);
+            else
+                return this.experimentalTrackTitleFactory.getTrackTitlePrefix(alignmentQueryContext, targetAlignment);
+        });
+    }
+    getTrackTitleFlagColor(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (targetAlignment.target_id && TagDelimiter.isModel(targetAlignment.target_id))
+                return this.modelTrackTitleFactory.getTrackTitleFlagColor(alignmentQueryContext, targetAlignment);
+            else
+                return this.experimentalTrackTitleFactory.getTrackTitleFlagColor(alignmentQueryContext, targetAlignment);
+        });
+    }
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/AnnotationsTrackTitleFactory.d.ts

@@ -1,6 +1,6 @@
+import { RcsbFvLink } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
 import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
 import { TrackManagerInterface } from "../../RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
-import { RcsbFvLink } from "@rcsb/rcsb-saguaro";
 export declare class AnnotationsTrackTitleFactory implements TrackTitleFactoryInterface<[TrackManagerInterface]> {
     getTrackTitle(trackManager: TrackManagerInterface): Promise<string | RcsbFvLink>;
     getTrackTitleFlagColor(trackManager: TrackManagerInterface): Promise<string>;

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/AnnotationsTrackTitleFactory.js

@@ -0,0 +1,34 @@
+import { __awaiter } from "tslib";
+import { RcsbAnnotationConstants } from "../../../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { FeatureTools } from "../../../../RcsbCollectTools/FeatureTools/FeatureTools";
+export class AnnotationsTrackTitleFactory {
+    getTrackTitle(trackManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const c = trackManager.getConfig();
+            return c ? buildRowTitle(c) : trackManager.getId();
+        });
+    }
+    getTrackTitleFlagColor(trackManager) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const provenance = Array.from((_b = (_a = trackManager.getConfig()) === null || _a === void 0 ? void 0 : _a.provenanceList) !== null && _b !== void 0 ? _b : []);
+            if (provenance.length == 1
+                &&
+                    (provenance[0] === RcsbAnnotationConstants.provenanceName.pdb || provenance[0] === RcsbAnnotationConstants.provenanceName.promotif)) {
+                return RcsbAnnotationConstants.provenanceColorCode.rcsbPdb;
+            }
+            else {
+                return RcsbAnnotationConstants.provenanceColorCode.external;
+            }
+        });
+    }
+    getTrackTitlePrefix(trackManager) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_b = (_a = trackManager.getConfig()) === null || _a === void 0 ? void 0 : _a.prefix) !== null && _b !== void 0 ? _b : "";
+        });
+    }
+}
+function buildRowTitle(annConfig) {
+    return annConfig.prefix ? FeatureTools.parseLink(annConfig.title) : annConfig.title;
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/ExperimentalAlignmentTrackTitleFactory.d.ts

@@ -1,7 +1,7 @@
+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 { RcsbFvLink } from "@rcsb/rcsb-saguaro";
 import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
 export declare class ExperimentalAlignmentTrackTitleFactory implements TrackTitleFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
     private readonly entityInstanceTranslator;

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/ExperimentalAlignmentTrackTitleFactory.js

@@ -0,0 +1,77 @@
+import { __awaiter } from "tslib";
+import { SequenceReference } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import resource from "../../../../RcsbServerConfig/web.resources.json";
+import { RcsbAnnotationConstants } from "../../../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class ExperimentalAlignmentTrackTitleFactory {
+    constructor(entityInstanceTranslator) {
+        this.entityInstanceTranslator = undefined;
+        this.entityInstanceTranslator = entityInstanceTranslator;
+    }
+    getTrackTitle(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let rowTitle;
+            assertDefined(targetAlignment.target_id);
+            if (alignmentQueryContext.excludeAlignmentLinks) {
+                rowTitle = targetAlignment.target_id;
+            }
+            else if (alignmentQueryContext.to === SequenceReference.PdbInstance && this.entityInstanceTranslator != null) {
+                const entityId = this.entityInstanceTranslator.translateAsymToEntity(TagDelimiter.parseInstance(targetAlignment.target_id).instanceId);
+                assertDefined(entityId);
+                rowTitle = {
+                    visibleTex: this.buildInstanceId(targetAlignment.target_id),
+                    url: resource.rcsb_entry.url + TagDelimiter.parseInstance(targetAlignment.target_id).entryId + "#entity-" + entityId,
+                    style: {
+                        fontWeight: "bold",
+                        color: RcsbAnnotationConstants.provenanceColorCode.rcsbLink
+                    }
+                };
+            }
+            else if (alignmentQueryContext.to === SequenceReference.PdbEntity) {
+                const entityId = TagDelimiter.parseEntity(targetAlignment.target_id).entityId;
+                rowTitle = {
+                    visibleTex: targetAlignment.target_id,
+                    url: resource.rcsb_entry.url + TagDelimiter.parseEntity(targetAlignment.target_id).entryId + "#entity-" + entityId,
+                    style: {
+                        fontWeight: "bold",
+                        color: RcsbAnnotationConstants.provenanceColorCode.rcsbLink
+                    }
+                };
+            }
+            else if (alignmentQueryContext.to === SequenceReference.Uniprot) {
+                rowTitle = {
+                    visibleTex: targetAlignment.target_id,
+                    url: resource.rcsb_uniprot.url + targetAlignment.target_id,
+                    style: {
+                        fontWeight: "bold",
+                        color: RcsbAnnotationConstants.provenanceColorCode.rcsbLink
+                    }
+                };
+            }
+            else {
+                rowTitle = targetAlignment.target_id;
+            }
+            return rowTitle;
+        });
+    }
+    getTrackTitlePrefix(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return alignmentQueryContext.to && !alignmentQueryContext.to.includes("PDB") ? alignmentQueryContext.to.replace("_", " ") + " " + TagDelimiter.alignmentTitle : "";
+        });
+    }
+    getTrackTitleFlagColor(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (alignmentQueryContext.to === SequenceReference.Uniprot)
+                return RcsbAnnotationConstants.provenanceColorCode.external;
+            return RcsbAnnotationConstants.provenanceColorCode.rcsbPdb;
+        });
+    }
+    buildInstanceId(targetId) {
+        var _a;
+        const labelAsymId = TagDelimiter.parseInstance(targetId).instanceId;
+        const authAsymId = (_a = this.entityInstanceTranslator) === null || _a === void 0 ? void 0 : _a.translateAsymToAuth(labelAsymId);
+        return TagDelimiter.parseInstance(targetId).entryId + TagDelimiter.instance + (labelAsymId === authAsymId || !authAsymId ? labelAsymId : labelAsymId + "[auth " + authAsymId + "]");
+    }
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/InstanceSequenceTrackTitleFactory.d.ts

@@ -1,7 +1,7 @@
+import { RcsbFvLink } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
 import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
 import { AlignmentRequestContextType } from "../TrackFactoryImpl/AlignmentTrackFactory";
 import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
-import { RcsbFvLink } from "@rcsb/rcsb-saguaro";
 export declare class InstanceSequenceTrackTitleFactory implements TrackTitleFactoryInterface<[AlignmentRequestContextType]> {
     private readonly trackTitleFactory;
     constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate);

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/InstanceSequenceTrackTitleFactory.js

@@ -0,0 +1,22 @@
+import { __awaiter } from "tslib";
+import { SequenceTrackTitleFactory } from "./SequenceTrackTitleFactory";
+export class InstanceSequenceTrackTitleFactory {
+    constructor(entityInstanceTranslator) {
+        this.trackTitleFactory = new SequenceTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrackTitle(alignmentQueryContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.trackTitleFactory.getTrackTitle(alignmentQueryContext);
+        });
+    }
+    getTrackTitlePrefix(alignmentQueryContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return "CHAIN";
+        });
+    }
+    getTrackTitleFlagColor(alignmentQueryContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.trackTitleFactory.getTrackTitleFlagColor(alignmentQueryContext);
+        });
+    }
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/ModelAlignmentTrackTitleFactory.d.ts

@@ -1,7 +1,7 @@
+import { RcsbFvLink } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
 import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
 import { AlignmentRequestContextType } from "../TrackFactoryImpl/AlignmentTrackFactory";
 import { TargetAlignment } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
-import { RcsbFvLink } from "@rcsb/rcsb-saguaro";
 import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
 export declare class ModelAlignmentTrackTitleFactory implements TrackTitleFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
     private readonly alignmentTrackTitleFactory;

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/ModelAlignmentTrackTitleFactory.js

@@ -0,0 +1,27 @@
+import { __awaiter } from "tslib";
+import { RcsbAnnotationConstants } from "../../../../RcsbAnnotationConfig/RcsbAnnotationConstants";
+import { ExperimentalAlignmentTrackTitleFactory } from "./ExperimentalAlignmentTrackTitleFactory";
+export class ModelAlignmentTrackTitleFactory {
+    constructor(entityInstanceTranslator) {
+        this.alignmentTrackTitleFactory = new ExperimentalAlignmentTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrackTitle(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rowTitle = yield this.alignmentTrackTitleFactory.getTrackTitle(alignmentQueryContext, targetAlignment);
+            return typeof rowTitle === "string" ? rowTitle : Object.assign(Object.assign({}, rowTitle), { style: {
+                    fontWeight: "bold",
+                    color: RcsbAnnotationConstants.provenanceColorCode.rcsbLink
+                } });
+        });
+    }
+    getTrackTitlePrefix(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.alignmentTrackTitleFactory.getTrackTitlePrefix(alignmentQueryContext, targetAlignment);
+        });
+    }
+    getTrackTitleFlagColor(alignmentQueryContext, targetAlignment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return RcsbAnnotationConstants.provenanceColorCode.csm;
+        });
+    }
+}

package/{build/dist → lib}/RcsbFvWeb/RcsbFvFactories/RcsbFvTrackFactory/TrackTitleFactoryImpl/SequenceTrackTitleFactory.d.ts

@@ -1,6 +1,6 @@
+import { RcsbFvLink } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
 import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
 import { AlignmentRequestContextType } from "../TrackFactoryImpl/AlignmentTrackFactory";
-import { RcsbFvLink } from "@rcsb/rcsb-saguaro";
 import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
 export declare class SequenceTrackTitleFactory implements TrackTitleFactoryInterface<[AlignmentRequestContextType]> {
     private readonly entityInstanceTranslator;