@jbrowse/plugin-canvas 4.0.0

package/esm/CanvasFeatureRenderer/layout/layoutUtils.js

@@ -0,0 +1,129 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { createSubfeatureLabelMetadata } from '@jbrowse/plugin-linear-genome-view';
+import { createTranscriptFloatingLabel } from "../floatingLabels.js";
+import { builtinGlyphs } from "../glyphs/index.js";
+export function convertToCanvasCoords(layout, offsetX, offsetY) {
+    const canvasX = offsetX + layout.x;
+    const canvasY = offsetY + layout.y;
+    return {
+        ...layout,
+        x: canvasX,
+        y: canvasY,
+        children: layout.children.map(child => convertToCanvasCoords(child, canvasX, canvasY)),
+    };
+}
+function findMatchingGlyph(feature, configContext, pluginManager) {
+    const builtinMatch = builtinGlyphs.find(glyph => glyph.hasIndexableChildren && glyph.match(feature, configContext));
+    if (builtinMatch) {
+        return builtinMatch;
+    }
+    if (pluginManager) {
+        const glyphTypes = pluginManager.getGlyphTypes();
+        const sortedGlyphs = [...glyphTypes].sort((a, b) => b.priority - a.priority);
+        const pluggableMatch = sortedGlyphs.find(glyph => glyph.match?.(feature) && glyph.getChildFeatures);
+        if (pluggableMatch) {
+            return pluggableMatch;
+        }
+    }
+    return undefined;
+}
+export function buildChildrenIndex({ layout, featureLayout, subfeatureCoords, subfeatureInfos, config, configContext, pluginManager, subfeatureLabels, transcriptTypes, labelColor, parentTooltip, }) {
+    addChildrenRecursive({
+        layout,
+        featureLayout,
+        subfeatureCoords,
+        subfeatureInfos,
+        config,
+        configContext,
+        pluginManager,
+        subfeatureLabels,
+        transcriptTypes,
+        labelColor,
+        parentTooltip,
+    });
+}
+function addChildrenRecursive({ layout, featureLayout, subfeatureCoords, subfeatureInfos, config, configContext, pluginManager, subfeatureLabels, transcriptTypes, labelColor, parentTooltip, }) {
+    const feature = featureLayout.feature;
+    const featureType = feature.get('type');
+    const isGene = featureType === 'gene';
+    const matchingGlyph = findMatchingGlyph(feature, configContext, pluginManager);
+    const hasTranscriptChildren = isGene &&
+        featureLayout.children.some(child => transcriptTypes.includes(child.feature.get('type')));
+    const shouldIndexChildren = matchingGlyph || hasTranscriptChildren;
+    const showSubfeatureLabels = subfeatureLabels !== 'none';
+    if (shouldIndexChildren) {
+        for (const child of featureLayout.children) {
+            const childFeature = child.feature;
+            const childType = childFeature.get('type');
+            if (hasTranscriptChildren && !matchingGlyph) {
+                if (!transcriptTypes.includes(childType)) {
+                    continue;
+                }
+            }
+            const leftPx = child.x;
+            const rightPx = child.x + child.totalLayoutWidth;
+            const topPx = child.y;
+            const bottomPx = child.y + child.totalLayoutHeight;
+            subfeatureCoords.push(leftPx, topPx, rightPx, bottomPx);
+            const glyphMouseover = matchingGlyph?.getSubfeatureMouseover?.(childFeature);
+            const displayLabel = glyphMouseover ??
+                String(readConfObject(config, 'subfeatureMouseover', {
+                    feature: childFeature,
+                }) || '');
+            subfeatureInfos.push({
+                featureId: childFeature.id(),
+                parentFeatureId: featureLayout.feature.id(),
+                displayLabel,
+                type: childType,
+                leftPx,
+                topPx,
+                rightPx,
+                bottomPx,
+            });
+            const floatingLabels = [];
+            if (showSubfeatureLabels && displayLabel) {
+                const label = createTranscriptFloatingLabel({
+                    displayLabel,
+                    featureHeight: child.height,
+                    subfeatureLabels,
+                    color: labelColor,
+                    parentFeatureId: featureLayout.feature.id(),
+                    subfeatureId: childFeature.id(),
+                    tooltip: matchingGlyph ? displayLabel : parentTooltip,
+                });
+                if (label) {
+                    floatingLabels.push(label);
+                }
+            }
+            const childStart = childFeature.get('start');
+            const childEnd = childFeature.get('end');
+            layout.addRect(childFeature.id(), childStart, childEnd, bottomPx - topPx, childFeature, showSubfeatureLabels && floatingLabels.length > 0
+                ? createSubfeatureLabelMetadata({
+                    refName: childFeature.get('refName'),
+                    floatingLabels,
+                    totalFeatureHeight: child.height,
+                    totalLayoutWidth: child.totalLayoutWidth,
+                    actualTopPx: topPx,
+                    featureWidth: child.width,
+                    featureStartBp: childStart,
+                    featureEndBp: childEnd,
+                })
+                : { refName: childFeature.get('refName') });
+        }
+    }
+    for (const child of featureLayout.children) {
+        addChildrenRecursive({
+            layout,
+            featureLayout: child,
+            subfeatureCoords,
+            subfeatureInfos,
+            config,
+            configContext,
+            pluginManager,
+            subfeatureLabels,
+            transcriptTypes,
+            labelColor,
+            parentTooltip,
+        });
+    }
+}

package/esm/CanvasFeatureRenderer/makeImageData.d.ts

@@ -0,0 +1,14 @@
+import type { RenderConfigContext } from './renderConfig.ts';
+import type { FlatbushItem, LayoutRecord, RenderArgs, SubfeatureInfo } from './types.ts';
+export declare function makeImageData({ ctx, layoutRecords, canvasWidth, renderArgs, configContext, }: {
+    ctx: CanvasRenderingContext2D;
+    layoutRecords: LayoutRecord[];
+    canvasWidth: number;
+    renderArgs: RenderArgs;
+    configContext: RenderConfigContext;
+}): {
+    flatbush: ArrayBufferLike;
+    items: FlatbushItem[];
+    subfeatureFlatbush: ArrayBufferLike;
+    subfeatureInfos: SubfeatureInfo[];
+};

package/esm/CanvasFeatureRenderer/makeImageData.js

@@ -0,0 +1,90 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+import { createJBrowseTheme } from '@jbrowse/core/ui';
+import { bpToPx } from '@jbrowse/core/util';
+import Flatbush from '@jbrowse/core/util/flatbush';
+import { checkStopToken2, createStopTokenChecker, } from '@jbrowse/core/util/stopToken';
+import { drawFeature } from "./drawFeature.js";
+import { buildChildrenIndex, convertToCanvasCoords, } from "./layout/layoutUtils.js";
+function buildFlatbush(coords, count) {
+    const fb = new Flatbush(Math.max(count, 1));
+    if (coords.length) {
+        for (let i = 0; i < coords.length; i += 4) {
+            fb.add(coords[i], coords[i + 1], coords[i + 2], coords[i + 3]);
+        }
+    }
+    else {
+        fb.add(0, 0, 0, 0);
+    }
+    fb.finish();
+    return fb;
+}
+export function makeImageData({ ctx, layoutRecords, canvasWidth, renderArgs, configContext, }) {
+    const { bpPerPx, regions, theme: configTheme, stopToken, layout, peptideDataMap, colorByCDS, pluginManager, } = renderArgs;
+    const region = regions[0];
+    const theme = createJBrowseTheme(configTheme);
+    const drawContext = {
+        region,
+        bpPerPx,
+        configContext,
+        theme,
+        canvasWidth,
+        peptideDataMap,
+        colorByCDS,
+    };
+    const coords = [];
+    const items = [];
+    const subfeatureCoords = [];
+    const subfeatureInfos = [];
+    ctx.textBaseline = 'top';
+    ctx.textAlign = 'left';
+    const { subfeatureLabels, transcriptTypes, config } = configContext;
+    const lastCheck = createStopTokenChecker(stopToken);
+    for (const record of layoutRecords) {
+        const { feature, layout: featureLayout, topPx: recordTopPx, label, description, } = record;
+        const featureStartBp = feature.get(region.reversed ? 'end' : 'start');
+        const startPx = bpToPx(featureStartBp, region, bpPerPx);
+        const canvasLayout = convertToCanvasCoords(featureLayout, startPx, recordTopPx);
+        drawFeature(ctx, canvasLayout, drawContext, pluginManager);
+        const bounds = {
+            left: canvasLayout.x,
+            right: canvasLayout.x + canvasLayout.totalLayoutWidth,
+            top: canvasLayout.y,
+            bottom: canvasLayout.y + canvasLayout.totalLayoutHeight,
+        };
+        const tooltip = String(readConfObject(config, 'mouseover', { feature, label, description }) ||
+            '');
+        coords.push(bounds.left, bounds.top, bounds.right, bounds.bottom);
+        items.push({
+            featureId: feature.id(),
+            type: 'box',
+            startBp: feature.get('start'),
+            endBp: feature.get('end'),
+            leftPx: bounds.left,
+            rightPx: bounds.right,
+            topPx: bounds.top,
+            bottomPx: bounds.bottom,
+            tooltip,
+        });
+        buildChildrenIndex({
+            layout,
+            featureLayout: canvasLayout,
+            subfeatureCoords,
+            subfeatureInfos,
+            config,
+            configContext,
+            pluginManager,
+            subfeatureLabels,
+            transcriptTypes,
+            labelColor: theme.palette.text.primary,
+            parentTooltip: tooltip,
+        });
+        checkStopToken2(lastCheck);
+    }
+    return {
+        flatbush: buildFlatbush(coords, items.length).data,
+        items,
+        subfeatureFlatbush: buildFlatbush(subfeatureCoords, subfeatureInfos.length)
+            .data,
+        subfeatureInfos,
+    };
+}

package/esm/CanvasFeatureRenderer/peptides/aggregateAminoAcids.d.ts

@@ -0,0 +1,8 @@
+export interface AggregatedAminoAcid {
+    aminoAcid: string;
+    startIndex: number;
+    endIndex: number;
+    length: number;
+    proteinIndex: number;
+}
+export declare function aggregateAminos(protein: string, g2p: Record<string, number>, featureStart: number, featureEnd: number, strand: number): AggregatedAminoAcid[];

package/esm/CanvasFeatureRenderer/peptides/aggregateAminoAcids.js

@@ -0,0 +1,45 @@
+export function aggregateAminos(protein, g2p, featureStart, featureEnd, strand) {
+    const aggregated = [];
+    const len = featureEnd - featureStart;
+    let currentElt = undefined;
+    let currentAminoAcid = null;
+    let startIndex = 0;
+    let idx = 0;
+    for (let i = 0; i < len; i++) {
+        const pos = strand === -1 ? featureEnd - i : featureStart + i;
+        const elt = g2p[pos];
+        if (elt === undefined) {
+            console.warn(`No g2p mapping for position ${pos}`);
+            continue;
+        }
+        const aminoAcid = protein[elt] ?? '&';
+        if (currentElt === undefined) {
+            currentElt = elt;
+            currentAminoAcid = aminoAcid;
+            startIndex = idx;
+        }
+        else if (currentElt !== elt) {
+            aggregated.push({
+                aminoAcid: currentAminoAcid,
+                startIndex,
+                endIndex: idx - 1,
+                length: idx - startIndex,
+                proteinIndex: currentElt,
+            });
+            currentElt = elt;
+            currentAminoAcid = aminoAcid;
+            startIndex = idx;
+        }
+        idx++;
+    }
+    if (currentAminoAcid !== null) {
+        aggregated.push({
+            aminoAcid: currentAminoAcid,
+            startIndex,
+            endIndex: idx - 1,
+            length: idx - startIndex,
+            proteinIndex: currentElt,
+        });
+    }
+    return aggregated;
+}

package/esm/CanvasFeatureRenderer/peptides/drawCDSBackground.d.ts

@@ -0,0 +1,16 @@
+import type { AggregatedAminoAcid } from './prepareAminoAcidData.ts';
+interface DrawCDSBackgroundArgs {
+    ctx: CanvasRenderingContext2D;
+    aggregatedAminoAcids: AggregatedAminoAcid[];
+    baseColor: string;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    bpPerPx: number;
+    strand: number;
+    reversed: boolean;
+    canvasWidth: number;
+}
+export declare function drawCDSBackground(args: DrawCDSBackgroundArgs): void;
+export {};

package/esm/CanvasFeatureRenderer/peptides/drawCDSBackground.js

@@ -0,0 +1,24 @@
+import { colord } from '@jbrowse/core/util/colord';
+import { darken, lighten } from '@mui/material';
+import { getEffectiveStrand, getStrandAwareX } from "../util.js";
+export function drawCDSBackground(args) {
+    const { ctx, aggregatedAminoAcids, baseColor, left, top, width, height, bpPerPx, strand, reversed, canvasWidth, } = args;
+    const effectiveStrand = getEffectiveStrand(strand, reversed);
+    const pxPerBp = 1 / bpPerPx;
+    const baseHex = colord(baseColor).toHex();
+    const color1 = lighten(baseHex, 0.2);
+    const color2 = darken(baseHex, 0.1);
+    for (let i = 0, l = aggregatedAminoAcids.length; i < l; i++) {
+        const aa = aggregatedAminoAcids[i];
+        const bgColor = i % 2 === 1 ? color2 : color1;
+        const startX = getStrandAwareX(left, width, aa.startIndex, pxPerBp, effectiveStrand);
+        const endX = getStrandAwareX(left, width, aa.endIndex + 1, pxPerBp, effectiveStrand);
+        const rectLeft = Math.min(startX, endX);
+        const rectWidth = Math.abs(startX - endX);
+        if (rectLeft + rectWidth < 0 || rectLeft > canvasWidth) {
+            continue;
+        }
+        ctx.fillStyle = bgColor;
+        ctx.fillRect(rectLeft, top, rectWidth, height);
+    }
+}

package/esm/CanvasFeatureRenderer/peptides/drawPeptidesOnCDS.d.ts

@@ -0,0 +1,15 @@
+import type { AggregatedAminoAcid } from './prepareAminoAcidData.ts';
+interface DrawPeptidesArgs {
+    ctx: CanvasRenderingContext2D;
+    aggregatedAminoAcids: AggregatedAminoAcid[];
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    bpPerPx: number;
+    strand: number;
+    reversed: boolean;
+    canvasWidth: number;
+}
+export declare function drawPeptidesOnCDS(args: DrawPeptidesArgs): void;
+export {};

package/esm/CanvasFeatureRenderer/peptides/drawPeptidesOnCDS.js

@@ -0,0 +1,28 @@
+import { getEffectiveStrand, getStrandAwareX } from "../util.js";
+export function drawPeptidesOnCDS(args) {
+    const { ctx, aggregatedAminoAcids, left, top, width, height, bpPerPx, strand, reversed, canvasWidth, } = args;
+    if (height < 8) {
+        return;
+    }
+    const effectiveStrand = getEffectiveStrand(strand, reversed);
+    const pxPerBp = 1 / bpPerPx;
+    const fontSize = height;
+    ctx.font = `${fontSize}px sans-serif`;
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    const yCenter = top + height / 2;
+    for (const aa of aggregatedAminoAcids) {
+        const startX = getStrandAwareX(left, width, aa.startIndex, pxPerBp, effectiveStrand);
+        const endX = getStrandAwareX(left, width, aa.endIndex + 1, pxPerBp, effectiveStrand);
+        const x = (startX + endX) / 2;
+        if (x < 0 || x > canvasWidth) {
+            continue;
+        }
+        const isNonTriplet = aa.length % 3 !== 0 || aa.aminoAcid === '&';
+        ctx.fillStyle = isNonTriplet ? 'red' : 'black';
+        const text = isNonTriplet || aa.aminoAcid === '*' || aa.aminoAcid === '&'
+            ? aa.aminoAcid
+            : `${aa.aminoAcid}${aa.proteinIndex + 1}`;
+        ctx.fillText(text, x, yCenter);
+    }
+}

package/esm/CanvasFeatureRenderer/peptides/index.d.ts

@@ -0,0 +1,5 @@
+export { type AggregatedAminoAcid, aggregateAminos, } from './aggregateAminoAcids.ts';
+export { drawCDSBackground } from './drawCDSBackground.ts';
+export { drawPeptidesOnCDS } from './drawPeptidesOnCDS.ts';
+export { fetchPeptideData } from './peptideUtils.ts';
+export { prepareAminoAcidData } from './prepareAminoAcidData.ts';

package/esm/CanvasFeatureRenderer/peptides/index.js

@@ -0,0 +1,5 @@
+export { aggregateAminos, } from "./aggregateAminoAcids.js";
+export { drawCDSBackground } from "./drawCDSBackground.js";
+export { drawPeptidesOnCDS } from "./drawPeptidesOnCDS.js";
+export { fetchPeptideData } from "./peptideUtils.js";
+export { prepareAminoAcidData } from "./prepareAminoAcidData.js";

package/esm/CanvasFeatureRenderer/peptides/peptideUtils.d.ts

@@ -0,0 +1,5 @@
+import type { PeptideData } from '../types.ts';
+import type PluginManager from '@jbrowse/core/PluginManager';
+import type { RenderArgsDeserialized } from '@jbrowse/core/pluggableElementTypes/renderers/BoxRendererType';
+import type { Feature } from '@jbrowse/core/util';
+export declare function fetchPeptideData(pluginManager: PluginManager, renderProps: RenderArgsDeserialized, features: Map<string, Feature>): Promise<Map<string, PeptideData>>;

package/esm/CanvasFeatureRenderer/peptides/peptideUtils.js

@@ -0,0 +1,129 @@
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import { defaultCodonTable, generateCodonTable, revcom, } from '@jbrowse/core/util';
+import { convertCodingSequenceToPeptides } from '@jbrowse/core/util/convertCodingSequenceToPeptides';
+import { firstValueFrom, toArray } from 'rxjs';
+import { shouldRenderPeptideBackground } from "../zoomThresholds.js";
+async function fetchSequence(pluginManager, renderProps, region) {
+    const { sessionId, sequenceAdapter } = renderProps;
+    if (!sequenceAdapter) {
+        return undefined;
+    }
+    try {
+        const { dataAdapter } = await getAdapter(pluginManager, sessionId, sequenceAdapter);
+        const feats = await firstValueFrom(dataAdapter
+            .getFeatures({
+            ...region,
+            refName: region.seqAdapterRefName ?? region.refName,
+            start: Math.max(0, region.start),
+        })
+            .pipe(toArray()));
+        return feats[0]?.get('seq');
+    }
+    catch (error) {
+        console.warn('[fetchSequence] Failed to fetch sequence:', error);
+        return undefined;
+    }
+}
+const DEFAULT_TRANSCRIPT_TYPES = [
+    'mRNA',
+    'transcript',
+    'primary_transcript',
+    'protein_coding_primary_transcript',
+];
+function isTranscriptType(type, transcriptTypes = DEFAULT_TRANSCRIPT_TYPES) {
+    return transcriptTypes.includes(type);
+}
+function hasCDSSubfeatures(feature) {
+    const subfeatures = feature.get('subfeatures');
+    return subfeatures?.some((sub) => sub.get('type') === 'CDS') ?? false;
+}
+function findTranscriptsWithCDS(features) {
+    const transcripts = [];
+    for (const feature of features.values()) {
+        const type = feature.get('type');
+        const subfeatures = feature.get('subfeatures');
+        if (type === 'gene' && subfeatures?.length) {
+            for (const subfeature of subfeatures) {
+                const subType = subfeature.get('type');
+                if (isTranscriptType(subType) && hasCDSSubfeatures(subfeature)) {
+                    transcripts.push(subfeature);
+                }
+            }
+        }
+        else if (isTranscriptType(type) && hasCDSSubfeatures(feature)) {
+            transcripts.push(feature);
+        }
+    }
+    return transcripts;
+}
+function extractCDSRegions(feature) {
+    const subfeatures = feature.get('subfeatures') || [];
+    const featureStart = feature.get('start');
+    return subfeatures
+        .filter((sub) => sub.get('type') === 'CDS')
+        .sort((a, b) => a.get('start') - b.get('start'))
+        .map((sub) => ({
+        start: sub.get('start') - featureStart,
+        end: sub.get('end') - featureStart,
+    }));
+}
+async function fetchTranscriptPeptides(pluginManager, renderProps, transcript) {
+    try {
+        const baseRegion = renderProps.regions[0];
+        const region = {
+            ...baseRegion,
+            start: transcript.get('start'),
+            end: transcript.get('end'),
+        };
+        let seq = await fetchSequence(pluginManager, renderProps, region);
+        if (!seq) {
+            return undefined;
+        }
+        const strand = transcript.get('strand');
+        let cds = extractCDSRegions(transcript);
+        if (cds.length === 0) {
+            return undefined;
+        }
+        if (strand === -1) {
+            seq = revcom(seq);
+            const seqLen = seq.length;
+            cds = cds
+                .map(region => ({
+                start: seqLen - region.end,
+                end: seqLen - region.start,
+            }))
+                .reverse();
+        }
+        const sequenceData = { seq, cds };
+        try {
+            const protein = convertCodingSequenceToPeptides({
+                cds,
+                sequence: seq,
+                codonTable: generateCodonTable(defaultCodonTable),
+            });
+            return { sequenceData, protein };
+        }
+        catch (error) {
+            console.warn(`[fetchTranscriptPeptides] Failed to convert sequence to peptides for ${transcript.id()}:`, error);
+            return { sequenceData };
+        }
+    }
+    catch (error) {
+        console.warn(`[fetchTranscriptPeptides] Failed to fetch sequence for transcript ${transcript.id()}:`, error);
+        return undefined;
+    }
+}
+export async function fetchPeptideData(pluginManager, renderProps, features) {
+    const { colorByCDS, bpPerPx } = renderProps;
+    const peptideDataMap = new Map();
+    if (!colorByCDS || !shouldRenderPeptideBackground(bpPerPx)) {
+        return peptideDataMap;
+    }
+    for (const transcript of findTranscriptsWithCDS(features)) {
+        const peptideData = await fetchTranscriptPeptides(pluginManager, renderProps, transcript);
+        if (peptideData) {
+            peptideDataMap.set(transcript.id(), peptideData);
+        }
+    }
+    return peptideDataMap;
+}

package/esm/CanvasFeatureRenderer/peptides/prepareAminoAcidData.d.ts

@@ -0,0 +1,9 @@
+import type { Feature } from '@jbrowse/core/util';
+export interface AggregatedAminoAcid {
+    aminoAcid: string;
+    startIndex: number;
+    endIndex: number;
+    length: number;
+    proteinIndex: number;
+}
+export declare function prepareAminoAcidData(parent: Feature, protein: string, featureStart: number, featureEnd: number, strand: number): import("./aggregateAminoAcids.ts").AggregatedAminoAcid[];

package/esm/CanvasFeatureRenderer/peptides/prepareAminoAcidData.js

@@ -0,0 +1,5 @@
+import { genomeToTranscriptSeqMapping } from 'g2p_mapper';
+import { aggregateAminos } from "./aggregateAminoAcids.js";
+export function prepareAminoAcidData(parent, protein, featureStart, featureEnd, strand) {
+    return aggregateAminos(protein, genomeToTranscriptSeqMapping(parent.toJSON()).g2p, featureStart, featureEnd, strand);
+}

package/esm/CanvasFeatureRenderer/renderConfig.d.ts

@@ -0,0 +1,26 @@
+import type { AnyConfigurationModel } from '@jbrowse/core/configuration';
+import type { Feature } from '@jbrowse/core/util';
+export interface CachedConfig<T> {
+    value: T;
+    isCallback: boolean;
+}
+export declare function readCachedConfig<T>(cached: CachedConfig<T>, config: AnyConfigurationModel, key: string | string[], feature: Feature): T;
+export interface RenderConfigContext {
+    config: AnyConfigurationModel;
+    displayMode: string;
+    showLabels: boolean;
+    showDescriptions: boolean;
+    subfeatureLabels: string;
+    transcriptTypes: string[];
+    containerTypes: string[];
+    color1: CachedConfig<string>;
+    color2: CachedConfig<string>;
+    color3: CachedConfig<string>;
+    outline: CachedConfig<string>;
+    featureHeight: CachedConfig<number>;
+    fontHeight: CachedConfig<number>;
+    labelAllowed: boolean;
+    geneGlyphMode: string;
+    displayDirectionalChevrons: boolean;
+}
+export declare function createRenderConfigContext(config: AnyConfigurationModel): RenderConfigContext;

package/esm/CanvasFeatureRenderer/renderConfig.js

@@ -0,0 +1,35 @@
+import { readConfObject } from '@jbrowse/core/configuration';
+export function readCachedConfig(cached, config, key, feature) {
+    return cached.isCallback
+        ? readConfObject(config, key, { feature })
+        : cached.value;
+}
+function createCachedConfig(config, key, defaultValue) {
+    const configSlot = Array.isArray(key)
+        ? key.reduce((acc, k) => acc?.[k], config)
+        : config[key];
+    const isCallback = configSlot?.isCallback ?? false;
+    const value = isCallback ? defaultValue : readConfObject(config, key);
+    return { value, isCallback };
+}
+export function createRenderConfigContext(config) {
+    const displayMode = readConfObject(config, 'displayMode');
+    return {
+        config,
+        displayMode,
+        showLabels: readConfObject(config, 'showLabels'),
+        showDescriptions: readConfObject(config, 'showDescriptions'),
+        subfeatureLabels: readConfObject(config, 'subfeatureLabels'),
+        transcriptTypes: readConfObject(config, 'transcriptTypes'),
+        containerTypes: readConfObject(config, 'containerTypes'),
+        geneGlyphMode: readConfObject(config, 'geneGlyphMode'),
+        displayDirectionalChevrons: readConfObject(config, 'displayDirectionalChevrons'),
+        color1: createCachedConfig(config, 'color1', 'goldenrod'),
+        color2: createCachedConfig(config, 'color2', '#f0f'),
+        color3: createCachedConfig(config, 'color3', '#357089'),
+        outline: createCachedConfig(config, 'outline', ''),
+        featureHeight: createCachedConfig(config, 'height', 10),
+        fontHeight: createCachedConfig(config, ['labels', 'fontSize'], 12),
+        labelAllowed: displayMode !== 'collapse',
+    };
+}