@jbrowse/core 5.0.0-beta.11 → 5.0.0-beta.14

package/esm/ui/radioSubMenu.js

@@ -7,7 +7,7 @@ import { radioItems } from './toggleMenuItems.js';
  * appended after the radios (e.g. a related checkbox) within the same submenu.
  *
  * Every display has a submenu of this shape naming the one thing it draws —
- * wiggle's "Plot type", MAF's "Row coloring", Hi-C's "Color scheme", the arc
+ * wiggle's and MAF's "Plot type", Hi-C's "Color scheme", the arc
  * display's "Display mode". The labels stay display-specific (they name
  * genuinely different choices); the construction is shared so a hand-rolled
  * copy can't forget that a settings row keeps the menu open.
@@ -25,7 +25,7 @@ export function makeRadioSubMenu(opts) {
         subMenu: [
             // via radioItems so these keep the menu open like every other
             // setting row — a plot type is usually picked by trying a couple
-            ...radioItems(options.map(([value, label]) => ({ value, label })), value, onChange),
+            ...radioItems(options.map(option => 'value' in option ? option : { value: option[0], label: option[1] }), value, onChange),
             ...extraItems,
         ],
     };

package/esm/ui/rampKey.d.ts

@@ -0,0 +1,15 @@
+import type { RampScale } from './colorScale.ts';
+/**
+ * A ramp's bar as columns, for a host that draws the key itself, such as R
+ * through V8: each stop's `offset`, `#rrggbb` `color` and `opacity`, and the
+ * end labels the on-screen bar prints.
+ */
+export declare function rampKeyOf(scale: RampScale): {
+    minLabel: string;
+    maxLabel: string;
+    id: string;
+    title: string;
+    offset: number[];
+    color: string[];
+    opacity: number[];
+};

package/esm/ui/rampKey.js

@@ -0,0 +1,17 @@
+import { cssColorToHex } from '../util/colorBits.js';
+import { rampLabels } from './colorScale.js';
+/**
+ * A ramp's bar as columns, for a host that draws the key itself, such as R
+ * through V8: each stop's `offset`, `#rrggbb` `color` and `opacity`, and the
+ * end labels the on-screen bar prints.
+ */
+export function rampKeyOf(scale) {
+    return {
+        id: scale.id,
+        title: scale.title ?? '',
+        ...rampLabels(scale),
+        offset: scale.stops.map(stop => stop.offset),
+        color: scale.stops.map(stop => cssColorToHex(stop.color)),
+        opacity: scale.stops.map(stop => stop.opacity ?? 1),
+    };
+}

package/esm/ui/showSubMenu.d.ts

@@ -6,11 +6,6 @@ import type { MenuItem } from './MenuTypes.ts';
  * multi-row painting with no legend) drops the row rather than opening an empty
  * submenu.
  *
- * One helper because this was eleven hand-written literals that had already
- * drifted three ways: the wiggle family said `'Show'` where everyone else said
- * `'Show...'`, only some set the redundant `type: 'subMenu'`, and only the
- * wiggle family omitted the empty submenu.
- *
  * Not exported from `ui/menuItems.ts`: the icon is a value import, and that
  * entry is the React-free one (see its header). Import this module directly —
  * `@jbrowse/core/ui/showSubMenu` — which costs one icon rather than the

package/esm/ui/showSubMenu.js

@@ -1,4 +1,5 @@
 import VisibilityIcon from '@mui/icons-material/Visibility';
+import { subMenuIfAny } from './MenuTypes.js';
 /**
  * The "Show..." submenu every display groups its visibility toggles under, and
  * the empty-omit that goes with it: a display whose toggles are all
@@ -6,25 +7,15 @@ import VisibilityIcon from '@mui/icons-material/Visibility';
  * multi-row painting with no legend) drops the row rather than opening an empty
  * submenu.
  *
- * One helper because this was eleven hand-written literals that had already
- * drifted three ways: the wiggle family said `'Show'` where everyone else said
- * `'Show...'`, only some set the redundant `type: 'subMenu'`, and only the
- * wiggle family omitted the empty submenu.
- *
  * Not exported from `ui/menuItems.ts`: the icon is a value import, and that
  * entry is the React-free one (see its header). Import this module directly —
  * `@jbrowse/core/ui/showSubMenu` — which costs one icon rather than the
  * `@jbrowse/core/ui` barrel's ~80 Material components.
  */
 export function makeShowSubMenu(items) {
-    return items.length
-        ? [
-            {
-                label: 'Show...',
-                icon: VisibilityIcon,
-                type: 'subMenu',
-                subMenu: items,
-            },
-        ]
-        : [];
+    return subMenuIfAny({
+        label: 'Show...',
+        icon: VisibilityIcon,
+        subMenu: items,
+    });
 }

package/esm/ui/theme.d.ts

@@ -14,9 +14,9 @@ type FramesOptions = FrameTuple<PaletteColorOptions>;
 declare module '@mui/material/styles' {
     interface Palette extends StringColors {
         /**
-         * The primary colour where it marks something on the page's own ground,
+         * The primary color where it marks something on the page's own ground,
          * such as a checked box or a selected row. `primary.main` in light mode,
-         * and the secondary text colour in dark mode, where a midnight primary
+         * and the secondary text color in dark mode, where a midnight primary
          * vanishes
          */
         accent: string;

package/esm/ui/theme.js

@@ -67,7 +67,7 @@ const baseThemeOptions = {
     components: {
         MuiAppBar: {
             // JBrowse's header keeps its brand in dark mode; MUI's default is to
-            // flatten it to the paper colour. A property of the app rather than of
+            // flatten it to the paper color. A property of the app rather than of
             // one palette — it used to sit on `darkStock` alone, so the theme a
             // reader reaches by picking Dark over the default palette lost the
             // header the old dark theme had. MUI reads this only in dark mode.

package/esm/ui/useAssemblySelection.d.ts

@@ -74,6 +74,7 @@ export declare function useAssemblySelection(session: AbstractSessionModel, loca
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {
@@ -141,6 +142,7 @@ export declare function useAssemblySelection(session: AbstractSessionModel, loca
         getCanonicalRefName2(refName: string): string;
         isValidRefName(refName: string): boolean;
     } & {
+        isCircularRefName(refName: string): boolean;
         getRefNamePosition(refName: string): number | undefined;
         getAliasesForRefName(refName: string): string[];
         getRefNameMapForAdapter(adapterConf: {

package/esm/ui/useMouseTracking.d.ts

@@ -20,28 +20,16 @@ export declare function useClearTrackedPointer(): () => void;
  * Container-relative mouse position for the overlays that follow the pointer
  * (`Crosshairs`, tooltips), coalesced to one update per frame.
  *
- * The position is measured against the box of whatever element the handlers are
- * bound to, which is what the overlays are positioned in — off `currentTarget`,
- * so there is no ref to pass and no way to bind the two to different elements.
+ * The position is measured against the box of the element the handlers are
+ * bound to, off `currentTarget`, which is what the overlays are positioned in.
  * A display that also hit-tests takes `onMove`, so its hit and its guides come
- * off one measurement in one frame instead of two pointer paths that have to
- * agree.
+ * off one measurement in one frame.
  *
- * **It returns a `mouseTracker` rather than the position, and that is the
- * load-bearing part.** Its one caller is `DisplayChromeBase`, which owns the
- * container the handlers bind to — so if the position were state here, every
- * mouse move would re-render the chrome itself (re-running
- * `useRenderingBackend`), the status container with a fresh inline `style`
- * object, all three overlays, and only then the body that actually wanted the
- * coordinate. That is a whole display's chrome repainting because the cursor
- * moved a pixel over it; it cost a full document `Layout` plus three `Paint`s
- * per mousemove on the wiggle displays, back when each display called this hook
- * itself and every one of them had it.
- *
- * So the position is published instead, and whoever wants it calls
- * `useMouseState(mouseTracker)` — from inside the chrome's body, where the
- * overlays live. Re-rendering then starts at the component that reads it.
- * Passing the tracker down a prop is free; passing `mouseState` down is the bug.
+ * It returns a `mouseTracker` and not the position: the caller is
+ * `DisplayChromeBase`, and position held as state there would re-render the
+ * whole chrome on every mouse move. Whoever draws at the cursor calls
+ * `useMouseState(mouseTracker)`, so re-rendering starts at that component.
+ * Pass the tracker down, never the position.
  */
 export declare function useMouseTracking(onMove?: (state?: MouseState) => void): {
     mouseTracker: MouseTracker;

package/esm/ui/useMouseTracking.js

@@ -27,16 +27,11 @@ function createMouseStore() {
 /**
  * Drop the tracked pointer, published by whoever bound the handlers.
  *
- * `mouseleave` reports the pointer leaving an element, and the browser decides
- * that by comparing the hover chain before a move to the chain after it. A menu
- * portalled to the body opens under the cursor with no move at all, and closing
- * it detaches the chain's nodes — so hover restarts at `body` and the display
- * the menu covered is never told anything again. Its overlays then keep drawing
- * at the coordinate the pointer had when the menu opened, wherever the pointer
- * has since gone.
- *
- * `ContextMenu` calls this on close, which is why the default is a no-op: a menu
- * raised outside a display's chrome has no tracked pointer to drop.
+ * A menu portalled to the body opens under the cursor with no move, and
+ * closing it detaches the hover chain, so the display it covered never gets a
+ * `mouseleave` and its overlays keep drawing where the menu opened.
+ * `ContextMenu` calls this on close; the default is a no-op for a menu raised
+ * outside a display's chrome.
  */
 const ClearTrackedPointerContext = createContext(() => { });
 export const ClearTrackedPointerProvider = ClearTrackedPointerContext.Provider;
@@ -47,44 +42,25 @@ export function useClearTrackedPointer() {
  * Container-relative mouse position for the overlays that follow the pointer
  * (`Crosshairs`, tooltips), coalesced to one update per frame.
  *
- * The position is measured against the box of whatever element the handlers are
- * bound to, which is what the overlays are positioned in — off `currentTarget`,
- * so there is no ref to pass and no way to bind the two to different elements.
+ * The position is measured against the box of the element the handlers are
+ * bound to, off `currentTarget`, which is what the overlays are positioned in.
  * A display that also hit-tests takes `onMove`, so its hit and its guides come
- * off one measurement in one frame instead of two pointer paths that have to
- * agree.
- *
- * **It returns a `mouseTracker` rather than the position, and that is the
- * load-bearing part.** Its one caller is `DisplayChromeBase`, which owns the
- * container the handlers bind to — so if the position were state here, every
- * mouse move would re-render the chrome itself (re-running
- * `useRenderingBackend`), the status container with a fresh inline `style`
- * object, all three overlays, and only then the body that actually wanted the
- * coordinate. That is a whole display's chrome repainting because the cursor
- * moved a pixel over it; it cost a full document `Layout` plus three `Paint`s
- * per mousemove on the wiggle displays, back when each display called this hook
- * itself and every one of them had it.
+ * off one measurement in one frame.
  *
- * So the position is published instead, and whoever wants it calls
- * `useMouseState(mouseTracker)` — from inside the chrome's body, where the
- * overlays live. Re-rendering then starts at the component that reads it.
- * Passing the tracker down a prop is free; passing `mouseState` down is the bug.
+ * It returns a `mouseTracker` and not the position: the caller is
+ * `DisplayChromeBase`, and position held as state there would re-render the
+ * whole chrome on every mouse move. Whoever draws at the cursor calls
+ * `useMouseState(mouseTracker)`, so re-rendering starts at that component.
+ * Pass the tracker down, never the position.
  */
 export function useMouseTracking(onMove) {
     const rafRef = useRef(undefined);
     const storeRef = useRef(undefined);
     storeRef.current ??= createMouseStore();
     const store = storeRef.current;
-    // Reached through a ref rather than captured, so `handleMouseLeave` below can
-    // be identity-stable — one of its callers is an effect, and a handler that
-    // changed identity every render would make that effect re-run every render.
-    // Reading the latest is also the better answer for the frame callback, which
-    // runs after the render whose closure scheduled it.
-    //
-    // Written in an effect rather than during render: a render React discards must
-    // not leave this pointing at a callback from it. Nothing can read it before
-    // the first commit — both users are event/effect callbacks — and `useRef`'s
-    // initial value covers the first commit itself.
+    // Reached through a ref so `handleMouseLeave` is identity-stable (an effect
+    // depends on it), and written in an effect so a render React discards cannot
+    // leave it pointing at that render's callback.
     const onMoveRef = useRef(onMove);
     useEffect(() => {
         onMoveRef.current = onMove;
@@ -92,11 +68,10 @@ export function useMouseTracking(onMove) {
     /**
      * Drop the published position and tell `onMove` the pointer is gone.
      *
-     * Bound as the container's `onMouseLeave` — and called directly for the two
-     * cases `mouseleave` cannot report: the container being *removed* rather than
-     * left, and a portalled menu closing over it. `DisplayChromeBase` makes both
-     * calls, the second by publishing this on `ClearTrackedPointerProvider`.
-     * Identity-stable for both.
+     * Bound as the container's `onMouseLeave`, and called directly for the three
+     * cases `mouseleave` cannot report: the container being removed, a portalled
+     * menu closing over it, and the pointer moving onto a portalled overlay.
+     * `DisplayChromeBase` makes all three calls. Identity-stable.
      */
     const handleMouseLeave = useCallback(() => {
         if (rafRef.current) {
@@ -107,28 +82,14 @@ export function useMouseTracking(onMove) {
         onMoveRef.current?.(undefined);
     }, [store]);
     const handleMouseMove = (event) => {
-        // An overlay portaled out of the container still *bubbles* its React events
-        // here, even though its DOM node is not a descendant — so the coordinate
-        // would be measured against a box the pointer isn't in. HiC guarded this by
-        // hand (its resolution dropdown and legend portal); it is a hazard for any
-        // display with a portaled overlay, and several have one, so the guard lives
-        // here and applies to all of them. Treated as a leave: the pointer is over
-        // something else, and the guides should drop rather than freeze.
-        const { target } = event;
-        if (target instanceof Node && !event.currentTarget.contains(target)) {
-            handleMouseLeave();
-            return;
-        }
         if (rafRef.current) {
             cancelAnimationFrame(rafRef.current);
         }
         const clientX = event.clientX;
         const clientY = event.clientY;
-        // Captured here rather than read in the frame: React clears `currentTarget`
-        // once the handler returns. `isConnected` then stands in for the ref check
-        // this used to do — a display unmounted between the move and the frame
-        // measures as a zero rect, and would publish the client point as if the
-        // pointer were at the origin of a box that is gone.
+        // Captured here: React clears `currentTarget` once the handler returns. A
+        // display unmounted before the frame measures as a zero rect, hence the
+        // `isConnected` check.
         const container = event.currentTarget;
         rafRef.current = requestAnimationFrame(() => {
             if (container.isConnected) {

package/esm/ui/usePlacedMenuFocus.d.ts

@@ -0,0 +1,19 @@
+import type { PopoverActions } from '@mui/material';
+/**
+ * Props that move a MUI Menu's opening focus to after the menu is placed.
+ *
+ * MUI focuses the first row while the menu mounts, before Popover writes the
+ * paper's position, so the focused row still sits at the viewport's top-left.
+ * Firefox scrolls every enclosing frame to reveal a focused element, so a page
+ * that embeds JBrowse in an iframe jumped to the frame's top whenever a menu
+ * opened with that top scrolled out of view.
+ *
+ * The `onEntering` returned here places the paper through Popover's
+ * `updatePosition`, then focuses the first row without scrolling anything.
+ */
+export declare function usePlacedMenuFocus(): {
+    action: import("react").RefObject<PopoverActions | null>;
+    autoFocus: boolean;
+    disableAutoFocus: boolean;
+    onEntering: (paper: HTMLElement) => void;
+};

package/esm/ui/usePlacedMenuFocus.js

@@ -0,0 +1,28 @@
+import { useRef } from 'react';
+const FIRST_ROW = '[role^="menuitem"]:not(.Mui-disabled)';
+/**
+ * Props that move a MUI Menu's opening focus to after the menu is placed.
+ *
+ * MUI focuses the first row while the menu mounts, before Popover writes the
+ * paper's position, so the focused row still sits at the viewport's top-left.
+ * Firefox scrolls every enclosing frame to reveal a focused element, so a page
+ * that embeds JBrowse in an iframe jumped to the frame's top whenever a menu
+ * opened with that top scrolled out of view.
+ *
+ * The `onEntering` returned here places the paper through Popover's
+ * `updatePosition`, then focuses the first row without scrolling anything.
+ */
+export function usePlacedMenuFocus() {
+    const action = useRef(null);
+    return {
+        action,
+        autoFocus: false,
+        disableAutoFocus: true,
+        onEntering: (paper) => {
+            action.current?.updatePosition();
+            paper
+                .querySelector(FIRST_ROW)
+                ?.focus({ preventScroll: true });
+        },
+    };
+}

package/esm/util/Base1DViewModel.d.ts

@@ -4,9 +4,11 @@ import type { Instance } from '@jbrowse/mobx-state-tree';
 /**
  * #stateModel Base1DView
  * #category general
- * used in non-lgv view representations of a 1d view e.g. the two axes of the
- * dotplot use this. categorized General rather than View because it is not a
- * pluggable view type, which the name-suffix heuristic would otherwise assume
+ * Holds a one-dimensional axis of displayed regions, with its zoom and scroll
+ * offset, for views other than the linear genome view, such as the two axes of
+ * the dotplot.
+ *
+ * Its page sits under General because it is not a pluggable view type.
  */
 declare const Base1DView: import("@jbrowse/mobx-state-tree").IModelType<{
     id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;

package/esm/util/Base1DViewModel.js

@@ -7,9 +7,11 @@ import { ElementId } from './types/mst.js';
 /**
  * #stateModel Base1DView
  * #category general
- * used in non-lgv view representations of a 1d view e.g. the two axes of the
- * dotplot use this. categorized General rather than View because it is not a
- * pluggable view type, which the name-suffix heuristic would otherwise assume
+ * Holds a one-dimensional axis of displayed regions, with its zoom and scroll
+ * offset, for views other than the linear genome view, such as the two axes of
+ * the dotplot.
+ *
+ * Its page sits under General because it is not a pluggable view type.
  */
 const Base1DView = types
     .model('Base1DView', {

package/esm/util/SvgCanvas.js

@@ -175,7 +175,7 @@ export class SvgCanvas {
     // treats as the same rect anchored at `x-w`) is NOT normalized here — SVG
     // would emit `width="-w"` and silently not render. Callers must pass a
     // non-negative size; spans resolve both edges and take
-    // `left = min(x1,x2)` / `w = abs(x2-x1)` (see render-core/CLAUDE.md), the
+    // `left = min(x1,x2)` / `w = abs(x2-x1)`, the
     // same convention that keeps reversed blocks correct.
     transformRect(x, y, w, h) {
         const [tx, ty] = this.transformPoint(this.a < 0 ? x + w : x, this.d < 0 ? y + h : y);

package/esm/util/aggregateFieldName.d.ts

@@ -1,10 +1 @@
-/**
- * The field an aggregate op writes: `as` where named, else `count` for a
- * count, else `<op>_<field>`. Imports nothing, so the validator's copy of the
- * mark rule list carries it unchanged.
- */
-export declare function aggregateFieldName({ op, field, as, }: {
-    op: string;
-    field?: string;
-    as?: string;
-}): string;
+export { aggregateFieldName } from './stepOutputs.ts';

package/esm/util/aggregateFieldName.js

@@ -1,8 +1 @@
-/**
- * The field an aggregate op writes: `as` where named, else `count` for a
- * count, else `<op>_<field>`. Imports nothing, so the validator's copy of the
- * mark rule list carries it unchanged.
- */
-export function aggregateFieldName({ op, field, as, }) {
-    return as || (op === 'count' || !field ? op : `${op}_${field}`);
-}
+export { aggregateFieldName } from './stepOutputs.js';

package/esm/util/alignedBytes.d.ts

@@ -0,0 +1,19 @@
+export declare const DASH = 45;
+export declare const SPACE = 32;
+export declare const LOWER_BIT = 32;
+export declare const N_UPPER = 78;
+/** No base at this column of a row: a gap, or the padding of a short row. */
+export declare function isGapByte(b: number): b is 32 | 45;
+export declare function sameBase(a: number, b: number): boolean;
+/**
+ * An `N` reference base, which a row neither matches nor mismatches, so
+ * identity leaves it uncounted.
+ */
+export declare function isUnknownBase(b: number): boolean;
+/**
+ * The first column carrying the row's own sequence. A gap run reaching either
+ * end of a row measures where the block was cut, not the alignment.
+ */
+export declare function firstDrawn(bytes: Uint8Array, at: number, len: number): number;
+/** The last column carrying the row's own sequence, from `firstDrawn`'s answer. */
+export declare function lastDrawn(bytes: Uint8Array, at: number, len: number, first: number): number;

package/esm/util/alignedBytes.js

@@ -0,0 +1,37 @@
+export const DASH = 45;
+export const SPACE = 32;
+export const LOWER_BIT = 0x20;
+export const N_UPPER = 78;
+/** No base at this column of a row: a gap, or the padding of a short row. */
+export function isGapByte(b) {
+    return b === DASH || b === SPACE;
+}
+export function sameBase(a, b) {
+    return (a | LOWER_BIT) === (b | LOWER_BIT);
+}
+/**
+ * An `N` reference base, which a row neither matches nor mismatches, so
+ * identity leaves it uncounted.
+ */
+export function isUnknownBase(b) {
+    return (b & ~LOWER_BIT) === N_UPPER;
+}
+/**
+ * The first column carrying the row's own sequence. A gap run reaching either
+ * end of a row measures where the block was cut, not the alignment.
+ */
+export function firstDrawn(bytes, at, len) {
+    let first = 0;
+    while (first < len && isGapByte(bytes[at + first])) {
+        first++;
+    }
+    return first;
+}
+/** The last column carrying the row's own sequence, from `firstDrawn`'s answer. */
+export function lastDrawn(bytes, at, len, first) {
+    let last = len - 1;
+    while (last > first && isGapByte(bytes[at + last])) {
+        last--;
+    }
+    return last;
+}

package/esm/util/analytics.d.ts

@@ -1,26 +1,22 @@
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfigurationModel, TrackConfigEntry } from '../configuration/index.ts';
+import type { ActivitySession } from './sessionActivity.ts';
 declare global {
     interface Window {
         ga?: (...args: unknown[]) => void;
     }
 }
-type TrackConfig = AnyConfigurationModel & {
-    type: string;
-};
 interface AnalyticsRootModel {
     jbrowse: {
-        tracks: TrackConfig[];
+        tracks: TrackConfigEntry[];
         assemblies: unknown[];
         plugins?: {
             name?: string;
         }[];
     };
-    session?: {
-        sessionTracks: TrackConfig[];
-        views: unknown[];
-    };
+    session?: ActivitySession;
     version: string;
 }
+export declare function urlParamNames(search: string): string;
 type AnalyticsRootModelWithConfig = AnalyticsRootModel & {
     jbrowse: {
         configuration: AnyConfigurationModel;
@@ -28,5 +24,6 @@ type AnalyticsRootModelWithConfig = AnalyticsRootModel & {
 };
 export declare function writeAWSAnalytics(rootModel: AnalyticsRootModel, initialTimestamp: number, sessionQuery?: string | null): Promise<void>;
 export declare function writeGAAnalytics(rootModel: AnalyticsRootModel, initialTimestamp: number): Promise<void>;
+export declare function writeAWSSessionEnd(): Promise<void>;
 export declare function doAnalytics(rootModel: AnalyticsRootModelWithConfig | undefined, initialTimestamp: number, initialSessionQuery: string | null | undefined): void;
 export {};