@jbrowse/plugin-data-management 2.8.0 → 2.10.0

package/esm/HierarchicalTrackSelectorWidget/model.d.ts

@@ -1,7 +1,7 @@
 import { Instance } from 'mobx-state-tree';
 import { AnyConfigurationModel } from '@jbrowse/core/configuration';
 import PluginManager from '@jbrowse/core/PluginManager';
-import { TreeNode } from './generateHierarchy';
+type MaybeAnyConfigurationModel = AnyConfigurationModel | undefined;
 /**
  * #stateModel HierarchicalTrackSelectorWidget
  */
@@ -34,13 +34,103 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
      * #property
      */
     view: import("mobx-state-tree").IMaybe<import("mobx-state-tree").IReferenceType<import("mobx-state-tree").IAnyType>>;
+    /**
+     * #property
+     */
+    faceted: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IModelType<{
+        filterText: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
+        showSparse: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        showFilters: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        showOptions: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+        panelWidth: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<number>, [undefined]>; /**
+         * #property
+         */
+    }, {
+        visible: Record<string, boolean>;
+        widths: Record<string, number | undefined>;
+        useShoppingCart: boolean;
+        filters: import("mobx").ObservableMap<string, string[]>;
+    } & {
+        setFilter(key: string, value: string[]): void;
+        setPanelWidth(width: number): void;
+        setUseShoppingCart(f: boolean): void;
+        setFilterText(str: string): void;
+        setShowSparse(f: boolean): void;
+        setShowOptions(f: boolean): void; /**
+         * #getter
+         */
+        setShowFilters(f: boolean): void;
+    } & {
+        readonly allTrackConfigurations: ({
+            [x: string]: any;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            setSubschema(slotName: string, data: unknown): any;
+        } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
+    } & {
+        readonly rows: {
+            readonly id: string;
+            readonly conf: {
+                [x: string]: any;
+            } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+                setSubschema(slotName: string, data: unknown): any;
+            } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
+            readonly name: string;
+            readonly category: string;
+            readonly adapter: string;
+            readonly description: string;
+            readonly metadata: any;
+        }[];
+    } & {
+        readonly filteredNonMetadataKeys: string[] | readonly ["category", "adapter", "description"];
+        readonly metadataKeys: string[];
+        readonly filteredMetadataKeys: string[];
+        readonly fields: string[];
+        readonly filteredRows: {
+            readonly id: string;
+            readonly conf: {
+                [x: string]: any;
+            } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+                setSubschema(slotName: string, data: unknown): any;
+            } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>;
+            readonly name: string;
+            readonly category: string;
+            readonly adapter: string;
+            readonly description: string;
+            readonly metadata: any;
+        }[];
+    } & {
+        setVisible(args: Record<string, boolean>): void;
+        setWidths(args: Record<string, number | undefined>): void;
+        afterAttach(): void;
+    }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>, [undefined]>;
 }, {
+    favorites: string[];
+    recentlyUsed: string[];
     selection: ({
         [x: string]: any;
     } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
         setSubschema(slotName: string, data: unknown): any;
     } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
     filterText: string;
+    recentlyUsedCounter: number;
+    favoritesCounter: number;
+} & {
+    /**
+     * #getter
+     */
+    readonly selectionSet: Set<{
+        [x: string]: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: unknown): any;
+    } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>>;
+    /**
+     * #getter
+     */
+    readonly favoritesSet: Set<string>;
+    /**
+     * #getter
+     */
+    readonly recentlyUsedSet: Set<string>;
 } & {
     /**
      * #action
@@ -66,6 +156,42 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
      * #action
      */
     clearSelection(): void;
+    /**
+     * #action
+     */
+    addToFavorites(trackId: string): void;
+    /**
+     * #action
+     */
+    removeFromFavorites(trackId: string): void;
+    /**
+     * #action
+     */
+    clearFavorites(): void;
+    /**
+     * #action
+     */
+    setRecentlyUsedCounter(val: number): void;
+    /**
+     * #action
+     */
+    setRecentlyUsed(str: string[]): void;
+    /**
+     * #action
+     */
+    setFavorites(str: string[]): void;
+    /**
+     * #action
+     */
+    setFavoritesCounter(val: number): void;
+    /**
+     * #action
+     */
+    addToRecentlyUsed(id: string): void;
+    /**
+     * #action
+     */
+    clearRecentlyUsed(): void;
     /**
      * #action
      */
@@ -94,13 +220,33 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
     /**
      * #method
      */
-    getRefSeqTrackConf(assemblyName: string): AnyConfigurationModel | undefined;
+    isSelected(track: AnyConfigurationModel): boolean;
+    /**
+     * #method
+     */
+    isFavorite(trackId: string): boolean;
+    /**
+     * #method
+     */
+    isRecentlyUsed(trackId: string): boolean;
+    /**
+     * #method
+     */
+    getRefSeqTrackConf(assemblyName: string): MaybeAnyConfigurationModel;
 } & {
     /**
      * #getter
      */
     readonly assemblyNames: string[];
 } & {
+    /**
+     * #getter
+     */
+    readonly recentlyUsedLocalStorageKey: string;
+    /**
+     * #getter
+     */
+    readonly favoritesLocalStorageKey: string;
     /**
      * #getter
      */
@@ -110,34 +256,53 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
      */
     readonly activeSortCategories: any;
     /**
-     * #method
-     * filter out tracks that don't match the current display types
+     * #getter
+     * filter out tracks that don't match the current assembly/display types
      */
-    connectionTrackConfigurations(connection: {
-        tracks: AnyConfigurationModel[];
-    }): ({
+    readonly configAndSessionTrackConfigurations: ({
         [x: string]: any;
     } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
         setSubschema(slotName: string, data: unknown): any;
     } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
     /**
      * #getter
-     * filter out tracks that don't match the current assembly/display types
      */
-    readonly trackConfigurations: ({
+    readonly allTrackConfigurations: ({
         [x: string]: any;
     } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
         setSubschema(slotName: string, data: unknown): any;
     } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
+    /**
+     * #getter
+     */
+    readonly allTrackConfigurationTrackIdSet: Map<any, {
+        [x: string]: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: unknown): any;
+    } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>>;
 } & {
     /**
-     * #method
+     * #getter
+     * filters out tracks that are not in the favorites group
      */
-    connectionHierarchy(connection: {
-        name: string;
-        tracks: AnyConfigurationModel[];
-    }): TreeNode[];
+    readonly favoriteTracks: ({
+        [x: string]: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: unknown): any;
+    } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
+    /**
+     * #getter
+     * filters out tracks that are not in the recently used group
+     */
+    readonly recentlyUsedTracks: ({
+        [x: string]: any;
+    } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        setSubschema(slotName: string, data: unknown): any;
+    } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
 } & {
+    /**
+     * #getter
+     */
     readonly allTracks: {
         group: any;
         tracks: ({
@@ -145,6 +310,8 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
         } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
             setSubschema(slotName: string, data: unknown): any;
         } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[];
+        noCategories: boolean;
+        menuItems: never[];
     }[];
 } & {
     /**
@@ -153,10 +320,15 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
     readonly hierarchy: {
         name: string;
         id: string;
+        isOpenByDefault: boolean;
+        type: "category";
         children: {
             name: any;
             id: any;
-            children: TreeNode[];
+            type: "category";
+            isOpenByDefault: boolean;
+            menuItems: never[];
+            children: import("./generateHierarchy").TreeNode[];
         }[];
     };
 } & {
@@ -171,7 +343,13 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
 } & {
     afterCreate(): void;
 } & {
+    /**
+     * #getter
+     */
     readonly hasAnySubcategories: boolean;
+} & {
+    afterAttach(): void;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
 export type HierarchicalTrackSelectorStateModel = ReturnType<typeof stateTreeFactory>;
 export type HierarchicalTrackSelectorModel = Instance<HierarchicalTrackSelectorStateModel>;
+export {};

package/esm/HierarchicalTrackSelectorWidget/model.js

@@ -1,11 +1,29 @@
-import { types } from 'mobx-state-tree';
+import { types, addDisposer } from 'mobx-state-tree';
+import { autorun } from 'mobx';
 import { getConf, readConfObject, } from '@jbrowse/core/configuration';
-import { dedupe, getSession, notEmpty } from '@jbrowse/core/util';
+import { dedupe, getSession, localStorageGetItem, localStorageSetItem, notEmpty, } from '@jbrowse/core/util';
 import { ElementId } from '@jbrowse/core/util/types/mst';
 // locals
 import { filterTracks } from './filterTracks';
 import { generateHierarchy } from './generateHierarchy';
 import { findSubCategories, findTopLevelCategories } from './util';
+import { facetedStateTreeF } from './facetedModel';
+// for settings that are config dependent
+function postNoConfigF() {
+    return typeof window !== undefined
+        ? [window.location.host, window.location.pathname].join('-')
+        : 'empty';
+}
+// for settings that are not config dependent
+function postF() {
+    return typeof window !== undefined
+        ? [
+            postNoConfigF(),
+            new URLSearchParams(window.location.search).get('config'),
+        ].join('-')
+        : 'empty';
+}
+const MAX_RECENTLY_USED = 10;
 /**
  * #stateModel HierarchicalTrackSelectorWidget
  */
@@ -40,10 +58,38 @@ export default function stateTreeFactory(pluginManager) {
          * #property
          */
         view: types.safeReference(pluginManager.pluggableMstType('view', 'stateModel')),
+        /**
+         * #property
+         */
+        faceted: types.optional(facetedStateTreeF(), {}),
     })
         .volatile(() => ({
+        favorites: [],
+        recentlyUsed: [],
         selection: [],
         filterText: '',
+        recentlyUsedCounter: 0,
+        favoritesCounter: 0,
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get selectionSet() {
+            return new Set(self.selection);
+        },
+        /**
+         * #getter
+         */
+        get favoritesSet() {
+            return new Set(self.favorites);
+        },
+        /**
+         * #getter
+         */
+        get recentlyUsedSet() {
+            return new Set(self.recentlyUsed);
+        },
     }))
         .actions(self => ({
         /**
@@ -74,7 +120,8 @@ export default function stateTreeFactory(pluginManager) {
          * #action
          */
         removeFromSelection(elt) {
-            self.selection = self.selection.filter(f => !elt.includes(f));
+            const s = new Set(elt);
+            self.selection = self.selection.filter(f => !s.has(f));
         },
         /**
          * #action
@@ -82,6 +129,67 @@ export default function stateTreeFactory(pluginManager) {
         clearSelection() {
             self.selection = [];
         },
+        /**
+         * #action
+         */
+        addToFavorites(trackId) {
+            self.favoritesCounter += 1;
+            self.favorites = [...self.favorites, trackId];
+        },
+        /**
+         * #action
+         */
+        removeFromFavorites(trackId) {
+            self.favorites = self.favorites.filter(f => f !== trackId);
+        },
+        /**
+         * #action
+         */
+        clearFavorites() {
+            self.favorites = [];
+        },
+        /**
+         * #action
+         */
+        setRecentlyUsedCounter(val) {
+            self.recentlyUsedCounter = val;
+        },
+        /**
+         * #action
+         */
+        setRecentlyUsed(str) {
+            self.recentlyUsed = str;
+        },
+        /**
+         * #action
+         */
+        setFavorites(str) {
+            self.favorites = str;
+        },
+        /**
+         * #action
+         */
+        setFavoritesCounter(val) {
+            self.favoritesCounter = val;
+        },
+        /**
+         * #action
+         */
+        addToRecentlyUsed(id) {
+            if (!self.recentlyUsed.includes(id)) {
+                self.recentlyUsedCounter = Math.min(self.recentlyUsedCounter + 1, MAX_RECENTLY_USED);
+                self.recentlyUsed =
+                    self.recentlyUsed.length >= MAX_RECENTLY_USED
+                        ? [...self.recentlyUsed.slice(1), id]
+                        : [...self.recentlyUsed, id];
+            }
+        },
+        /**
+         * #action
+         */
+        clearRecentlyUsed() {
+            self.recentlyUsed = [];
+        },
         /**
          * #action
          */
@@ -120,6 +228,24 @@ export default function stateTreeFactory(pluginManager) {
         },
     }))
         .views(self => ({
+        /**
+         * #method
+         */
+        isSelected(track) {
+            return self.selectionSet.has(track);
+        },
+        /**
+         * #method
+         */
+        isFavorite(trackId) {
+            return self.favoritesSet.has(trackId);
+        },
+        /**
+         * #method
+         */
+        isRecentlyUsed(trackId) {
+            return self.recentlyUsedSet.has(trackId);
+        },
         /**
          * #method
          */
@@ -149,6 +275,22 @@ export default function stateTreeFactory(pluginManager) {
         },
     }))
         .views(self => ({
+        /**
+         * #getter
+         */
+        get recentlyUsedLocalStorageKey() {
+            return `recentlyUsedTracks-${[postF(), self.assemblyNames.join(',')]
+                .filter(f => !!f)
+                .join('-')}`;
+        },
+        /**
+         * #getter
+         */
+        get favoritesLocalStorageKey() {
+            // this has a extra } at the end because that's how it was initially
+            // released
+            return `favoriteTracks-${postF()}}`;
+        },
         /**
          * #getter
          */
@@ -163,47 +305,71 @@ export default function stateTreeFactory(pluginManager) {
             var _a;
             return ((_a = self.sortCategories) !== null && _a !== void 0 ? _a : getConf(getSession(self), ['hierarchical', 'sort', 'categories']));
         },
-        /**
-         * #method
-         * filter out tracks that don't match the current display types
-         */
-        connectionTrackConfigurations(connection) {
-            return filterTracks(connection.tracks, self);
-        },
         /**
          * #getter
          * filter out tracks that don't match the current assembly/display types
          */
-        get trackConfigurations() {
+        get configAndSessionTrackConfigurations() {
             return [
                 ...self.assemblyNames.map(a => self.getRefSeqTrackConf(a)),
                 ...filterTracks(getSession(self).tracks, self),
             ].filter(notEmpty);
         },
+        /**
+         * #getter
+         */
+        get allTrackConfigurations() {
+            const { connectionInstances = [] } = getSession(self);
+            return [
+                ...this.configAndSessionTrackConfigurations,
+                ...connectionInstances === null || connectionInstances === void 0 ? void 0 : connectionInstances.flatMap(c => c.tracks),
+            ];
+        },
+        /**
+         * #getter
+         */
+        get allTrackConfigurationTrackIdSet() {
+            return new Map(this.allTrackConfigurations.map(t => [t.trackId, t]));
+        },
     }))
         .views(self => ({
         /**
-         * #method
+         * #getter
+         * filters out tracks that are not in the favorites group
+         */
+        get favoriteTracks() {
+            return self.favorites
+                .filter(t => self.allTrackConfigurationTrackIdSet.has(t))
+                .map(t => self.allTrackConfigurationTrackIdSet.get(t));
+        },
+        /**
+         * #getter
+         * filters out tracks that are not in the recently used group
          */
-        connectionHierarchy(connection) {
-            return generateHierarchy({
-                model: self,
-                trackConfs: self.connectionTrackConfigurations(connection),
-                extra: connection.name,
-            });
+        get recentlyUsedTracks() {
+            return self.recentlyUsed
+                .filter(t => self.allTrackConfigurationTrackIdSet.has(t))
+                .map(t => self.allTrackConfigurationTrackIdSet.get(t));
         },
     }))
         .views(self => ({
+        /**
+         * #getter
+         */
         get allTracks() {
             const { connectionInstances = [] } = getSession(self);
             return [
                 {
                     group: 'Tracks',
-                    tracks: self.trackConfigurations,
+                    tracks: self.configAndSessionTrackConfigurations,
+                    noCategories: false,
+                    menuItems: [],
                 },
                 ...connectionInstances.flatMap(c => ({
                     group: getConf(c, 'name'),
                     tracks: c.tracks,
+                    noCategories: false,
+                    menuItems: [],
                 })),
             ];
         },
@@ -216,17 +382,21 @@ export default function stateTreeFactory(pluginManager) {
             return {
                 name: 'Root',
                 id: 'Root',
-                children: self.allTracks
-                    .map(s => ({
+                isOpenByDefault: true,
+                type: 'category',
+                children: self.allTracks.map(s => ({
                     name: s.group,
                     id: s.group,
+                    type: 'category',
+                    isOpenByDefault: !self.collapsed.get(s.group),
+                    menuItems: s.menuItems,
                     children: generateHierarchy({
                         model: self,
                         trackConfs: s.tracks,
+                        extra: s.group,
+                        noCategories: s.noCategories,
                     }),
-                }))
-                    // always keep the Tracks entry at idx 0
-                    .filter((f, idx) => idx === 0 || !!f.children.length),
+                })),
             };
         },
     }))
@@ -286,8 +456,25 @@ export default function stateTreeFactory(pluginManager) {
         },
     }))
         .views(self => ({
+        /**
+         * #getter
+         */
         get hasAnySubcategories() {
             return self.allTracks.some(group => group.tracks.some(t => { var _a; return ((_a = readConfObject(t, 'category')) === null || _a === void 0 ? void 0 : _a.length) > 1; }));
         },
+    }))
+        .actions(self => ({
+        afterAttach() {
+            // this should be the first autorun to properly initialize
+            addDisposer(self, autorun(() => {
+                self.setRecentlyUsed(JSON.parse(localStorageGetItem(self.recentlyUsedLocalStorageKey) || '[]'));
+                self.setFavorites(JSON.parse(localStorageGetItem(self.favoritesLocalStorageKey) || '[]'));
+            }));
+            // this should be the second autorun
+            addDisposer(self, autorun(() => {
+                localStorageSetItem(self.favoritesLocalStorageKey, JSON.stringify(self.favorites));
+                localStorageSetItem(self.recentlyUsedLocalStorageKey, JSON.stringify(self.recentlyUsed));
+            }));
+        },
     }));
 }

package/esm/ucsc-trackhub/doConnect.d.ts

@@ -0,0 +1 @@
+export declare function doConnect(self: any): Promise<void>;