@jbrowse/plugin-data-management 2.7.2 → 2.9.0

package/esm/HierarchicalTrackSelectorWidget/model.js

@@ -1,11 +1,30 @@
-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 lsKeyFavoritesF = () => `favoriteTracks-${postF()}}`;
+const lsKeyRecentlyUsedF = () => `recentlyUsedTracks-${postF()}}`;
 /**
  * #stateModel HierarchicalTrackSelectorWidget
  */
@@ -40,10 +59,48 @@ export default function stateTreeFactory(pluginManager) {
          * #property
          */
         view: types.safeReference(pluginManager.pluggableMstType('view', 'stateModel')),
+        /**
+         * #property
+         * this is removed in postProcessSnapshot, so is generally only loaded
+         * from localstorage
+         */
+        favorites: types.optional(types.array(types.string), () => JSON.parse(localStorageGetItem(lsKeyFavoritesF()) || '[]')),
+        /**
+         * #property
+         * this is removed in postProcessSnapshot, so is generally only loaded
+         * from localstorage
+         */
+        recentlyUsed: types.optional(types.array(types.string), () => JSON.parse(localStorageGetItem(lsKeyRecentlyUsedF()) || '[]')),
+        /**
+         * #property
+         */
+        faceted: types.optional(facetedStateTreeF(), {}),
     })
         .volatile(() => ({
         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 +131,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 +140,55 @@ export default function stateTreeFactory(pluginManager) {
         clearSelection() {
             self.selection = [];
         },
+        /**
+         * #action
+         */
+        addToFavorites(trackId) {
+            self.favoritesCounter += 1;
+            self.favorites.push(trackId);
+        },
+        /**
+         * #action
+         */
+        removeFromFavorites(trackId) {
+            self.favorites.remove(trackId);
+        },
+        /**
+         * #action
+         */
+        clearFavorites() {
+            self.favorites.clear();
+        },
+        /**
+         * #action
+         */
+        setRecentlyUsedCounter(val) {
+            self.recentlyUsedCounter = val;
+        },
+        /**
+         * #action
+         */
+        setFavoritesCounter(val) {
+            self.favoritesCounter = val;
+        },
+        /**
+         * #action
+         */
+        addToRecentlyUsed(id) {
+            self.recentlyUsedCounter += 1;
+            if (!self.recentlyUsed.includes(id)) {
+                if (self.recentlyUsed.length >= 10) {
+                    self.recentlyUsed.shift();
+                }
+                self.recentlyUsed.push(id);
+            }
+        },
+        /**
+         * #action
+         */
+        clearRecentlyUsed() {
+            self.recentlyUsed.clear();
+        },
         /**
          * #action
          */
@@ -120,6 +227,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
          */
@@ -163,47 +288,58 @@ 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);
         },
+        get allTrackConfigurations() {
+            const { connectionInstances = [] } = getSession(self);
+            return [
+                ...this.configAndSessionTrackConfigurations,
+                ...connectionInstances === null || connectionInstances === void 0 ? void 0 : connectionInstances.flatMap(c => c.tracks),
+            ];
+        },
     }))
         .views(self => ({
         /**
-         * #method
+         * #getter
+         * filters out tracks that are not in the favorites group
+         */
+        get favoriteTracks() {
+            return self.allTrackConfigurations.filter(t => self.favoritesSet.has(t.trackId));
+        },
+        /**
+         * #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.allTrackConfigurations.filter(t => self.recentlyUsedSet.has(t.trackId));
         },
     }))
         .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 +352,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 +426,23 @@ 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() {
+            addDisposer(self, autorun(() => {
+                localStorageSetItem(lsKeyFavoritesF(), JSON.stringify(self.favorites));
+                localStorageSetItem(lsKeyRecentlyUsedF(), JSON.stringify(self.recentlyUsed));
+            }));
+        },
+    }))
+        .postProcessSnapshot(snap => {
+        const { favorites: _, recentlyUsed: __, ...rest } = snap;
+        return rest;
+    });
 }

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

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

package/esm/ucsc-trackhub/doConnect.js

@@ -0,0 +1,127 @@
+import { HubFile, SingleFileHub } from '@gmod/ucsc-hub';
+import { generateTracks, fetchGenomesFile, fetchTrackDbFile, } from './ucscTrackHub';
+import { getConf } from '@jbrowse/core/configuration';
+import { getSession } from '@jbrowse/core/util';
+import { openLocation } from '@jbrowse/core/util/io';
+import { nanoid } from '@jbrowse/core/util/nanoid';
+function resolve(uri, baseUri) {
+    return new URL(uri, baseUri).href;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function doConnect(self) {
+    var _a;
+    const session = getSession(self);
+    const notLoadedAssemblies = [];
+    try {
+        const hubFileLocation = getConf(self, 'hubTxtLocation');
+        const hubFileText = await openLocation(hubFileLocation).readFile('utf8');
+        // @ts-expect-error
+        const hubUri = resolve(hubFileLocation.uri, hubFileLocation.baseUri);
+        const { assemblyManager } = session;
+        if (hubFileText.includes('useOneFile on')) {
+            const hub = new SingleFileHub(hubFileText);
+            const { genome, tracks } = hub;
+            const genomeName = genome.name;
+            const asm = assemblyManager.get(genomeName);
+            if (!asm) {
+                // @ts-expect-error
+                session.addSessionAssembly({
+                    name: genomeName,
+                    sequence: {
+                        type: 'ReferenceSequenceTrack',
+                        trackId: `${genomeName}-${nanoid()}`,
+                        adapter: {
+                            type: 'TwoBitAdapter',
+                            twoBitLocation: {
+                                uri: resolve(genome.data.twoBitPath, hubUri),
+                            },
+                            chromSizesLocation: {
+                                uri: resolve(genome.data.chromSizes, hubUri),
+                            },
+                        },
+                    },
+                });
+            }
+            const asm2 = assemblyManager.get(genomeName);
+            const sequenceAdapter = getConf(asm2, ['sequence', 'adapter']);
+            const tracksNew = generateTracks({
+                trackDb: tracks,
+                trackDbLoc: hubFileLocation,
+                assemblyName: genomeName,
+                sequenceAdapter,
+            });
+            self.addTrackConfs(tracksNew);
+        }
+        else {
+            const hubFile = new HubFile(hubFileText);
+            const genomeFile = hubFile.data.genomesFile;
+            if (!genomeFile) {
+                throw new Error('genomesFile not found on hub');
+            }
+            // @ts-expect-error
+            const hubUri = resolve(hubFileLocation.uri, hubFileLocation.baseUri);
+            const genomesFileLocation = hubUri
+                ? {
+                    uri: resolve(genomeFile, hubUri),
+                    locationType: 'UriLocation',
+                }
+                : {
+                    localPath: genomeFile,
+                    locationType: 'LocalPathLocation',
+                };
+            const genomesFile = await fetchGenomesFile(genomesFileLocation);
+            const map = {};
+            for (const [genomeName, genome] of Object.entries(genomesFile.data)) {
+                const assemblyNames = getConf(self, 'assemblyNames');
+                if (assemblyNames.length > 0 && !assemblyNames.includes(genomeName)) {
+                    continue;
+                }
+                const asm = assemblyManager.get(genomeName);
+                if (!asm) {
+                    notLoadedAssemblies.push(genomeName);
+                    continue;
+                }
+                // @ts-expect-error
+                const db = genome.data.trackDb;
+                if (!db) {
+                    throw new Error('genomesFile not found on hub');
+                }
+                const base = new URL(genomeFile, hubUri);
+                const loc = hubUri
+                    ? {
+                        uri: new URL(db, base).href,
+                        locationType: 'UriLocation',
+                    }
+                    : {
+                        localPath: db,
+                        locationType: 'LocalPathLocation',
+                    };
+                const trackDb = await fetchTrackDbFile(loc);
+                const sequenceAdapter = getConf(asm, ['sequence', 'adapter']);
+                const tracks = generateTracks({
+                    trackDb,
+                    trackDbLoc: loc,
+                    assemblyName: genomeName,
+                    sequenceAdapter,
+                });
+                self.addTrackConfs(tracks);
+                map[genomeName] = tracks.length;
+            }
+            const loadedAssemblies = Object.entries(map);
+            const str1 = loadedAssemblies.length
+                ? `Loaded data from these assemblies: ${loadedAssemblies
+                    .map(([key, val]) => `${key} (${val} tracks)`)
+                    .join(', ')}`
+                : '';
+            const str2 = notLoadedAssemblies.length
+                ? `Skipped data from these assemblies: ${notLoadedAssemblies.join(', ')}`
+                : '';
+            session.notify([str1, str2].filter(f => !!f).join('. '), 'success');
+        }
+    }
+    catch (e) {
+        console.error(e);
+        session.notify(`${getConf(self, 'name')}: "${e}"`, 'error');
+        (_a = session.breakConnection) === null || _a === void 0 ? void 0 : _a.call(session, self.configuration);
+    }
+}

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

@@ -1,4 +1,8 @@
 import PluginManager from '@jbrowse/core/PluginManager';
+/**
+ * #stateModel UCSCTrackHubConnection
+ * extends BaseConnectionModel
+ */
 export default function UCSCTrackHubConnection(pluginManager: PluginManager): import("mobx-state-tree").IModelType<{
     name: import("mobx-state-tree").ISimpleType<string>;
     tracks: import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>;
@@ -10,11 +14,16 @@ export default function UCSCTrackHubConnection(pluginManager: PluginManager): im
         };
         assemblyNames: {
             type: string;
-            defaultValue: never[];
+            defaultValue: never[]; /**
+             * #action
+             */
             description: string;
         };
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>;
 } & {
+    /**
+     * #property
+     */
     configuration: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
         hubTxtLocation: {
             type: string;
@@ -25,7 +34,9 @@ export default function UCSCTrackHubConnection(pluginManager: PluginManager): im
             description: string;
         };
         assemblyNames: {
-            type: string;
+            type: string; /**
+             * #property
+             */
             defaultValue: never[];
             description: string;
         };
@@ -41,6 +52,9 @@ export default function UCSCTrackHubConnection(pluginManager: PluginManager): im
             description: string;
         };
     }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "connectionId">>, undefined>>;
+    /**
+     * #property
+     */
     type: import("mobx-state-tree").ISimpleType<"UCSCTrackHubConnection">;
 }, {
     connect(_arg: {
@@ -67,5 +81,8 @@ export default function UCSCTrackHubConnection(pluginManager: PluginManager): im
     } & import("mobx-state-tree").IStateTreeNode<import("@jbrowse/core/configuration").AnyConfigurationSchemaType>)[]): import("mobx-state-tree").IMSTArray<import("mobx-state-tree").IAnyModelType> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IArrayType<import("mobx-state-tree").IAnyModelType>>;
     clear(): void;
 } & {
+    /**
+     * #action
+     */
     connect(): Promise<void>;
 }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;

package/esm/ucsc-trackhub/model.js

@@ -1,87 +1,32 @@
 import { BaseConnectionModelFactory } from '@jbrowse/core/pluggableElementTypes/models';
-import { ConfigurationReference, readConfObject, getConf, } from '@jbrowse/core/configuration';
-import { getSession } from '@jbrowse/core/util';
+import { ConfigurationReference } from '@jbrowse/core/configuration';
 import { types } from 'mobx-state-tree';
 // locals
 import configSchema from './configSchema';
+/**
+ * #stateModel UCSCTrackHubConnection
+ * extends BaseConnectionModel
+ */
 export default function UCSCTrackHubConnection(pluginManager) {
     return types
         .compose('UCSCTrackHubConnection', BaseConnectionModelFactory(pluginManager), types.model({
+        /**
+         * #property
+         */
         configuration: ConfigurationReference(configSchema),
+        /**
+         * #property
+         */
         type: types.literal('UCSCTrackHubConnection'),
     }))
         .actions(self => ({
+        /**
+         * #action
+         */
         async connect() {
-            var _a, _b;
-            const session = getSession(self);
-            const notLoadedAssemblies = [];
-            try {
-                const hubFileLocation = getConf(self, 'hubTxtLocation');
-                const { generateTracks, fetchGenomesFile, fetchTrackDbFile, fetchHubFile, } = await import('./ucscTrackHub');
-                const hubFile = await fetchHubFile(hubFileLocation);
-                const genomeFile = hubFile.get('genomesFile');
-                if (!genomeFile) {
-                    throw new Error('genomesFile not found on hub');
-                }
-                const hubUri = new URL(hubFileLocation.uri, hubFileLocation.baseUri);
-                const genomesFileLocation = hubUri
-                    ? {
-                        uri: new URL(genomeFile, hubUri).href,
-                        locationType: 'UriLocation',
-                    }
-                    : {
-                        localPath: genomeFile,
-                        locationType: 'LocalPathLocation',
-                    };
-                const genomesFile = await fetchGenomesFile(genomesFileLocation);
-                const map = {};
-                for (const [genomeName, genome] of genomesFile) {
-                    const assemblyNames = getConf(self, 'assemblyNames');
-                    if (assemblyNames.length > 0 &&
-                        !assemblyNames.includes(genomeName)) {
-                        continue;
-                    }
-                    const conf = (_a = session.assemblyManager.get(genomeName)) === null || _a === void 0 ? void 0 : _a.configuration;
-                    if (!conf) {
-                        notLoadedAssemblies.push(genomeName);
-                        continue;
-                    }
-                    const db = genome.get('trackDb');
-                    if (!db) {
-                        throw new Error('genomesFile not found on hub');
-                    }
-                    const base = new URL(genomeFile, hubUri);
-                    const loc = hubUri
-                        ? {
-                            uri: new URL(db, base).href,
-                            locationType: 'UriLocation',
-                        }
-                        : {
-                            localPath: db,
-                            locationType: 'LocalPathLocation',
-                        };
-                    const trackDb = await fetchTrackDbFile(loc);
-                    const seqAdapter = readConfObject(conf, ['sequence', 'adapter']);
-                    const tracks = generateTracks(trackDb, loc, genomeName, seqAdapter);
-                    self.addTrackConfs(tracks);
-                    map[genomeName] = tracks.length;
-                }
-                const loadedAssemblies = Object.entries(map);
-                const str1 = loadedAssemblies.length
-                    ? `Loaded data from these assemblies: ${loadedAssemblies
-                        .map(([key, val]) => `${key} (${val} tracks)`)
-                        .join(', ')}`
-                    : '';
-                const str2 = notLoadedAssemblies.length
-                    ? `Skipped data from these assemblies: ${notLoadedAssemblies.join(', ')}`
-                    : '';
-                session.notify([str1, str2].filter(f => !!f).join('. '), 'success');
-            }
-            catch (e) {
-                console.error(e);
-                session.notify(`There was a problem connecting to the UCSC Track Hub "${self.configuration.name}". Please make sure you have entered a valid hub.txt file. The error that was thrown is: "${e}"`, 'error');
-                (_b = session.breakConnection) === null || _b === void 0 ? void 0 : _b.call(session, self.configuration);
-            }
+            const { doConnect } = await import('./doConnect');
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            doConnect(self);
         },
     }));
 }