@jbrowse/product-core 2.6.1

package/dist/Session/Connections.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionWithConnections = exports.ConnectionManagementSessionMixin = void 0;
+const configuration_1 = require("@jbrowse/core/configuration");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const BaseSession_1 = require("./BaseSession");
+/**
+ * #stateModel ConnectionManagementSessionMixin
+ */
+function ConnectionManagementSessionMixin(pluginManager) {
+    return mobx_state_tree_1.types
+        .model({
+        /**
+         * #property
+         */
+        connectionInstances: mobx_state_tree_1.types.array(pluginManager.pluggableMstType('connection', 'stateModel')),
+    })
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get connections() {
+            const { jbrowse } = self;
+            return jbrowse.connections;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        makeConnection(configuration, initialSnapshot = {}) {
+            const type = configuration.type;
+            if (!type) {
+                throw new Error('track configuration has no `type` listed');
+            }
+            const name = (0, configuration_1.readConfObject)(configuration, 'name');
+            const connectionType = pluginManager.getConnectionType(type);
+            if (!connectionType) {
+                throw new Error(`unknown connection type ${type}`);
+            }
+            const length = self.connectionInstances.push({
+                ...initialSnapshot,
+                name,
+                // @ts-expect-error unsure why ts doesn't like `type` here, but is
+                // needed
+                type,
+                configuration,
+            });
+            return self.connectionInstances[length - 1];
+        },
+        /**
+         * #action
+         */
+        prepareToBreakConnection(configuration) {
+            const root = self;
+            const callbacksToDeref = [];
+            const derefTypeCount = {};
+            const name = (0, configuration_1.readConfObject)(configuration, 'name');
+            const connection = self.connectionInstances.find(c => c.name === name);
+            if (!connection) {
+                return undefined;
+            }
+            for (const track of connection.tracks) {
+                const ref = root.getReferring(track);
+                root.removeReferring(ref, track, callbacksToDeref, derefTypeCount);
+            }
+            return [
+                () => {
+                    callbacksToDeref.forEach(cb => cb());
+                    this.breakConnection(configuration);
+                },
+                derefTypeCount,
+            ];
+        },
+        /**
+         * #action
+         */
+        breakConnection(configuration) {
+            const name = (0, configuration_1.readConfObject)(configuration, 'name');
+            const connection = self.connectionInstances.find(c => c.name === name);
+            if (!connection) {
+                throw new Error(`no connection found with name ${name}`);
+            }
+            self.connectionInstances.remove(connection);
+        },
+        /**
+         * #action
+         */
+        deleteConnection(configuration) {
+            const { jbrowse } = self;
+            return jbrowse.deleteConnectionConf(configuration);
+        },
+        /**
+         * #action
+         */
+        addConnectionConf(connectionConf) {
+            const { jbrowse } = self;
+            return jbrowse.addConnectionConf(connectionConf);
+        },
+        /**
+         * #action
+         */
+        clearConnections() {
+            self.connectionInstances.clear();
+        },
+    }));
+}
+exports.ConnectionManagementSessionMixin = ConnectionManagementSessionMixin;
+/** Type guard for SessionWithConnections */
+function isSessionWithConnections(session) {
+    return (0, BaseSession_1.isBaseSession)(session) && 'connectionInstances' in session;
+}
+exports.isSessionWithConnections = isSessionWithConnections;

package/dist/Session/DialogQueue.d.ts

@@ -0,0 +1,34 @@
+/** MST mixin for managing a queue of dialogs at the level of the session */
+import PluginManager from '@jbrowse/core/PluginManager';
+import { DialogComponentType } from '@jbrowse/core/util';
+import { IAnyStateTreeNode, Instance } from 'mobx-state-tree';
+/**
+ * #stateModel DialogQueueSessionMixin
+ */
+export declare function DialogQueueSessionMixin(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{}, {
+    queueOfDialogs: [DialogComponentType, unknown][];
+} & {
+    /**
+     * #getter
+     */
+    readonly DialogComponent: DialogComponentType;
+    /**
+     * #getter
+     */
+    readonly DialogProps: unknown;
+} & {
+    /**
+     * #action
+     */
+    removeActiveDialog(): void;
+    /**
+     * #action
+     */
+    queueDialog(cb: (doneCallback: () => void) => [DialogComponentType, unknown]): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+/** Session mixin MST type for a session that has `queueOfDialogs`, etc. */
+export type SessionWithDialogsType = ReturnType<typeof DialogQueueSessionMixin>;
+/** Instance of a session that has dialogs */
+export type SessionWithDialogs = Instance<SessionWithDialogsType>;
+/** Type guard for SessionWithDialogs */
+export declare function isSessionWithDialogs(session: IAnyStateTreeNode): session is SessionWithDialogs;

package/dist/Session/DialogQueue.js

@@ -0,0 +1,55 @@
+"use strict";
+/** MST mixin for managing a queue of dialogs at the level of the session */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionWithDialogs = exports.DialogQueueSessionMixin = void 0;
+const mobx_state_tree_1 = require("mobx-state-tree");
+const BaseSession_1 = require("./BaseSession");
+/**
+ * #stateModel DialogQueueSessionMixin
+ */
+function DialogQueueSessionMixin(pluginManager) {
+    return mobx_state_tree_1.types
+        .model('DialogQueueSessionMixin', {})
+        .volatile(() => ({
+        queueOfDialogs: [],
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get DialogComponent() {
+            var _a;
+            return (_a = self.queueOfDialogs[0]) === null || _a === void 0 ? void 0 : _a[0];
+        },
+        /**
+         * #getter
+         */
+        get DialogProps() {
+            var _a;
+            return (_a = self.queueOfDialogs[0]) === null || _a === void 0 ? void 0 : _a[1];
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        removeActiveDialog() {
+            self.queueOfDialogs = self.queueOfDialogs.slice(1);
+        },
+        /**
+         * #action
+         */
+        queueDialog(cb) {
+            const [component, props] = cb(() => {
+                this.removeActiveDialog();
+            });
+            self.queueOfDialogs = [...self.queueOfDialogs, [component, props]];
+        },
+    }));
+}
+exports.DialogQueueSessionMixin = DialogQueueSessionMixin;
+/** Type guard for SessionWithDialogs */
+function isSessionWithDialogs(session) {
+    return (0, BaseSession_1.isBaseSession)(session) && 'queueOfDialogs' in session;
+}
+exports.isSessionWithDialogs = isSessionWithDialogs;

package/dist/Session/DrawerWidgets.d.ts

@@ -0,0 +1,88 @@
+import { IAnyStateTreeNode, Instance } from 'mobx-state-tree';
+import PluginManager from '@jbrowse/core/PluginManager';
+import { AnyConfigurationModel } from '@jbrowse/core/configuration';
+/**
+ * #stateModel DrawerWidgetSessionMixin
+ */
+export declare function DrawerWidgetSessionMixin(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
+    /**
+     * #property
+     */
+    drawerPosition: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+    /**
+     * #property
+     */
+    drawerWidth: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>;
+    /**
+     * #property
+     */
+    widgets: import("mobx-state-tree").IMapType<import("mobx-state-tree").IAnyType>;
+    /**
+     * #property
+     */
+    activeWidgets: import("mobx-state-tree").IMapType<import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>>;
+    /**
+     * #property
+     */
+    minimized: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+}, {
+    /**
+     * #getter
+     */
+    readonly visibleWidget: any;
+} & {
+    /**
+     * #action
+     */
+    setDrawerPosition(arg: string): void;
+    /**
+     * #action
+     */
+    updateDrawerWidth(drawerWidth: number): number;
+    /**
+     * #action
+     */
+    resizeDrawer(distance: number): number;
+    /**
+     * #action
+     */
+    addWidget(typeName: string, id: string, initialState?: {}, conf?: unknown): any;
+    /**
+     * #action
+     */
+    showWidget(widget: any): void;
+    /**
+     * #action
+     */
+    hasWidget(widget: any): boolean;
+    /**
+     * #action
+     */
+    hideWidget(widget: any): void;
+    /**
+     * #action
+     */
+    minimizeWidgetDrawer(): void;
+    /**
+     * #action
+     */
+    showWidgetDrawer(): void;
+    /**
+     * #action
+     */
+    hideAllWidgets(): void;
+    /**
+     * #action
+     * opens a configuration editor to configure the given thing,
+     * and sets the current task to be configuring it
+     * @param configuration -
+     */
+    editConfiguration(configuration: AnyConfigurationModel): void;
+    afterAttach(): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+/** Session mixin MST type for a session that manages drawer widgets */
+export type SessionWithDrawerWidgetsType = ReturnType<typeof DrawerWidgetSessionMixin>;
+/** Instance of a session that manages drawer widgets */
+export type SessionWithDrawerWidgets = Instance<SessionWithDrawerWidgetsType>;
+/** Type guard for SessionWithDrawerWidgets */
+export declare function isSessionWithDrawerWidgets(session: IAnyStateTreeNode): session is SessionWithDrawerWidgets;

package/dist/Session/DrawerWidgets.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSessionWithDrawerWidgets = exports.DrawerWidgetSessionMixin = void 0;
+const mobx_state_tree_1 = require("mobx-state-tree");
+const util_1 = require("@jbrowse/core/util");
+const mobx_1 = require("mobx");
+const configuration_1 = require("@jbrowse/core/configuration");
+const BaseSession_1 = require("./BaseSession");
+const minDrawerWidth = 128;
+/**
+ * #stateModel DrawerWidgetSessionMixin
+ */
+function DrawerWidgetSessionMixin(pluginManager) {
+    const widgetStateModelType = pluginManager.pluggableMstType('widget', 'stateModel');
+    return mobx_state_tree_1.types
+        .model({
+        /**
+         * #property
+         */
+        drawerPosition: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.string, () => (0, util_1.localStorageGetItem)('drawerPosition') || 'right'),
+        /**
+         * #property
+         */
+        drawerWidth: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.refinement(mobx_state_tree_1.types.integer, width => width >= minDrawerWidth), 384),
+        /**
+         * #property
+         */
+        widgets: mobx_state_tree_1.types.map(widgetStateModelType),
+        /**
+         * #property
+         */
+        activeWidgets: mobx_state_tree_1.types.map(mobx_state_tree_1.types.safeReference(widgetStateModelType)),
+        /**
+         * #property
+         */
+        minimized: mobx_state_tree_1.types.optional(mobx_state_tree_1.types.boolean, false),
+    })
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get visibleWidget() {
+            if ((0, mobx_state_tree_1.isAlive)(self)) {
+                // returns most recently added item in active widgets
+                return [...self.activeWidgets.values()][self.activeWidgets.size - 1];
+            }
+            return undefined;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setDrawerPosition(arg) {
+            self.drawerPosition = arg;
+            localStorage.setItem('drawerPosition', arg);
+        },
+        /**
+         * #action
+         */
+        updateDrawerWidth(drawerWidth) {
+            if (drawerWidth === self.drawerWidth) {
+                return self.drawerWidth;
+            }
+            let newDrawerWidth = drawerWidth;
+            if (newDrawerWidth < minDrawerWidth) {
+                newDrawerWidth = minDrawerWidth;
+            }
+            self.drawerWidth = newDrawerWidth;
+            return newDrawerWidth;
+        },
+        /**
+         * #action
+         */
+        resizeDrawer(distance) {
+            if (self.drawerPosition === 'left') {
+                distance *= -1;
+            }
+            const oldDrawerWidth = self.drawerWidth;
+            const newDrawerWidth = this.updateDrawerWidth(oldDrawerWidth - distance);
+            return oldDrawerWidth - newDrawerWidth;
+        },
+        /**
+         * #action
+         */
+        addWidget(typeName, id, initialState = {}, conf) {
+            const typeDefinition = pluginManager.getElementType('widget', typeName);
+            if (!typeDefinition) {
+                throw new Error(`unknown widget type ${typeName}`);
+            }
+            const data = {
+                ...initialState,
+                id,
+                type: typeName,
+                configuration: conf || { type: typeName },
+            };
+            self.widgets.set(id, data);
+            return self.widgets.get(id);
+        },
+        /**
+         * #action
+         */
+        showWidget(widget) {
+            if (self.activeWidgets.has(widget.id)) {
+                self.activeWidgets.delete(widget.id);
+            }
+            self.activeWidgets.set(widget.id, widget);
+            self.minimized = false;
+        },
+        /**
+         * #action
+         */
+        hasWidget(widget) {
+            return self.activeWidgets.has(widget.id);
+        },
+        /**
+         * #action
+         */
+        hideWidget(widget) {
+            self.activeWidgets.delete(widget.id);
+        },
+        /**
+         * #action
+         */
+        minimizeWidgetDrawer() {
+            self.minimized = true;
+        },
+        /**
+         * #action
+         */
+        showWidgetDrawer() {
+            self.minimized = false;
+        },
+        /**
+         * #action
+         */
+        hideAllWidgets() {
+            self.activeWidgets.clear();
+        },
+        /**
+         * #action
+         * opens a configuration editor to configure the given thing,
+         * and sets the current task to be configuring it
+         * @param configuration -
+         */
+        editConfiguration(configuration) {
+            if (!(0, configuration_1.isConfigurationModel)(configuration)) {
+                throw new Error('must pass a configuration model to editConfiguration');
+            }
+            const editor = this.addWidget('ConfigurationEditorWidget', 'configEditor', { target: configuration });
+            this.showWidget(editor);
+        },
+        afterAttach() {
+            (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.autorun)(() => {
+                (0, util_1.localStorageSetItem)('drawerPosition', self.drawerPosition);
+            }));
+        },
+    }));
+}
+exports.DrawerWidgetSessionMixin = DrawerWidgetSessionMixin;
+/** Type guard for SessionWithDrawerWidgets */
+function isSessionWithDrawerWidgets(session) {
+    return ((0, BaseSession_1.isBaseSession)(session) &&
+        'widgets' in session &&
+        'drawerPosition' in session);
+}
+exports.isSessionWithDrawerWidgets = isSessionWithDrawerWidgets;