@jbrowse/app-core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/ui/App/AppReadyMarker.js

@@ -1,78 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { openTracks, openViews } from '@jbrowse/core/util/openViews';
-import { observer } from 'mobx-react';
-function trackLoading(track) {
-    return track.displays.some(d => d.displayPhase === 'loading');
-}
-/**
- * A view whose init failed (its assembly was never found) stays uninitialized
- * for good and paints its error, so like a display's terminal phase it is
- * finished, not pending: without this the whole app read `loading` for as long
- * as that view was open, and every settle answered false with no reason.
- *
- * `pendingLaunch` is the third term and the one that was missing. `initialized`
- * goes true mid-launch — LGV's flips the moment displayedRegions land, while
- * the same apply pass still has the spec's tracks to attach — and `showLoading`
- * goes false at the same moment, deliberately, so the reader sees the
- * navigated view rather than a spinner while its tracks arrive. That left a
- * window, exactly as wide as attaching the tracks, in which the marker said
- * `ready` over a session missing everything it had been asked for.
- * `whenViewSettled` states the same rule for the callers that await a single
- * view, and says why in more detail. Not shared as one predicate: that one
- * requires `initialized`, while absent here means not loading, and an adapter
- * between the two null rules would read as agreement it does not have.
- */
-function viewLoading(view) {
-    const flags = view;
-    return (flags.error === undefined &&
-        (flags.showLoading === true ||
-            flags.initialized === false ||
-            flags.pendingLaunch !== undefined));
-}
-/**
- * One element that says whether the whole app has finished, and what is open.
- *
- * `[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.
- *
- * The census attributes beside it — `data-app-views`, `data-app-assemblies`,
- * `data-app-tracks` (the latter two JSON arrays) — publish WHAT is open the
- * same way the phase publishes whether it is done, so an outside reader asking
- * "is the track I requested actually open" reads one element instead of
- * walking `window.JBrowseSession` with its own copy of the view nesting. The
- * walk itself is `openViews`/`openTracks` over each view's declared
- * `ownViews`/`ownTracks`, so this component knows nothing about which property
- * a container view keeps its children on either.
- *
- * 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, }) {
-    const views = openViews(session);
-    const tracks = openTracks(session);
-    const loading = views.some(viewLoading) || tracks.some(trackLoading);
-    return (_jsx("span", { hidden: true, "data-testid": "app-ready-marker", "data-app-phase": loading ? 'loading' : 'ready', "data-app-views": session.views.length, "data-app-assemblies": JSON.stringify([
-            ...new Set(views.flatMap(v => v.assemblyNames ?? [])),
-        ]), "data-app-tracks": JSON.stringify(tracks.map(t => t.configuration.trackId ?? '(unnamed)')) }));
-});
-export default AppReadyMarker;