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

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationBlockManager.js

@@ -0,0 +1,98 @@
+import { __awaiter } from "tslib";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+export class AnnotationBlockManager {
+    constructor(trackManagerFactory, rcsbAnnotationConfig, polymerEntityInstanceTranslator) {
+        this.annotationTracks = new Map();
+        this.trackManagerFactory = trackManagerFactory;
+        this.rcsbAnnotationConfig = rcsbAnnotationConfig;
+        this.polymerEntityInstanceTranslator = polymerEntityInstanceTranslator;
+    }
+    setData(requestConfig, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.processAnnotations(requestConfig, data);
+            this.mergeTracks();
+        });
+    }
+    getTracks() {
+        var _a;
+        return (_a = this.orderedTypes()
+            .filter(type => { var _a, _b; return this.has(type) && ((_b = (_a = this.annotationTracks.get(type)) === null || _a === void 0 ? void 0 : _a.size()) !== null && _b !== void 0 ? _b : 0) > 0; })
+            .map(type => this.annotationTracks.get(type))
+            .filter((track) => track != null)) !== null && _a !== void 0 ? _a : [];
+    }
+    has(type) {
+        return this.annotationTracks.has(type);
+    }
+    orderedTypes() {
+        return [
+            this.rcsbAnnotationConfig.instanceOrder(),
+            this.rcsbAnnotationConfig.entityOrder(),
+            this.rcsbAnnotationConfig.uniprotOrder(),
+            Array.from(this.annotationTracks.keys()).filter(type => !this.rcsbAnnotationConfig.allTypes().has(type))
+        ].flat();
+    }
+    processAnnotations(requestConfig, data) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(data.map(ann => {
+                var _a, _b;
+                return (_b = (_a = ann.features) === null || _a === void 0 ? void 0 : _a.map((feature) => __awaiter(this, void 0, void 0, function* () {
+                    if (feature)
+                        return yield this.addFeature(requestConfig, ann, feature);
+                }))) !== null && _b !== void 0 ? _b : [];
+            }).flat());
+            (_b = (_a = requestConfig.annotationProcessing) === null || _a === void 0 ? void 0 : _a.computeAnnotationValue) === null || _b === void 0 ? void 0 : _b.call(_a, this.annotationTracks);
+        });
+    }
+    addFeature(requestConfig, ann, feature) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (feature.type && ((_a = this.rcsbAnnotationConfig.getConfig(feature.type)) === null || _a === void 0 ? void 0 : _a.ignore))
+                return;
+            const type = yield this.rcsbAnnotationConfig.getAnnotationType(requestConfig, ann, feature);
+            if (!this.annotationTracks.has(type)) {
+                const o = (_b = this.rcsbAnnotationConfig.getConfig(type)) !== null && _b !== void 0 ? _b : {
+                    type: type,
+                    display: "block" /* RcsbFvDisplayTypes.BLOCK */,
+                    title: type,
+                    provenanceList: new Set()
+                };
+                assertDefined(o, `Unknown type: ${type}`);
+                this.annotationTracks.set(type, this.trackManagerFactory.getTrackManager(type, o, this.polymerEntityInstanceTranslator));
+            }
+            const queryId = (_c = requestConfig.queryId) !== null && _c !== void 0 ? _c : requestConfig.groupId;
+            assertDefined(queryId, "undefined queryId or groupId");
+            assertDefined(ann.source, "undefined source");
+            assertDefined(ann.target_id, "undefined target_id");
+            (_d = this.annotationTracks.get(type)) === null || _d === void 0 ? void 0 : _d.addFeature({
+                reference: (_e = requestConfig.reference) !== null && _e !== void 0 ? _e : undefined,
+                queryId: queryId,
+                source: ann.source,
+                targetId: ann.target_id,
+                feature: feature
+            }, requestConfig.annotationProcessing);
+        });
+    }
+    mergeTracks() {
+        const typeList = Array.from(this.annotationTracks.keys());
+        typeList.forEach((type) => {
+            var _a, _b, _c, _d, _e;
+            if (this.rcsbAnnotationConfig.isMergedType(type)) {
+                const newType = (_a = this.rcsbAnnotationConfig.getMergeConfig(type)) === null || _a === void 0 ? void 0 : _a.type;
+                assertDefined(newType);
+                const color = (_b = this.rcsbAnnotationConfig.getConfig(type)) === null || _b === void 0 ? void 0 : _b.color;
+                if (!this.annotationTracks.has(newType)) {
+                    const o = this.rcsbAnnotationConfig.getConfig(newType);
+                    assertDefined(o);
+                    this.annotationTracks.set(newType, this.trackManagerFactory.getTrackManager(newType, o, this.polymerEntityInstanceTranslator));
+                }
+                const o = this.annotationTracks.get(type);
+                if (o && typeof color === "string")
+                    (_c = this.annotationTracks.get(newType)) === null || _c === void 0 ? void 0 : _c.addAll(o, color);
+                this.rcsbAnnotationConfig.addMultipleProvenance(newType, Array.from((_e = (_d = this.annotationTracks.get(newType)) === null || _d === void 0 ? void 0 : _d.getTrackProvenance()) !== null && _e !== void 0 ? _e : []));
+                this.annotationTracks.delete(type);
+            }
+        });
+    }
+}

package/lib/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/AnnotationTrackManager.d.ts

@@ -0,0 +1,11 @@
+import { RcsbFvTrackDataElementGapInterface } from "@rcsb/rcsb-saguaro/lib/RcsbDataManager/RcsbDataManager";
+import { FeaturePosition } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { PolymerEntityInstanceTranslate } from "../../../../RcsbUtils/Translators/PolymerEntityInstanceTranslate";
+import { RcsbAnnotationConfigInterface } from "../../../../RcsbAnnotationConfig/AnnotationConfigInterface";
+import { TrackManagerFactoryInterface, TrackManagerInterface } from "./TrackManagerInterface";
+export interface FeaturePositionGaps extends FeaturePosition {
+    gaps?: Array<RcsbFvTrackDataElementGapInterface>;
+}
+export declare class AnnotationTrackManagerFactory implements TrackManagerFactoryInterface<[string, RcsbAnnotationConfigInterface, PolymerEntityInstanceTranslate]> {
+    getTrackManager(trackId: string, annotationConfig: RcsbAnnotationConfigInterface, entityInstanceTranslator?: PolymerEntityInstanceTranslate): TrackManagerInterface;
+}

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

@@ -0,0 +1,241 @@
+import { Source } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { TrackUtils } from "../../RcsbFvTrackFactory/TrackFactoryImpl/Helper/TrackUtils";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertElementListDefined = Assertions.assertElementListDefined;
+var assertDefined = Assertions.assertDefined;
+import { TagDelimiter } from "@rcsb/rcsb-api-tools/build/RcsbUtils/TagDelimiter";
+export class AnnotationTrackManagerFactory {
+    getTrackManager(trackId, annotationConfig, entityInstanceTranslator) {
+        return new AnnotationTrackManager(trackId, annotationConfig, entityInstanceTranslator);
+    }
+}
+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 == Source.PdbInstance && this.entityInstanceTranslator != null ?
+            TagDelimiter.parseInstance(targetId).entryId + TagDelimiter.instance + this.entityInstanceTranslator.translateAsymToAuth(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.transformSourceFromTarget(targetId, source),
+            provenanceName: provenance,
+            provenanceColor: 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/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/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/BlockManagerInterface.js

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

package/lib/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/RcsbFvWeb/RcsbFvFactories/RcsbFvBlockFactory/BlockManager/TrackManagerInterface.js

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

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

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

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

@@ -0,0 +1,128 @@
+import { __awaiter } from "tslib";
+import { FeatureTools } from "../../../../RcsbCollectTools/FeatureTools/FeatureTools";
+import { SequenceTrackFactory } from "./SequenceTrackFactory";
+import { AlignmentTrackTitleFactory } from "../TrackTitleFactoryImpl/AlignmentTrackTitleFactory";
+import { TrackUtils } from "./Helper/TrackUtils";
+import { Assertions } from "../../../../RcsbUtils/Helpers/Assertions";
+var assertDefined = Assertions.assertDefined;
+export class AlignmentTrackFactory {
+    constructor(entityInstanceTranslator, trackTitleFactory) {
+        this.sequenceTrackFactory = new SequenceTrackFactory(entityInstanceTranslator);
+        this.trackTitleFactory = trackTitleFactory !== null && trackTitleFactory !== void 0 ? trackTitleFactory : new AlignmentTrackTitleFactory(entityInstanceTranslator);
+    }
+    getTrack(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { alignedBlocks, mismatchData, sequenceData } = this.getAlignmentTrackConfiguration(alignmentRequestContext, targetAlignment, alignedRegionToTrackElementList !== null && alignedRegionToTrackElementList !== void 0 ? alignedRegionToTrackElementList : this.alignedRegionToTrackElementList.bind(this));
+            const sequenceDisplay = {
+                displayType: "sequence" /* RcsbFvDisplayTypes.SEQUENCE */,
+                displayColor: "#000000",
+                displayData: sequenceData
+            };
+            const mismatchDisplay = {
+                displayType: "pin" /* RcsbFvDisplayTypes.PIN */,
+                displayColor: "#FF9999",
+                displayData: mismatchData
+            };
+            const alignmentDisplay = {
+                displayType: "block" /* 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.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                        provenanceName: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentQueryContext.to).name,
+                        provenanceColor: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentQueryContext.to).color,
+                        type: "MISMATCH",
+                        title: "MISMATCH"
+                    }, alignmentContext));
+                });
+        });
+        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.transformSourceFromTarget(alignmentContext.targetId, alignmentContext.to),
+                provenanceName: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).name,
+                provenanceColor: TrackUtils.getProvenanceConfigFormTarget(alignmentContext.targetId, alignmentContext.to).color,
+                openBegin: openBegin,
+                openEnd: openEnd,
+                type: "ALIGNED_BLOCK",
+                title: "ALIGNED REGION"
+            }, alignmentContext)];
+    }
+    addAuthorResIds(e, alignmentContext) {
+        return this.sequenceTrackFactory.addAuthorResIds(e, alignmentContext);
+    }
+}
+function findMismatch(seqA, seqB) {
+    const out = [];
+    if (seqA.length === seqB.length) {
+        for (let i = 0; i < seqA.length; i++) {
+            if (seqA.charAt(i) !== seqB.charAt(i)) {
+                out.push(i);
+            }
+        }
+    }
+    else {
+        console.error("Find alignment missmatch failed. Sequence regions of different length");
+    }
+    return out;
+}

package/lib/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>;
+}