@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/addTrackComponent.d.ts

@@ -0,0 +1,72 @@
+import type PluginManager from '../PluginManager.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+import type { ComponentType } from 'react';
+/**
+ * The slice of the add-track widget model an adapter-specific picker gets. It
+ * is deliberately narrower than the widget's own model: a picker reads which
+ * adapter is selected and contributes config fragments through `mixinData`,
+ * which the widget merges into the track config on submit.
+ */
+export interface AddTrackComponentModel extends IStateTreeNode {
+    assembly: string | undefined;
+    setAssembly: (arg: string) => void;
+    trackAdapterType: string | undefined;
+    mixinData: Record<string, unknown>;
+    setMixinData: (data: Record<string, unknown>) => void;
+}
+export interface AddTrackComponentProps {
+    model: AddTrackComponentModel;
+}
+declare module '../PluginManager.ts' {
+    interface ExtensionPointRegistry {
+        'Core-addTrackComponent': ComponentSlot<AddTrackComponentProps>;
+        'Core-addTrackComponentAdapterTypes': {
+            args: readonly string[];
+            result: readonly string[];
+        };
+    }
+}
+/**
+ * Show `component` in the add-track widget whenever the selected adapter is one
+ * of `adapterTypes`. Wraps `Core-addTrackComponent` so a plugin states only
+ * which adapters it claims, instead of restating the "match or pass the
+ * accumulated component through" fold.
+ *
+ * `ownsAssembly` is the one thing a picker cannot be left to decide by
+ * omission. The widget's own assembly dropdown is *not* rendered for a picker
+ * that claims it, because a synteny picker asks for the assembly **pair** and
+ * two dropdowns disagreeing about which one wins is worse than one. Every other
+ * picker keeps the dropdown above it and contributes only its own fields — the
+ * default, because a picker that simply forgot to render an assembly selector
+ * used to silently remove the only way to choose one.
+ */
+export declare function addAddTrackComponent(pluginManager: PluginManager, { adapterTypes, component, ownsAssembly, }: {
+    adapterTypes: readonly string[];
+    component: ComponentType<AddTrackComponentProps>;
+    /**
+     * The picker asks for the assembly itself, so the widget yields its own
+     * assembly dropdown to it — and a workflow that can only guess from a
+     * filename cannot build this format at all.
+     */
+    ownsAssembly?: boolean;
+}): void;
+/**
+ * Whether a picker supplies this adapter's assembly, i.e. the file alone does
+ * not describe the track. A synteny picker contributes the assembly pair — on
+ * the adapter *and* as the track's `assemblyNames`, because a synteny view only
+ * offers tracks covering every assembly it displays — so a config built without
+ * one lands in the session and then never appears in the view it was made for.
+ *
+ * Two callers, both reading the same fact:
+ *
+ * - The widget hides its own assembly dropdown, leaving the picker to ask.
+ * - Workflows that guess a config straight from a filename and so cannot run
+ *   the picker (bulk add) decline the file and send the user to the
+ *   single-track form.
+ *
+ * A picker contributing only optional fields answers false, and its file adds
+ * like any other. The list is written by `addAddTrackComponent`, so it covers
+ * every plugin that registers one rather than a hardcoded set that goes stale
+ * when the next plugin lands.
+ */
+export declare function adapterNeedsAddTrackComponent(pluginManager: PluginManager, adapterType: string): boolean;

package/esm/util/addTrackComponent.js

@@ -0,0 +1,53 @@
+/**
+ * Show `component` in the add-track widget whenever the selected adapter is one
+ * of `adapterTypes`. Wraps `Core-addTrackComponent` so a plugin states only
+ * which adapters it claims, instead of restating the "match or pass the
+ * accumulated component through" fold.
+ *
+ * `ownsAssembly` is the one thing a picker cannot be left to decide by
+ * omission. The widget's own assembly dropdown is *not* rendered for a picker
+ * that claims it, because a synteny picker asks for the assembly **pair** and
+ * two dropdowns disagreeing about which one wins is worse than one. Every other
+ * picker keeps the dropdown above it and contributes only its own fields — the
+ * default, because a picker that simply forgot to render an assembly selector
+ * used to silently remove the only way to choose one.
+ */
+export function addAddTrackComponent(pluginManager, { adapterTypes, component, ownsAssembly = false, }) {
+    pluginManager.addToExtensionPoint(
+    /** #extensionPoint Core-addTrackComponent | sync | Inject a custom React component into the add-track widget */
+    'Core-addTrackComponent', (accumulated, { model }) => {
+        const type = model.trackAdapterType;
+        return type !== undefined && adapterTypes.includes(type)
+            ? component
+            : accumulated;
+    });
+    if (ownsAssembly) {
+        pluginManager.contributeToExtensionPoint(
+        /** #extensionPoint Core-addTrackComponentAdapterTypes | sync | Adapter types whose add-track picker supplies the assembly */
+        'Core-addTrackComponentAdapterTypes', () => [...adapterTypes]);
+    }
+}
+/**
+ * Whether a picker supplies this adapter's assembly, i.e. the file alone does
+ * not describe the track. A synteny picker contributes the assembly pair — on
+ * the adapter *and* as the track's `assemblyNames`, because a synteny view only
+ * offers tracks covering every assembly it displays — so a config built without
+ * one lands in the session and then never appears in the view it was made for.
+ *
+ * Two callers, both reading the same fact:
+ *
+ * - The widget hides its own assembly dropdown, leaving the picker to ask.
+ * - Workflows that guess a config straight from a filename and so cannot run
+ *   the picker (bulk add) decline the file and send the user to the
+ *   single-track form.
+ *
+ * A picker contributing only optional fields answers false, and its file adds
+ * like any other. The list is written by `addAddTrackComponent`, so it covers
+ * every plugin that registers one rather than a hardcoded set that goes stale
+ * when the next plugin lands.
+ */
+export function adapterNeedsAddTrackComponent(pluginManager, adapterType) {
+    return pluginManager
+        .evaluateExtensionPoint('Core-addTrackComponentAdapterTypes', [])
+        .includes(adapterType);
+}

package/esm/util/addTrackFromWidget.d.ts

@@ -0,0 +1,91 @@
+import type { AssemblyNameResolver } from './tracks.ts';
+import type { AbstractSessionModel, SessionWithPublishTrackConf, TrackContainer } from './types/index.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Whether the target track list currently displays any of the track's
+ * assemblies, i.e. the track can be shown there after adding it.
+ *
+ * Both sides resolve through the aliases, because the two names meeting here
+ * come from different places: the container holds whatever the session opened
+ * the view on, and the config holds whatever its author wrote. `===` read a
+ * track configured against `hg38` as undisplayable in a view on `GRCh38`, so
+ * the add landed and nothing appeared, under a snackbar naming the assembly the
+ * user was looking at as one this view does not have open.
+ */
+export declare function containerDisplaysAssembly(container: {
+    assemblyNames?: readonly string[];
+} | undefined, assemblyNames: readonly (string | undefined)[] | undefined, assemblyManager: AssemblyNameResolver): boolean;
+/** the slice of the add-track widget every workflow's submit path writes to */
+export interface AddTrackWidgetSelf extends IStateTreeNode {
+    /**
+     * Where a submitted track opens: the view, or one track list within it when
+     * the widget was opened from a synteny level's track selector. Not the same
+     * as `view` — a workflow reaching past this for `view` adds the track to the
+     * wrong list.
+     */
+    trackContainer: TrackContainer | undefined;
+    clearData: () => void;
+}
+/**
+ * The slice of the add-track widget a whole workflow gets: the submit path
+ * above plus the assembly it writes into. Structural rather than the widget's
+ * own model type, so a plugin contributing a workflow doesn't take a package
+ * dependency on the plugin that owns the widget.
+ */
+export interface AddTrackWorkflowModel extends AddTrackWidgetSelf {
+    assembly: string | undefined;
+    setAssembly: (arg: string) => void;
+}
+/**
+ * Reset the form and dismiss the widget after a successful add.
+ *
+ * Only ever on an add that landed something: finishing throws away what the
+ * user assembled, so doing it when every config was rejected buries the
+ * snackbars explaining why behind an empty form with nothing to retry from.
+ */
+export declare function finishAddTrack(model: AddTrackWidgetSelf, session: AbstractSessionModel): void;
+/**
+ * Add one track config from an add-track workflow, reveal it, and dismiss the
+ * widget — the tail every workflow shares, so all of them decide "show vs.
+ * warn vs. dismiss" the same way.
+ *
+ * Three things a workflow doing this by hand has got wrong:
+ *
+ * - It shows the track in `model.view`, which is the wrong list when the widget
+ *   was opened from a synteny level's track selector. `trackContainer` is the
+ *   target.
+ * - It shows a track whose assembly the container doesn't display, which is
+ *   silently nothing on screen. Say so instead.
+ * - It dismisses the widget even when `publishTrackConf` rejected the config,
+ *   wiping the form behind the error snackbar.
+ *
+ * **A track on an assembly the view synthesized takes neither destination.** The
+ * widget reads its assembly off the containing view and offers no choice of one
+ * outside it (`setAssembly` lists `session.assemblyNames`, which excludes the
+ * temporary ones), so a user opening a file in a read-vs-ref panel arrives here
+ * naming an assembly that goes back when that view closes — and a session list
+ * would keep the config, once per file, in the snapshot they save and share.
+ * That is ADR-084's leak reached through the widget rather than through a
+ * launcher, so it takes ADR-084's answer: the config rides on the track as
+ * `showTrack`'s `inlineConf`, works for the life of the view, and goes out with
+ * it. The container is the one this assembly came from, so it displays it.
+ *
+ * Returns the added config, or undefined when `publishTrackConf` rejected it — it
+ * has already surfaced its own error, and a second, vaguer snackbar on top of
+ * that helps nobody.
+ */
+export declare function addTrackFromWidget({ model, session, conf, }: {
+    model: AddTrackWidgetSelf;
+    session: AbstractSessionModel;
+    conf: Parameters<SessionWithPublishTrackConf['publishTrackConf']>[0] & {
+        trackId: string;
+        name?: string;
+        assemblyNames?: (string | undefined)[];
+    };
+}): import("../configuration/types.ts").AnyConfigurationModel | (import("@jbrowse/mobx-state-tree").$EmptyObjectBrand & Partial<{
+    [x: string]: any;
+}> & {
+    trackId: string;
+    name?: string;
+    assemblyNames?: (string | undefined)[];
+}) | undefined;

package/esm/util/addTrackFromWidget.js

@@ -0,0 +1,91 @@
+import { coarseStripHTML } from './coarseStripHTML.js';
+import { namesTemporaryAssembly } from './temporaryAssembly.js';
+import { isSameAssemblyName } from './tracks.js';
+import { isSessionModelWithWidgets, isSessionWithPublishTrackConf, } from './types/index.js';
+/**
+ * Whether the target track list currently displays any of the track's
+ * assemblies, i.e. the track can be shown there after adding it.
+ *
+ * Both sides resolve through the aliases, because the two names meeting here
+ * come from different places: the container holds whatever the session opened
+ * the view on, and the config holds whatever its author wrote. `===` read a
+ * track configured against `hg38` as undisplayable in a view on `GRCh38`, so
+ * the add landed and nothing appeared, under a snackbar naming the assembly the
+ * user was looking at as one this view does not have open.
+ */
+export function containerDisplaysAssembly(container, assemblyNames, assemblyManager) {
+    return !!container?.assemblyNames?.some(a => assemblyNames?.some(b => isSameAssemblyName(a, b, assemblyManager)));
+}
+/**
+ * Reset the form and dismiss the widget after a successful add.
+ *
+ * Only ever on an add that landed something: finishing throws away what the
+ * user assembled, so doing it when every config was rejected buries the
+ * snackbars explaining why behind an empty form with nothing to retry from.
+ */
+export function finishAddTrack(model, session) {
+    model.clearData();
+    if (isSessionModelWithWidgets(session)) {
+        session.hideWidget(model);
+    }
+}
+/**
+ * Add one track config from an add-track workflow, reveal it, and dismiss the
+ * widget — the tail every workflow shares, so all of them decide "show vs.
+ * warn vs. dismiss" the same way.
+ *
+ * Three things a workflow doing this by hand has got wrong:
+ *
+ * - It shows the track in `model.view`, which is the wrong list when the widget
+ *   was opened from a synteny level's track selector. `trackContainer` is the
+ *   target.
+ * - It shows a track whose assembly the container doesn't display, which is
+ *   silently nothing on screen. Say so instead.
+ * - It dismisses the widget even when `publishTrackConf` rejected the config,
+ *   wiping the form behind the error snackbar.
+ *
+ * **A track on an assembly the view synthesized takes neither destination.** The
+ * widget reads its assembly off the containing view and offers no choice of one
+ * outside it (`setAssembly` lists `session.assemblyNames`, which excludes the
+ * temporary ones), so a user opening a file in a read-vs-ref panel arrives here
+ * naming an assembly that goes back when that view closes — and a session list
+ * would keep the config, once per file, in the snapshot they save and share.
+ * That is ADR-084's leak reached through the widget rather than through a
+ * launcher, so it takes ADR-084's answer: the config rides on the track as
+ * `showTrack`'s `inlineConf`, works for the life of the view, and goes out with
+ * it. The container is the one this assembly came from, so it displays it.
+ *
+ * Returns the added config, or undefined when `publishTrackConf` rejected it — it
+ * has already surfaced its own error, and a second, vaguer snackbar on top of
+ * that helps nobody.
+ */
+export function addTrackFromWidget({ model, session, conf, }) {
+    if (!isSessionWithPublishTrackConf(session)) {
+        throw new Error("Can't add tracks to this session");
+    }
+    const { trackContainer } = model;
+    if (namesTemporaryAssembly(session, conf)) {
+        if (!trackContainer) {
+            session.notify(`Could not add "${coarseStripHTML(conf.name ?? conf.trackId)}": the view it was being added to has closed, and it uses an assembly that only that view had.`, 'warning');
+            return undefined;
+        }
+        void trackContainer.launchTrack(conf.trackId, {}, {}, conf);
+        finishAddTrack(model, session);
+        return conf;
+    }
+    const added = session.publishTrackConf(conf);
+    if (!added) {
+        return undefined;
+    }
+    if (containerDisplaysAssembly(trackContainer, conf.assemblyNames, session.assemblyManager)) {
+        void trackContainer?.launchTrack(conf.trackId);
+    }
+    else {
+        const assemblies = conf.assemblyNames?.filter(a => !!a) ?? [];
+        session.notify(`Added track "${coarseStripHTML(conf.name ?? conf.trackId)}" to the session, but it was not displayed because it uses ${assemblies.length
+            ? `assembly "${assemblies.join('", "')}"`
+            : 'an assembly'}, which is not open in this view. Open a view for that assembly and use its track selector to display it.`, 'warning');
+    }
+    finishAddTrack(model, session);
+    return added;
+}

package/esm/util/aggregateFieldName.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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;

package/esm/util/aggregateFieldName.js

@@ -0,0 +1,8 @@
+/**
+ * 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}`);
+}

package/esm/util/analytics.d.ts

@@ -1,3 +1,32 @@
-export declare function writeAWSAnalytics(rootModel: any, initialTimeStamp: number, sessionQuery?: string | null): Promise<void>;
-export declare function writeGAAnalytics(rootModel: any, initialTimestamp: number): Promise<void>;
-export declare function doAnalytics(rootModel: any, initialTimestamp: number, initialSessionQuery: string | null | undefined): void;
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+declare global {
+    interface Window {
+        ga?: (...args: unknown[]) => void;
+    }
+}
+type TrackConfig = AnyConfigurationModel & {
+    type: string;
+};
+interface AnalyticsRootModel {
+    jbrowse: {
+        tracks: TrackConfig[];
+        assemblies: unknown[];
+        plugins?: {
+            name?: string;
+        }[];
+    };
+    session?: {
+        sessionTracks: TrackConfig[];
+        views: unknown[];
+    };
+    version: string;
+}
+type AnalyticsRootModelWithConfig = AnalyticsRootModel & {
+    jbrowse: {
+        configuration: AnyConfigurationModel;
+    };
+};
+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 doAnalytics(rootModel: AnalyticsRootModelWithConfig | undefined, initialTimestamp: number, initialSessionQuery: string | null | undefined): void;
+export {};

package/esm/util/analytics.js

@@ -1,80 +1,166 @@
-import { readConfObject } from "../configuration/index.js";
-import { isElectron } from "../util/index.js";
-export async function writeAWSAnalytics(rootModel, initialTimeStamp, sessionQuery) {
+import { effectiveRenderer, getGraphicsCapabilities, } from '@jbrowse/render-core/graphicsCapabilities';
+import { readConfObject } from '../configuration/index.js';
+import { isElectron, rIC } from '../util/index.js';
+// Both writers are fire-and-forget from several call sites, so they swallow
+// their own failures rather than rejecting: a floating rejected promise trips
+// the webpack-dev-server overlay (it listens for unhandledrejection), and an
+// analytics ping is never worth interrupting a session for.
+export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuery) {
     try {
         const url = 'https://analytics.jbrowse.org/api/v1';
-        const multiAssemblyTracks = rootModel.jbrowse.tracks.filter((track) => (readConfObject(track, 'assemblyNames') || []).length > 1).length;
-        const savedSessionCount = Object.keys(localStorage).filter(name => name.includes('localSaved-')).length;
+        const multiAssemblyTracks = rootModel.jbrowse.tracks.filter(track => readConfObject(track, 'assemblyNames').length > 1).length;
+        // The rung createGpuHal built where a display has built one by idle time,
+        // else the ladder's prediction with any page-wide pin applied — so a
+        // session that fell back to Canvas2D is counted as Canvas2D rather than as
+        // what the hardware could have done.
+        const capabilities = await getGraphicsCapabilities();
+        const renderer = effectiveRenderer(capabilities);
+        // The coarse bit only. `glRenderer` names the exact driver and stays local
+        // to the stack-trace dialog, the same line vendor/architecture hold — this
+        // says whether a WebGL2 user is on a rasterizer, which is the population
+        // that pays ~25x Canvas2D on the main thread and the number that decides
+        // whether the ladder should route around it. 'unknown' where nothing probed
+        // or the browser withholds the extension, which must not read as 'false'.
+        const softwareRendering = capabilities.softwareWebgl ?? 'unknown';
         const { jbrowse: config, session, version: ver } = rootModel;
         const { tracks, assemblies, plugins } = config;
+        // stats to be recorded in db
         const stats = {
             ver,
-            'plugins-count': plugins?.length || 0,
-            'plugin-names': plugins?.map((p) => p.name).join(','),
+            'plugins-count': plugins?.length ?? 0,
+            'plugin-names': plugins?.map(p => p.name).join(','),
             'assemblies-count': assemblies.length,
             'tracks-count': tracks.length,
-            'session-tracks-count': session?.sessionTracks.length || 0,
-            'open-views': session?.views.length || 0,
+            'session-tracks-count': session?.sessionTracks.length ?? 0,
+            'open-views': session?.views.length ?? 0,
             'synteny-tracks-count': multiAssemblyTracks,
-            'saved-sessions-count': savedSessionCount,
-            'existing-session-param-type': sessionQuery?.split('-')[0] || 'none',
+            // No `saved-sessions-count`: it counted localStorage keys matching
+            // `localSaved-`, a format nothing has written since autosaved sessions
+            // moved to IndexedDB (`sessionsDB`), so it reported 0 for every user. The
+            // live count is `savedSessionMetadata`, which is web-only and populated by
+            // an async open — reporting it here would race the boot rather than
+            // measure anything, so the field is gone instead of re-sourced.
+            // field if existing session param in query before autogenerated param
+            'existing-session-param-type': sessionQuery?.split('-', 1)[0] || 'none',
+            // screen geometry
             'scn-h': window.screen.height,
             'scn-w': window.screen.width,
+            // window geometry
             'win-h': window.innerHeight,
             'win-w': window.innerWidth,
+            dpr: window.devicePixelRatio,
             electron: isElectron,
-            loadTime: (Date.now() - initialTimeStamp) / 1000,
+            renderer,
+            'software-rendering': softwareRendering,
+            loadTime: (Date.now() - initialTimestamp) / 1000,
             jb2: true,
         };
-        tracks.forEach((track) => {
+        // tallies get processed in the lambda, keyed as e.g. track-types-FeatureTrack
+        const trackTypeCounts = {};
+        for (const track of tracks) {
             const key = `track-types-${track.type}`;
-            stats[key] = stats[key] + 1 || 1;
-        });
-        session?.sessionTracks.forEach((track) => {
+            trackTypeCounts[key] = (trackTypeCounts[key] ?? 0) + 1;
+        }
+        const sessionTrackTypeCounts = {};
+        for (const track of session?.sessionTracks ?? []) {
             const key = `sessionTrack-types-${track.type}`;
-            stats[key] = stats[key] + 1 || 1;
-        });
-        const qs = Object.keys(stats)
-            .map(key => `${key}=${stats[key]}`)
-            .join('&');
+            sessionTrackTypeCounts[key] = (sessionTrackTypeCounts[key] ?? 0) + 1;
+        }
+        Object.assign(stats, trackTypeCounts, sessionTrackTypeCounts);
+        const qs = new URLSearchParams(Object.entries(stats).map(([key, value]) => [key, String(value)])).toString();
         await fetch(`${url}?${qs}`);
     }
     catch (e) {
-        console.error('Failed to write analytics to AWS.', e);
+        console.warn('Failed to write analytics to AWS.', e);
     }
 }
 export async function writeGAAnalytics(rootModel, initialTimestamp) {
-    const jbrowseUser = 'UA-7115575-5';
-    const stats = {
-        'tracks-count': rootModel.jbrowse.tracks.length,
-        ver: rootModel.version,
-        electron: isElectron,
-        loadTime: Date.now() - initialTimestamp,
-        pluginNames: rootModel.jbrowse.plugins?.map((plugin) => plugin.name) || '',
-    };
-    let analyticsScript = "(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){";
-    analyticsScript +=
-        '(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),';
-    analyticsScript +=
-        'm=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)';
-    analyticsScript +=
-        "})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');";
-    analyticsScript += `ga('create', '${jbrowseUser}', 'auto', 'jbrowseTracker');`;
-    const gaData = {};
-    const googleDimensions = 'tracks-count ver electron loadTime pluginNames';
-    for (const [index, key] of googleDimensions.split(/\s+/).entries()) {
-        gaData[`dimension${index + 1}`] = stats[key];
+    try {
+        const jbrowseUser = 'UA-7115575-5';
+        const loadTime = Date.now() - initialTimestamp;
+        // custom dimension/metric indices are wired up on the GA property side, so
+        // this order (tracks-count, ver, electron, loadTime, pluginNames) must stay
+        // dimension1..5
+        const gaData = {
+            dimension1: rootModel.jbrowse.tracks.length, // this is all possible tracks
+            dimension2: rootModel.version,
+            dimension3: isElectron,
+            dimension4: loadTime,
+            dimension5: rootModel.jbrowse.plugins?.map(p => p.name).join(',') ?? '',
+            metric1: Math.round(loadTime),
+        };
+        // Plugin names come from the loaded config and are not trusted content (a
+        // config can be loaded from an arbitrary URL). Only this static bootstrap,
+        // with no interpolated data, is ever parsed as script source; gaData is
+        // handed to ga() as a real JS value afterward so untrusted strings can never
+        // break out of the <script> tag the way interpolating them into it would.
+        const analyticsBootstrap = "(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){" +
+            '(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),' +
+            'm=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)' +
+            "})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');";
+        const analyticsScriptNode = document.createElement('script');
+        analyticsScriptNode.innerHTML = analyticsBootstrap;
+        document.head.append(analyticsScriptNode);
+        window.ga?.('create', jbrowseUser, 'auto', 'jbrowseTracker');
+        window.ga?.('jbrowseTracker.send', 'pageview', gaData);
+    }
+    catch (e) {
+        console.warn('Failed to write analytics to GA.', e);
     }
-    gaData.metric1 = Math.round(stats.loadTime);
-    analyticsScript += `ga('jbrowseTracker.send', 'pageview',${JSON.stringify(gaData)});`;
-    const analyticsScriptNode = document.createElement('script');
-    analyticsScriptNode.innerHTML = analyticsScript;
-    document.getElementsByTagName('head')[0].append(analyticsScriptNode);
 }
+// One pageview per page load, not per pluginManager. jbrowse-web rebuilds the
+// whole pluginManager (and rootModel) whenever plugins change, and StrictMode
+// builds it twice on mount — without this guard each rebuild re-pings AWS and
+// appends another Google Analytics <script> to <head>, inflating pageviews and
+// growing the document on every plugin install.
+let analyticsSent = false;
 export function doAnalytics(rootModel, initialTimestamp, initialSessionQuery) {
     if (rootModel &&
+        !analyticsSent &&
         !readConfObject(rootModel.jbrowse.configuration, 'disableAnalytics')) {
-        writeAWSAnalytics(rootModel, initialTimestamp, initialSessionQuery);
-        writeGAAnalytics(rootModel, initialTimestamp);
+        analyticsSent = true;
+        // writeGAAnalytics injects Google's scripts and writeAWSAnalytics probes
+        // graphics capabilities, hundreds of ms of main-thread work together. Idle
+        // time alone is not late enough: a load spends most of its time idle,
+        // waiting on the network, so rIC ran them mid-boot. The writers measure
+        // loadTime up to when they run, so the start they get is moved forward by
+        // the wait, and loadTime still ends here.
+        const calledAt = Date.now();
+        afterAppReady(() => {
+            rIC(() => {
+                const start = initialTimestamp + (Date.now() - calledAt);
+                void writeAWSAnalytics(rootModel, start, initialSessionQuery);
+                void writeGAAnalytics(rootModel, start);
+            });
+        });
     }
 }
+// `[data-app-phase="ready"]`, or a timeout for a page that never shows one
+// (Desktop's start screen)
+function afterAppReady(callback, maxWaitMs = 10_000) {
+    const isReady = () => document.querySelector('[data-app-phase="ready"]') !== null;
+    if (isReady()) {
+        callback();
+        return;
+    }
+    let done = false;
+    const finish = () => {
+        if (!done) {
+            done = true;
+            observer.disconnect();
+            clearTimeout(timer);
+            callback();
+        }
+    };
+    const observer = new MutationObserver(() => {
+        if (isReady()) {
+            finish();
+        }
+    });
+    const timer = setTimeout(finish, maxWaitMs);
+    observer.observe(document.body, {
+        subtree: true,
+        childList: true,
+        attributeFilter: ['data-app-phase'],
+    });
+}

package/esm/util/animationAllowed.d.ts

@@ -0,0 +1,26 @@
+import type { AnimationMode } from './types/index.ts';
+/**
+ * Whether a motion may play at all, before anything about what would move is
+ * consulted: a frame clock has to exist, and the resolved animation mode has to
+ * allow motion — 'enabled' always does, 'disabled' never does, and 'system'
+ * honors the OS prefers-reduced-motion setting, so reduced-motion users get
+ * instant snaps unless they explicitly opt in. The mode comes from the session
+ * preference (`configuration.preferences.animationMode` + user override), which
+ * is `getSession(self).animationMode`.
+ *
+ * In core rather than beside either caller because the two that ask are a
+ * feature-layout morph in the canvas plugin and a viewport flight in the LGV,
+ * and a second copy of this check is a second answer to "does this user want
+ * motion" — the one a reduced-motion reader notices when only half the app
+ * honors it.
+ */
+export declare function animationAllowed(mode: AnimationMode): boolean;
+/** how long a layout morph takes from where it drew to where it now draws */
+export declare const MORPH_DURATION_MS = 300;
+export declare function easeInOutCubic(t: number): number;
+/**
+ * The wall clock a morph is timed on. Falls back to the epoch clock rather than
+ * a constant where `performance` is missing: a clock that never advances
+ * leaves a frame loop at progress 0 forever.
+ */
+export declare function morphClockMs(): number;

package/esm/util/animationAllowed.js

@@ -0,0 +1,35 @@
+/**
+ * Whether a motion may play at all, before anything about what would move is
+ * consulted: a frame clock has to exist, and the resolved animation mode has to
+ * allow motion — 'enabled' always does, 'disabled' never does, and 'system'
+ * honors the OS prefers-reduced-motion setting, so reduced-motion users get
+ * instant snaps unless they explicitly opt in. The mode comes from the session
+ * preference (`configuration.preferences.animationMode` + user override), which
+ * is `getSession(self).animationMode`.
+ *
+ * In core rather than beside either caller because the two that ask are a
+ * feature-layout morph in the canvas plugin and a viewport flight in the LGV,
+ * and a second copy of this check is a second answer to "does this user want
+ * motion" — the one a reduced-motion reader notices when only half the app
+ * honors it.
+ */
+export function animationAllowed(mode) {
+    const hasFrameClock = typeof requestAnimationFrame === 'function';
+    const prefersReduced = typeof matchMedia === 'function' &&
+        matchMedia('(prefers-reduced-motion: reduce)').matches;
+    return (hasFrameClock &&
+        (mode === 'enabled' || (mode === 'system' && !prefersReduced)));
+}
+/** how long a layout morph takes from where it drew to where it now draws */
+export const MORPH_DURATION_MS = 300;
+export function easeInOutCubic(t) {
+    return t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+}
+/**
+ * The wall clock a morph is timed on. Falls back to the epoch clock rather than
+ * a constant where `performance` is missing: a clock that never advances
+ * leaves a frame loop at progress 0 forever.
+ */
+export function morphClockMs() {
+    return typeof performance === 'undefined' ? Date.now() : performance.now();
+}