@jbrowse/product-core 2.6.1

package/esm/Session/Connections.js

@@ -0,0 +1,108 @@
+import { readConfObject, } from '@jbrowse/core/configuration';
+import { types } from 'mobx-state-tree';
+import { isBaseSession } from './BaseSession';
+/**
+ * #stateModel ConnectionManagementSessionMixin
+ */
+export function ConnectionManagementSessionMixin(pluginManager) {
+    return types
+        .model({
+        /**
+         * #property
+         */
+        connectionInstances: 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 = 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 = 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 = 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();
+        },
+    }));
+}
+/** Type guard for SessionWithConnections */
+export function isSessionWithConnections(session) {
+    return isBaseSession(session) && 'connectionInstances' in session;
+}

package/esm/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/esm/Session/DialogQueue.js

@@ -0,0 +1,50 @@
+/** MST mixin for managing a queue of dialogs at the level of the session */
+import { types } from 'mobx-state-tree';
+import { isBaseSession } from './BaseSession';
+/**
+ * #stateModel DialogQueueSessionMixin
+ */
+export function DialogQueueSessionMixin(pluginManager) {
+    return 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]];
+        },
+    }));
+}
+/** Type guard for SessionWithDialogs */
+export function isSessionWithDialogs(session) {
+    return isBaseSession(session) && 'queueOfDialogs' in session;
+}

package/esm/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/esm/Session/DrawerWidgets.js

@@ -0,0 +1,162 @@
+import { addDisposer, isAlive, types, } from 'mobx-state-tree';
+import { localStorageGetItem, localStorageSetItem } from '@jbrowse/core/util';
+import { autorun } from 'mobx';
+import { isConfigurationModel, } from '@jbrowse/core/configuration';
+import { isBaseSession } from './BaseSession';
+const minDrawerWidth = 128;
+/**
+ * #stateModel DrawerWidgetSessionMixin
+ */
+export function DrawerWidgetSessionMixin(pluginManager) {
+    const widgetStateModelType = pluginManager.pluggableMstType('widget', 'stateModel');
+    return types
+        .model({
+        /**
+         * #property
+         */
+        drawerPosition: types.optional(types.string, () => localStorageGetItem('drawerPosition') || 'right'),
+        /**
+         * #property
+         */
+        drawerWidth: types.optional(types.refinement(types.integer, width => width >= minDrawerWidth), 384),
+        /**
+         * #property
+         */
+        widgets: types.map(widgetStateModelType),
+        /**
+         * #property
+         */
+        activeWidgets: types.map(types.safeReference(widgetStateModelType)),
+        /**
+         * #property
+         */
+        minimized: types.optional(types.boolean, false),
+    })
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get visibleWidget() {
+            if (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 (!isConfigurationModel(configuration)) {
+                throw new Error('must pass a configuration model to editConfiguration');
+            }
+            const editor = this.addWidget('ConfigurationEditorWidget', 'configEditor', { target: configuration });
+            this.showWidget(editor);
+        },
+        afterAttach() {
+            addDisposer(self, autorun(() => {
+                localStorageSetItem('drawerPosition', self.drawerPosition);
+            }));
+        },
+    }));
+}
+/** Type guard for SessionWithDrawerWidgets */
+export function isSessionWithDrawerWidgets(session) {
+    return (isBaseSession(session) &&
+        'widgets' in session &&
+        'drawerPosition' in session);
+}