@jbrowse/product-core 2.6.1

package/dist/Session/MultipleViews.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionWithMultipleViews = exports.MultipleViewsSessionMixin = void 0;
+const mobx_state_tree_1 = require("mobx-state-tree");
+const configuration_1 = require("@jbrowse/core/configuration");
+const DrawerWidgets_1 = require("./DrawerWidgets");
+// locals
+const BaseSession_1 = require("./BaseSession");
+/**
+ * #stateModel MultipleViewsSessionMixin
+ */
+function MultipleViewsSessionMixin(pluginManager) {
+    return mobx_state_tree_1.types
+        .compose((0, BaseSession_1.BaseSessionModel)(pluginManager), (0, DrawerWidgets_1.DrawerWidgetSessionMixin)(pluginManager))
+        .props({
+        /**
+         * #property
+         */
+        views: mobx_state_tree_1.types.array(pluginManager.pluggableMstType('view', 'stateModel')),
+    })
+        .actions(self => ({
+        /**
+         * #action
+         */
+        moveViewUp(id) {
+            const idx = self.views.findIndex(v => v.id === id);
+            if (idx === -1) {
+                return;
+            }
+            if (idx > 0) {
+                self.views.splice(idx - 1, 2, self.views[idx], self.views[idx - 1]);
+            }
+        },
+        /**
+         * #action
+         */
+        moveViewDown(id) {
+            const idx = self.views.findIndex(v => v.id === id);
+            if (idx === -1) {
+                return;
+            }
+            if (idx < self.views.length - 1) {
+                self.views.splice(idx, 2, self.views[idx + 1], self.views[idx]);
+            }
+        },
+        /**
+         * #action
+         */
+        addView(typeName, initialState = {}) {
+            const typeDefinition = pluginManager.getElementType('view', typeName);
+            if (!typeDefinition) {
+                throw new Error(`unknown view type ${typeName}`);
+            }
+            const length = self.views.push({
+                ...initialState,
+                type: typeName,
+            });
+            return self.views[length - 1];
+        },
+        /**
+         * #action
+         */
+        removeView(view) {
+            for (const [, widget] of self.activeWidgets) {
+                if (widget.view && widget.view.id === view.id) {
+                    self.hideWidget(widget);
+                }
+            }
+            self.views.remove(view);
+        },
+        /**
+         * #action
+         */
+        addLinearGenomeViewOfAssembly(assemblyName, initialState = {}) {
+            return this.addViewOfAssembly('LinearGenomeView', assemblyName, initialState);
+        },
+        /**
+         * #action
+         */
+        addViewOfAssembly(viewType, assemblyName, initialState = {}) {
+            const asm = self.assemblies.find(s => (0, configuration_1.readConfObject)(s, 'name') === assemblyName);
+            if (!asm) {
+                throw new Error(`Could not add view of assembly "${assemblyName}", assembly name not found`);
+            }
+            return this.addView(viewType, {
+                ...initialState,
+                displayRegionsFromAssemblyName: (0, configuration_1.readConfObject)(asm, 'name'),
+            });
+        },
+        /**
+         * #action
+         */
+        addViewFromAnotherView(viewType, otherView, initialState = {}) {
+            const state = { ...initialState };
+            state.displayedRegions = (0, mobx_state_tree_1.getSnapshot)(otherView.displayedRegions);
+            return this.addView(viewType, state);
+        },
+    }));
+}
+exports.MultipleViewsSessionMixin = MultipleViewsSessionMixin;
+/** Type guard for SessionWithMultipleViews */
+function isSessionWithMultipleViews(session) {
+    return (0, BaseSession_1.isBaseSession)(session) && 'views' in session;
+}
+exports.isSessionWithMultipleViews = isSessionWithMultipleViews;

package/dist/Session/ReferenceManagement.d.ts

@@ -0,0 +1,34 @@
+/** MST props, views, actions, etc related to managing connections */
+import PluginManager from '@jbrowse/core/PluginManager';
+import { IAnyStateTreeNode, Instance } from 'mobx-state-tree';
+import type { BaseTrackConfig } from '@jbrowse/core/pluggableElementTypes';
+export interface ReferringNode {
+    node: IAnyStateTreeNode;
+    key: string;
+}
+/**
+ * #stateModel ReferenceManagementSessionMixin
+ */
+export declare function ReferenceManagementSessionMixin(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{}, {
+    /**
+     * #method
+     * See if any MST nodes currently have a types.reference to this object.
+     *
+     * @param object - object
+     * @returns An array where the first element is the node referring
+     * to the object and the second element is they property name the node is
+     * using to refer to the object
+     */
+    getReferring(object: IAnyStateTreeNode): ReferringNode[];
+} & {
+    /**
+     * #action
+     */
+    removeReferring(referring: ReferringNode[], track: BaseTrackConfig, callbacks: Function[], dereferenceTypeCount: Record<string, number>): void;
+}, import("mobx-state-tree")._NotCustomized, import("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()`, `removeReferring()`)  */
+export type SessionWithReferenceManagement = Instance<SessionWithReferenceManagementType>;
+/** Type guard for SessionWithReferenceManagement */
+export declare function isSessionWithReferenceManagement(thing: IAnyStateTreeNode): thing is SessionWithReferenceManagement;

package/dist/Session/ReferenceManagement.js

@@ -0,0 +1,91 @@
+"use strict";
+/** MST props, views, actions, etc related to managing connections */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionWithReferenceManagement = exports.ReferenceManagementSessionMixin = void 0;
+const util_1 = require("@jbrowse/core/util");
+const mobx_state_tree_1 = require("mobx-state-tree");
+// locals
+const BaseSession_1 = require("./BaseSession");
+/**
+ * #stateModel ReferenceManagementSessionMixin
+ */
+function ReferenceManagementSessionMixin(pluginManager) {
+    return mobx_state_tree_1.types
+        .model('ReferenceManagementSessionMixin', {})
+        .views(self => ({
+        /**
+         * #method
+         * See if any MST nodes currently have a types.reference to this object.
+         *
+         * @param object - object
+         * @returns An array where the first element is the node referring
+         * to the object and the second element is they property name the node is
+         * using to refer to the object
+         */
+        getReferring(object) {
+            const refs = [];
+            (0, mobx_state_tree_1.walk)((0, mobx_state_tree_1.getParent)(self), node => {
+                if ((0, mobx_state_tree_1.isModelType)((0, mobx_state_tree_1.getType)(node))) {
+                    const members = (0, mobx_state_tree_1.getMembers)(node);
+                    Object.entries(members.properties).forEach(([key, value]) => {
+                        if ((0, mobx_state_tree_1.isReferenceType)(value) && node[key] === object) {
+                            refs.push({ node, key });
+                        }
+                    });
+                }
+            });
+            return refs;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        removeReferring(referring, track, callbacks, dereferenceTypeCount) {
+            referring.forEach(({ node }) => {
+                let dereferenced = false;
+                try {
+                    // If a view is referring to the track config, remove the track
+                    // from the view
+                    const type = 'open track(s)';
+                    const view = (0, util_1.getContainingView)(node);
+                    callbacks.push(() => view.hideTrack(track.trackId));
+                    dereferenced = true;
+                    if (!dereferenceTypeCount[type]) {
+                        dereferenceTypeCount[type] = 0;
+                    }
+                    dereferenceTypeCount[type] += 1;
+                }
+                catch (err1) {
+                    // ignore
+                }
+                if ((0, util_1.isSessionModelWithWidgets)(self) && self.widgets.has(node.id)) {
+                    // If a configuration editor widget has the track config
+                    // open, close the widget
+                    const type = 'configuration editor widget(s)';
+                    if ((0, util_1.isSessionModelWithWidgets)(self)) {
+                        callbacks.push(() => self.hideWidget(node));
+                    }
+                    dereferenced = true;
+                    if (!dereferenceTypeCount[type]) {
+                        dereferenceTypeCount[type] = 0;
+                    }
+                    dereferenceTypeCount[type] += 1;
+                }
+                if (!dereferenced) {
+                    throw new Error(`Error when closing this connection, the following node is still referring to a track configuration: ${JSON.stringify((0, mobx_state_tree_1.getSnapshot)(node))}`);
+                }
+            });
+        },
+    }));
+}
+exports.ReferenceManagementSessionMixin = ReferenceManagementSessionMixin;
+/** Type guard for SessionWithReferenceManagement */
+function isSessionWithReferenceManagement(thing) {
+    return ((0, BaseSession_1.isBaseSession)(thing) &&
+        'getReferring' in thing &&
+        typeof thing.getReferring === 'function' &&
+        'removeReferring' in thing &&
+        typeof thing.removeReferring === 'function');
+}
+exports.isSessionWithReferenceManagement = isSessionWithReferenceManagement;