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

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationTrackManager.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationTrackManagerFactory = void 0;
+const GqlTypes_1 = require("@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes");
+const TrackUtils_1 = require("../../RcsbFvTrackFactory/TrackFactoryImpl/Helper/TrackUtils");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var assertElementListDefined = Assertions_1.Assertions.assertElementListDefined;
+var assertDefined = Assertions_1.Assertions.assertDefined;
+const TagDelimiter_1 = require("@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter");
+class AnnotationTrackManagerFactory {
+    getTrackManager(trackId, annotationConfig, entityInstanceTranslator) {
+        return new AnnotationTrackManager(trackId, annotationConfig, entityInstanceTranslator);
+    }
+}
+exports.AnnotationTrackManagerFactory = AnnotationTrackManagerFactory;
+class AnnotationTrackManager {
+    constructor(type, annotationConfig, entityInstanceTranslator) {
+        this.valueRange = { max: Number.MIN_SAFE_INTEGER, min: Number.MAX_SAFE_INTEGER };
+        this.trackElementMap = new Map();
+        this.entityInstanceTranslator = entityInstanceTranslator;
+        this.type = type;
+        this.annotationConfig = annotationConfig;
+    }
+    getId() {
+        return this.type;
+    }
+    getConfig() {
+        return this.annotationConfig;
+    }
+    getRange() {
+        return this.valueRange;
+    }
+    addFeature(ann, annotationProcessing) {
+        assertElementListDefined(ann.feature.feature_positions);
+        computeFeatureGaps(ann.feature.feature_positions).forEach(p => {
+            if (p.beg_seq_id != null) {
+                this.annotationRangeKeys(p).forEach(rangeKey => {
+                    this.addRange(ann.reference, ann.queryId, ann.source, ann.targetId, ann.feature, p, rangeKey, annotationProcessing);
+                });
+            }
+        });
+    }
+    size() {
+        return this.trackElementMap.size;
+    }
+    forEach(f) {
+        this.trackElementMap.forEach((ann, loc) => {
+            f(ann, loc);
+        });
+    }
+    addAll(trackElementsMap, color) {
+        trackElementsMap.forEach((ann, loc) => {
+            ann.color = color !== null && color !== void 0 ? color : ann.color;
+            this.trackElementMap.set(loc, ann);
+        });
+    }
+    getTrackProvenance() {
+        return new Set(Array.from(this.trackElementMap.values()).map(e => e.provenanceName).filter((x) => x != null));
+    }
+    values() {
+        return Array.from(this.trackElementMap.values());
+    }
+    buildRcsbFvTrackDataElement(p, d, targetId, source, provenance) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        let title = (_b = (_a = this.annotationConfig) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : this.type;
+        let value = undefined;
+        if (this.isNumericalDisplay(this.type)) {
+            if ((_c = this.annotationConfig) === null || _c === void 0 ? void 0 : _c.transformToNumerical) {
+                value = 1;
+            }
+            else {
+                value = Array.isArray(p.values) && p.values[0] ? p.values[0] : 0;
+            }
+        }
+        if (Array.isArray(p.values) && p.values.length > 0) {
+            assertElementListDefined(p.values);
+            if (Math.max(...p.values) > this.valueRange.max)
+                this.valueRange.max = Math.max(...p.values);
+            if (Math.min(...p.values) < this.valueRange.min)
+                this.valueRange.min = Math.min(...p.values);
+        }
+        else if (typeof value === "number") {
+            if (value > this.valueRange.max)
+                this.valueRange.max = value;
+            if (value < this.valueRange.min)
+                this.valueRange.min = value;
+        }
+        const sourceId = source == GqlTypes_1.Source.PdbInstance && this.entityInstanceTranslator != null ?
+            TagDelimiter_1.TagDelimiter.parseInstance(targetId).entryId + TagDelimiter_1.TagDelimiter.instance + this.entityInstanceTranslator.translateAsymToAuth(TagDelimiter_1.TagDelimiter.parseInstance(targetId).instanceId) : targetId;
+        assertDefined(p.beg_seq_id);
+        return {
+            begin: p.beg_seq_id,
+            end: (_d = p.end_seq_id) !== null && _d !== void 0 ? _d : p.beg_seq_id,
+            oriBegin: (_e = p.beg_ori_id) !== null && _e !== void 0 ? _e : undefined,
+            oriEnd: (_g = ((_f = p.end_ori_id) !== null && _f !== void 0 ? _f : p.beg_ori_id)) !== null && _g !== void 0 ? _g : undefined,
+            description: new Array(),
+            featureId: (_h = d.feature_id) !== null && _h !== void 0 ? _h : undefined,
+            type: this.type,
+            title: title,
+            name: (_j = d.name) !== null && _j !== void 0 ? _j : undefined,
+            value: value,
+            gaps: p.gaps,
+            sourceId: sourceId,
+            source: TrackUtils_1.TrackUtils.transformSourceFromTarget(targetId, source),
+            provenanceName: provenance,
+            provenanceColor: TrackUtils_1.TrackUtils.getProvenanceColorFromProvenance(provenance),
+            openBegin: (_k = p.open_begin) !== null && _k !== void 0 ? _k : undefined,
+            openEnd: (_l = p.open_end) !== null && _l !== void 0 ? _l : undefined
+        };
+    }
+    addRange(reference, queryId, source, targetId, d, p, rangeKey, annotationProcessing) {
+        var _a, _b, _c, _d;
+        const key = rangeKey.join(":");
+        if (!this.trackElementMap.has(key)) {
+            const a = this.buildRcsbFvTrackDataElement(p, d, targetId, source, (_a = d.provenance_source) !== null && _a !== void 0 ? _a : undefined);
+            if ((_b = this.annotationConfig) === null || _b === void 0 ? void 0 : _b.transformToNumerical)
+                this.transformToNumerical(targetId, rangeKey, key, a, d, p, annotationProcessing === null || annotationProcessing === void 0 ? void 0 : annotationProcessing.getAnnotationValue);
+            if (typeof (annotationProcessing === null || annotationProcessing === void 0 ? void 0 : annotationProcessing.addTrackElementCallback) === "function")
+                annotationProcessing === null || annotationProcessing === void 0 ? void 0 : annotationProcessing.addTrackElementCallback({ type: this.type, targetId: targetId, positionKey: key, d: d, p: p });
+            const translateContext = {
+                from: reference,
+                to: source,
+                queryId: queryId,
+                targetId: targetId
+            };
+            this.addAuthorResIds(a, translateContext);
+            this.trackElementMap.set(key, a);
+            if (Array.isArray(p.values)) {
+                assertElementListDefined(p.values);
+                this.expandValues(a, p.values, translateContext);
+            }
+        }
+        else if (this.isNumericalDisplay(this.type) && ((_c = this.annotationConfig) === null || _c === void 0 ? void 0 : _c.transformToNumerical) && typeof ((_d = this.trackElementMap.get(key)) === null || _d === void 0 ? void 0 : _d.value) === "number") {
+            const o = this.trackElementMap.get(key);
+            assertDefined(o === null || o === void 0 ? void 0 : o.value);
+            if (typeof o.value !== "number")
+                return;
+            o.value += typeof (annotationProcessing === null || annotationProcessing === void 0 ? void 0 : annotationProcessing.getAnnotationValue) === "function" ? annotationProcessing.getAnnotationValue({ type: this.type, targetId: targetId, positionKey: key, d: d, p: p }) : 1;
+            if (o.value > this.valueRange.max)
+                this.valueRange.max = o.value;
+            if (o.value < this.valueRange.min)
+                this.valueRange.min = o.value;
+        }
+        if (typeof d.description === "string") {
+            const o = this.trackElementMap.get(key);
+            if (o) {
+                if (!o.description)
+                    o.description = [];
+                o.description.push(d.description);
+            }
+        }
+    }
+    transformToNumerical(targetId, rangeKey, key, a, d, p, getAnnotationValue) {
+        if (typeof getAnnotationValue === "function")
+            a.value = getAnnotationValue({ type: this.type, targetId: targetId, positionKey: key, d: d, p: p });
+        a.begin = rangeKey[0];
+        a.end = rangeKey[0];
+    }
+    expandValues(e, values, translateContext) {
+        values.forEach((v, i) => {
+            if (i > 0) {
+                const key = (e.begin + i).toString();
+                const a = Object.assign(Object.assign({}, e), { begin: (e.begin + i), end: undefined, oriBegin: e.oriBegin ? (e.oriBegin + i) : undefined, oriEnd: undefined, value: v });
+                this.addAuthorResIds(a, translateContext);
+                this.trackElementMap.set(key, a);
+            }
+        });
+    }
+    addAuthorResIds(e, annotationContext) {
+        let o = e;
+        if (this.entityInstanceTranslator != null && annotationContext.from) {
+            this.entityInstanceTranslator.addAuthorResIds(o, annotationContext);
+        }
+        return o;
+    }
+    isNumericalDisplay(type) {
+        return (this.annotationConfig != null && (this.annotationConfig.display === "area" /* RcsbFvDisplayTypes.AREA */ || this.annotationConfig.display === "block-area" /* RcsbFvDisplayTypes.BLOCK_AREA */ || this.annotationConfig.display === "multi-area" /* RcsbFvDisplayTypes.MULTI_AREA */ || this.annotationConfig.display === "line" /* RcsbFvDisplayTypes.LINE */));
+    }
+    annotationRangeKeys(p) {
+        var _a, _b, _c;
+        const rangeKeys = new Array();
+        if (((_a = this.annotationConfig) === null || _a === void 0 ? void 0 : _a.transformToNumerical) && p.beg_seq_id && p.end_seq_id != null) {
+            for (let i = p.beg_seq_id; i <= p.end_seq_id; i++) {
+                rangeKeys.push([i]);
+            }
+        }
+        else if (((_b = this.annotationConfig) === null || _b === void 0 ? void 0 : _b.transformToNumerical) && p.beg_seq_id) {
+            rangeKeys.push([p.beg_seq_id]);
+        }
+        else if (p.beg_seq_id) {
+            const key = p.end_seq_id != null ? [p.beg_seq_id, p.end_seq_id] : [p.beg_seq_id, p.beg_seq_id];
+            if ((_c = this.annotationConfig) === null || _c === void 0 ? void 0 : _c.displayCooccurrence)
+                key.push(Math.ceil(Math.random() * 1000000000000));
+            rangeKeys.push(key);
+        }
+        return rangeKeys;
+    }
+}
+function computeFeatureGaps(featurePositions) {
+    const rangeIdMap = new Map();
+    const out = new Array();
+    featurePositions.forEach(fp => {
+        var _a;
+        if (fp.range_id != null) {
+            if (!rangeIdMap.has(fp.range_id))
+                rangeIdMap.set(fp.range_id, new Array());
+            (_a = rangeIdMap.get(fp.range_id)) === null || _a === void 0 ? void 0 : _a.push(fp);
+        }
+        else {
+            out.push(fp);
+        }
+    });
+    rangeIdMap.forEach((fpList, rangeId) => {
+        var _a, _b, _c;
+        if (fpList.length == 1) {
+            out.push(fpList[0]);
+        }
+        else {
+            const sorted = fpList.sort((a, b) => {
+                if (a.beg_seq_id && b.beg_seq_id)
+                    return a.beg_seq_id - b.beg_seq_id;
+                return Number.MAX_SAFE_INTEGER;
+            });
+            const gapedFeaturePosition = Object.assign(Object.assign({}, sorted[0]), { end_seq_id: sorted[sorted.length - 1].end_seq_id, end_ori_id: sorted[sorted.length - 1].end_ori_id, open_end: sorted[sorted.length - 1].open_end, gaps: new Array() });
+            for (let n = 0; n < sorted.length - 1; n++) {
+                const prevEnd = sorted[n].end_seq_id;
+                const nextBeg = sorted[n + 1].beg_seq_id;
+                if (prevEnd && nextBeg)
+                    (_a = gapedFeaturePosition === null || gapedFeaturePosition === void 0 ? void 0 : gapedFeaturePosition.gaps) === null || _a === void 0 ? void 0 : _a.push({
+                        begin: prevEnd,
+                        end: nextBeg,
+                        isConnected: (sorted[n].beg_ori_id == null ||
+                            sorted[n].end_ori_id == null ||
+                            sorted[n + 1].beg_ori_id == null ||
+                            sorted[n + 1].end_ori_id == null ||
+                            ((_b = sorted[n].end_ori_id) !== null && _b !== void 0 ? _b : Number.MIN_SAFE_INTEGER) + 1 == sorted[n + 1].beg_ori_id ||
+                            sorted[n].end_ori_id == ((_c = sorted[n + 1].beg_ori_id) !== null && _c !== void 0 ? _c : Number.MIN_SAFE_INTEGER) + 1 ||
+                            sorted[n].end_ori_id == sorted[n + 1].beg_ori_id)
+                    });
+            }
+            out.push(gapedFeaturePosition);
+        }
+    });
+    return out;
+}

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/BlockManagerInterface.d.ts

@@ -0,0 +1,5 @@
+import { TrackManagerInterface } from "./TrackManagerInterface";
+export interface BlockManagerInterface<T extends any[]> {
+    setData(...args: T): Promise<void>;
+    getTracks(): TrackManagerInterface[];
+}

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/BlockManagerInterface.js

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

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface.d.ts

@@ -0,0 +1,28 @@
+import { RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+import { RcsbAnnotationConfigInterface } from "../../../../RcsbAnnotationConfig/AnnotationConfigInterface";
+import { Feature, SequenceReference, Source } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { AnnotationProcessingInterface } from "../../../../RcsbCollectTools/AnnotationCollector/AnnotationCollectorInterface";
+import { RcsbFvTrackDataAnnotationInterface } from "../../RcsbFvTrackFactory/RcsbFvTrackDataAnnotationInterface";
+export interface TrackManagerFactoryInterface<T extends any[]> {
+    getTrackManager(...args: T): TrackManagerInterface;
+}
+export interface TrackManagerInterface {
+    getId(): string;
+    getConfig(): RcsbAnnotationConfigInterface | undefined;
+    getRange(): {
+        min: number;
+        max: number;
+    };
+    addFeature(ann: {
+        reference: SequenceReference | undefined;
+        queryId: string;
+        source: Source;
+        targetId: string;
+        feature: Feature;
+    }, annotationProcessing?: AnnotationProcessingInterface): void;
+    size(): number;
+    forEach(f: (ann: RcsbFvTrackDataAnnotationInterface, loc: string) => void): void;
+    addAll(trackElementsMap: TrackManagerInterface, color?: string): void;
+    getTrackProvenance(): Set<string>;
+    values(): Array<RcsbFvTrackDataElementInterface>;
+}

package/lib/commonjs/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface.js

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

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

@@ -0,0 +1,35 @@
+import { RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+export interface RcsbFvTrackDataAnnotationInterface extends RcsbFvTrackDataElementInterface {
+    /**Name of the start position. This information might be displayed in the annotation tooltip*/
+    beginName?: string;
+    /**Name of the end position. This information might be displayed in the annotation tooltip*/
+    endName?: string;
+    /**Annotation original reference start position. This information might be displayed in the annotation tooltip*/
+    oriBegin?: number;
+    /**Annotation original reference end position. This information might be displayed in the annotation tooltip*/
+    oriEnd?: number;
+    /**Name of the original reference start position. This information might be displayed in the annotation tooltip*/
+    oriBeginName?: string;
+    /**Name of the original reference end position. This information might be displayed in the annotation tooltip*/
+    oriEndName?: string;
+    /**Name of the original reference. This information might be displayed in the annotation tooltip*/
+    indexName?: string;
+    /**Annotation name. This information might be displayed in the annotation tooltip*/
+    name?: string;
+    /**Id of the annotation element (protein or gene) source*/
+    sourceId?: string;
+    /**Source reference database name*/
+    source?: string;
+    /**Name of the resource that dispatched the data*/
+    provenanceName?: string;
+    /**color associated to the resource that dispatched the data*/
+    provenanceColor?: string;
+    /**Description associated to the annotation. This information might be displayed in the annotation tooltip*/
+    description?: Array<string>;
+    /**Annotation Id*/
+    featureId?: string;
+    /**Annotation type. This information might be displayed in the annotation tooltip*/
+    type?: string;
+    /**Track title. This information might be displayed in the annotation tooltip*/
+    title?: string;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { RcsbFvTrackDataElementInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+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 { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
+export type AlignmentRequestContextType = AlignmentCollectConfig & {
+    querySequence?: string;
+};
+export declare class AlignmentTrackFactory implements TrackFactoryInterface<[AlignmentRequestContextType, TargetAlignment]> {
+    private readonly sequenceTrackFactory;
+    private readonly trackTitleFactory;
+    constructor(entityInstanceTranslator?: PolymerEntityInstanceTranslate, trackTitleFactory?: TrackTitleFactoryInterface<[AlignmentRequestContextType, TargetAlignment]>);
+    getTrack(alignmentRequestContext: AlignmentRequestContextType, targetAlignment: TargetAlignment, alignedRegionToTrackElementList?: (region: AlignedRegion, alignmentContext: AlignmentContextInterface) => Array<RcsbFvTrackDataElementInterface>): Promise<RcsbFvRowConfigInterface>;
+    private getAlignmentTrackConfiguration;
+    alignedRegionToTrackElementList(region: AlignedRegion, alignmentContext: AlignmentContextInterface): Array<RcsbFvTrackDataElementInterface>;
+    addAuthorResIds(e: RcsbFvTrackDataElementInterface, alignmentContext: AlignmentContextInterface): RcsbFvTrackDataElementInterface;
+}

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlignmentTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const FeatureTools_1 = require("../../../../RcsbCollectTools/FeatureTools/FeatureTools");
+const SequenceTrackFactory_1 = require("./SequenceTrackFactory");
+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 AlignmentTrackFactory {
+    constructor(entityInstanceTranslator, trackTitleFactory) {
+        this.sequenceTrackFactory = new SequenceTrackFactory_1.SequenceTrackFactory(entityInstanceTranslator);
+        this.trackTitleFactory = trackTitleFactory !== null && trackTitleFactory !== void 0 ? trackTitleFactory : new AlignmentTrackTitleFactory_1.AlignmentTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList) {
+        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" /* RcsbFvDisplayTypes.BLOCK */,
+                displayColor: "#9999FF",
+                displayData: alignedBlocks
+            };
+            return {
+                trackId: "targetSequenceTrack_" + targetAlignment.target_id,
+                displayType: "composite" /* RcsbFvDisplayTypes.COMPOSITE */,
+                overlap: true,
+                trackColor: "#F9F9F9",
+                rowPrefix: yield this.trackTitleFactory.getTrackTitlePrefix(alignmentRequestContext, targetAlignment),
+                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;
+        assertDefined(alignmentQueryContext.queryId), assertDefined(targetAlignment.target_id);
+        const alignedBlocks = [];
+        const mismatchData = [];
+        const targetSequence = targetAlignment.target_sequence;
+        const sequenceData = [];
+        const alignmentContext = {
+            queryId: alignmentQueryContext.queryId,
+            targetId: targetAlignment.target_id,
+            from: alignmentQueryContext.from,
+            to: alignmentQueryContext.to,
+            targetSequenceLength: (_a = targetAlignment.target_sequence) === null || _a === void 0 ? void 0 : _a.length,
+            querySequenceLength: (_b = alignmentQueryContext.querySequence) === null || _b === void 0 ? void 0 : _b.length
+        };
+        (_c = targetAlignment.aligned_regions) === null || _c === void 0 ? void 0 : _c.forEach(region => {
+            var _a, _b;
+            assertDefined(region);
+            const regionSequence = targetSequence && region.target_begin && region.target_end ? targetSequence.substring(region.target_begin - 1, region.target_end) : "";
+            this.sequenceTrackFactory.buildSequenceData(Object.assign(Object.assign({}, alignmentContext), { sequence: regionSequence, begin: region.query_begin, oriBegin: region === null || region === void 0 ? void 0 : region.target_begin }), "to").forEach(sd => {
+                sequenceData.push(sd);
+            });
+            alignedRegionToTrackElementList(region, Object.assign(Object.assign({}, alignmentContext), { targetSequenceLength: (_a = alignmentContext.targetSequenceLength) !== null && _a !== void 0 ? _a : (_b = targetAlignment.target_sequence) === null || _b === void 0 ? void 0 : _b.length })).forEach(r => {
+                alignedBlocks.push(r);
+            });
+            if (alignmentQueryContext.querySequence)
+                findMismatch(regionSequence, alignmentQueryContext.querySequence.substring(region.query_begin - 1, region.query_end)).forEach(m => {
+                    var _a;
+                    assertDefined(alignmentContext.to), assertDefined(alignmentQueryContext.to);
+                    mismatchData.push(this.sequenceTrackFactory.addAuthorResIds({
+                        begin: (m + region.query_begin),
+                        oriBegin: (m + region.target_begin),
+                        sourceId: (_a = targetAlignment.target_id) !== null && _a !== void 0 ? _a : undefined,
+                        source: TrackUtils_1.TrackUtils.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                        provenanceName: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentQueryContext.to).name,
+                        provenanceColor: TrackUtils_1.TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentQueryContext.to).color,
+                        type: "MISMATCH",
+                        title: "MISMATCH"
+                    }, alignmentContext));
+                });
+        });
+        FeatureTools_1.FeatureTools.mergeBlocks(alignedBlocks);
+        return { alignedBlocks, mismatchData, sequenceData };
+    }
+    alignedRegionToTrackElementList(region, alignmentContext) {
+        let openBegin = false;
+        if (region.target_begin != 1)
+            openBegin = true;
+        let openEnd = false;
+        if (alignmentContext.targetSequenceLength && region.target_end != alignmentContext.targetSequenceLength)
+            openEnd = true;
+        assertDefined(alignmentContext.to);
+        return [this.sequenceTrackFactory.addAuthorResIds({
+                begin: region.query_begin,
+                end: region.query_end,
+                oriBegin: region.target_begin,
+                oriEnd: region.target_end,
+                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"
+            }, alignmentContext)];
+    }
+    addAuthorResIds(e, alignmentContext) {
+        return this.sequenceTrackFactory.addAuthorResIds(e, alignmentContext);
+    }
+}
+exports.AlignmentTrackFactory = AlignmentTrackFactory;
+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);
+            }
+        }
+    }
+    else {
+        console.error("Find alignment missmatch failed. Sequence regions of different length");
+    }
+    return out;
+}

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

@@ -0,0 +1,9 @@
+import { RcsbFvRowConfigInterface } from "@rcsb/rcsb-saguaro/lib/RcsbFv/RcsbFvConfig/RcsbFvConfigInterface";
+import { TrackFactoryInterface } from "../TrackFactoryInterface";
+import { TrackManagerInterface } from "../../RcsbFvBlockFactory/BlockManager/TrackManagerInterface";
+import { TrackTitleFactoryInterface } from "../TrackTitleFactoryInterface";
+export declare class AnnotationsTrackFactory implements TrackFactoryInterface<[TrackManagerInterface]> {
+    private readonly trackTitleFactory;
+    constructor(trackTitleFactory?: TrackTitleFactoryInterface<[TrackManagerInterface]>);
+    getTrack(annotations: TrackManagerInterface): Promise<RcsbFvRowConfigInterface>;
+}

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnotationsTrackFactory = void 0;
+const tslib_1 = require("tslib");
+const RcsbAnnotationConfig_1 = require("../../../../RcsbAnnotationConfig/RcsbAnnotationConfig");
+const AnnotationsTrackTitleFactory_1 = require("../TrackTitleFactoryImpl/AnnotationsTrackTitleFactory");
+const Assertions_1 = require("../../../../RcsbUtils/Helpers/Assertions");
+var assertDefined = Assertions_1.Assertions.assertDefined;
+class AnnotationsTrackFactory {
+    constructor(trackTitleFactory) {
+        this.trackTitleFactory = trackTitleFactory !== null && trackTitleFactory !== void 0 ? trackTitleFactory : new AnnotationsTrackTitleFactory_1.AnnotationsTrackTitleFactory();
+    }
+    getTrack(annotations) {
+        return tslib_1.__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) });
+        });
+    }
+}
+exports.AnnotationsTrackFactory = AnnotationsTrackFactory;
+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_1.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_1.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_1.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/commonjs/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;
+}