Skip to main content

HierarchicalTrackSelectorWidget

Auto-generated @jbrowse/mobx-state-tree API for the current JBrowse release — see pluggable elements for concepts. Provided by the data-management plugin. View source.

Properties

MemberDescription
id
id: ElementId
type
type: types.literal('HierarchicalTrackSelectorWidget')
view
view: types.safeReference(
        pluginManager.pluggableMstType('view', 'stateModel'),
      )
trackContainerId
trackContainerId: types.maybe(types.string)		Which of the view's track containers this selector writes into, by id. Absent — the usual case — means the view itself. A view owning several track lists (the synteny view, one per level band) names one here; the container is resolved through view.trackContainerFor rather than referenced directly, because it isn't a view and so isn't a legal target for the view reference above.

Volatiles

MemberDescription
favorites
favorites: localStorageGetJSON<string[]>(favoritesK(), [])
recentlyUsed
recentlyUsed: [] as string[]
selectedTrackIds
selectedTrackIds: [] as string[]		the shopping cart, by trackId — like favorites, recentlyUsed and shownTrackIds, and unlike the config objects it used to hold. A config is not a stable identity: a non-admin's edit to an admin track resolves through a fresh merged object (ADR-032), so a selection holding the old one kept counting in the cart while the row it belonged to went back to looking unselected. Read selection for the configs.
sortTrackNames
sortTrackNames: localStorageGetJSON<boolean | undefined>(
        sortTrackNamesK,
        undefined,
      )
sortCategories
sortCategories: localStorageGetJSON<boolean | undefined>(
        sortCategoriesK,
        undefined,
      )
categoryMode
categoryMode: observable.map<string, CategoryMode>()		per-category rendering mode; absent means expanded. Collapsed and folder are mutually exclusive by construction, so un-foldering a category can't reveal a stale collapse underneath it
filterText
filterText: ''
recentlyUsedCounter
recentlyUsedCounter: 0
favoritesCounter
favoritesCounter: 0

Getters

MemberDescription
trackContainer
TrackContainer | undefined		The track list this selector shows and writes into: the view itself, or one of its containers when trackContainerId names one.
shownTrackIds
Set<string>
favoritesSet
Set<string>
recentlyUsedSet
Set<string>
assemblyNames
string[]
activeSortTrackNames
any
activeSortCategories
any
configAndSessionTrackConfigurations
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
filter out tracks that don't match the current assembly/display types
allTracks
{ group: string; id: string; tracks: TrackNodeSource[]; defaultCollapsed: boolean; loading: boolean; }[]
one group per connection config (not just live instances), so a connection shows in the tree before it's loaded; expanding it hydrates the connection (see toggleCategory). Tracks are empty until then.

Each track is resolved to a TrackNodeSource and sorted here rather than in generateHierarchy, so a filterText keystroke reads no configs and re-sorts nothing (filtering preserves order)
filterQuery
string		the normalized filter box contents; empty when nothing is being searched for
filterActive
boolean		a query is being searched for, which forces categories open (isFilterForcedOpen)
filteredTrackSet
Set<ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>>
tracks matching filterText. An empty query matches everything, since ''.includes is always true, so there is no unfiltered special case
sessionTrackIds
Set<any>		a non-admin's added/copied tracks, which the tree groups under a "Session tracks" category. Membership is the session's own list — the source of truth — not a suffix baked into the trackId
allTrackConfigurations
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
every track the current view can display, tree order. Derived from allTracks so there is exactly one filterTracks() pass, shared with the tree: the faceted selector, favorites and recently-used then can't offer a track the view has no way to open. Connection tracks used to reach the faceted selector unfiltered, which listed a connection's other-assembly tracks next to the config's filtered ones
allTrackConfigurationMap
Map<any, ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>>
selection
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
The selected track configs, resolved from selectedTrackIds on read exactly as favorites and recently-used are. That is the one gate for every delete path (the cart's own "Delete tracks", a single track's menu) — a track that has gone away no longer resolves, so nothing has to clean up after it — and it is what keeps an edited track selected, since the id outlives the config object an edit replaces.
selectionSet
Set<string>		the selected trackIds that still resolve to a track — selection's ids, so a row can ask whether it is selected without the config identity comparison that used to answer it
favoriteTracks
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
filters out tracks that are not in the favorites group
recentlyUsedTracks
(ModelInstanceTypeProps<…> & { setSubschema(slotName: string, data: Record<string, unknown>): any; setSlot(slotName: string, value: unknown): void; } & IStateTreeNode<...>)[]
filters out tracks that are not in the recently used group
hierarchy
{ name: string; id: string; type: "category"; children: {…}[]; }		a group is kept even when no track in it survives the filter, so an empty connection still shows in the tree
rows
TreeRow[]		every rendered row, in order, with its height and scroll offset
treeHeight
number
folderTrackNodes
Map<string, TreeTrackNode[]>
folderCategoryStats
Map<string, { active: number; total: number; }>
hasAnySubcategories
boolean

Methods

MemberDescription
isFavorite
(trackId: string) => boolean
isRecentlyUsed
(trackId: string) => boolean
getRefSeqTrackConf
(assemblyName: string) => (ModelInstanceTypeProps<…> & {…} & IStateTreeNode<…>) | undefined
isSelected
(trackId: string) => boolean
visibleRange
(height: number, scrollTop: number) => { startIndex: number; endIndex: number; }

Actions

MemberDescription
setSortTrackNames
(val: boolean) => void
setSortCategories
(val: boolean) => void
setSelection
(trackIds: string[]) => void
addToSelection
(trackIds: string[]) => void
removeFromSelection
(trackIds: string[]) => void
clearSelection
() => void
addToFavorites
(trackId: string) => void
removeFromFavorites
(trackId: string) => void
clearFavorites
() => void
setRecentlyUsedCounter
(val: number) => void
setRecentlyUsed
(str: string[]) => void
setFavoritesCounter
(val: number) => void
addToRecentlyUsed
(id: string) => void
clearRecentlyUsed
() => void
setView
(view: unknown) => void
setTrackContainerId
(id: string | undefined) => void
setCategoryMode
(id: string, mode: CategoryMode | undefined) => void
clearCategoryModes
() => void
clearFilterText
() => void
setFilterText
(newText: string) => void
setCategoryCollapsed
(id: string, collapsed: boolean) => void		the single gate on accordion state: a folder is a mode the user picked, not an accordion that happens to be shut, so every collapse/expand — one row, a bulk menu item, or "expand all" — passes it by
setFolderCategory
(id: string, isFolder: boolean) => void		folder and collapsed are the same slot, so leaving folder mode always lands on an expanded category
expandAllCategories
() => void
toggleCategory
(id: string) => void
collapseSubCategories
() => void
collapseTopLevelCategories
() => void