@jbrowse/plugin-data-management 2.7.2 → 2.9.0

package/esm/HierarchicalTrackSelectorWidget/facetedModel.js

@@ -0,0 +1,202 @@
+import { addDisposer, getParent, types } from 'mobx-state-tree';
+import { matches } from './util';
+import { readConfObject, } from '@jbrowse/core/configuration';
+import { getTrackName } from '@jbrowse/core/util/tracks';
+import { getSession, localStorageGetItem, measureGridWidth, } from '@jbrowse/core/util';
+import { autorun, observable } from 'mobx';
+import { getRootKeys, findNonSparseKeys } from './facetedUtil';
+const nonMetadataKeys = ['category', 'adapter', 'description'];
+/**
+ * #stateModel FacetedModel
+ */
+export function facetedStateTreeF() {
+    return types
+        .model('FacetedModel', {
+        /**
+         * #property
+         */
+        filterText: types.optional(types.string, ''),
+        /**
+         * #property
+         */
+        showSparse: types.optional(types.boolean, () => JSON.parse(localStorageGetItem('facet-showSparse') || 'false')),
+        /**
+         * #property
+         */
+        showFilters: types.optional(types.boolean, () => JSON.parse(localStorageGetItem('facet-showFilters') || 'true')),
+        /**
+         * #property
+         */
+        showOptions: types.optional(types.boolean, () => JSON.parse(localStorageGetItem('facet-showTableOptions') || 'false')),
+        /**
+         * #property
+         */
+        panelWidth: types.optional(types.number, () => JSON.parse(localStorageGetItem('facet-panelWidth') || '400')),
+    })
+        .volatile(() => ({
+        visible: {},
+        widths: {},
+        useShoppingCart: false,
+        filters: observable.map(),
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setFilter(key, value) {
+            self.filters.set(key, value);
+        },
+        /**
+         * #action
+         */
+        setPanelWidth(width) {
+            self.panelWidth = width;
+        },
+        /**
+         * #action
+         */
+        setUseShoppingCart(f) {
+            self.useShoppingCart = f;
+        },
+        /**
+         * #action
+         */
+        setFilterText(str) {
+            self.filterText = str;
+        },
+        /**
+         * #action
+         */
+        setShowSparse(f) {
+            self.showSparse = f;
+        },
+        /**
+         * #action
+         */
+        setShowOptions(f) {
+            self.showOptions = f;
+        },
+        /**
+         * #action
+         */
+        setShowFilters(f) {
+            self.showFilters = f;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get allTrackConfigurations() {
+            return getParent(self).allTrackConfigurations;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get rows() {
+            const session = getSession(self);
+            const { allTrackConfigurations, filterText } = self;
+            // metadata is spread onto the object for easier access and sorting
+            // by the mui data grid (it's unable to sort by nested objects)
+            return allTrackConfigurations
+                .filter(conf => matches(filterText, conf, session))
+                .map(track => {
+                var _a, _b;
+                const metadata = readConfObject(track, 'metadata');
+                return {
+                    id: track.trackId,
+                    conf: track,
+                    name: getTrackName(track, session),
+                    category: (_a = readConfObject(track, 'category')) === null || _a === void 0 ? void 0 : _a.join(', '),
+                    adapter: (_b = readConfObject(track, 'adapter')) === null || _b === void 0 ? void 0 : _b.type,
+                    description: readConfObject(track, 'description'),
+                    metadata,
+                };
+            });
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get filteredNonMetadataKeys() {
+            return self.showSparse
+                ? nonMetadataKeys
+                : findNonSparseKeys(nonMetadataKeys, self.rows, (r, f) => r[f]);
+        },
+        /**
+         * #getter
+         */
+        get metadataKeys() {
+            return [...new Set(self.rows.flatMap(row => getRootKeys(row.metadata)))];
+        },
+        get filteredMetadataKeys() {
+            return self.showSparse
+                ? this.metadataKeys
+                : findNonSparseKeys(this.metadataKeys, self.rows, 
+                // @ts-expect-error
+                (r, f) => r.metadata[f]);
+        },
+        /**
+         * #getter
+         */
+        get fields() {
+            return [
+                'name',
+                ...this.filteredNonMetadataKeys,
+                ...this.filteredMetadataKeys.map(m => `metadata.${m}`),
+            ];
+        },
+        /**
+         * #getter
+         */
+        get filteredRows() {
+            const arrFilters = [...self.filters.entries()]
+                .filter(f => f[1].length > 0)
+                .map(([key, val]) => [key, new Set(val)]);
+            return self.rows.filter(row => 
+            // @ts-expect-error
+            arrFilters.every(([key, val]) => val.has(row[key])));
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setVisible(args) {
+            self.visible = args;
+        },
+        /**
+         * #action
+         */
+        setWidths(args) {
+            self.widths = args;
+        },
+        afterAttach() {
+            addDisposer(self, autorun(() => {
+                this.setVisible(Object.fromEntries(self.fields.map(c => [c, true])));
+            }));
+            addDisposer(self, autorun(() => {
+                this.setWidths({
+                    name: measureGridWidth(self.rows.map(r => r.name), { maxWidth: 500, stripHTML: true }) + 15,
+                    ...Object.fromEntries(self.filteredNonMetadataKeys
+                        .filter(f => self.visible[f])
+                        .map(e => [
+                        e,
+                        measureGridWidth(self.rows.map(r => r[e]), { maxWidth: 400, stripHTML: true }),
+                    ])),
+                    ...Object.fromEntries(self.filteredMetadataKeys
+                        .filter(f => self.visible['metadata.' + f])
+                        .map(e => {
+                        return [
+                            'metadata.' + e,
+                            measureGridWidth(self.rows.map(r => r.metadata[e]), { maxWidth: 400, stripHTML: true }),
+                        ];
+                    })),
+                });
+            }));
+        },
+    }));
+}

package/esm/HierarchicalTrackSelectorWidget/facetedUtil.d.ts

@@ -0,0 +1,2 @@
+export declare function findNonSparseKeys(keys: readonly string[], rows: Record<string, unknown>[], cb: (row: Record<string, unknown>, f: string) => unknown): string[];
+export declare function getRootKeys(obj: Record<string, unknown>): string[];

package/esm/HierarchicalTrackSelectorWidget/{components/faceted/util.js → facetedUtil.js}

@@ -1,3 +1,6 @@
+export function findNonSparseKeys(keys, rows, cb) {
+    return keys.filter(f => rows.map(r => cb(r, f)).filter(f => !!f).length > 5);
+}
 export function getRootKeys(obj) {
     return Object.entries(obj)
         .map(([key, val]) => (typeof val === 'string' ? key : ''))

package/esm/HierarchicalTrackSelectorWidget/generateHierarchy.d.ts

@@ -1,13 +1,23 @@
 import { AnyConfigurationModel } from '@jbrowse/core/configuration';
-export interface TreeNode {
+import { MenuItem } from '@jbrowse/core/ui';
+export interface TreeTrackNode {
     name: string;
     id: string;
-    conf?: AnyConfigurationModel;
-    checked?: boolean;
-    isOpenByDefault?: boolean;
+    trackId: string;
+    conf: AnyConfigurationModel;
+    checked: boolean;
     children: TreeNode[];
+    type: 'track';
 }
-export declare function generateHierarchy({ model, trackConfs, extra, }: {
+export interface TreeCategoryNode {
+    name: string;
+    id: string;
+    isOpenByDefault: boolean;
+    children: TreeNode[];
+    type: 'category';
+}
+export type TreeNode = TreeTrackNode | TreeCategoryNode;
+export declare function generateHierarchy({ model, trackConfs, extra, noCategories, menuItems, }: {
     model: {
         filterText: string;
         activeSortTrackNames: boolean;
@@ -19,6 +29,8 @@ export declare function generateHierarchy({ model, trackConfs, extra, }: {
             }[];
         };
     };
+    noCategories?: boolean;
+    menuItems?: MenuItem[];
     trackConfs: AnyConfigurationModel[];
     extra?: string;
 }): TreeNode[];

package/esm/HierarchicalTrackSelectorWidget/generateHierarchy.js

@@ -37,7 +37,7 @@ function sortConfs(confs, sortNames, sortCategories) {
     }
     return ret.map(a => a[0]);
 }
-export function generateHierarchy({ model, trackConfs, extra, }) {
+export function generateHierarchy({ model, trackConfs, extra, noCategories, menuItems, }) {
     const hierarchy = { children: [] };
     const { collapsed, filterText, activeSortTrackNames, activeSortCategories, view, } = model;
     if (!view) {
@@ -56,25 +56,29 @@ export function generateHierarchy({ model, trackConfs, extra, }) {
             categories.unshift(' Session tracks');
         }
         let currLevel = hierarchy;
-        // find existing category to put track into or create it
-        for (let i = 0; i < categories.length; i++) {
-            const category = categories[i];
-            const ret = currLevel.children.find(c => c.name === category);
-            const id = [extra, categories.slice(0, i + 1).join(',')]
-                .filter(f => !!f)
-                .join('-');
-            if (!ret) {
-                const n = {
-                    children: [],
-                    name: category,
-                    id,
-                    isOpenByDefault: !collapsed.get(id),
-                };
-                currLevel.children.push(n);
-                currLevel = n;
-            }
-            else {
-                currLevel = ret;
+        if (!noCategories) {
+            // find existing category to put track into or create it
+            for (let i = 0; i < categories.length; i++) {
+                const category = categories[i];
+                const ret = currLevel.children.find(c => c.name === category);
+                const id = [extra, categories.slice(0, i + 1).join(',')]
+                    .filter(f => !!f)
+                    .join('-');
+                if (!ret) {
+                    const n = {
+                        children: [],
+                        name: category,
+                        id,
+                        isOpenByDefault: !collapsed.get(id),
+                        menuItems,
+                        type: 'category',
+                    };
+                    currLevel.children.push(n);
+                    currLevel = n;
+                }
+                else {
+                    currLevel = ret;
+                }
             }
         }
         // uses splice to try to put all leaf nodes above "category nodes" if you
@@ -83,11 +87,13 @@ export function generateHierarchy({ model, trackConfs, extra, }) {
         const r = currLevel.children.findIndex(elt => elt.children.length);
         const idx = r === -1 ? currLevel.children.length : r;
         currLevel.children.splice(idx, 0, {
-            id: conf.trackId,
+            id: [extra, conf.trackId].filter(f => !!f).join(','),
+            trackId: conf.trackId,
             name: getTrackName(conf, session),
             conf,
             checked: viewTracks.some(f => f.configuration === conf),
             children: [],
+            type: 'track',
         });
     }
     return hierarchy.children;

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,6 +34,90 @@ 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
+     * this is removed in postProcessSnapshot, so is generally only loaded
+     * from localstorage
+     */
+    favorites: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
+    /**
+     * #property
+     * this is removed in postProcessSnapshot, so is generally only loaded
+     * from localstorage
+     */
+    recentlyUsed: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
+    /**
+     * #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;
+        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; /**
+             * #action
+             */
+            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; /**
+             * #action
+             */
+            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]>;
 }, {
     selection: ({
         [x: string]: any;
@@ -41,6 +125,25 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
         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 +169,34 @@ 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
+     */
+    setFavoritesCounter(val: number): void;
+    /**
+     * #action
+     */
+    addToRecentlyUsed(id: string): void;
+    /**
+     * #action
+     */
+    clearRecentlyUsed(): void;
     /**
      * #action
      */
@@ -94,7 +225,19 @@ 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
@@ -110,34 +253,42 @@ 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>)[];
+    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
-     * filter out tracks that don't match the current assembly/display types
+     * filters out tracks that are not in the favorites group
      */
-    readonly trackConfigurations: ({
+    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>)[];
-} & {
     /**
-     * #method
+     * #getter
+     * filters out tracks that are not in the recently used group
      */
-    connectionHierarchy(connection: {
-        name: string;
-        tracks: AnyConfigurationModel[];
-    }): TreeNode[];
+    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 +296,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 +306,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 +329,28 @@ export default function stateTreeFactory(pluginManager: PluginManager): import("
 } & {
     afterCreate(): void;
 } & {
+    /**
+     * #getter
+     */
     readonly hasAnySubcategories: boolean;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+} & {
+    afterAttach(): void;
+}, import("mobx-state-tree")._NotCustomized, {
+    type: "HierarchicalTrackSelectorWidget";
+    view: import("mobx-state-tree").ReferenceIdentifier | undefined;
+    id: string;
+    collapsed: import("mobx").IKeyValueMap<boolean>;
+    initialized: boolean | undefined;
+    sortTrackNames: boolean | undefined;
+    sortCategories: boolean | undefined;
+    faceted: import("mobx-state-tree").ModelSnapshotType<{
+        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]>;
+    }>;
+}>;
 export type HierarchicalTrackSelectorStateModel = ReturnType<typeof stateTreeFactory>;
 export type HierarchicalTrackSelectorModel = Instance<HierarchicalTrackSelectorStateModel>;
+export {};