@jbrowse/app-core 5.0.0-beta.1 → 5.0.0-beta.10

package/esm/ui/App/ViewContainerTitle.js

@@ -1,10 +1,10 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import EditableTypography from '@jbrowse/core/ui/EditableTypography';
 import { getSession } from '@jbrowse/core/util';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
-import { Tooltip } from '@mui/material';
+import { Tooltip, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
-import { viewTitle } from './viewTitle.js';
+import { viewName, viewTitle } from './viewTitle.js';
 const useStyles = makeStyles()(theme => ({
     input: {
         paddingBottom: 0,
@@ -28,18 +28,21 @@ const useStyles = makeStyles()(theme => ({
         borderColor: theme.palette.primary.main,
         backgroundColor: theme.palette.secondary.light,
     },
+    minimized: {
+        color: theme.palette.secondary.contrastText,
+    },
 }));
 const ViewContainerTitle = observer(function ViewContainerTitle({ view, }) {
     const { classes } = useStyles();
     const { assemblyManager } = getSession(view);
-    const title = viewTitle(view, r => assemblyManager.getDisplayName(r));
-    return (_jsx(Tooltip, { title: `${title} (click to rename)`, arrow: true, children: _jsx(EditableTypography, { value: title, setValue: val => {
-                view.setDisplayName(val);
-            }, variant: "body2", classes: {
-                input: classes.input,
-                inputBase: classes.inputBase,
-                inputRoot: classes.inputRoot,
-                inputFocused: classes.inputFocused,
-            } }) }));
+    const getDisplayName = (r) => assemblyManager.getDisplayName(r);
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: `${viewTitle(view, getDisplayName)} (click to rename)`, arrow: true, children: _jsx(EditableTypography, { value: viewName(view, getDisplayName), setValue: val => {
+                        view.setDisplayName(val);
+                    }, variant: "body2", classes: {
+                        input: classes.input,
+                        inputBase: classes.inputBase,
+                        inputRoot: classes.inputRoot,
+                        inputFocused: classes.inputFocused,
+                    } }) }), view.minimized ? (_jsx(Typography, { variant: "body2", className: classes.minimized, children: "(minimized)" })) : null] }));
 });
 export default ViewContainerTitle;

package/esm/ui/App/ViewLauncher.js

@@ -22,7 +22,7 @@ const ViewLauncher = observer(function ViewLauncher({ session, }) {
     return (_jsxs(Paper, { className: classes.selectPaper, children: [_jsx(Typography, { children: "Select a view to launch" }), _jsx(FormControl, { className: classes.m2, children: _jsx(Select, { value: value, onChange: event => {
                         setValue(event.target.value);
                     }, children: viewTypes.map(({ displayName, name }) => (_jsx(MenuItem, { value: name, children: displayName }, name))) }) }), _jsx(FormControl, { className: classes.m2, children: _jsx(Button, { onClick: () => {
-                        session.addView(value, {});
+                        void session.launchView(value, {});
                     }, variant: "contained", color: "primary", children: "Launch view" }) })] }));
 });
 export default ViewLauncher;

package/esm/ui/App/ViewMenu.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { CascadingMenuButton } from '@jbrowse/core/ui';
 import { getSession } from '@jbrowse/core/util';
+import { renameIds } from '@jbrowse/core/util/types/mst';
 import { getSnapshot } from '@jbrowse/mobx-state-tree';
 import ContentCopyIcon from '@mui/icons-material/ContentCopy';
 import KeyboardArrowDownIcon from '@mui/icons-material/KeyboardArrowDown';
@@ -11,7 +12,6 @@ import MenuIcon from '@mui/icons-material/Menu';
 import OpenInNewIcon from '@mui/icons-material/OpenInNew';
 import VerticalSplitIcon from '@mui/icons-material/VerticalSplit';
 import { observer } from 'mobx-react';
-import { renameIds } from './copyView.js';
 // takes the icon's class, not an SvgIconProps object: the object was built
 // inline by ViewHeader and so was new on each of its renders, which defeated
 // mobx-react's memo for this whole menu (a Tooltip and an IconButton) every
@@ -63,7 +63,7 @@ const ViewMenu = observer(function ViewMenu({ model, className, }) {
                             label: 'Copy view',
                             icon: ContentCopyIcon,
                             onClick: () => {
-                                session.addView(model.type, renameIds(structuredClone(getSnapshot(model))));
+                                session.addView(model.type, renameIds(getSnapshot(model)));
                             },
                         },
                         {

package/esm/ui/App/ViewStack.js

@@ -10,6 +10,12 @@ import ViewContainer from './ViewContainer.js';
 // the amount that makes that gesture reach, and any more is room to scroll the
 // content off its own surface.
 //
+// It is scrollable room rather than content, so anything measuring how tall the
+// session is discounts it by its `view-stack-overscroll` testid — `overflow` in
+// jbApi does, and a filmed take paid for that: counted as content, it told
+// `jb.fitToWindow` the session was 300px taller than it was, and the dotplot
+// absorbing the cut came out a third of the height that fit.
+//
 // Capped, because half a port stops being a courtesy on a tall screen. 300px is
 // the cap the classic stack has always had and it stays the answer there — a
 // full window is comfortably past twice it. What the cap was hiding is the
@@ -37,6 +43,6 @@ const ViewStack = observer(function ViewStack({ views, session, className, }) {
     // restore / initial load), so they must not steal scroll when they mount. A
     // view whose id isn't in this set was added later and auto-scrolls into view.
     const [initialViewIds] = useState(() => new Set(views.map(v => v.id)));
-    return (_jsxs(_Fragment, { children: [_jsx("div", { ref: viewsRef, className: className, children: views.map(view => (_jsx(ViewContainer, { view: view, session: session, scrollOnMount: !initialViewIds.has(view.id) }, view.id))) }), scrollable ? _jsx("div", { className: classes.spacer }) : null] }));
+    return (_jsxs(_Fragment, { children: [_jsx("div", { ref: viewsRef, className: className, children: views.map(view => (_jsx(ViewContainer, { view: view, session: session, scrollOnMount: !initialViewIds.has(view.id) }, view.id))) }), scrollable ? (_jsx("div", { className: classes.spacer, "data-testid": "view-stack-overscroll" })) : null] }));
 });
 export default ViewStack;

package/esm/ui/App/ViewsContainer.d.ts

@@ -1,7 +1,5 @@
 import type { AppSession } from './types.ts';
-interface Props {
-    HeaderButtons?: React.ReactElement;
+declare const ViewsContainer: ({ session, }: {
     session: AppSession;
-}
-declare const ViewsContainer: (props: Props) => import("react").JSX.Element;
+}) => import("react").JSX.Element;
 export default ViewsContainer;

package/esm/ui/App/ViewsContainer.js

@@ -1,22 +1,16 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { Suspense, lazy } from 'react';
+import { Suspense } from 'react';
 import { makeStyles } from '@jbrowse/core/util/tss-react';
 import { observer } from 'mobx-react';
 import { isSessionWithWorkspaceLayout } from '../../WorkspaceLayout/model.js';
-import { lazyChunk } from './lazyChunk.js';
-const ClassicViewsContainer = lazy(lazyChunk('ClassicViewsContainer', () => import('./ClassicViewsContainer.js')));
-const WorkspaceContainer = lazy(lazyChunk('WorkspaceContainer', () => import('../../WorkspaceLayout/WorkspaceContainer.js').then(m => ({
-    default: m.WorkspaceContainer,
-}))));
-const ViewLauncher = lazy(lazyChunk('ViewLauncher', () => import('./ViewLauncher.js')));
+import { ClassicViewsContainer, ViewLauncher, WorkspaceContainer, } from './lazyParts.js';
 const useStyles = makeStyles()({
     viewsContainer: {
         gridRow: 'components',
         overflow: 'hidden',
     },
 });
-const ViewsContainer = observer(function ViewsContainer(props) {
-    const { session } = props;
+const ViewsContainer = observer(function ViewsContainer({ session, }) {
     const { views, effectiveUseWorkspaces } = session;
     const { classes } = useStyles();
     return (_jsx("div", { className: classes.viewsContainer, children: _jsx(Suspense, { fallback: null, children: views.length > 0 ? (effectiveUseWorkspaces && isSessionWithWorkspaceLayout(session) ? (_jsx(WorkspaceContainer, { session: session })) : (_jsx(ClassicViewsContainer, { session: session }))) : (_jsx(ViewLauncher, { session: session })) }) }));

package/esm/ui/App/index.d.ts

@@ -1,3 +1,3 @@
 export { App } from './App.tsx';
-export { default as AppReadyMarker } from './AppReadyMarker.tsx';
 export { default as DialogQueue } from './DialogQueue.tsx';
+export { preloadAppFrame, preloadAppShell } from './preloadAppShell.ts';

package/esm/ui/App/index.js

@@ -1,3 +1,3 @@
 export { App } from './App.js';
-export { default as AppReadyMarker } from './AppReadyMarker.js';
 export { default as DialogQueue } from './DialogQueue.js';
+export { preloadAppFrame, preloadAppShell } from './preloadAppShell.js';

package/esm/ui/App/lazyParts.d.ts

@@ -0,0 +1,32 @@
+export declare const DrawerWidget: import("react").LazyExoticComponent<({ session, }: {
+    session: import("@jbrowse/core/util").SessionWithFocusedViewAndDrawerWidgets;
+}) => import("react").JSX.Element> & {
+    preload: () => Promise<{
+        default: ({ session, }: {
+            session: import("@jbrowse/core/util").SessionWithFocusedViewAndDrawerWidgets;
+        }) => import("react").JSX.Element;
+    }>;
+};
+export declare const ClassicViewsContainer: import("react").LazyExoticComponent<({ session, }: import("./ClassicViewsContainer.tsx").ClassicViewsContainerProps) => import("react").JSX.Element> & {
+    preload: () => Promise<{
+        default: ({ session, }: import("./ClassicViewsContainer.tsx").ClassicViewsContainerProps) => import("react").JSX.Element;
+    }>;
+};
+export declare const WorkspaceContainer: import("react").LazyExoticComponent<({ session, }: {
+    session: import("@jbrowse/core/util").SessionWithFocusedViewAndDrawerWidgets & import("../../index.ts").WorkspaceLayout;
+}) => import("react").JSX.Element> & {
+    preload: () => Promise<{
+        default: ({ session, }: {
+            session: import("@jbrowse/core/util").SessionWithFocusedViewAndDrawerWidgets & import("../../index.ts").WorkspaceLayout;
+        }) => import("react").JSX.Element;
+    }>;
+};
+export declare const ViewLauncher: import("react").LazyExoticComponent<({ session, }: {
+    session: import("@jbrowse/core/util").SessionWithDrawerWidgets;
+}) => import("react").JSX.Element> & {
+    preload: () => Promise<{
+        default: ({ session, }: {
+            session: import("@jbrowse/core/util").SessionWithDrawerWidgets;
+        }) => import("react").JSX.Element;
+    }>;
+};

package/esm/ui/App/lazyParts.js

@@ -0,0 +1,8 @@
+import { lazyWithPreload } from '@jbrowse/core/util/lazyWithPreload';
+import { lazyChunk } from './lazyChunk.js';
+export const DrawerWidget = lazyWithPreload(lazyChunk('DrawerWidget', () => import('./DrawerWidget.js')));
+export const ClassicViewsContainer = lazyWithPreload(lazyChunk('ClassicViewsContainer', () => import('./ClassicViewsContainer.js')));
+export const WorkspaceContainer = lazyWithPreload(lazyChunk('WorkspaceContainer', () => import('../../WorkspaceLayout/WorkspaceContainer.js').then(m => ({
+    default: m.WorkspaceContainer,
+}))));
+export const ViewLauncher = lazyWithPreload(lazyChunk('ViewLauncher', () => import('./ViewLauncher.js')));

package/esm/ui/App/preloadAppShell.d.ts

@@ -0,0 +1,14 @@
+import type { AppSession } from './types.ts';
+/**
+ * Load the views container and the drawer while the session's own view code
+ * downloads, settling when both have. An app that renders after this renders
+ * its frame in one pass; otherwise the first render suspends on them and React
+ * holds the retry for 300 ms.
+ */
+export declare function preloadAppFrame(): Promise<void>;
+/**
+ * Request the app frame's lazy parts that `session` will show (its views
+ * container, the drawer and the widget open in it) as soon as the session
+ * exists. Rendering asks for each only when it reaches it, a round trip apiece.
+ */
+export declare function preloadAppShell(session: AppSession): void;

package/esm/ui/App/preloadAppShell.js

@@ -0,0 +1,41 @@
+import { preloadComponent } from '@jbrowse/core/util/preloadComponent';
+import { getEnv } from '@jbrowse/mobx-state-tree';
+import { isSessionWithWorkspaceLayout } from '../../WorkspaceLayout/model.js';
+import { ClassicViewsContainer, DrawerWidget, WorkspaceContainer, } from './lazyParts.js';
+/**
+ * Load the views container and the drawer while the session's own view code
+ * downloads, settling when both have. An app that renders after this renders
+ * its frame in one pass; otherwise the first render suspends on them and React
+ * holds the retry for 300 ms.
+ */
+export async function preloadAppFrame() {
+    await Promise.allSettled([
+        ClassicViewsContainer.preload(),
+        DrawerWidget.preload(),
+    ]);
+}
+/**
+ * Request the app frame's lazy parts that `session` will show (its views
+ * container, the drawer and the widget open in it) as soon as the session
+ * exists. Rendering asks for each only when it reaches it, a round trip apiece.
+ */
+export function preloadAppShell(session) {
+    if (session.views.length > 0) {
+        preloadComponent(session.effectiveUseWorkspaces && isSessionWithWorkspaceLayout(session)
+            ? WorkspaceContainer
+            : ClassicViewsContainer);
+    }
+    const { drawerVisible, visibleWidget } = session;
+    if (drawerVisible) {
+        preloadComponent(DrawerWidget);
+    }
+    if (drawerVisible && visibleWidget) {
+        const { pluginManager } = getEnv(session);
+        try {
+            preloadComponent(pluginManager.getWidgetType(visibleWidget.type).ReactComponent);
+        }
+        catch {
+            // an unknown widget type is reported when the drawer renders it
+        }
+    }
+}

package/esm/ui/App/types.d.ts

@@ -2,15 +2,20 @@ import type { Menu } from '../../menus.ts';
 import type { ErrorDialogState, SnackbarMessage } from '@jbrowse/core/ui/SnackbarModel';
 import type { SessionWithFocusedViewAndDrawerWidgets } from '@jbrowse/core/util';
 export { type Menu } from '../../menus.ts';
-export type WorkspaceSessionType = SessionWithFocusedViewAndDrawerWidgets & {
-    renameCurrentSession: (arg: string) => void;
-    snackbarMessages: SnackbarMessage[];
-    popSnackbarMessage: () => unknown;
-    orderViews: (ids: string[]) => void;
-};
-export type AppSession = WorkspaceSessionType & {
+export interface ThemeSwitchSession {
+    themeMode: 'light' | 'dark' | 'system';
+    effectiveThemeMode: 'light' | 'dark';
+    themeIsDark: boolean;
+    systemThemeOverride?: 'light' | 'dark';
+    setSystemThemeOverride: (mode?: 'light' | 'dark') => void;
+}
+export type WorkspaceSessionType = SessionWithFocusedViewAndDrawerWidgets;
+export type AppSession = WorkspaceSessionType & ThemeSwitchSession & {
     menus: () => Menu[];
     errorDialog: ErrorDialogState | undefined;
     setErrorDialog: (state: ErrorDialogState | undefined) => void;
     effectiveUseWorkspaces: boolean;
+    renameCurrentSession: (arg: string) => void;
+    snackbarMessages: SnackbarMessage[];
+    popSnackbarMessage: () => unknown;
 };

package/esm/ui/App/useViewVisibility.d.ts

@@ -1,7 +1,6 @@
 /**
- * View-level lazy mounting. A view only mounts its (GPU-heavy) body when it is
- * within `rootMargin` of the viewport, and collapses to a height-preserving
- * spacer once scrolled far away. This bounds the number of simultaneously-live
+ * View-level lazy mounting. A view only mounts its (GPU-heavy) body while it is
+ * on screen, and collapses to a height-preserving spacer once scrolled away. This bounds the number of simultaneously-live
  * GPU canvases/contexts — the root cause of the "workspaces freeze" with many
  * stacked views (one WebGL context per display canvas blows past the browser's
  * per-page cap; see agent-docs/reference/ARCHITECTURAL_LIMITS.md, "One WebGL2
@@ -10,10 +9,12 @@
  * `root: null` (viewport) is container-agnostic: it reports on-screen-ness the
  * same way whether the views scroll inside the classic container or a workspace
  * panel, so neither container needs to know about windowing. It also means
- * **`rootMargin` has no effect** — an observer clips the target against each
- * scrolling ancestor before intersecting with the root box that the margin
- * expands, and both containers are `overflow-y: auto`. So this is a hard
- * window with no hysteresis: a view is torn down the moment it leaves its
+ * **a `rootMargin` would have no effect** wherever a container scrolls — an
+ * observer clips the target against each scrolling ancestor before
+ * intersecting with the root box that the margin expands, and both containers
+ * are `overflow-y: auto`. Only an embed whose page scrolls instead would feel
+ * one, and it gets the same window. So this is a hard window with no
+ * hysteresis: a view is torn down the moment it leaves its
  * container and rebuilt when it returns, which on a GPU backend costs a fresh
  * WebGL2 context and a full shader recompile per display.
  *
@@ -27,7 +28,7 @@
  * Starts hidden so a cold load with N crammed views doesn't mount them all at
  * once; the observer's first callback mounts only what's near the viewport.
  */
-export declare function useViewVisibility(rootMargin: string): {
+export declare function useViewVisibility(): {
     ref: import("react").RefObject<HTMLDivElement | null>;
     visible: boolean;
     measuredHeight: number | undefined;

package/esm/ui/App/useViewVisibility.js

@@ -5,9 +5,8 @@ function intersectionObserverAvailable() {
     return typeof window !== 'undefined' && 'IntersectionObserver' in window;
 }
 /**
- * View-level lazy mounting. A view only mounts its (GPU-heavy) body when it is
- * within `rootMargin` of the viewport, and collapses to a height-preserving
- * spacer once scrolled far away. This bounds the number of simultaneously-live
+ * View-level lazy mounting. A view only mounts its (GPU-heavy) body while it is
+ * on screen, and collapses to a height-preserving spacer once scrolled away. This bounds the number of simultaneously-live
  * GPU canvases/contexts — the root cause of the "workspaces freeze" with many
  * stacked views (one WebGL context per display canvas blows past the browser's
  * per-page cap; see agent-docs/reference/ARCHITECTURAL_LIMITS.md, "One WebGL2
@@ -16,10 +15,12 @@ function intersectionObserverAvailable() {
  * `root: null` (viewport) is container-agnostic: it reports on-screen-ness the
  * same way whether the views scroll inside the classic container or a workspace
  * panel, so neither container needs to know about windowing. It also means
- * **`rootMargin` has no effect** — an observer clips the target against each
- * scrolling ancestor before intersecting with the root box that the margin
- * expands, and both containers are `overflow-y: auto`. So this is a hard
- * window with no hysteresis: a view is torn down the moment it leaves its
+ * **a `rootMargin` would have no effect** wherever a container scrolls — an
+ * observer clips the target against each scrolling ancestor before
+ * intersecting with the root box that the margin expands, and both containers
+ * are `overflow-y: auto`. Only an embed whose page scrolls instead would feel
+ * one, and it gets the same window. So this is a hard window with no
+ * hysteresis: a view is torn down the moment it leaves its
  * container and rebuilt when it returns, which on a GPU backend costs a fresh
  * WebGL2 context and a full shader recompile per display.
  *
@@ -33,7 +34,7 @@ function intersectionObserverAvailable() {
  * Starts hidden so a cold load with N crammed views doesn't mount them all at
  * once; the observer's first callback mounts only what's near the viewport.
  */
-export function useViewVisibility(rootMargin) {
+export function useViewVisibility() {
     const ref = useRef(null);
     const [state, setState] = useState(() => ({
         visible: !intersectionObserverAvailable(),
@@ -69,14 +70,14 @@ export function useViewVisibility(rootMargin) {
                         };
                     });
                 }
-            }, { rootMargin });
+            });
             io.observe(node);
             return () => {
                 io.disconnect();
             };
         }
         return undefined;
-    }, [rootMargin]);
+    }, []);
     // `measuredHeight` is undefined until the body has been seen at least once.
     // The caller supplies the estimate, and supplies it lazily. See ViewContainer
     return {

package/esm/ui/App/viewTitle.d.ts

@@ -1,5 +1,12 @@
-export declare function viewTitle(view: {
+interface TitledView {
     displayName?: string;
     assemblyNames?: string[];
-    minimized: boolean;
-}, getDisplayName: (assemblyName: string) => string): string;
+    minimized?: boolean;
+}
+/**
+ * The view's own name, or its assemblies'. An emptied name counts as unset, so
+ * clearing the title in the header puts the derived one back.
+ */
+export declare function viewName(view: TitledView, getDisplayName: (assemblyName: string) => string): string;
+export declare function viewTitle(view: TitledView, getDisplayName: (assemblyName: string) => string): string;
+export {};

package/esm/ui/App/viewTitle.js

@@ -1,9 +1,17 @@
-export function viewTitle(view, getDisplayName) {
+/**
+ * The view's own name, or its assemblies'. An emptied name counts as unset, so
+ * clearing the title in the header puts the derived one back.
+ */
+export function viewName(view, getDisplayName) {
     // assemblyNames is [] (not undefined) for a view with no displayed regions
     // yet, so fall back on emptiness rather than nullishness
     const assemblyNames = view.assemblyNames ?? [];
-    return (view.displayName ??
-        `${assemblyNames.length
-            ? assemblyNames.map(r => getDisplayName(r)).join(',')
-            : 'Untitled view'}${view.minimized ? ' (minimized)' : ''}`);
+    return (view.displayName ||
+        (assemblyNames.length
+            ? assemblyNames.map(r => getDisplayName(r)).join(', ')
+            : 'Untitled view'));
+}
+export function viewTitle(view, getDisplayName) {
+    const name = viewName(view, getDisplayName);
+    return view.minimized ? `${name} (minimized)` : name;
 }

package/esm/ui/index.d.ts

@@ -1 +1 @@
-export { App, AppReadyMarker, DialogQueue } from './App/index.ts';
+export { App, DialogQueue, preloadAppFrame, preloadAppShell, } from './App/index.ts';

package/esm/ui/index.js

@@ -1 +1 @@
-export { App, AppReadyMarker, DialogQueue } from './App/index.js';
+export { App, DialogQueue, preloadAppFrame, preloadAppShell, } from './App/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/app-core",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.10",
   "type": "module",
   "description": "JBrowse 2 code shared between the 'full featured' apps e.g. jbrowse-web and jbrowse-desktop",
   "keywords": [
@@ -24,13 +24,13 @@
     "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/product-core": "^5.0.0-beta.1",
-    "@jbrowse/core": "^5.0.0-beta.1"
+    "@jbrowse/product-core": "^5.0.0-beta.10",
+    "@jbrowse/core": "^5.0.0-beta.10"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/esm/ui/App/AppReadyMarker.d.ts

@@ -1,34 +0,0 @@
-import type { AppSession } from './types.ts';
-/**
- * One element that says whether the whole app has finished.
- *
- * `[data-app-phase="ready"]` is the entire readiness contract for anything
- * driving JBrowse from outside — a screenshot tool, a test, an agent. Wait for
- * that selector and you are done; there is no chain to assemble and no
- * per-display census to take.
- *
- * Why it exists when `data-view-phase` and `data-display-phase` already do:
- * those are per-element and NEGATIVE. Asking them "is everything finished"
- * means asserting that no element carries the loading value, which is equally
- * true of an app that has not started — and the gap is real, measured at about
- * a second on a two-track session. A positive attribute cannot be satisfied
- * early, because something has to render it.
- *
- * Its own component, and `hidden`, for two reasons: an observer here subscribes
- * to every view's phase without re-rendering the app shell around it, and a
- * marker that is never drawn cannot be mistaken for UI or shift a layout. It is
- * still found by `querySelector`, which is what reads it.
- *
- * **What it is silent about**: a display in a TERMINAL state. `error` is a
- * finished state, so this reads `ready` over a display whose fetch failed —
- * correctly, since nothing is still working. A capture wants more than that: it
- * wants a picture, and an error banner is not one. `waitForDisplaysDone` after
- * this is what draws that line, keying on the `data-display-drawn` the two
- * comparative canvases publish from their stricter `settled` gate (see
- * `comparativeReadiness` in `@jbrowse/synteny-core`, which holds both answers
- * and says why an error separates them). Both harnesses do it in that order.
- */
-declare const AppReadyMarker: ({ session, }: {
-    session: AppSession;
-}) => import("react").JSX.Element;
-export default AppReadyMarker;

package/esm/ui/App/AppReadyMarker.js

@@ -1,56 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { observer } from 'mobx-react';
-function containerLoading(container) {
-    return (container.tracks ?? []).some(track => (track.displays ?? []).some(d => d.displayPhase === 'loading'));
-}
-/**
- * Is anything in this session still working?
- *
- * The same two facts the per-element attributes publish — a view still
- * resolving its assembly, a display still in its own fetch — reduced to one
- * answer for the whole app. Duck-typed rather than imported: every view type
- * would otherwise have to be a dependency of the app shell.
- */
-function anythingLoading(views) {
-    return views.some(view => view.showLoading === true ||
-        view.initialized === false ||
-        containerLoading(view) ||
-        // A view whose tracks hang off something else — the synteny view's are on
-        // its levels, one list per band. `view.tracks` is empty there, so without
-        // this a stack of ribbons still fetching reads as idle.
-        (view.trackContainers ?? []).some(containerLoading) ||
-        anythingLoading(view.views ?? []));
-}
-/**
- * One element that says whether the whole app has finished.
- *
- * `[data-app-phase="ready"]` is the entire readiness contract for anything
- * driving JBrowse from outside — a screenshot tool, a test, an agent. Wait for
- * that selector and you are done; there is no chain to assemble and no
- * per-display census to take.
- *
- * Why it exists when `data-view-phase` and `data-display-phase` already do:
- * those are per-element and NEGATIVE. Asking them "is everything finished"
- * means asserting that no element carries the loading value, which is equally
- * true of an app that has not started — and the gap is real, measured at about
- * a second on a two-track session. A positive attribute cannot be satisfied
- * early, because something has to render it.
- *
- * Its own component, and `hidden`, for two reasons: an observer here subscribes
- * to every view's phase without re-rendering the app shell around it, and a
- * marker that is never drawn cannot be mistaken for UI or shift a layout. It is
- * still found by `querySelector`, which is what reads it.
- *
- * **What it is silent about**: a display in a TERMINAL state. `error` is a
- * finished state, so this reads `ready` over a display whose fetch failed —
- * correctly, since nothing is still working. A capture wants more than that: it
- * wants a picture, and an error banner is not one. `waitForDisplaysDone` after
- * this is what draws that line, keying on the `data-display-drawn` the two
- * comparative canvases publish from their stricter `settled` gate (see
- * `comparativeReadiness` in `@jbrowse/synteny-core`, which holds both answers
- * and says why an error separates them). Both harnesses do it in that order.
- */
-const AppReadyMarker = observer(function AppReadyMarker({ session, }) {
-    return (_jsx("span", { hidden: true, "data-testid": "app-ready-marker", "data-app-phase": anythingLoading(session.views) ? 'loading' : 'ready' }));
-});
-export default AppReadyMarker;

package/esm/ui/App/DrawerControls.d.ts

@@ -1 +0,0 @@
-export { DrawerControls as default } from '@jbrowse/product-core';

package/esm/ui/App/DrawerControls.js

@@ -1 +0,0 @@
-export { DrawerControls as default } from '@jbrowse/product-core';

package/esm/ui/App/copyView.d.ts

@@ -1 +0,0 @@
-export declare function renameIds(obj: Record<string, unknown>): Record<string, unknown>;

package/esm/ui/App/copyView.js

@@ -1,29 +0,0 @@
-import { createElementId } from '@jbrowse/core/util/types/mst';
-export function renameIds(obj) {
-    const idMap = new Map();
-    function transformIds(value) {
-        if (value === null || value === undefined) {
-            return value;
-        }
-        if (Array.isArray(value)) {
-            return value.map(transformIds);
-        }
-        if (typeof value === 'object') {
-            const result = {};
-            for (const [key, val] of Object.entries(value)) {
-                if (key === 'id' && typeof val === 'string') {
-                    if (!idMap.has(val)) {
-                        idMap.set(val, createElementId());
-                    }
-                    result[key] = idMap.get(val);
-                }
-                else {
-                    result[key] = transformIds(val);
-                }
-            }
-            return result;
-        }
-        return value;
-    }
-    return transformIds(obj);
-}