@jbrowse/plugin-linear-genome-view 4.2.1 → 5.0.0-beta.1

package/esm/FeatureTrack/configSchema.d.ts

@@ -1,84 +1,123 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
+/**
+ * #config FeatureTrack
+ * #category track
+ * used for basic gene and feature tracks, generally used with LinearBasicDisplay
+ *
+ * #example
+ * A minimal hand-authored entry in the top-level `tracks` array — `adapter`
+ * points at the data file, and the track opens with a `LinearBasicDisplay`:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.sorted.gff.gz',
+ *   },
+ * }
+ * ```
+ *
+ * #example
+ * The same track, colored. Rather than writing out the full `displays` array,
+ * you can put appearance settings in a `displayDefaults` object — JBrowse works
+ * out which display they belong to and applies them for you (here, the track's
+ * `LinearBasicDisplay`), so you don't have to know display names. A `jexl:`
+ * value gives per-feature coloring:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.sorted.gff.gz',
+ *   },
+ *   displayDefaults: { color: "jexl:feature.type=='CDS'?'red':'blue'" },
+ * }
+ * ```
+ */
 declare const configSchema: (pluginManager: PluginManager) => import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    name: {
-        description: string;
-        type: string;
-        defaultValue: string;
+    readonly name: {
+        readonly description: "descriptive name of the track, falls back to the trackId when unset";
+        readonly type: "string";
+        readonly defaultValue: "";
     };
-    assemblyNames: {
-        description: string;
-        type: string;
-        defaultValue: string[];
+    readonly assemblyNames: {
+        readonly description: "name of the assembly (or assemblies) track belongs to";
+        readonly type: "stringArray";
+        readonly defaultValue: readonly ["assemblyName"];
     };
-    description: {
-        description: string;
-        type: string;
-        defaultValue: string;
+    readonly description: {
+        readonly description: "a description of the track";
+        readonly type: "string";
+        readonly defaultValue: "";
     };
-    category: {
-        description: string;
-        type: string;
-        defaultValue: never[];
+    readonly category: {
+        readonly description: "the category and sub-categories of a track";
+        readonly type: "stringArray";
+        readonly defaultValue: readonly [];
     };
-    metadata: {
-        type: string;
-        description: string;
-        defaultValue: {};
+    readonly metadata: {
+        readonly type: "frozen";
+        readonly description: "anything to add about this track";
+        readonly defaultValue: {};
     };
-    rpcDriverName: {
-        type: string;
-        description: string;
-        defaultValue: string;
-    };
-    adapter: import("@jbrowse/mobx-state-tree").IAnyModelType;
-    textSearching: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        indexingAttributes: {
-            type: string;
-            description: string;
-            defaultValue: string[];
+    readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+    readonly textSearching: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly indexingAttributes: {
+            readonly type: "stringArray";
+            readonly description: "list of which feature attributes to index for text searching";
+            readonly defaultValue: readonly ["Name", "ID", "symbol"];
+        };
+        readonly indexingFeatureTypesToExclude: {
+            readonly type: "stringArray";
+            readonly description: "list of feature types to exclude in text search index";
+            readonly defaultValue: readonly ["CDS", "exon"];
         };
-        indexingFeatureTypesToExclude: {
-            type: string;
-            description: string;
-            defaultValue: string[];
+        readonly indexingFeatureTypesToInclude: {
+            readonly type: "stringArray";
+            readonly description: "the only feature types to index; empty means index every type not excluded";
+            readonly defaultValue: readonly [];
         };
-        textSearchAdapter: import("@jbrowse/mobx-state-tree").IAnyModelType;
+        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").IAnyType;
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-    displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyModelType>;
-    formatDetails: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        feature: {
-            type: string;
-            description: string;
-            defaultValue: {};
-            contextVariable: string[];
+    readonly displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
+    readonly formatDetails: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly feature: {
+            readonly type: "frozen";
+            readonly description: "adds extra fields to the feature details";
+            readonly defaultValue: {};
+            readonly contextVariable: ["feature"];
         };
-        subfeatures: {
-            type: string;
-            description: string;
-            defaultValue: {};
-            contextVariable: string[];
+        readonly subfeatures: {
+            readonly type: "frozen";
+            readonly description: "adds extra fields to the subfeatures of a feature";
+            readonly defaultValue: {};
+            readonly contextVariable: ["feature"];
         };
-        depth: {
-            type: string;
-            defaultValue: number;
-            description: string;
+        readonly depth: {
+            readonly type: "maybeNumber";
+            readonly description: "levels of subfeature the formatDetails.subfeatures callback runs on, default 2";
         };
-        maxDepth: {
-            type: string;
-            defaultValue: number;
-            description: string;
+        readonly maxDepth: {
+            readonly type: "maybeNumber";
+            readonly description: "hide subfeatures nested deeper than this, default no limit";
         };
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
-    formatAbout: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-        config: {
-            type: string;
-            description: string;
-            defaultValue: {};
-            contextVariable: string[];
+    readonly formatAbout: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly config: {
+            readonly type: "frozen";
+            readonly description: "formats configuration object in about dialog";
+            readonly defaultValue: {};
+            readonly contextVariable: ["config"];
         };
-        hideUris: {
-            type: string;
-            defaultValue: boolean;
+        readonly hideUris: {
+            readonly type: "boolean";
+            readonly defaultValue: false;
         };
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "trackId">>, "trackId">>;

package/esm/FeatureTrack/configSchema.js

@@ -1,8 +1,54 @@
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import { createBaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
-function x() { }
+/**
+ * #config FeatureTrack
+ * #category track
+ * used for basic gene and feature tracks, generally used with LinearBasicDisplay
+ *
+ * #example
+ * A minimal hand-authored entry in the top-level `tracks` array — `adapter`
+ * points at the data file, and the track opens with a `LinearBasicDisplay`:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.sorted.gff.gz',
+ *   },
+ * }
+ * ```
+ *
+ * #example
+ * The same track, colored. Rather than writing out the full `displays` array,
+ * you can put appearance settings in a `displayDefaults` object — JBrowse works
+ * out which display they belong to and applies them for you (here, the track's
+ * `LinearBasicDisplay`), so you don't have to know display names. A `jexl:`
+ * value gives per-feature coloring:
+ * ```js
+ * {
+ *   type: 'FeatureTrack',
+ *   trackId: 'genes',
+ *   name: 'Genes',
+ *   assemblyNames: ['hg38'],
+ *   adapter: {
+ *     type: 'Gff3TabixAdapter',
+ *     uri: 'https://example.com/genes.sorted.gff.gz',
+ *   },
+ *   displayDefaults: { color: "jexl:feature.type=='CDS'?'red':'blue'" },
+ * }
+ * ```
+ */
 const configSchema = (pluginManager) => ConfigurationSchema('FeatureTrack', {}, {
+    /**
+     * #baseConfiguration
+     */
     baseConfiguration: createBaseTrackConfig(pluginManager),
+    /**
+     * #identifier
+     */
     explicitIdentifier: 'trackId',
 });
 export default configSchema;

package/esm/FeatureTrack/index.js

@@ -1,5 +1,5 @@
 import { TrackType, createBaseTrackModel, } from '@jbrowse/core/pluggableElementTypes';
-import configSchemaF from "./configSchema.js";
+import configSchemaF from './configSchema.js';
 export default function FeatureTrackF(pm) {
     pm.addTrackType(() => {
         const configSchema = configSchemaF(pm);

package/esm/LaunchLinearGenomeView/index.d.ts

@@ -1,2 +1,16 @@
+import type { InitState, LinearGenomeViewLaunchProps } from '../LinearGenomeView/types.ts';
 import type PluginManager from '@jbrowse/core/PluginManager';
+import type { AbstractViewContainer } from '@jbrowse/core/util';
+export type LaunchLinearGenomeViewArgs = Partial<InitState> & LinearGenomeViewLaunchProps & {
+    session: AbstractViewContainer;
+    id?: string;
+};
+declare module '@jbrowse/core/PluginManager' {
+    interface ExtensionPointRegistry {
+        'LaunchView-LinearGenomeView': {
+            args: LaunchLinearGenomeViewArgs;
+            result: LaunchLinearGenomeViewArgs;
+        };
+    }
+}
 export default function LaunchLinearGenomeViewF(pluginManager: PluginManager): void;

package/esm/LaunchLinearGenomeView/index.js

@@ -1,17 +1,22 @@
+import { linearGenomeViewPropKeys, partitionLaunchKeys, warnUnknownLaunchKeys, } from '../LinearGenomeView/initKeys.js';
 export default function LaunchLinearGenomeViewF(pluginManager) {
-    pluginManager.addToExtensionPoint('LaunchView-LinearGenomeView', async ({ session, assembly, loc, tracks = [], tracklist, nav, highlight, }) => {
-        if (!assembly) {
+    /** #extensionPoint LaunchView-LinearGenomeView | async | Programmatically launch a linear genome view */
+    pluginManager.addToExtensionPoint('LaunchView-LinearGenomeView', args => {
+        const { session, id, ...spec } = args;
+        if (!spec.assembly) {
             throw new Error('No assembly provided when launching linear genome view');
         }
-        session.addView('LinearGenomeView', {
-            init: {
-                assembly,
-                loc,
-                tracks,
-                tracklist,
-                nav,
-                highlight,
-            },
-        });
+        // Resolution keys go into the one-shot `init` blob afterAttach applies and
+        // discards; plain props go straight onto the view snapshot, where MST
+        // restores them natively (and, except for the purely localStorage-backed
+        // showCenterLine, persist on save). Anything in neither set is a typo — MST
+        // drops unknown snapshot keys and `init` is a frozen blob, so nothing
+        // downstream would notice.
+        const { init, viewProps, unknown } = partitionLaunchKeys(spec, linearGenomeViewPropKeys(pluginManager));
+        warnUnknownLaunchKeys('LaunchView-LinearGenomeView', unknown);
+        // A provided id is passed top-level so MST's optional identifier honors it
+        // (undefined falls back to an auto-generated id).
+        session.addView('LinearGenomeView', { id, ...viewProps, init });
+        return args;
     });
 }

package/esm/LinearGenomeView/FloatingSvgOverlay.d.ts

@@ -0,0 +1,5 @@
+export declare const FloatingSvgOverlay: ({ width, height, children, }: {
+    width: number;
+    height: number;
+    children: React.ReactNode;
+}) => import("react").JSX.Element;

package/esm/LinearGenomeView/FloatingSvgOverlay.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TrackOverlayPortal } from '@jbrowse/display-ui';
+import { observer } from 'mobx-react';
+// Lifts an SVG legend / chrome above the inter-region padding masks: a
+// full-track, pointer-events:none <svg> portaled into the TrackContainer overlay
+// node (see TrackOverlayPortal). The SVG counterpart to the HTML overlays
+// (FloatingLegend, HicOverlayPanel) — used where the same legend
+// markup is also drawn by an SVG-export path, so it must stay <svg>.
+//
+// Children draw in <svg> user space; the wrapping <svg> stays pointer-events:none
+// so it doesn't eat canvas events, so any interactive sub-content (a dismiss
+// "×", clickable swatches) must set pointer-events:auto on its own element.
+// fallbackInline={false}: outside a TrackContainer it renders nothing, matching
+// callers whose export path draws its own inline legend.
+export const FloatingSvgOverlay = observer(function FloatingSvgOverlay({ width, height, children, }) {
+    return (_jsx(TrackOverlayPortal, { fallbackInline: false, children: _jsx("svg", { style: {
+                position: 'absolute',
+                top: 0,
+                left: 0,
+                width,
+                height,
+                pointerEvents: 'none',
+                overflow: 'hidden',
+            }, children: children }) }));
+});

package/esm/LinearGenomeView/afterAttach.d.ts

@@ -1,5 +1,23 @@
 import type { LinearGenomeViewModel } from './model.ts';
+import type { InitState } from './types.ts';
+import type { AssemblyHost, NotificationSink } from '@jbrowse/core/util';
+/**
+ * Apply an init blob's `highlight` entries to a view, coercing each locstring
+ * or wire-format object and reporting a bad one without taking out its
+ * siblings.
+ *
+ * Exported because a LinearSyntenyView row is a LinearGenomeView that does NOT
+ * go through this file's init autorun — the synteny view builds each row's
+ * snapshot and navigates it itself — so the row's own `highlight` had nowhere
+ * to be applied and was dropped in silence.
+ */
+export declare function applyInitHighlights(self: LinearGenomeViewModel, session: AssemblyHost & NotificationSink, init: Pick<InitState, 'highlight' | 'assembly'>): void;
+/**
+ * Autorun that handles the init state - navigating to initial location,
+ * showing tracks, etc.
+ */
 export declare function setupInitAutorun(self: LinearGenomeViewModel): void;
-export declare function setupCoarseDynamicBlocksAutorun(self: LinearGenomeViewModel): void;
-export declare function setupLocalStorageAutorun(self: LinearGenomeViewModel): void;
+/**
+ * Sets up all afterAttach autoruns for the LinearGenomeView
+ */
 export declare function doAfterAttach(self: LinearGenomeViewModel): void;