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

package/esm/pluggableElementTypes/models/BaseViewModel.js

@@ -20,6 +20,10 @@ function containingViewOf(node) {
     }
     return undefined;
 }
+function bodyInDom(view) {
+    const parent = containingViewOf(view);
+    return (view.bodyMounted !== false && (parent === undefined || bodyInDom(parent)));
+}
 /**
  * #stateModel BaseViewModel
  * #category view
@@ -50,7 +54,7 @@ const BaseViewModel = types
      *
      * `ViewContainer` mounts a view's body only while an IntersectionObserver
      * says it is on screen, to hold the app under the WebGL2 context ceiling
-     * (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has
+     * (`reference/GPU_PORTABILITY.md`). A view below the fold therefore has
      * no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint
      * term of `displayPhase` pins every display in it at `loading` with nothing
      * left to resolve it — which parks `[data-app-phase="ready"]` for the whole
@@ -69,15 +73,27 @@ const BaseViewModel = types
     .views(self => ({
     /**
      * #getter
-     * Whether this view's body is in the DOM, counting the views it is nested
-     * inside — which is the question a display's phase actually asks.
+     * Overridable hook (default true): whether this view's mounted body
+     * renders its own displays. A linear genome view collapsed to its ruler
+     * mounts the scalebar and none of its tracks, so a display in it can no
+     * more paint than one in a view scrolled off screen. Views nested in this
+     * one are unaffected: they paint wherever their own body is.
+     */
+    get rendersDisplays() {
+        return true;
+    },
+    /**
+     * #getter
+     * Whether this view's displays have a canvas to paint into: its body is in
+     * the DOM, counting the views it is nested inside, and the body renders
+     * them (`rendersDisplays`). This is the question a display's phase asks.
      *
-     * `bodyMounted` alone answers it only for a view a container renders
-     * directly. A view nested in another view (a synteny row, a breakpoint
-     * panel) has no container writing its flag, so it reads `true` forever
-     * while its whole subtree is out of the DOM, and every display in it waits
-     * for a first paint that nothing will make — the hang this flag exists to
-     * prevent, one level down.
+     * `bodyMounted` alone answers the DOM half only for a view a container
+     * renders directly. A view nested in another view (a synteny row, a
+     * breakpoint panel) has no container writing its flag, so it reads `true`
+     * forever while its whole subtree is out of the DOM, and every display in
+     * it waits for a first paint that nothing will make — the hang this flag
+     * exists to prevent, one level down.
      *
      * An ancestor that does not carry the flag at all leaves the answer alone
      * rather than excusing the paint: only an explicit `false` unmounts, so a
@@ -85,8 +101,7 @@ const BaseViewModel = types
      * that shows up as a slow test rather than as a picture of an empty view.
      */
     get effectiveBodyMounted() {
-        return (self.bodyMounted &&
-            containingViewOf(self)?.effectiveBodyMounted !== false);
+        return this.rendersDisplays && bodyInDom(self);
     },
     /**
      * #method
@@ -94,6 +109,34 @@ const BaseViewModel = types
     menuItems() {
         return [];
     },
+    /**
+     * #getter
+     * The tracks this view puts in the census — its own, not a nested view's.
+     *
+     * Empty here, and overridden by the views that have any: the base cannot
+     * read `self.tracks` for them, because what a view keeps under that name
+     * is the view's business. react-msaview's holds its MSA annotation rows —
+     * `{ReactComponent, model}` objects with no configuration and no displays
+     * — and a base that helped itself to them handed them to the readiness
+     * marker as tracks, which error-paged every session holding an MSA view.
+     */
+    get ownTracks() {
+        return [];
+    },
+    /**
+     * #getter
+     * The views nested directly inside this one, which the census counts as
+     * views in their own right — a synteny stack's genome rows, a breakpoint
+     * split view's panels.
+     *
+     * Empty here for the same reason, and the dotplot is why it has to be a
+     * declaration rather than a walk of `views`: that prop name holds its two
+     * 1D *axis* models, which are view-shaped and are not views the user
+     * opened. No structural test separates the two — only the view knows.
+     */
+    get ownViews() {
+        return [];
+    },
 }))
     .actions(self => ({
     /**

package/esm/pluggableElementTypes/models/InternetAccountModel.d.ts

@@ -20,31 +20,41 @@ export declare const InternetAccount: import("@jbrowse/mobx-state-tree").IModelT
      */
     configuration: import("../../configuration/configurationSchema.ts").IConfigurationReference<import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly name: {
-            readonly description: "descriptive name of the internet account";
-            readonly type: "string";
-            readonly defaultValue: "";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly description: {
-            readonly description: "a description of the internet account";
-            readonly type: "string";
-            readonly defaultValue: "";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly authHeader: {
-            readonly description: "request header for credentials";
-            readonly type: "string";
-            readonly defaultValue: "Authorization";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly tokenType: {
-            readonly description: "a custom name for a token to include in the header";
-            readonly type: "string";
-            readonly defaultValue: "";
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         readonly domains: {
-            readonly description: "array of valid domains the url can contain to use this account";
-            readonly type: "stringArray";
-            readonly defaultValue: readonly [];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId">>>;
+        type: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+        internetAccountId: {
+            type: "string";
+        } & {
+            defaultValue: string;
+        };
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>>;
 }, {
     /**
      * #getter

package/esm/pluggableElementTypes/models/assertDisplayContract.d.ts

@@ -1,8 +1,10 @@
 import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
 /**
- * Dev-only check that a display's fetch foundation attached it exactly once —
- * the one ordering contract here that is a *state* rather than a declaration,
- * so no selector can reach it. No-op in production.
+ * Checks that a display's fetch foundation attached it exactly once — the one
+ * ordering contract here that is a *state* rather than a declaration, so no
+ * selector can reach it. Costs a `WeakSet` lookup, so it runs in a production
+ * build too and reports through `contractReports`, which is silent until
+ * something arms it.
  *
  * Called once per display from **whichever fetch foundation installed its
  * autoruns** — `MultiRegionDisplayMixin`'s `afterAttach` for the per-region
@@ -48,7 +50,7 @@ export type FetchAutorunOutcome =
  * answers nothing either way — the same deferral `awaitingPrerequisite` gets,
  * reached from inside the foundation rather than declared by the display. The
  * per-region family's in-flight-fetch skip is the case: `reload()` signals the
- * running fetch's stop token but `activeStopToken` clears in `runFetch`'s
+ * running fetch's signal but `activeSignal` clears in `runFetch`'s
  * finally, so the very next run can still see `isLoading` — and that fetch
  * ending bumps `fetchGeneration`, which the autorun tracks. Consuming the bump
  * there would answer the retry with a run that predates it.
@@ -58,8 +60,9 @@ interface RetryContractHost {
     reloadCounter: number;
     fetchInert: boolean;
     /**
-     * Optional: the comparative family has no two-stage fetch, so nothing there
-     * declares it. A family that grows one declares it and gets the deferral.
+     * Optional: chord and the breakpoint overlay have no two-stage fetch, so
+     * neither declares it. A fetch that grows one declares it and gets the
+     * deferral.
      */
     awaitingPrerequisite?: boolean;
     /**
@@ -69,14 +72,15 @@ interface RetryContractHost {
      */
     viewportEmpty?: boolean;
 }
-/** Called by `FetchMixin.runFetch`. Dev-only. */
+/** Called by `FetchMixin.runFetch`. */
 export declare function noteFetchStarted(self: object): void;
 /** Reads and clears the flag above, so each check starts from a known state. */
 export declare function takeFetchStarted(self: object): boolean;
 /**
- * Dev-only check that a display's `reload()` can actually reach a fetch — the
- * retry contract, which `DisplayErrorBar` depends on and which no type can
- * state. No-op in production.
+ * Checks that a display's `reload()` can actually reach a fetch — the retry
+ * contract, which `DisplayErrorBar` depends on and which no type can state.
+ * Costs an `untracked` read per autorun run against a fetch, so it runs in a
+ * production build too and reports through `contractReports`.
  *
  * **The button is the contract.** `DisplayErrorBar`'s only action is
  * `model.reload()`, so every state that can raise the error bar has to be one
@@ -89,7 +93,7 @@ export declare function takeFetchStarted(self: object): boolean;
  * has changed. Arc shipped exactly that: a `prepare` declining on `dataCurrent`,
  * with the error clearing on click and no arcs ever coming back. The fix this
  * message asks for is what `GlobalFetchMixin.reload()` now does for that whole
- * family — drop `loadedFetchSignature`, so `dataCurrent` goes false and the
+ * family — drop `loadedFetchKey`, so `dataCurrent` goes false and the
  * gate opens.
  *
  * Detected at the moment it happens rather than statically, because the relation

package/esm/pluggableElementTypes/models/assertDisplayContract.js

@@ -1,19 +1,19 @@
 import { getMembers } from '@jbrowse/mobx-state-tree';
+import { reportContractViolation } from '@jbrowse/render-core/contractReports';
 import { untracked } from 'mobx';
 // Nodes whose fetch foundation has already installed its autoruns. Keyed on the
 // node rather than the model type: every display of a type would otherwise
 // report from the second instance onward.
 const attached = new WeakSet();
 function report(message) {
-    // `console.error`, never `throw`: an error escaping `afterAttach` is read by
-    // the session loader as an invalid track and the display is silently dropped
-    // — which would hide the very contract violation this is reporting.
-    console.error(`[jbrowse display contract] ${message}`);
+    reportContractViolation('display', message);
 }
 /**
- * Dev-only check that a display's fetch foundation attached it exactly once —
- * the one ordering contract here that is a *state* rather than a declaration,
- * so no selector can reach it. No-op in production.
+ * Checks that a display's fetch foundation attached it exactly once — the one
+ * ordering contract here that is a *state* rather than a declaration, so no
+ * selector can reach it. Costs a `WeakSet` lookup, so it runs in a production
+ * build too and reports through `contractReports`, which is silent until
+ * something arms it.
  *
  * Called once per display from **whichever fetch foundation installed its
  * autoruns** — `MultiRegionDisplayMixin`'s `afterAttach` for the per-region
@@ -46,19 +46,17 @@ function report(message) {
  * points nowhere near the cause.
  */
 export function assertDisplayContract(self, installedBy = "the per-region fetch foundation's afterAttach") {
-    if (process.env.NODE_ENV !== 'production') {
-        if (attached.has(self)) {
-            report(`${getMembers(self).name}: ${installedBy} ran twice on one display, ` +
-                `so its fetch autoruns are installed twice (double fetches, double ` +
-                `clears). Our MST fork auto-chains lifecycle hooks, so the usual ` +
-                `cause is a superAfterAttach() call in this display's afterAttach — ` +
-                `delete it. Otherwise this display composes two fetch foundations, ` +
-                `or calls an installer it already gets from a mixin. ` +
-                `See agent-docs/ARCHITECTURE.md §"What not to do".`);
-        }
-        else {
-            attached.add(self);
-        }
+    if (attached.has(self)) {
+        report(`${getMembers(self).name}: ${installedBy} ran twice on one display, ` +
+            `so its fetch autoruns are installed twice (double fetches, double ` +
+            `clears). Our MST fork auto-chains lifecycle hooks, so the usual ` +
+            `cause is a superAfterAttach() call in this display's afterAttach — ` +
+            `delete it. Otherwise this display composes two fetch foundations, ` +
+            `or calls an installer it already gets from a mixin. ` +
+            `See agent-docs/ARCHITECTURE.md §"What not to do".`);
+    }
+    else {
+        attached.add(self);
     }
 }
 // Displays whose fetch has started since the last time the caller looked, and
@@ -85,11 +83,8 @@ export function assertDisplayContract(self, installedBy = "the per-region fetch
 // on the display with the liveliest one.
 const fetchStarted = new WeakSet();
 const ledgers = new WeakMap();
-/** Called by `FetchMixin.runFetch`. Dev-only. */
+/** Called by `FetchMixin.runFetch`. */
 export function noteFetchStarted(self) {
-    if (process.env.NODE_ENV === 'production') {
-        return;
-    }
     fetchStarted.add(self);
     ledgers.get(self)?.('fetched');
 }
@@ -98,9 +93,10 @@ export function takeFetchStarted(self) {
     return fetchStarted.delete(self);
 }
 /**
- * Dev-only check that a display's `reload()` can actually reach a fetch — the
- * retry contract, which `DisplayErrorBar` depends on and which no type can
- * state. No-op in production.
+ * Checks that a display's `reload()` can actually reach a fetch — the retry
+ * contract, which `DisplayErrorBar` depends on and which no type can state.
+ * Costs an `untracked` read per autorun run against a fetch, so it runs in a
+ * production build too and reports through `contractReports`.
  *
  * **The button is the contract.** `DisplayErrorBar`'s only action is
  * `model.reload()`, so every state that can raise the error bar has to be one
@@ -113,7 +109,7 @@ export function takeFetchStarted(self) {
  * has changed. Arc shipped exactly that: a `prepare` declining on `dataCurrent`,
  * with the error clearing on click and no arcs ever coming back. The fix this
  * message asks for is what `GlobalFetchMixin.reload()` now does for that whole
- * family — drop `loadedFetchSignature`, so `dataCurrent` goes false and the
+ * family — drop `loadedFetchKey`, so `dataCurrent` goes false and the
  * gate opens.
  *
  * Detected at the moment it happens rather than statically, because the relation
@@ -195,9 +191,6 @@ export function takeFetchStarted(self) {
  * is worse than the bug being checked for.
  */
 export function makeRetryContractCheck(self) {
-    if (process.env.NODE_ENV === 'production') {
-        return () => { };
-    }
     // eslint-disable-next-line no-restricted-syntax -- instrumentation
     let lastCounter = untracked(() => self.reloadCounter);
     function noteRetryContractOutcome(outcome) {
@@ -229,7 +222,7 @@ export function makeRetryContractCheck(self) {
                     `fetch autorun's gate still declines, so Retry is a dead ` +
                     `button — it clears the error and nothing refetches. reload() has ` +
                     `to invalidate whatever that gate reads, not just bump the ` +
-                    `counter (GlobalFetchMixin.reload drops loadedFetchSignature so ` +
+                    `counter (GlobalFetchMixin.reload drops loadedFetchKey so ` +
                     `dataCurrent goes false). If this display is deliberately not ` +
                     `fetching, say so with fetchInert — the loading scrim and the SVG ` +
                     `export read it too; if this run declined only because a ` +

package/esm/pluggableElementTypes/models/baseConnectionConfig.d.ts

@@ -1,30 +1,34 @@
 import type { Instance } from '@jbrowse/mobx-state-tree';
 /**
  * #config BaseConnection
- * #gotcha A connection config is only a pointer: the hub's track list is
- * fetched when the connection loads and held in memory, and is **not** written
- * into a saved or shared session. Only a track you actually open is stored
- * (under `connectionTrackConfigs`, keyed by `trackId`), which is what keeps a
- * shared session small even against a very large hub.
+ * #gotcha JBrowse fetches the hub's track list when the connection loads and
+ * holds it in memory, and does **not** write it into a saved or shared session.
+ * The session stores only the tracks you open (under `connectionTrackConfigs`,
+ * keyed by `trackId`), so a shared session stays small even for a very large
+ * hub.
  */
 declare const BaseConnectionConfig: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     readonly name: {
-        readonly type: "string";
-        readonly defaultValue: "nameOfConnection";
-        readonly description: "a unique name for this connection";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly assemblyNames: {
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
-        readonly description: "optional list of names of assemblies in this connection";
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId">>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    connectionId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "connectionId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export default BaseConnectionConfig;
 export type BaseConnectionConfigSchema = typeof BaseConnectionConfig;
 export type BaseConnectionConfigModel = Instance<BaseConnectionConfigSchema>;

package/esm/pluggableElementTypes/models/baseConnectionConfig.js

@@ -1,11 +1,11 @@
 import { ConfigurationSchema } from '../../configuration/index.js';
 /**
  * #config BaseConnection
- * #gotcha A connection config is only a pointer: the hub's track list is
- * fetched when the connection loads and held in memory, and is **not** written
- * into a saved or shared session. Only a track you actually open is stored
- * (under `connectionTrackConfigs`, keyed by `trackId`), which is what keeps a
- * shared session small even against a very large hub.
+ * #gotcha JBrowse fetches the hub's track list when the connection loads and
+ * holds it in memory, and does **not** write it into a saved or shared session.
+ * The session stores only the tracks you open (under `connectionTrackConfigs`,
+ * keyed by `trackId`), so a shared session stays small even for a very large
+ * hub.
  */
 const BaseConnectionConfig = ConfigurationSchema('BaseConnection', {
     /**

package/esm/pluggableElementTypes/models/baseInternetAccountConfig.d.ts

@@ -3,44 +3,39 @@
  * the "base" internet account type
  */
 export declare const BaseInternetAccountConfig: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     readonly name: {
-        readonly description: "descriptive name of the internet account";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly description: {
-        readonly description: "a description of the internet account";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly authHeader: {
-        readonly description: "request header for credentials";
-        readonly type: "string";
-        readonly defaultValue: "Authorization";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly tokenType: {
-        readonly description: "a custom name for a token to include in the header";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly domains: {
-        readonly description: "array of valid domains the url can contain to use this account";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId">>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    internetAccountId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "internetAccountId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;