@jbrowse/product-core 4.3.0 → 5.0.0-beta.10

package/esm/Session/Preferences.js

@@ -0,0 +1,58 @@
+import { localStorageGetItem, localStorageSetItem, setNumberGrouping, } from '@jbrowse/core/util';
+import { freezeDeep } from '@jbrowse/core/util/freezeDeep';
+import { addDisposer, types } from '@jbrowse/mobx-state-tree';
+import { autorun } from 'mobx';
+import { BaseSessionModel } from './BaseSession.js';
+import { applyDeveloperMode } from './developerMode.js';
+const PREFS_KEY = 'jbrowsePreferences';
+function loadStoredPreferences() {
+    const stored = localStorageGetItem(PREFS_KEY);
+    let result = {};
+    if (stored) {
+        try {
+            const parsed = JSON.parse(stored);
+            if (typeof parsed === 'object' && parsed !== null) {
+                result = parsed;
+            }
+        }
+        catch {
+            // malformed localStorage value; keep empty defaults
+        }
+    }
+    return result;
+}
+/**
+ * #stateModel PreferencesSessionMixin
+ *
+ * loads and persists user-preference overrides (the BaseSession
+ * `preferencesOverrides` volatile) to localStorage. Compose into products that
+ * let users edit preferences (web, desktop); embedded sessions omit it and
+ * resolve preferences from `configuration.preferences` admin defaults only.
+ */
+export function PreferencesSessionMixin(pluginManager) {
+    return types
+        .compose(BaseSessionModel(pluginManager), types.model({}))
+        .actions(self => ({
+        afterAttach() {
+            // the restore path bypasses `setPreferenceOverride`, so it freezes here
+            // too
+            self.preferencesOverrides.replace(freezeDeep(loadStoredPreferences()));
+            // Applied once, here, rather than reactively: the same setting has to
+            // hold in the RPC workers (which format tooltip strings from jexl
+            // `mouseover` slots) and they only learn it at boot, so a live
+            // main-thread update would leave the app formatted two ways at once.
+            // The dialog says a reload is needed; this is where the reload lands.
+            setNumberGrouping(self.numberGrouping);
+            // and the same second pass for the developer-notice channel, whose
+            // admin default BaseSession already read: a user's stored override is
+            // only loaded a line above this
+            applyDeveloperMode(self);
+            addDisposer(self, autorun(function persistPreferences() {
+                // observable.map doesn't JSON-serialize to an object on its own;
+                // fromEntries also reads every key so the autorun re-persists on
+                // any per-key change
+                localStorageSetItem(PREFS_KEY, JSON.stringify(Object.fromEntries(self.preferencesOverrides)));
+            }, { name: 'PreferencesOverrides' }));
+        },
+    }));
+}

package/esm/Session/ReferenceManagement.d.ts

@@ -1,15 +1,40 @@
+/** MST props, views, actions, etc related to managing connections */
 import type PluginManager from '@jbrowse/core/PluginManager';
-import type { BaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
 import type { IAnyStateTreeNode, Instance } from '@jbrowse/mobx-state-tree';
 export interface ReferringNode {
     node: IAnyStateTreeNode;
     key: string;
 }
+/**
+ * #stateModel ReferenceManagementSessionMixin
+ */
 export declare function ReferenceManagementSessionMixin(_pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{}, {
-    getReferring(object: IAnyStateTreeNode): ReferringNode[];
+    /**
+     * #method
+     * Walk the tree once and map each requested trackId to the nodes holding a
+     * `types.reference` that resolves to it (a view's track entry, a config
+     * editor widget). Track configs are matched by trackId, not identity, so a
+     * frozen base and its hydrated MST node compare equal.
+     */
+    getReferringMultiple(trackIds: string[]): Map<string, ReferringNode[]>;
 } & {
-    removeReferring(referring: ReferringNode[], track: BaseTrackConfig, callbacks: ((arg: string) => void)[], dereferenceTypeCount: Record<string, number>): void;
+    /**
+     * #method
+     * The nodes currently referring to `trackId` (see getReferringMultiple).
+     */
+    getReferring(trackId: string): ReferringNode[];
+} & {
+    /**
+     * #action
+     * Remove `trackId` from every view referring to it and close any config
+     * editor widget open on it. Runs immediately: the walk that produced
+     * `referring` has finished, so mutating those views here is safe.
+     */
+    dereferenceTrack(trackId: string, referring: ReferringNode[]): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+/** Session mixin MST type for a session that manages multiple views */
 export type SessionWithReferenceManagementType = ReturnType<typeof ReferenceManagementSessionMixin>;
+/** Instance of a session with MST reference management (`getReferring()`, `dereferenceTrack()`)  */
 export type SessionWithReferenceManagement = Instance<SessionWithReferenceManagementType>;
+/** Type guard for SessionWithReferenceManagement */
 export declare function isSessionWithReferenceManagement(thing: IAnyStateTreeNode): thing is SessionWithReferenceManagement;

package/esm/Session/ReferenceManagement.js

@@ -1,73 +1,88 @@
+/** MST props, views, actions, etc related to managing connections */
 import { getContainingView, isSessionModelWithWidgets, } from '@jbrowse/core/util';
 import { getMembers, getParent, getSnapshot, getType, isModelType, isReferenceType, types, walk, } from '@jbrowse/mobx-state-tree';
-import { isBaseSession } from "./BaseSession.js";
+import { isBaseSession } from './BaseSession.js';
+/**
+ * #stateModel ReferenceManagementSessionMixin
+ */
 export function ReferenceManagementSessionMixin(_pluginManager) {
     return types
         .model('ReferenceManagementSessionMixin', {})
         .views(self => ({
-        getReferring(object) {
-            const refs = [];
-            const targetTrackId = object.trackId;
+        /**
+         * #method
+         * Walk the tree once and map each requested trackId to the nodes holding a
+         * `types.reference` that resolves to it (a view's track entry, a config
+         * editor widget). Track configs are matched by trackId, not identity, so a
+         * frozen base and its hydrated MST node compare equal.
+         */
+        getReferringMultiple(trackIds) {
+            const ids = new Set(trackIds);
+            const result = new Map();
+            if (ids.size === 0) {
+                return result;
+            }
             walk(getParent(self), node => {
                 if (isModelType(getType(node))) {
-                    const members = getMembers(node);
-                    for (const [key, value] of Object.entries(members.properties)) {
+                    for (const [key, value] of Object.entries(getMembers(node).properties)) {
                         if (isReferenceType(value)) {
-                            const ref = node[key];
-                            const refTrackId = ref?.trackId;
-                            if (ref === object ||
-                                (targetTrackId && refTrackId && refTrackId === targetTrackId)) {
-                                refs.push({ node, key });
+                            const id = node[key]?.trackId;
+                            if (id !== undefined && ids.has(id)) {
+                                const existing = result.get(id) ?? [];
+                                existing.push({ node, key });
+                                result.set(id, existing);
                             }
                         }
                     }
                 }
             });
-            return refs;
+            return result;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #method
+         * The nodes currently referring to `trackId` (see getReferringMultiple).
+         */
+        getReferring(trackId) {
+            return self.getReferringMultiple([trackId]).get(trackId) ?? [];
         },
     }))
         .actions(self => ({
-        removeReferring(referring, track, callbacks, dereferenceTypeCount) {
+        /**
+         * #action
+         * Remove `trackId` from every view referring to it and close any config
+         * editor widget open on it. Runs immediately: the walk that produced
+         * `referring` has finished, so mutating those views here is safe.
+         */
+        dereferenceTrack(trackId, referring) {
             for (const { node } of referring) {
-                let dereferenced = false;
+                let view;
                 try {
-                    const type = 'open track(s)';
-                    const view = getContainingView(node);
-                    callbacks.push(() => {
-                        view.hideTrack(track.trackId);
-                    });
-                    dereferenced = true;
-                    if (!dereferenceTypeCount[type]) {
-                        dereferenceTypeCount[type] = 0;
-                    }
-                    dereferenceTypeCount[type] += 1;
+                    view = getContainingView(node);
                 }
-                catch (err1) {
+                catch {
+                    // node isn't contained in a view (e.g. it's a widget)
                 }
-                if (isSessionModelWithWidgets(self) && self.widgets.has(node.id)) {
-                    const type = 'configuration editor widget(s)';
-                    if (isSessionModelWithWidgets(self)) {
-                        callbacks.push(() => {
-                            self.hideWidget(node);
-                        });
-                    }
-                    dereferenced = true;
-                    if (!dereferenceTypeCount[type]) {
-                        dereferenceTypeCount[type] = 0;
-                    }
-                    dereferenceTypeCount[type] += 1;
+                const widget = isSessionModelWithWidgets(self) && self.widgets.has(node.id);
+                if (view) {
+                    view.hideTrack(trackId);
+                }
+                else if (widget) {
+                    self.hideWidget(node);
                 }
-                if (!dereferenced) {
-                    throw new Error(`Error when closing this connection, the following node is still referring to a track configuration: ${JSON.stringify(getSnapshot(node))}`);
+                else {
+                    throw new Error(`node still refers to track ${trackId}: ${JSON.stringify(getSnapshot(node))}`);
                 }
             }
         },
     }));
 }
+/** Type guard for SessionWithReferenceManagement */
 export function isSessionWithReferenceManagement(thing) {
     return (isBaseSession(thing) &&
         'getReferring' in thing &&
         typeof thing.getReferring === 'function' &&
-        'removeReferring' in thing &&
-        typeof thing.removeReferring === 'function');
+        'dereferenceTrack' in thing &&
+        typeof thing.dereferenceTrack === 'function');
 }