@jbrowse/plugin-linear-genome-view 5.0.0-beta.1 → 5.0.0-beta.10

package/esm/searchUtils.js

@@ -1,5 +1,6 @@
 import { RefSequenceResult } from '@jbrowse/core/TextSearch/BaseResults';
-import { assembleLocString, dedupe, getEnv, getNotificationSink, getSession, matchRefNames, MAX_GLOB_REGIONS, parseLocString, UnknownRefNameError, } from '@jbrowse/core/util';
+import { groupByPlace } from '@jbrowse/core/TextSearch/places';
+import { dedupe, getEnv, getNotificationSink, getSession, matchRefNames, MAX_GLOB_REGIONS, UnknownRefNameError, } from '@jbrowse/core/util';
 import { isAlive } from '@jbrowse/mobx-state-tree';
 import { parseLocStrings } from './LinearGenomeView/util.js';
 // Budget for refName suggestions from a query. Deliberately far below the
@@ -36,37 +37,6 @@ export function isOpenInView(result, model) {
     const trackId = result.getTrackId();
     return trackId !== undefined && !!model.getTrack(trackId);
 }
-// One spelling of a locstring, so two indexes that answer `chr1:1-100` and
-// `1:1..100` are recognised as one place. An unparseable string is compared
-// raw, which can only ever split a group that would otherwise have merged —
-// the safe direction, since the picker is what an unprovable match falls back
-// to.
-function canonicalLocString(locString, assembly) {
-    try {
-        const loc = parseLocString(locString, refName => assembly.isValidRefName(refName));
-        return assembleLocString({
-            ...loc,
-            refName: assembly.getCanonicalRefName2(loc.refName),
-        });
-    }
-    catch (e) {
-        console.warn('failed to parse location string', locString, e);
-        return locString;
-    }
-}
-// What a hit means as a destination: the name it shows and the place it goes.
-// A hit with no location has no destination and can never join a group.
-function destination(result, assembly) {
-    const locString = result.getLocation();
-    return locString
-        ? [
-            result.getDisplayString(),
-            assembly?.initialized
-                ? canonicalLocString(locString, assembly)
-                : locString,
-        ].join('\u0000')
-        : undefined;
-}
 // Which hit of an agreeing group to travel through, best rung first: a track
 // the view already has on screen, then one the session could open if asked,
 // then whatever the ranking put first. The middle rung is not hypothetical —
@@ -86,40 +56,48 @@ function trackRank(result, model, session) {
         return session.getTrackById(trackId) ? 1 : 3;
     }
 }
-// The picker exists to disambiguate, and hits that name one feature at one
-// place are not ambiguous — they are several indexes having found it. An
-// instance carrying a handful of gene tracks turns every gene search into a
-// table whose only varying column is Track, which is issues #4302 and #5068.
-// When the hits agree there is nothing to ask, so navigate instead.
-export function unanimousResult({ results, model, session, assembly, }) {
-    // computed once per hit rather than once per comparison: a broad query can
-    // carry a hundred results, and each one costs a locstring parse
-    const destinations = results.map(r => destination(r, assembly));
-    const agree = destinations[0] !== undefined &&
-        destinations.every(d => d === destinations[0]);
-    // stable, so an agreeing group with nothing to choose between keeps the
-    // order the ranking handed it
-    return agree
-        ? [...results].sort((a, b) => trackRank(a, model, session) - trackRank(b, model, session))[0]
-        : undefined;
+// The pick is a stable minimum, so a linear scan rather than a sort: keeping
+// the first strictly-lowest rung leaves a group with nothing to choose between
+// in the order the ranking handed it. A comparator would ask `trackRank`, and
+// through it `session.getTrackById`, O(n log n) times.
+function bestRanked(results, model, session) {
+    let best = results[0];
+    let bestRank = trackRank(best, model, session);
+    for (let i = 1; i < results.length; i++) {
+        const rank = trackRank(results[i], model, session);
+        if (rank < bestRank) {
+            best = results[i];
+            bestRank = rank;
+        }
+    }
+    return best;
+}
+// One hit per place, in the order the ranking first reached each. Hits that
+// name one feature at one place are several indexes having found it, not a
+// choice to put to the user: a handful of gene tracks turned every gene search
+// into a picker whose only varying column was Track (issues #4302 and #5068),
+// and two whose gene models end a few bases apart still did.
+export function distinctDestinations({ results, model, session, assembly, }) {
+    return groupByPlace(results, assembly).map(group => bestRanked(group, model, session));
 }
 // Every multi-hit result set reaches the picker through here, so the two
-// search surfaces cannot disagree about when one is worth raising. Returns
-// whether the view moved.
-export async function showSearchResults({ results, query, model, assemblyName, grow, }) {
+// search surfaces cannot disagree about when one is worth raising: only when
+// the hits name more than one place. Returns whether the view moved.
+export async function showSearchResults({ results, query, model, assemblyName, grow, showHitTrack, }) {
     const session = getSession(model);
-    const unanimous = unanimousResult({
+    const places = distinctDestinations({
         results,
         model,
         session,
         assembly: session.assemblyManager.get(assemblyName),
     });
-    if (unanimous) {
-        await navToOption({ option: unanimous, model, assemblyName, grow });
+    const land = (option) => navToOption({ option, model, assemblyName, grow, showHitTrack });
+    if (places.length === 1) {
+        await land(places[0]);
         return true;
     }
     else {
-        model.setSearchResults(results, query, assemblyName);
+        model.setSearchResults(places, query, assemblyName, land);
         return false;
     }
 }
@@ -127,17 +105,33 @@ export async function showSearchResults({ results, query, model, assemblyName, g
 // own edges, which is what this default is; a caller that asked for a specific
 // padding gets that instead.
 const SEARCH_HIT_GROW = 0.2;
-export async function navToOption({ option, model, assemblyName, grow, }) {
+// The track to show beside a hit: the one its index came from, when this
+// session has it. A shared index names tracks of whichever config it was built
+// for — the UCSC hg38 names index says `hg38-ncbiRefSeqGff`, which the HPRC
+// pangenome config reuses without carrying — and launching a track the session
+// lacks turned every gene search there into a "Could not resolve identifier"
+// error over a view that had navigated fine.
+export function hitTrackToShow(result, session) {
+    const trackId = result.getTrackId();
+    return trackId !== undefined && session.getTrackById(trackId)
+        ? trackId
+        : undefined;
+}
+// A hit lands with the track its index came from shown, which is what a name
+// typed into the search box wants. A session spec that named its own tracks
+// passes false: it asked for those tracks, and a hosted config's full RefSeq
+// appearing beside the curated one it listed read as a bug.
+export async function navToOption({ option, model, assemblyName, grow, showHitTrack = true, }) {
     // getLocation() can be an empty string when a result reports hasLocation()
     // but carries no coordinates; treat that as "no location" and fall back to
     // the label rather than forwarding '' into an empty, view-blanking parse
     const location = option.getLocation() || option.getLabel();
-    const trackId = option.getTrackId();
     const session = getSession(model);
     const { assemblyManager } = session;
     await model.navToLocations(parseLocStrings(location, assemblyName, (ref, asm) => assemblyManager.isValidRefName(ref, asm)), assemblyName, grow ?? SEARCH_HIT_GROW);
+    const trackId = showHitTrack ? hitTrackToShow(option, session) : undefined;
     if (trackId && isAlive(model)) {
-        model.showTrack(trackId);
+        await model.launchTrack(trackId);
     }
     // same detach hazard as showTrack above: navToLocations awaits, and handlers
     // read off the view (the canvas one calls getSession(model) and model.tracks),
@@ -174,7 +168,7 @@ export function notifySearchFailure(session, e) {
 // about where to go and so raise the picker, and a view detached while the
 // search RPC ran — and each of them resolves, so a caller awaiting this cannot
 // otherwise tell "showing it" from "asked you which one".
-export async function handleSelectedRegion({ input, model, assemblyName, grow, }) {
+export async function handleSelectedRegion({ input, model, assemblyName, grow, showHitTrack, }) {
     const { assemblyManager, textSearchManager } = getSession(model);
     // resolves only once regions/aliases are loaded, which isValidRefName needs
     // (it throws otherwise). A load failure is not this function's to report:
@@ -241,14 +235,14 @@ export async function handleSelectedRegion({ input, model, assemblyName, grow, }
         // adapters answer 'exact' by filtering exactly this list. An adapter that
         // tags nothing simply never wins the exact pass, which is the behaviour it
         // had when it returned nothing for searchType: 'exact'.
-        const allResults = await fetchResults({
+        const found = await searchNames({
             queryString: input,
             assemblyName,
             textSearchManager,
             assembly,
         });
-        const exactResults = allResults.filter(r => r.isExact());
-        const results = exactResults.length ? exactResults : allResults;
+        const exactResults = found.results.filter(r => r.isExact());
+        const results = exactResults.length ? exactResults : found.results;
         // the view may have been closed/detached while the text-search RPC ran
         if (!isAlive(model)) {
             return false;
@@ -260,6 +254,7 @@ export async function handleSelectedRegion({ input, model, assemblyName, grow, }
                 model,
                 assemblyName,
                 grow,
+                showHitTrack,
             });
         }
         else if (results.length === 1) {
@@ -272,6 +267,7 @@ export async function handleSelectedRegion({ input, model, assemblyName, grow, }
                 model,
                 assemblyName,
                 grow,
+                showHitTrack,
             });
             return true;
         }
@@ -279,8 +275,8 @@ export async function handleSelectedRegion({ input, model, assemblyName, grow, }
             // no search hits: still try to resolve the input as a locstring (bare
             // refname, "ref start end" triplet, etc). if that also can't find a
             // refname AND the input is a single bare token (a plausible gene name),
-            // reframe the unknown-ref error as a clean "no results" message; keep the
-            // specific ref error for coordinate/multi-part queries
+            // reframe the unknown-ref error as a name miss; keep the specific ref
+            // error for coordinate/multi-part queries
             try {
                 await navToLocstrings();
                 return true;
@@ -288,7 +284,7 @@ export async function handleSelectedRegion({ input, model, assemblyName, grow, }
             catch (e) {
                 const isPlainName = !input.includes(':') && !input.includes(' ');
                 if (e instanceof UnknownRefNameError && isPlainName) {
-                    throw new SearchResultsNotFoundError(`No results found for "${input}"`);
+                    throw nameNotFound(input, assemblyName, found);
                 }
                 else {
                     throw e;
@@ -301,11 +297,11 @@ export function checkRef(str, isRef) {
     const [ref, rest] = splitLast(str, ':');
     return isRef(str) || (isRef(ref) && /^\d/.test(rest));
 }
-export async function fetchResults({ queryString, searchType, assemblyName, textSearchManager, assembly, stopToken, }) {
-    const textSearchResults = await textSearchManager?.search({
+async function searchNames({ queryString, searchType, assemblyName, textSearchManager, assembly, signal, }) {
+    const report = await textSearchManager?.searchIndexes({
         queryString,
         searchType,
-        stopToken,
+        signal,
     }, assemblyName);
     // ensure aliases are loaded: allRefNames is a pure getter, so reading it does
     // not itself kick off the lazy load. A load failure just leaves allRefNames
@@ -314,7 +310,27 @@ export async function fetchResults({ queryString, searchType, assemblyName, text
     const refNameResults = assembly
         ? searchRefNames(assembly, queryString, searchType)
         : [];
-    return dedupe([...refNameResults, ...(textSearchResults ?? [])], elt => elt.getId());
+    return {
+        results: dedupe([...refNameResults, ...(report?.results ?? [])], elt => elt.getId()),
+        indexCount: report?.indexCount ?? 0,
+        failures: report?.failures ?? [],
+    };
+}
+export async function fetchResults(args) {
+    return (await searchNames(args)).results;
+}
+// A miss says when an index could not answer: with none answering it is a
+// failure, and with some answering it is still a miss, naming what failed
+export function nameNotFound(input, assemblyName, { indexCount, failures }) {
+    const [failure] = failures;
+    const miss = `No results found for "${input}"`;
+    return failure === undefined
+        ? new SearchResultsNotFoundError(indexCount ? miss : `${miss}: ${assemblyName} has no text search index`)
+        : failures.length === indexCount
+            ? new Error(`Searching for "${input}" failed: ${failure}`, {
+                cause: failure,
+            })
+            : new SearchResultsNotFoundError(`${miss} (a search index failed: ${failure})`, { cause: failure });
 }
 // Scan assembly refnames for query matches, resolving aliases (e.g. 'contigB')
 // to the canonical refname ('ctgB') so the dropdown shows the name that matches

package/esm/shared/RubberbandSpan.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { alpha } from '@jbrowse/core/ui/palette';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { Typography, alpha } from '@mui/material';
+import { Typography } from '@mui/material';
 import { LABEL_WIDTH, SpanEdgeLabels } from './coordLabels.js';
 const useStyles = makeStyles()(theme => ({
     rubberband: {

package/esm/shared/coordLabels.d.ts

@@ -1,4 +1,11 @@
 export declare const LABEL_WIDTH = 100;
+/** A red vertical line at `coordX` with `children` labelled above it. */
+export declare function VerticalGuideLine({ coordX, viewWidth, stickyTop, children, }: {
+    coordX: number;
+    viewWidth: number;
+    stickyTop: string | undefined;
+    children: React.ReactNode;
+}): import("react").JSX.Element;
 /**
  * The bp coordinate under a vertical guide, drawn just above the top of the
  * guide line so it covers neither the line nor the cursor hovering the scalebar

package/esm/shared/coordLabels.js

@@ -1,8 +1,8 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
+import { alpha } from '@jbrowse/core/ui/palette';
 import { MUI_TOOLTIP_Z_INDEX } from '@jbrowse/core/ui/zIndexes';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { alpha } from '@mui/material';
 import { createPortal } from 'react-dom';
 // roughly how wide a coordinate label is. the guide clamps itself half of this
 // from either border, and a rubberband label that would hang off a border goes
@@ -51,7 +51,21 @@ const useStyles = makeStyles()(theme => ({
     insideRightEdge: {
         right: 0,
     },
+    guideLine: {
+        pointerEvents: 'none',
+        height: '100%',
+        width: 1,
+        position: 'absolute',
+        left: 0,
+        background: 'red',
+        zIndex: 1001,
+    },
 }));
+/** A red vertical line at `coordX` with `children` labelled above it. */
+export function VerticalGuideLine({ coordX, viewWidth, stickyTop, children, }) {
+    const { classes } = useStyles();
+    return (_jsxs(_Fragment, { children: [_jsx(GuideLabel, { coordX: coordX, viewWidth: viewWidth, stickyTop: stickyTop, children: children }), _jsx("div", { className: classes.guideLine, style: { transform: `translateX(${coordX}px)` } })] }));
+}
 function anchorStyle(stickyTop) {
     return stickyTop === undefined
         ? { position: 'relative' }

package/esm/shared/useWindowDrag.d.ts

@@ -0,0 +1,18 @@
+import type React from 'react';
+export interface DragEnd {
+    startX: number;
+    endX: number;
+    isClick: boolean;
+    clientX: number;
+    clientY: number;
+}
+/**
+ * Follow a press that began at `startX` (px from `ref`'s left edge) through
+ * window events until it ends, so the pointer can leave the element mid-drag.
+ * A release within 3px of the press is a click. Undefined `startX` is no drag.
+ */
+export declare function useWindowDrag(ref: React.RefObject<HTMLElement | null>, startX: number | undefined, handlers: {
+    onMove: (x: number) => void;
+    onEnd: (end: DragEnd) => void;
+    onCancel: () => void;
+}): void;

package/esm/shared/useWindowDrag.js

@@ -0,0 +1,45 @@
+import { useEffect } from 'react';
+import { useEventCallback } from '@jbrowse/core/util/useEventCallback';
+/**
+ * Follow a press that began at `startX` (px from `ref`'s left edge) through
+ * window events until it ends, so the pointer can leave the element mid-drag.
+ * A release within 3px of the press is a click. Undefined `startX` is no drag.
+ */
+export function useWindowDrag(ref, startX, handlers) {
+    const onMove = useEventCallback(handlers.onMove);
+    const onEnd = useEventCallback(handlers.onEnd);
+    const onCancel = useEventCallback(handlers.onCancel);
+    useEffect(() => {
+        const el = ref.current;
+        if (startX === undefined || !el) {
+            return;
+        }
+        const { left } = el.getBoundingClientRect();
+        const mouseMove = (event) => {
+            onMove(event.clientX - left);
+        };
+        const mouseUp = ({ clientX, clientY }) => {
+            const endX = clientX - left;
+            onEnd({
+                startX,
+                endX,
+                isClick: Math.abs(endX - startX) <= 3,
+                clientX,
+                clientY,
+            });
+        };
+        const keyDown = (event) => {
+            if (event.key === 'Escape') {
+                onCancel();
+            }
+        };
+        window.addEventListener('mousemove', mouseMove);
+        window.addEventListener('mouseup', mouseUp);
+        window.addEventListener('keydown', keyDown);
+        return () => {
+            window.removeEventListener('mousemove', mouseMove);
+            window.removeEventListener('mouseup', mouseUp);
+            window.removeEventListener('keydown', keyDown);
+        };
+    }, [ref, startX, onMove, onEnd, onCancel]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-linear-genome-view",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.10",
   "type": "module",
   "description": "JBrowse 2 linear genome view",
   "keywords": [
@@ -21,15 +21,15 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.5.1",
-    "@mui/icons-material": "^9.3.1",
-    "@mui/material": "^9.3.1",
-    "mobx": "^7.0.3",
+    "@jbrowse/mobx-state-tree": "^6.6.1",
+    "@mui/icons-material": "^9.4.0",
+    "@mui/material": "^9.4.0",
+    "mobx": "^7.0.5",
     "mobx-react": "^10.0.2",
-    "@jbrowse/core": "^5.0.0-beta.1",
-    "@jbrowse/render-core": "^5.0.0-beta.1",
-    "@jbrowse/display-ui": "^5.0.0-beta.1",
-    "@jbrowse/display-kit": "^5.0.0-beta.1"
+    "@jbrowse/core": "^5.0.0-beta.10",
+    "@jbrowse/display-kit": "^5.0.0-beta.10",
+    "@jbrowse/render-core": "^5.0.0-beta.10",
+    "@jbrowse/display-ui": "^5.0.0-beta.10"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
@@ -40,7 +40,7 @@
   },
   "sideEffects": false,
   "devDependencies": {
-    "@jbrowse/display-test-utils": "^5.0.0-beta.1"
+    "@jbrowse/display-test-utils": "^5.0.0-beta.10"
   },
   "scripts": {
     "prebuild": "pnpm clean",

package/esm/LinearGenomeView/FloatingSvgOverlay.d.ts

@@ -1,5 +0,0 @@
-export declare const FloatingSvgOverlay: ({ width, height, children, }: {
-    width: number;
-    height: number;
-    children: React.ReactNode;
-}) => import("react").JSX.Element;

package/esm/LinearGenomeView/FloatingSvgOverlay.js

@@ -1,25 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { TrackOverlayPortal } from '@jbrowse/display-ui';
-import { observer } from 'mobx-react';
-// Lifts an SVG legend / chrome above the inter-region padding masks: a
-// full-track, pointer-events:none <svg> portaled into the TrackContainer overlay
-// node (see TrackOverlayPortal). The SVG counterpart to the HTML overlays
-// (FloatingLegend, HicOverlayPanel) — used where the same legend
-// markup is also drawn by an SVG-export path, so it must stay <svg>.
-//
-// Children draw in <svg> user space; the wrapping <svg> stays pointer-events:none
-// so it doesn't eat canvas events, so any interactive sub-content (a dismiss
-// "×", clickable swatches) must set pointer-events:auto on its own element.
-// fallbackInline={false}: outside a TrackContainer it renders nothing, matching
-// callers whose export path draws its own inline legend.
-export const FloatingSvgOverlay = observer(function FloatingSvgOverlay({ width, height, children, }) {
-    return (_jsx(TrackOverlayPortal, { fallbackInline: false, children: _jsx("svg", { style: {
-                position: 'absolute',
-                top: 0,
-                left: 0,
-                width,
-                height,
-                pointerEvents: 'none',
-                overflow: 'hidden',
-            }, children: children }) }));
-});

package/esm/LinearGenomeView/initKeys.d.ts

@@ -1,13 +0,0 @@
-export declare function partitionLaunchKeys(spec: object, viewPropKeys: ReadonlySet<string>): {
-    init: Record<string, unknown>;
-    viewProps: Record<string, unknown>;
-    unknown: Record<string, unknown>;
-};
-export declare function linearGenomeViewPropKeys(pluginManager: {
-    getViewType: (name: string) => {
-        stateModel: {
-            properties: object;
-        };
-    };
-}): ReadonlySet<string>;
-export declare function warnUnknownLaunchKeys(surface: string, unknown: object): void;

package/esm/LinearGenomeView/initKeys.js

@@ -1,104 +0,0 @@
-// The init keys are derived from their interface so they can't drift: the
-// Record requires exactly one entry per key, so adding a field without listing
-// it here is a compile error rather than a key that silently warns as "unknown".
-//
-// There is no matching list for the plain view props, and there must not be:
-// they are whatever the state model declares, read off it by the caller and
-// passed in as `viewPropKeys`. A hand-written eight is what left `hideHeader`,
-// `showGridlines`, `showCytobands` and five others declared, menu-settable and
-// silently unreachable from any spec — the same failure LinearSyntenyView's
-// `drawLocationMarkers` had.
-//
-// #launchKeys LinearGenomeView — the URL parameters page renders this list
-// rather than restating it; each of these keys has its own `&param=` section
-// there, which is why no description is attached here.
-const knownInitKeyMap = {
-    loc: true,
-    grow: true,
-    assembly: true,
-    displayedRegionNames: true,
-    tracks: true,
-    tracklist: true,
-    nav: true,
-    highlight: true,
-};
-const knownInitKeys = new Set(Object.keys(knownInitKeyMap));
-// Never settable from a spec, whatever the model declares: `type` picks the
-// view and `id` is passed top-level so MST's optional identifier honors it.
-const RESERVED = new Set(['id', 'type', 'init']);
-// The viewport keys from before it was stored as a window. They are no longer
-// declared properties, so the model's own property list does not contain them
-// and they would partition as typos — reported as unknown and dropped. They are
-// not typos: `preProcessSnapshot` still converts them, so they belong in the
-// snapshot bucket, and a URL or saved spec that names them goes on working.
-//
-// Deletable with `legacyBpPerPx` in the model, and for the same reason.
-const LEGACY_VIEWPORT_PROPS = new Set(['bpPerPx', 'offsetPx']);
-// Partition launch keys three ways, once, for every caller that needs to know
-// which is which:
-//
-// - `init`: resolution keys (loc, tracks, highlight, …) with no direct MST
-//   representation, which afterAttach applies on attach and then discards
-// - `viewProps`: plain persisted props MST restores natively, so they belong on
-//   the view snapshot rather than in the blob
-// - `unknown`: neither, i.e. a typo. MST silently drops unknown snapshot keys and
-//   `init` is a frozen blob, so nothing else would notice
-//
-// The two callers differ only in what they do with each bucket: the launcher
-// spreads a flat spec across the new view's snapshot and warns about the typos,
-// while afterAttach — which only ever sees an already-built blob — warns about
-// both a typo and a view prop that ended up inside it.
-export function partitionLaunchKeys(spec, 
-// The view's declared property names. Callers with a live node read it off
-// `getPropertyMembers(self).properties`; callers building a snapshot read it
-// off the registered view type's `stateModel.properties` — see
-// `linearGenomeViewPropKeys`.
-viewPropKeys) {
-    const init = {};
-    const viewProps = {};
-    const unknown = {};
-    for (const [key, value] of Object.entries(spec)) {
-        const bucket = knownInitKeys.has(key)
-            ? init
-            : (viewPropKeys.has(key) || LEGACY_VIEWPORT_PROPS.has(key)) &&
-                !RESERVED.has(key)
-                ? viewProps
-                : unknown;
-        bucket[key] = value;
-    }
-    return { init, viewProps, unknown };
-}
-// The registered LinearGenomeView's declared property names, for a caller that
-// has a PluginManager but no view yet (a launcher, or a synteny row being built).
-// A caller holding a live node reads the same thing off
-// `getPropertyMembers(self).properties` instead.
-//
-// `getViewType` THROWS on an unregistered name, and that is left alone: this is
-// only ever called from code that is about to add a LinearGenomeView, so an
-// absent view type is a broken plugin manager rather than a case to degrade
-// through — and degrading would mean silently dropping every property the
-// caller asked for, which is the failure this whole mechanism exists to end.
-//
-// Cached: the set is fixed for the life of the manager, and a launch that opens
-// a stack of rows would otherwise rebuild it per row.
-const propKeyCache = new WeakMap();
-export function linearGenomeViewPropKeys(pluginManager) {
-    const cached = propKeyCache.get(pluginManager);
-    if (cached) {
-        return cached;
-    }
-    const { stateModel } = pluginManager.getViewType('LinearGenomeView');
-    const keys = new Set(Object.keys(stateModel.properties));
-    propKeyCache.set(pluginManager, keys);
-    return keys;
-}
-// Report the `unknown` bucket. Both callers say the same thing about the same
-// mistake and differ only in which surface they name, so the wording lives next
-// to the partition that produces the bucket rather than in two hand-written
-// copies that drift.
-export function warnUnknownLaunchKeys(surface, unknown) {
-    const keys = Object.keys(unknown);
-    if (keys.length) {
-        console.warn(`${surface} ignored unknown key(s): ${keys.join(', ')}`);
-    }
-}

package/esm/MultiLevelRubberband/VerticalGuide.d.ts

@@ -1,6 +0,0 @@
-import type { MultiLevelRubberbandModel } from './types.ts';
-declare const VerticalGuide: ({ model, coordX, }: {
-    model: MultiLevelRubberbandModel;
-    coordX: number;
-}) => import("react").JSX.Element;
-export default VerticalGuide;

package/esm/MultiLevelRubberband/VerticalGuide.js

@@ -1,21 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { stringify } from '@jbrowse/core/util';
-import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { observer } from 'mobx-react';
-import { GuideLabel } from '../shared/coordLabels.js';
-const useStyles = makeStyles()({
-    guide: {
-        pointerEvents: 'none',
-        height: '100%',
-        width: 1,
-        position: 'absolute',
-        background: 'red',
-        zIndex: 1001,
-    },
-});
-const VerticalGuide = observer(function VerticalGuide({ model, coordX, }) {
-    const { classes } = useStyles();
-    const { views } = model;
-    return (_jsxs(_Fragment, { children: [_jsx(GuideLabel, { coordX: coordX, viewWidth: Math.min(...views.map(view => view.width)), stickyTop: undefined, children: views.map(view => (_jsx("div", { children: stringify(view.pxToBp(coordX), true) }, view.id))) }), _jsx("div", { className: classes.guide, style: { left: coordX } })] }));
-});
-export default VerticalGuide;

package/esm/lazyPluginExports.d.ts

@@ -1,23 +0,0 @@
-import type { LinearGenomeViewModel } from './LinearGenomeView/index.ts';
-export declare const LinearGenomeView: {
-    (props: {
-        model: LinearGenomeViewModel;
-    }): import("react").JSX.Element;
-    displayName: string;
-};
-export declare const SearchBox: {
-    (props: {
-        model: LinearGenomeViewModel;
-        showHelp?: boolean;
-        minWidth?: number;
-        maxWidth?: number;
-        style?: React.CSSProperties;
-    }): import("react").JSX.Element;
-    displayName: string;
-};
-export declare const ZoomControls: {
-    (props: {
-        model: LinearGenomeViewModel;
-    }): import("react").JSX.Element;
-    displayName: string;
-};