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

package/esm/util/mstUtils.d.ts

@@ -1,5 +1,5 @@
 import type PluginManager from '../PluginManager.ts';
-import type { AbstractDisplayModel, AbstractSessionModel, AbstractTrackModel, AbstractViewModel } from './types/index.ts';
+import type { AbstractDisplayModel, AbstractSessionModel, AbstractViewContainer, AbstractTrackModel, AbstractViewModel } from './types/index.ts';
 import type { AssemblyHost, RenderingServices } from './types/renderingServices.ts';
 import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
 export { findParentThat, findParentThatIs, getRpcSessionId, } from './parentWalk.ts';
@@ -49,33 +49,30 @@ export declare function getRenderingServices(node: IAnyStateTreeNode): Rendering
 /**
  * #api core/util
  * Resolve user-authored refName text against the assembly of the view
- * containing `node` — the one normalization layer, which resolves aliases and
- * casing together. Falls back to the input when the assembly is absent or its
- * aliases have not loaded.
+ * containing `node`, resolving aliases and casing together. Falls back to the
+ * input when the assembly is absent or its aliases have not loaded.
  *
- * Keyed off the VIEW's assembly rather than the track's, because the view is
- * what the comparison is against: displayed regions, loaded regions and blocks
- * all carry the refNames the view laid out.
+ * Uses the view's assembly, not the track's, because displayed regions, loaded
+ * regions and blocks all carry the refNames the view laid out.
  *
- * Reach for this wherever a refName a *person* wrote is about to be compared
- * against regions, features or blocks, which carry the assembly's canonical
- * name. A refName a display copied off a region is canonical already and needs
- * nothing; one that arrived in a session spec, a config slot or a URL is
- * whatever the author read out of the location box.
+ * Call it wherever a refName a *person* wrote is about to be compared against
+ * regions, features or blocks, which carry the assembly's canonical name. A
+ * refName a display copied off a region is already canonical. One from a
+ * session spec, a config slot or a URL is whatever the author typed.
  *
- * Skipping it fails silently and, worse, assembly-dependently: `chr12` matches
- * on an assembly canonicalized `chr12` and matches nothing on one canonicalized
- * `12`, so the same spec key works on one config and quietly does nothing on
- * the next, with no error for anyone to act on.
+ * Without it, matching depends on the assembly: `chr12` matches on an assembly
+ * canonicalized `chr12` and matches nothing on one canonicalized `12`. The
+ * same spec key works on one config and does nothing on the next, with no
+ * error.
  *
- * Resolves through `getCanonicalRefName2`, whose fallback is what keeps a spec
- * read before the alias file has loaded from throwing — and the getters that
- * read user specs do run from the first render.
+ * Resolves through `getCanonicalRefName2`, which falls back to the input
+ * instead of throwing when a spec is read before the alias file has loaded.
+ * The getters that read user specs run from the first render.
  *
- * Takes a refName, not a spec that might hold one: the resolver reads
- * `refName.toLowerCase()`, so anything else throws once the aliases are there,
- * and a caller reading an untyped `frozen` slot has to establish that it names
- * a refName at all before this is the right question to ask of it.
+ * Takes a refName, not a spec that might hold one. The resolver calls
+ * `refName.toLowerCase()`, so any other value throws once the aliases have
+ * loaded, and a caller reading an untyped `frozen` slot must first check that
+ * the value is a refName.
  */
 export declare function canonicalizeViewRefName(node: IAnyStateTreeNode, refName: string): string;
 /**
@@ -85,5 +82,16 @@ export declare function canonicalizeViewRefName(node: IAnyStateTreeNode, refName
 export declare function getEnv(obj: IAnyStateTreeNode): {
     pluginManager: PluginManager;
 };
+/**
+ * #api core/util
+ * `addOrReplaceView` for view types whose state model may be lazily loaded;
+ * the synchronous `addOrReplaceView` requires it loaded already.
+ */
+export declare function launchOrReplaceView(args: {
+    session: AbstractViewContainer;
+    typeName: string;
+    initialState?: Record<string, unknown>;
+    replacing?: AbstractViewModel;
+}): Promise<AbstractViewModel>;
 export declare function hashCode(str: string): number;
 export declare function objectHash(obj: object): string;

package/esm/util/mstUtils.js

@@ -1,6 +1,6 @@
-import { getEnv as getEnvMST } from '@jbrowse/mobx-state-tree';
+import { getEnv as getEnvMST, isStateTreeNode } from '@jbrowse/mobx-state-tree';
 import { cachedParent, findParentThatIs } from './parentWalk.js';
-import { isDisplayModel, isSessionModel, isTrackModel, isViewModel, } from './types/index.js';
+import { addOrReplaceView, isDisplayModel, isSessionModel, isTrackModel, isViewModel, } from './types/index.js';
 export { findParentThat, findParentThatIs, getRpcSessionId, } from './parentWalk.js';
 const containingDisplayCache = new WeakMap();
 const containingTrackCache = new WeakMap();
@@ -64,33 +64,30 @@ export function getRenderingServices(node) {
 /**
  * #api core/util
  * Resolve user-authored refName text against the assembly of the view
- * containing `node` — the one normalization layer, which resolves aliases and
- * casing together. Falls back to the input when the assembly is absent or its
- * aliases have not loaded.
+ * containing `node`, resolving aliases and casing together. Falls back to the
+ * input when the assembly is absent or its aliases have not loaded.
  *
- * Keyed off the VIEW's assembly rather than the track's, because the view is
- * what the comparison is against: displayed regions, loaded regions and blocks
- * all carry the refNames the view laid out.
+ * Uses the view's assembly, not the track's, because displayed regions, loaded
+ * regions and blocks all carry the refNames the view laid out.
  *
- * Reach for this wherever a refName a *person* wrote is about to be compared
- * against regions, features or blocks, which carry the assembly's canonical
- * name. A refName a display copied off a region is canonical already and needs
- * nothing; one that arrived in a session spec, a config slot or a URL is
- * whatever the author read out of the location box.
+ * Call it wherever a refName a *person* wrote is about to be compared against
+ * regions, features or blocks, which carry the assembly's canonical name. A
+ * refName a display copied off a region is already canonical. One from a
+ * session spec, a config slot or a URL is whatever the author typed.
  *
- * Skipping it fails silently and, worse, assembly-dependently: `chr12` matches
- * on an assembly canonicalized `chr12` and matches nothing on one canonicalized
- * `12`, so the same spec key works on one config and quietly does nothing on
- * the next, with no error for anyone to act on.
+ * Without it, matching depends on the assembly: `chr12` matches on an assembly
+ * canonicalized `chr12` and matches nothing on one canonicalized `12`. The
+ * same spec key works on one config and does nothing on the next, with no
+ * error.
  *
- * Resolves through `getCanonicalRefName2`, whose fallback is what keeps a spec
- * read before the alias file has loaded from throwing — and the getters that
- * read user specs do run from the first render.
+ * Resolves through `getCanonicalRefName2`, which falls back to the input
+ * instead of throwing when a spec is read before the alias file has loaded.
+ * The getters that read user specs run from the first render.
  *
- * Takes a refName, not a spec that might hold one: the resolver reads
- * `refName.toLowerCase()`, so anything else throws once the aliases are there,
- * and a caller reading an untyped `frozen` slot has to establish that it names
- * a refName at all before this is the right question to ask of it.
+ * Takes a refName, not a spec that might hold one. The resolver calls
+ * `refName.toLowerCase()`, so any other value throws once the aliases have
+ * loaded, and a caller reading an untyped `frozen` slot must first check that
+ * the value is a refName.
  */
 export function canonicalizeViewRefName(node, refName) {
     const { assemblyManager } = getSession(node);
@@ -105,6 +102,24 @@ export function canonicalizeViewRefName(node, refName) {
 export function getEnv(obj) {
     return getEnvMST(obj);
 }
+/**
+ * #api core/util
+ * `addOrReplaceView` for view types whose state model may be lazily loaded;
+ * the synchronous `addOrReplaceView` requires it loaded already.
+ */
+export async function launchOrReplaceView(args) {
+    // a test's fake session is not an MST node; addView's own guard is the
+    // error path there
+    if (isStateTreeNode(args.session)) {
+        const { pluginManager } = getEnvMST(args.session);
+        await pluginManager?.getViewType(args.typeName).loadStateModel();
+        // the displays of the tracks a launch opens with are dynamic imports too
+        await pluginManager?.preloadSessionTypes({
+            views: [{ type: args.typeName, ...args.initialState }],
+        });
+    }
+    return addOrReplaceView(args);
+}
 export function hashCode(str) {
     let hash = 0;
     if (str.length === 0) {

package/esm/util/numericUtils.d.ts

@@ -10,6 +10,13 @@ export declare function getNumberGrouping(): boolean;
 export declare function toLocale(n: number): string;
 export declare function toPrecision(s: number, n?: number): number;
 export declare function reducePrecision(s: number, n?: number): string;
+/**
+ * A score as a guide prints it: three significant figures below 100, whole
+ * numbers above, trailing fractional zeros dropped. The decimal-point guard
+ * matters because toPrecision can round up out of the fractional form —
+ * 99.95 comes back as "100", where a bare trailing-zero strip would report 1.
+ */
+export declare function formatScore(n: number): string;
 /**
  * A byte count as a person reads it. Shared by the region-too-large banner and
  * the save-track-data dialog, which quote the same index estimate and would

package/esm/util/numericUtils.js

@@ -98,6 +98,22 @@ export function toPrecision(s, n = 3) {
 export function reducePrecision(s, n = 3) {
     return toLocale(toPrecision(s, n));
 }
+/**
+ * A score as a guide prints it: three significant figures below 100, whole
+ * numbers above, trailing fractional zeros dropped. The decimal-point guard
+ * matters because toPrecision can round up out of the fractional form —
+ * 99.95 comes back as "100", where a bare trailing-zero strip would report 1.
+ */
+export function formatScore(n) {
+    if (n === 0) {
+        return '0';
+    }
+    if (Math.abs(n) >= 100) {
+        return n.toFixed(0);
+    }
+    const s = n.toPrecision(3);
+    return s.includes('.') ? s.replace(/\.?0+$/, '') : s;
+}
 /**
  * A byte count as a person reads it. Shared by the region-too-large banner and
  * the save-track-data dialog, which quote the same index estimate and would

package/esm/util/numericValue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A field's value as the number a quantitative channel or step reads, `NaN`
+ * where it holds none. `Number()` answers 0 for `null`, `''`, `[]` and
+ * `[null]` — a VCF's `DP=.` arrives as the last — which plots a missing value
+ * as a measured zero. A one-element list is its element, as a VCF INFO value
+ * is; a string has to hold digits; anything else is not a number.
+ *
+ * The order is the measurement: a number returns first, and a string converts
+ * before its blank check, which runs only on a zero. Over a million features
+ * against `Number()`, interleaved in one process: numbers 0.98x, strings
+ * 1.00-1.02x, one-element lists 0.28x. Testing the list first and trimming
+ * every string measured 1.11-1.16x on a string column.
+ */
+export declare function numericValue(value: unknown): number;

package/esm/util/numericValue.js

@@ -0,0 +1,34 @@
+function textNumber(text) {
+    const n = Number(text);
+    return n === 0 && text.trim() === '' ? Number.NaN : n;
+}
+/**
+ * A field's value as the number a quantitative channel or step reads, `NaN`
+ * where it holds none. `Number()` answers 0 for `null`, `''`, `[]` and
+ * `[null]` — a VCF's `DP=.` arrives as the last — which plots a missing value
+ * as a measured zero. A one-element list is its element, as a VCF INFO value
+ * is; a string has to hold digits; anything else is not a number.
+ *
+ * The order is the measurement: a number returns first, and a string converts
+ * before its blank check, which runs only on a zero. Over a million features
+ * against `Number()`, interleaved in one process: numbers 0.98x, strings
+ * 1.00-1.02x, one-element lists 0.28x. Testing the list first and trimming
+ * every string measured 1.11-1.16x on a string column.
+ */
+export function numericValue(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return textNumber(value);
+    }
+    if (Array.isArray(value) && value.length === 1) {
+        const v = value[0];
+        return typeof v === 'number'
+            ? v
+            : typeof v === 'string'
+                ? textNumber(v)
+                : Number.NaN;
+    }
+    return Number.NaN;
+}

package/esm/util/openFeatureWidget.d.ts

@@ -5,10 +5,15 @@ export interface FeatureWidgetTypeRef {
     type: string;
     id: string;
 }
+export interface ParentFeatureSummary {
+    name: string;
+    type?: string;
+}
 export declare function openFeatureWidget(node: IAnyStateTreeNode, featureData: SimpleFeatureSerialized, opts?: {
     widget?: FeatureWidgetTypeRef;
     extra?: Record<string, unknown>;
     feature?: Feature;
+    parentFeature?: ParentFeatureSummary;
 }): Widget | undefined;
 /**
  * The other half of the flow above: the details lookup came back with nothing,

package/esm/util/openFeatureWidget.js

@@ -30,13 +30,13 @@ export function openFeatureWidget(node, featureData, opts = {}) {
     }
     session.setSelection(opts.feature ?? new SimpleFeature(featureData));
     const { type, id } = opts.widget ?? DEFAULT_FEATURE_WIDGET;
-    const widget = session.addWidget(type, id, {
+    const widget = session.openWidget(type, id, {
         featureData,
+        parentFeature: opts.parentFeature,
         view: getContainingView(node),
         track: getContainingTrack(node),
         ...opts.extra,
     });
-    session.showWidget(widget);
     return widget;
 }
 /**

package/esm/util/openViews.d.ts

@@ -0,0 +1,17 @@
+import type { AbstractSessionModel, AbstractTrackModel, AbstractViewModel } from './types/index.ts';
+/**
+ * "What is open" — the reduction four consumers wanted and each used to walk
+ * for itself (AppReadyMarker, jbApi, and capture's session gate and busy
+ * check), on different and drifting spellings of the view nesting.
+ *
+ * The recursion lives here, once. What each view contributes lives on the view,
+ * once, as `ownViews`/`ownTracks`. Neither half guesses at the other: the
+ * census is declared intent, not a shape that can be discovered, because the
+ * two things that look enumerable are not — the dotplot's `views` prop holds
+ * view-shaped axis models the user never opened, and react-msaview's `tracks`
+ * getter holds annotation rows that are not tracks.
+ */
+export declare function openViews(session: AbstractSessionModel): AbstractViewModel[];
+/** Every track on every open view. */
+export declare function openTracks(session: AbstractSessionModel): AbstractTrackModel[];
+export declare function viewAndNested(view: AbstractViewModel): AbstractViewModel[];

package/esm/util/openViews.js

@@ -0,0 +1,22 @@
+/**
+ * "What is open" — the reduction four consumers wanted and each used to walk
+ * for itself (AppReadyMarker, jbApi, and capture's session gate and busy
+ * check), on different and drifting spellings of the view nesting.
+ *
+ * The recursion lives here, once. What each view contributes lives on the view,
+ * once, as `ownViews`/`ownTracks`. Neither half guesses at the other: the
+ * census is declared intent, not a shape that can be discovered, because the
+ * two things that look enumerable are not — the dotplot's `views` prop holds
+ * view-shaped axis models the user never opened, and react-msaview's `tracks`
+ * getter holds annotation rows that are not tracks.
+ */
+export function openViews(session) {
+    return session.views.flatMap(viewAndNested);
+}
+/** Every track on every open view. */
+export function openTracks(session) {
+    return openViews(session).flatMap(v => v.ownTracks ?? []);
+}
+export function viewAndNested(view) {
+    return [view, ...(view.ownViews ?? []).flatMap(viewAndNested)];
+}

package/esm/util/parentWalk.d.ts

@@ -14,7 +14,7 @@ export declare function findParentThatIs<T extends (a: IAnyStateTreeNode) => boo
  * Keying on the node is safe because nothing re-parents one — both `detach`
  * call sites hand the node straight to `scheduleDetachedDestroy` (ADR-069), so
  * a cached ancestor can only go stale by dying, which the `isAlive` check
- * catches. That is the difference from the three memos REJECTED_IDEAS records
+ * catches. That is the difference from the three memos agent-docs/architecture-decision-records/ records
  * removing: each keyed on something its caller had just allocated.
  */
 export declare function cachedParent<T>(cache: WeakMap<IAnyStateTreeNode, T>, node: IAnyStateTreeNode, finder: () => T, errorMsg: string): T;

package/esm/util/parentWalk.js

@@ -39,7 +39,7 @@ export function findParentThatIs(node, predicate) {
  * Keying on the node is safe because nothing re-parents one — both `detach`
  * call sites hand the node straight to `scheduleDetachedDestroy` (ADR-069), so
  * a cached ancestor can only go stale by dying, which the `isAlive` check
- * catches. That is the difference from the three memos REJECTED_IDEAS records
+ * catches. That is the difference from the three memos agent-docs/architecture-decision-records/ records
  * removing: each keyed on something its caller had just allocated.
  */
 export function cachedParent(cache, node, finder, errorMsg) {

package/esm/util/parseLineByLine.d.ts

@@ -1,6 +1,5 @@
 import { IntervalTree } from './IntervalTree.ts';
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 export type { StatusCallback };
 export type LineCallback = (line: string, lineIndex: number) => boolean | undefined;
 /**
@@ -36,11 +35,11 @@ export declare function makeFeatureIntervalTreeMap<T extends {
  *   contract is built on ("no channel, skip the bookkeeping"), and it used to
  *   default to `() => {}`, which says the opposite.
  * @param opts - `label` names the phase on the progress bar (a multi-phase
- *   adapter wants "Parsing PAF", not another "Loading" indistinguishable from
- *   the download that preceded it); `stopToken` makes a multi-GB parse
- *   interruptible instead of running to completion after a cancel.
+ *   adapter wants "Processing alignments", not another "Loading" indistinguishable from
+ *   the download that preceded it); `signal` is read on every line, but the
+ *   parse never yields, so it sees only an abort that landed before it began.
  */
 export declare function parseLineByLine(buffer: Uint8Array, lineCallback: LineCallback, statusCallback: StatusCallback | undefined, opts?: {
     label?: string;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
 }): void;

package/esm/util/parseLineByLine.js

@@ -96,22 +96,18 @@ function chunkBoundary(buffer, start) {
  *   contract is built on ("no channel, skip the bookkeeping"), and it used to
  *   default to `() => {}`, which says the opposite.
  * @param opts - `label` names the phase on the progress bar (a multi-phase
- *   adapter wants "Parsing PAF", not another "Loading" indistinguishable from
- *   the download that preceded it); `stopToken` makes a multi-GB parse
- *   interruptible instead of running to completion after a cancel.
+ *   adapter wants "Processing alignments", not another "Loading" indistinguishable from
+ *   the download that preceded it); `signal` is read on every line, but the
+ *   parse never yields, so it sees only an abort that landed before it began.
  */
 export function parseLineByLine(buffer, lineCallback, statusCallback, opts = {}) {
-    const { label = 'Loading', stopToken } = opts;
+    const { label = 'Loading', signal } = opts;
     const decoder = new TextDecoder('utf8');
-    // Time-gated, not gated on a line counter: a file of few but very expensive
-    // lines would never reach a count mask, freezing the bar at 0% for the whole
-    // parse (the failure createProgressReporter documents). The stop-token check
-    // rides the same tick, so cancellation lands within one window.
     const report = createProgressReporter({
         label,
         total: buffer.length,
         statusCallback,
-        stopToken,
+        signal,
     });
     let chunkStart = 0;
     let i = 0;
@@ -140,11 +136,9 @@ export function parseLineByLine(buffer, lineCallback, statusCallback, opts = {})
                     }
                 }
                 i++;
-                // Chunk-granular position, not line-granular: `report` is called every
-                // line so cancellation still lands within one throttle window, but the
-                // byte offset it publishes only advances per chunk. Interpolating
-                // within the chunk would mean converting a UTF-16 offset back to a byte
-                // offset, and at 64KB the bar already moves in sub-percent steps.
+                // Chunk-granular position: interpolating within the chunk would mean
+                // converting a UTF-16 offset back to a byte offset, and at 64KB the bar
+                // already moves in sub-percent steps.
                 report(chunkStart);
                 p = lineEnd + 1;
             }

package/esm/util/pluginStore.d.ts

@@ -10,14 +10,11 @@ import type { JBrowsePlugin } from './types/data.ts';
  *
  * Two independent reasons to hide an entry:
  *
- * - **No build this product can load.** Web runs ESM/UMD; a CJS-only entry needs
- *   Node's `require`, so only Desktop can install it. Asked of every build the
- *   entry publishes rather than only the top-level urls — an entry that pins urls
- *   per version, which `resolvePlugin`'s fallback exists to accommodate, used to
- *   vanish from Web's list with no diagnostic. An entry whose *resolved* build is
- *   the CJS-only one is still shown, since that is a fact about this JBrowse
- *   version rather than about the product, and PluginStoreCard already has a
- *   place to say so.
+ * - **No build at all.** Asked of every build the entry publishes rather than
+ *   only the top-level urls — an entry that pins urls per version, which
+ *   `resolvePlugin`'s fallback exists to accommodate, used to vanish from the
+ *   list with no diagnostic. Both products load the same two formats, so this
+ *   half no longer differs between them.
  * - **Already vendored into this product's core bundle**, where installing does
  *   nothing because `dropVendoredPlugins` drops the definition at load. Desktop's
  *   half of that list counts too, and is the half both surfaces were missing.
@@ -34,6 +31,7 @@ export interface PluginUpdate {
     name: string;
     definition: PluginDefinition;
 }
+export declare function releaseVersion(jbrowseVersion: string): string;
 export declare function resolvePlugin(plugin: JBrowsePlugin, jbrowseVersion: string): ResolvedPlugin;
 export declare function installedVersionFromUrl(url: string | undefined, packageName: string | undefined): string | undefined;
 /**

package/esm/util/pluginStore.js

@@ -16,14 +16,11 @@ function publishedBuilds(plugin) {
  *
  * Two independent reasons to hide an entry:
  *
- * - **No build this product can load.** Web runs ESM/UMD; a CJS-only entry needs
- *   Node's `require`, so only Desktop can install it. Asked of every build the
- *   entry publishes rather than only the top-level urls — an entry that pins urls
- *   per version, which `resolvePlugin`'s fallback exists to accommodate, used to
- *   vanish from Web's list with no diagnostic. An entry whose *resolved* build is
- *   the CJS-only one is still shown, since that is a fact about this JBrowse
- *   version rather than about the product, and PluginStoreCard already has a
- *   place to say so.
+ * - **No build at all.** Asked of every build the entry publishes rather than
+ *   only the top-level urls — an entry that pins urls per version, which
+ *   `resolvePlugin`'s fallback exists to accommodate, used to vanish from the
+ *   list with no diagnostic. Both products load the same two formats, so this
+ *   half no longer differs between them.
  * - **Already vendored into this product's core bundle**, where installing does
  *   nothing because `dropVendoredPlugins` drops the definition at load. Desktop's
  *   half of that list counts too, and is the half both surfaces were missing.
@@ -34,8 +31,14 @@ export function installablePlugins(plugins, isElectron) {
         ...(isElectron ? desktopVendoredPluginNames : []),
     ]);
     return plugins.filter(plugin => !vendored.has(plugin.name) &&
-        (isElectron ||
-            publishedBuilds(plugin).some(b => b.esmUrl ?? b.url ?? b.umdUrl)));
+        publishedBuilds(plugin).some(b => b.esmUrl ?? b.url ?? b.umdUrl));
+}
+// A prerelease host is its release for compatibility purposes. Under semver
+// 5.0.0-beta.1 sorts below 5.0.0, so a range written to keep a plugin off v5
+// (`<5.0.0`) would serve it to every beta host and a v5-only range (`>=5.0.0`)
+// would hide it from them. Store ranges are written against release versions.
+export function releaseVersion(jbrowseVersion) {
+    return jbrowseVersion.split('-')[0];
 }
 // `*` (and empty) mean "any JBrowse version"; compare-versions throws on those,
 // so handle them directly. A malformed range simply fails to match rather than
@@ -44,7 +47,7 @@ function rangeMatches(jbrowseVersion, range) {
     let matched = range === '*' || range === '';
     if (!matched) {
         try {
-            matched = satisfies(jbrowseVersion, range);
+            matched = satisfies(releaseVersion(jbrowseVersion), range);
         }
         catch {
             matched = false;
@@ -61,11 +64,9 @@ function definitionFrom(name, src) {
         ? { name, umdUrl: src.umdUrl, ...integrity }
         : src.esmUrl !== undefined
             ? { esmUrl: src.esmUrl }
-            : src.cjsUrl !== undefined
-                ? { cjsUrl: src.cjsUrl }
-                : src.url !== undefined
-                    ? { name, url: src.url, ...integrity }
-                    : undefined;
+            : src.url !== undefined
+                ? { name, url: src.url, ...integrity }
+                : undefined;
 }
 function highestVersion(versions) {
     return [...versions].sort((a, b) => compareVersions(b.pluginVersion, a.pluginVersion))[0];

package/esm/util/preloadComponent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Start loading a component made by `lazyWithPreload`; any other component is
+ * left alone. React-free, so an eagerly evaluated module can call it.
+ */
+export declare function preloadComponent(component: unknown): void;

package/esm/util/preloadComponent.js

@@ -0,0 +1,11 @@
+/**
+ * Start loading a component made by `lazyWithPreload`; any other component is
+ * left alone. React-free, so an eagerly evaluated module can call it.
+ */
+export function preloadComponent(component) {
+    const { preload } = (component ?? {});
+    if (typeof preload === 'function') {
+        ;
+        preload().catch(() => { });
+    }
+}