@rcsb/rcsb-saguaro/lib/commonjs/RcsbFv/RcsbFvTrack/RcsbFvDisplay.js

RCSB 1D Feature Viewer

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RcsbFvDisplay = void 0;
const RcsbAxisDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbAxisDisplay");
const RcsbPinDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbPinDisplay");
const RcsbBondDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbBondDisplay");
const RcsbFastSequenceDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbFastSequenceDisplay");
const RcsbCompositeDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbCompositeDisplay");
const RcsbBlockDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbBlockDisplay");
const RcsbLineDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbLineDisplay");
const RcsbAreaDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbAreaDisplay");
const RcsbVariantDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbVariantDisplay");
const RcsbVlineDisplay_1 = require("../../RcsbBoard/RcsbDisplay/RcsbVlineDisplay");
const RcsbFvTooltipManager_1 = require("../RcsbFvTooltip/RcsbFvTooltipManager");
const RcsbFvTooltip_1 = require("../RcsbFvTooltip/RcsbFvTooltipImplementation/RcsbFvTooltip");
class RcsbFvDisplay {
    constructor(config) {
        this.displayIds = [];
        this.displayConfig = config;
    }
    initDisplay() {
        const config = this.displayConfig;
        if (typeof config.displayType === "string" && config.displayType != "composite" /* RcsbFvDisplayTypes.COMPOSITE */) {
            const out = RcsbFvDisplay.singleDisplay(config.displayType, config);
            if (out != null)
                return out;
            else
                throw "Display config " + config + " not supported";
        }
        else if (typeof config.displayType === "string" && config.displayType == "composite" /* RcsbFvDisplayTypes.COMPOSITE */) {
            return this.composedDisplay(config);
        }
        else {
            throw "Display type " + config.displayType + " not supported";
        }
    }
    getDisplayIds() {
        return this.displayIds;
    }
    composedDisplay(config) {
        const display = new RcsbCompositeDisplay_1.RcsbCompositeDisplay();
        let i = 0;
        if (config.displayConfig != undefined)
            for (let displayItem of config.displayConfig) {
                let displayId = "displayId_" + Math.random().toString(36).substr(2);
                if (typeof displayItem.displayId === "string") {
                    displayId = displayItem.displayId;
                }
                const displayType = displayItem.displayType;
                let displayConfig = config;
                if (config.displayConfig) {
                    displayConfig = RcsbFvDisplay.setDisplayConfig(config, config.displayConfig[i]);
                    i++;
                }
                const singleDisplay = RcsbFvDisplay.singleDisplay(displayType, displayConfig);
                if (singleDisplay != null) {
                    display.addDisplay(displayId, singleDisplay);
                    this.displayIds.push(displayId);
                }
                else {
                    throw "Display type " + displayConfig + " not supported";
                }
            }
        return display;
    }
    static setDisplayConfig(config, displayConfig) {
        return Object.assign(Object.assign({}, config), displayConfig);
    }
    static singleDisplay(type, config) {
        let out;
        if (config.boardId != undefined && config.trackId != undefined && config.displayColor != undefined) {
            switch (type) {
                case "axis" /* RcsbFvDisplayTypes.AXIS */:
                    out = axisDisplay(config.boardId, config.trackId, config.length);
                    break;
                case "block" /* RcsbFvDisplayTypes.BLOCK */:
                    out = blockDisplay(config.boardId, config.trackId, config.displayColor);
                    break;
                case "pin" /* RcsbFvDisplayTypes.PIN */:
                    if (config.displayDomain != undefined)
                        out = pinDisplay(config.boardId, config.trackId, config.displayColor, config.displayDomain);
                    else
                        throw "Track displayDomain (yScale) not defined";
                    break;
                case "bond" /* RcsbFvDisplayTypes.BOND */:
                    out = bondDisplay(config.boardId, config.trackId, config.displayColor);
                    break;
                case "sequence" /* RcsbFvDisplayTypes.SEQUENCE */:
                    const dynamicDisplay = config.dynamicDisplay != undefined ? config.dynamicDisplay : false;
                    const nonEmptyDisplay = config.nonEmptyDisplay != undefined ? config.nonEmptyDisplay : false;
                    out = sequenceDisplay(config.boardId, config.trackId, config.displayColor, dynamicDisplay, nonEmptyDisplay);
                    break;
                case "line" /* RcsbFvDisplayTypes.LINE */:
                    if (config.displayDomain != undefined)
                        out = lineDisplay(config.boardId, config.trackId, config.displayColor, config.displayDomain, config.interpolationType);
                    else
                        throw "Track displayDomain (yScale) not defined";
                    break;
                case "area" /* RcsbFvDisplayTypes.AREA */:
                    if (config.displayDomain != undefined)
                        out = areaDisplay(config.boardId, config.trackId, config.displayColor, config.displayDomain, config.interpolationType);
                    else
                        throw "Track displayDomain (yScale) not defined";
                    break;
                case "block-area" /* RcsbFvDisplayTypes.BLOCK_AREA */:
                    if (config.displayDomain != undefined)
                        out = areaDisplay(config.boardId, config.trackId, config.displayColor, config.displayDomain, config.interpolationType, true);
                    else
                        throw "Track displayDomain (yScale) not defined";
                    break;
                case "multi-area" /* RcsbFvDisplayTypes.MULTI_AREA */:
                    if (config.displayDomain != undefined)
                        out = areaDisplay(config.boardId, config.trackId, config.displayColor, config.displayDomain, config.interpolationType, false, true);
                    else
                        throw "Track displayDomain (yScale) not defined";
                    break;
                case "variant" /* RcsbFvDisplayTypes.VARIANT */:
                    out = variantDisplay(config.boardId, config.trackId, config.displayColor);
                    break;
                case "vline" /* RcsbFvDisplayTypes.VLINE */:
                    out = vlineDisplay(config.boardId, config.trackId, config.displayColor);
                    break;
                default:
                    throw "Track type " + config.displayType + " is not supported";
            }
            configDisplay(out, config);
            configTooltip(out, config);
        }
        else {
            console.error(config);
            throw "Single Display failed missing boardId or displayColor";
        }
        return out;
    }
}
exports.RcsbFvDisplay = RcsbFvDisplay;
function configDisplay(display, config) {
    if (display != null && typeof config.elementClickCallback === "function") {
        display.elementSubject.mouseclick.subscribe(({ d, e }) => { var _a; return (_a = config.elementClickCallback) === null || _a === void 0 ? void 0 : _a.call(config, d, e); });
    }
    if (display != null && typeof config.elementEnterCallback === "function") {
        display.elementSubject.mouseenter.subscribe(({ d, e }) => { var _a; return (_a = config.elementEnterCallback) === null || _a === void 0 ? void 0 : _a.call(config, d, e); });
    }
    if (display != null && typeof config.elementLeaveCallback === "function") {
        display.elementSubject.mouseleave.subscribe(({ d, e }) => { var _a; return (_a = config.elementLeaveCallback) === null || _a === void 0 ? void 0 : _a.call(config, d, e); });
    }
    if (display != null && typeof config.updateDataOnMove === "function") {
        display.setUpdateDataOnMove(config.updateDataOnMove);
    }
    if (display != null && typeof config.minRatio === "number") {
        display.setMinRatio(config.minRatio);
    }
    if (display != null && typeof config.selectDataInRangeFlag === "boolean") {
        display.setSelectDataInRange(config.selectDataInRangeFlag);
    }
    if (display != null && typeof config.hideEmptyTrackFlag === "boolean") {
        display.setHideEmptyTrack(config.hideEmptyTrackFlag);
    }
}
function configTooltip(display, config) {
    var _a;
    if (config.includeTooltip) {
        const tooltipManager = new RcsbFvTooltipManager_1.RcsbFvTooltipManager(config.boardId, (_a = config.tooltipGenerator) !== null && _a !== void 0 ? _a : new RcsbFvTooltip_1.RcsbFvTooltip());
        display.elementSubject.mouseenter.subscribe(({ d, e }) => {
            tooltipManager.showTooltip(d);
            tooltipManager.showTooltipDescription(d);
        });
        display.elementSubject.mouseleave.subscribe(({ d, e }) => {
            tooltipManager.hideTooltip();
        });
    }
}
function axisDisplay(boardId, trackId, length) {
    return new RcsbAxisDisplay_1.RcsbAxisDisplay(boardId, trackId, length);
}
function sequenceDisplay(boardId, trackId, color, dynamicDisplayFlag, nonEmptyDisplayFlag) {
    const display = new RcsbFastSequenceDisplay_1.RcsbFastSequenceDisplay(boardId, trackId);
    display.setDisplayColor(color);
    if (dynamicDisplayFlag) {
        display.setDynamicDisplay();
    }
    if (nonEmptyDisplayFlag) {
        display.setNonEmptyDisplay(true);
    }
    return display;
}
function blockDisplay(boardId, trackId, color) {
    const display = new RcsbBlockDisplay_1.RcsbBlockDisplay(boardId, trackId);
    display.setDisplayColor(color);
    return display;
}
function pinDisplay(boardId, trackId, color, domain) {
    const display = new RcsbPinDisplay_1.RcsbPinDisplay(boardId, trackId);
    display.setDisplayColor(color);
    display.yDomain(domain);
    return display;
}
function bondDisplay(boardId, trackId, color) {
    const display = new RcsbBondDisplay_1.RcsbBondDisplay(boardId, trackId);
    display.setDisplayColor(color);
    return display;
}
function lineDisplay(boardId, trackId, color, domain, interpolationType) {
    const display = new RcsbLineDisplay_1.RcsbLineDisplay(boardId, trackId);
    display.setDisplayColor(color);
    display.yDomain(domain);
    if (interpolationType != undefined)
        display.setInterpolationType(interpolationType);
    return display;
}
function areaDisplay(boardId, trackId, color, domain, interpolationType, blockAreaFlag, multiAreaFlag) {
    const display = new RcsbAreaDisplay_1.RcsbAreaDisplay(boardId, trackId);
    display.setDisplayColor(color);
    display.yDomain(domain);
    if (typeof interpolationType === "string")
        display.setInterpolationType(interpolationType);
    if (typeof blockAreaFlag === "boolean")
        display.setBlockArea(blockAreaFlag);
    if (typeof multiAreaFlag === "boolean")
        display.setMultiArea(multiAreaFlag);
    return display;
}
function variantDisplay(boardId, trackId, color) {
    const display = new RcsbVariantDisplay_1.RcsbVariantDisplay(boardId, trackId);
    display.setDisplayColor(color);
    return display;
}
function vlineDisplay(boardId, trackId, color) {
    const display = new RcsbVlineDisplay_1.RcsbVlineDisplay(boardId, trackId);
    display.setDisplayColor(color);
    return display;
}