alinea 2.0.0-preview.13 → 2.0.0-preview.14

package/dist/dashboard/atoms/explorer.d.ts

@@ -2,6 +2,7 @@ import type { DragTypes, DropTarget, Key } from 'alinea/components';
 import type { Config } from 'alinea/core/Config';
 import { type EntryStatus } from 'alinea/core/Entry';
 import type { EntryFields } from 'alinea/core/EntryFields';
+import { type OpenFilter } from 'alinea/core/Filter';
 import type { Filter } from 'alinea/core/Filter';
 import type { GraphQuery } from 'alinea/core/Graph';
 import type { OverviewSort } from 'alinea/core/Overview';
@@ -74,6 +75,11 @@ export interface ExplorerOptions {
      * explorer. The explorers of a root share them.
      */
     filterState?: PrimitiveAtom<OverviewFilterSelection>;
+    /**
+     * The key of the tab the editor picked, defaults to state kept by the
+     * explorer. Page explorers keep it in the url.
+     */
+    tabState?: WritableAtom<string | undefined, [string | undefined], void>;
     showSelectionControls?: boolean;
     initialSelection?: Array<string>;
     /**
@@ -112,6 +118,11 @@ export interface ExplorerSortState {
 }
 export interface ExplorerReadyPage {
     canUpload: boolean;
+    /**
+     * The condition of the selected tab and the picked filters, undefined when
+     * none applies
+     */
+    filter: OpenFilter<EntryFields> | undefined;
     /** The filter options the listed entries match, by filter key */
     filters: OverviewFilterSelection;
     isMedia: boolean;
@@ -129,6 +140,8 @@ export interface ExplorerReadyPage {
     searchScope: 'workspace' | 'everything';
     searchesEverything: boolean;
     sort: ExplorerSortState;
+    /** The key of the tab shown, undefined when the overview has no tabs */
+    tab: string | undefined;
     view: ExplorerView;
 }
 export declare function explorerPageIsPending(page: ExplorerReadyPage, location: ExplorerLocation, locale: string | null): boolean;
@@ -316,6 +329,8 @@ export declare class ExplorerAtoms {
      * key. The page lists the ones that apply to its overview.
      */
     requestedFilters: PrimitiveAtom<OverviewFilterSelection>;
+    /** The key of the tab the editor picked, undefined for the first tab */
+    requestedTab: WritableAtom<string | undefined, [string | undefined], void>;
     selectedLocale: WritableAtom<string | null, [
         SetStateAction<string | null>
     ], void>;

package/dist/dashboard/atoms/explorer.js

@@ -24,11 +24,14 @@ import { MissingEntryError, treeEntryAtoms } from "./entry.js";
 import {
   columnLinkIds,
   loadColumnValues,
+  hasFilterLoaders,
+  loadFilterOptions,
   loadOverviewParent,
   overviewFilter,
   overviewOrder,
   pickedFilters,
   pickedSort,
+  pickedTab,
   resolveOverview,
   sortedColumn,
   summarizeRows,
@@ -73,7 +76,8 @@ function explorerScrollKey(page) {
     page.resultMode,
     page.searchScope,
     page.search.trim(),
-    page.filters
+    page.filters,
+    page.tab ?? null
   ]);
 }
 function explorerLocations(config, policy, options) {
@@ -284,6 +288,7 @@ var ExplorerAtoms = class {
     this.scrollOffset = options.scrollOffset ?? dispense((_key) => atom(0));
     this.requestedSort = options.sortState ?? atom(void 0);
     this.requestedFilters = options.filterState ?? atom({});
+    this.requestedTab = options.tabState ?? atom(void 0);
     this.mode = options.mode ?? "browse";
     this.hasRowAction = options.onAction !== void 0 || options.enableNavigation === true && options.onConfirm === void 0;
     this.rootScope = this.mode === "search" ? "workspace" : "current";
@@ -399,21 +404,28 @@ var ExplorerAtoms = class {
         uploadResource(location2, parent)
       );
       const items = await itemsPromise;
-      const shown = resolveOverview(
-        get(configAtom),
-        await get(get(this.#overviewParent)),
-        {
-          children: summarizeRows(
-            items.map((item) => get(get(item.data).data.item))
-          )
-        }
-      );
+      const shown = {
+        ...resolveOverview(
+          get(configAtom),
+          await get(get(this.#overviewParent)),
+          {
+            children: summarizeRows(
+              items.map((item) => get(get(item.data).data.item))
+            )
+          }
+        ),
+        // The filters do not follow the rows, their options are loaded
+        filters: overview.filters
+      };
       const requested = get(this.requestedSort);
       const sorted = search.trim() ? void 0 : pickedSort(shown, requested);
       const filters = pickedFilters(shown, requestedFilters);
-      const filtered = Object.keys(filters).length > 0;
+      const requestedTab = get(this.requestedTab);
+      const tab = pickedTab(shown, requestedTab);
+      const filtered = Object.keys(filters).length > 0 || Boolean(tab?.filter);
       return {
         canUpload,
+        filter: overviewFilter(shown, filters, requestedTab),
         filters,
         isMedia,
         items,
@@ -437,6 +449,7 @@ var ExplorerAtoms = class {
           // Entries can not be reordered between hidden ones
           manual: !search.trim() && !sorted && !shown.sort && !filtered
         },
+        tab: tab?.key,
         view
       };
     });
@@ -479,6 +492,8 @@ var ExplorerAtoms = class {
    * key. The page lists the ones that apply to its overview.
    */
   requestedFilters;
+  /** The key of the tab the editor picked, undefined for the first tab */
+  requestedTab;
   selectedLocale;
   root;
   itemsReady;
@@ -556,9 +571,15 @@ var ExplorerAtoms = class {
    */
   overview = atom(async (get) => {
     const parent = await get(get(this.#overviewParent));
-    return resolveOverview(get(configAtom), parent, {
+    const overview = resolveOverview(get(configAtom), parent, {
       mixed: !get(this.#listedParent)
     });
+    if (!hasFilterLoaders(overview)) return overview;
+    get(shaAtom);
+    return loadFilterOptions(overview, {
+      graph: get(graphAtom),
+      locale: get(this.selectedLocale)
+    });
   });
   #parentAt = dispense(
     (workspace, root, parentId) => atom(
@@ -795,7 +816,11 @@ var ExplorerAtoms = class {
         root: entry.root,
         parentId: entry.id,
         locale,
-        filter: overviewFilter(overview, requestedFilters),
+        filter: overviewFilter(
+          overview,
+          requestedFilters,
+          get(this.requestedTab)
+        ),
         status: "preferDraft",
         groupBy: Entry.id,
         orderBy: overviewOrder(overview, get(this.requestedSort)),
@@ -850,7 +875,11 @@ var ExplorerAtoms = class {
       const overview = await get(this.overview);
       const flatList = resultMode === "matches";
       const condition = flatList ? this.#options.condition : void 0;
-      const picked = overviewFilter(overview, requestedFilters);
+      const picked = overviewFilter(
+        overview,
+        requestedFilters,
+        get(this.requestedTab)
+      );
       const locations = searchesMultipleRoots ? get(this.locations) : void 0;
       if (locations?.length === 0) return void 0;
       const allowed = locations && {

package/dist/dashboard/atoms/graph.d.ts

@@ -1,3 +1,8 @@
+import type { SyncProgress } from 'alinea/core/db/LocalStore';
+/** The files fetched by a running sync from the remote. */
+export declare const syncProgressAtom: import("jotai").WritableAtom<SyncProgress | undefined, [], () => void> & {
+    onMount: (init: () => () => void) => () => void;
+};
 export declare const shaAtom: import("jotai").Atom<Promise<string | undefined>>;
 export declare const entryRevisionAtom: (id: string) => import("jotai").Atom<string | undefined>;
 export declare const syncAtom: import("jotai").WritableAtom<null, [], Promise<string | undefined>> & {

package/dist/dashboard/atoms/graph.js

@@ -8,6 +8,7 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/dashboard/atoms/graph.ts
 import { IndexEvent } from "alinea/core/db/IndexEvent";
+import { SyncEvent } from "../boot/SyncEvent.js";
 import { eventsAtom, graphAtom } from "./core.js";
 import { dispense } from "./utils.js";
 var indexStateValueAtom = atom({ entryRevisions: /* @__PURE__ */ new Map() });
@@ -34,6 +35,25 @@ var indexStateAtom = Object.assign(
   ),
   { onMount: (init) => init() }
 );
+var syncProgressValueAtom = atom(void 0);
+var syncProgressAtom = Object.assign(
+  atom(
+    (get) => get(syncProgressValueAtom),
+    (get, set) => {
+      const events = get(eventsAtom);
+      const listen = (event) => {
+        if (event instanceof SyncEvent)
+          set(syncProgressValueAtom, event.progress);
+      };
+      events.addEventListener(SyncEvent.type, listen);
+      return () => {
+        events.removeEventListener(SyncEvent.type, listen);
+        set(syncProgressValueAtom, void 0);
+      };
+    }
+  ),
+  { onMount: (init) => init() }
+);
 var shaAtom = atom(async (get) => {
   const current = get(indexStateAtom).sha;
   if (current) return current;
@@ -51,6 +71,7 @@ var syncAtom = atom(null, async (get, set) => {
 });
 var graphReadyAtom = atom(async (get) => {
   const graph = get(graphAtom);
+  if (isReadyGraph(graph)) return graph.ready();
   if (isSyncableGraph(graph)) await graph.sync();
 });
 function readGraphSha(graph) {
@@ -59,9 +80,13 @@ function readGraphSha(graph) {
 function isSyncableGraph(graph) {
   return typeof graph.sync === "function";
 }
+function isReadyGraph(graph) {
+  return typeof graph.ready === "function";
+}
 export {
   entryRevisionAtom,
   graphReadyAtom,
   shaAtom,
-  syncAtom
+  syncAtom,
+  syncProgressAtom
 };

package/dist/dashboard/atoms/nav.d.ts

@@ -2,6 +2,8 @@ import { Atom, type Getter } from 'jotai';
 import type { OverviewSort } from 'alinea/core/Overview';
 import type { EntryDefaultView } from 'alinea/core/Type';
 import { ReactNode } from 'react';
+import { nav } from '../Href.js';
+export { nav };
 export interface RouteBlock {
     confirm: () => void | Promise<void>;
 }
@@ -12,7 +14,10 @@ export declare const routeBlockAtom: import("jotai").PrimitiveAtom<RouteBlock |
     init: RouteBlock | null;
 };
 export interface DashboardRoute {
-    /** An edit link names an entry by its url, until it is looked up */
+    /**
+     * An edit link names an entry by its url, or by its id without workspace
+     * and root, until it is looked up
+     */
     page?: 'splash' | 'entry' | 'users' | 'edit';
     url?: string;
     workspace?: string;
@@ -22,22 +27,19 @@ export interface DashboardRoute {
     view?: EntryDefaultView;
     /** The column an overview is sorted by, eg. `price` or `-price` */
     sort?: string;
+    /** The tab an overview shows, eg. `active` */
+    tab?: string;
     /** Replace the current history entry instead of adding one */
     replace?: boolean;
 }
-interface ResolvedDashboardRoute extends DashboardRoute {
+export interface ResolvedDashboardRoute extends DashboardRoute {
     page: 'splash' | 'entry' | 'users' | 'edit';
 }
-export declare const nav: {
-    splash(): string;
-    users(): string;
-    /** The editor of the entry at `url`, as linked from a page of the site */
-    edit(url: string, workspace?: string, root?: string): string;
-    entry(workspace?: string, root?: string, entryId?: string, locale?: string | null, view?: EntryDefaultView, sort?: string): string;
-};
 /** The url parameter of an overview sort: the column, prefixed with - when descending */
 export declare function formatOverviewSort(sort?: OverviewSort): string | undefined;
 export declare function parseOverviewSort(value: string | undefined): OverviewSort | undefined;
+/** @internal */
+export declare function hashFromRoute(route: ResolvedDashboardRoute): string;
 interface NavigationRequest {
     browser?: boolean;
     replace?: boolean;
@@ -62,5 +64,9 @@ export declare const pageAtom: Atom<Page>;
  * when `entry` is null. The overview of the current page keeps it in the url.
  */
 export declare const overviewSortAtom: (workspace: string, root: string, entry: string | null) => import("jotai").WritableAtom<OverviewSort | undefined, [sort: OverviewSort | undefined], void>;
+/**
+ * The tab of the overview listing the children of an entry, or of a root
+ * when `entry` is null. The overview of the current page keeps it in the url.
+ */
+export declare const overviewTabAtom: (workspace: string, root: string, entry: string | null) => import("jotai").WritableAtom<string | undefined, [tab: string | undefined], void>;
 export declare function page(render: (page: Page, get: Getter) => ReactNode | Promise<ReactNode>): (page: Page, get: Getter) => ReactNode | Promise<ReactNode>;
-export {};

package/dist/dashboard/atoms/nav.js

@@ -64,32 +64,9 @@ import { workspaceAtom, workspacesAtom } from "./config.js";
 import { configAtom, graphAtom } from "./core.js";
 import { policyAtom } from "./user.js";
 import { dispense } from "./utils.js";
+import { nav } from "../Href.js";
 var routeGuardAtom = atom(null);
 var routeBlockAtom = atom(null);
-var nav = {
-  splash() {
-    return "/";
-  },
-  users() {
-    return "/users";
-  },
-  /** The editor of the entry at `url`, as linked from a page of the site */
-  edit(url, workspace, root) {
-    const params = new URLSearchParams({ url });
-    if (workspace) params.set("workspace", workspace);
-    if (root) params.set("root", root);
-    return `/edit?${params}`;
-  },
-  entry(workspace, root, entryId, locale, view, sort) {
-    const rootPart = root ? `${root}${locale ? `:${locale}` : ""}` : "";
-    const path = `/entry/${[workspace, rootPart, entryId].filter(Boolean).join("/")}`;
-    const params = new URLSearchParams();
-    if (view) params.set("view", view);
-    if (sort) params.set("sort", sort);
-    const search = params.toString();
-    return search ? `${path}?${search}` : path;
-  }
-};
 function formatOverviewSort(sort) {
   if (!sort) return void 0;
   return sort.direction === "desc" ? `-${sort.column}` : sort.column;
@@ -105,11 +82,21 @@ function listKey(workspace, root, entry) {
   return `${workspace ?? ""}/${root ?? ""}/${entry ?? ""}`;
 }
 var overviewSortMemoryAtom = atom(/* @__PURE__ */ new Map());
+var overviewTabMemoryAtom = atom(/* @__PURE__ */ new Map());
 function routeFromHash(hash) {
   const [path, search = ""] = hash.slice(1).split("?");
   const [action, workspace, rootPart = "", entry] = path.split("/").slice(1);
   const params = new URLSearchParams(search);
   const url = params.get("url");
+  const id = params.get("id");
+  const view = params.get("view");
+  if (action === "edit" && id)
+    return {
+      page: "edit",
+      entry: id,
+      locale: params.get("locale") ?? void 0,
+      view: view === "edit" || view === "overview" ? view : void 0
+    };
   if (action === "edit" && url)
     return {
       page: "edit",
@@ -119,8 +106,8 @@ function routeFromHash(hash) {
     };
   const page2 = action === "users" ? "users" : action === "entry" ? "entry" : "splash";
   const [root, locale] = rootPart.split(":");
-  const view = params.get("view");
   const sort = params.get("sort");
+  const tab = params.get("tab");
   return {
     page: page2,
     workspace: page2 === "entry" ? workspace : void 0,
@@ -128,12 +115,20 @@ function routeFromHash(hash) {
     entry: page2 === "entry" ? entry : void 0,
     locale: page2 === "entry" ? locale : void 0,
     view: page2 === "entry" && (view === "edit" || view === "overview") ? view : void 0,
-    sort: page2 === "entry" && sort ? sort : void 0
+    sort: page2 === "entry" && sort ? sort : void 0,
+    tab: page2 === "entry" && tab ? tab : void 0
   };
 }
 function routeFromUpdate(update) {
   if (update.page === "users") return { page: "users" };
   if (update.page === "splash") return { page: "splash" };
+  if (update.page === "edit" && update.entry)
+    return {
+      page: "edit",
+      entry: update.entry,
+      locale: update.locale,
+      view: update.view
+    };
   if (update.page === "edit")
     return update.url ? {
       page: "edit",
@@ -148,10 +143,13 @@ function routeFromUpdate(update) {
     entry: update.entry,
     locale: update.locale,
     view: update.view,
-    sort: update.sort
+    sort: update.sort,
+    tab: update.tab
   };
 }
 function hashFromRoute(route) {
+  if (route.page === "edit" && route.entry)
+    return `#${nav.link(route.entry, route.locale, route.view)}`;
   if (route.page === "edit")
     return `#${nav.edit(route.url ?? "/", route.workspace, route.root)}`;
   return route.page === "splash" ? `#${nav.splash()}` : route.page === "users" ? `#${nav.users()}` : `#${nav.entry(
@@ -160,7 +158,8 @@ function hashFromRoute(route) {
     route.entry,
     route.locale,
     route.view,
-    route.sort
+    route.sort,
+    route.tab
   )}`;
 }
 var locationAtom = atomWithLocation({
@@ -190,7 +189,10 @@ var routeAtom = Object.assign(
         replace: update.replace
       };
       if (request.route.page !== "edit")
-        return navigate(get, set, request, "sort" in update);
+        return navigate(get, set, request, {
+          sort: "sort" in update,
+          tab: "tab" in update
+        });
       const current = get(currentRouteAtom);
       const lookup = ++linkLookups;
       set(
@@ -201,7 +203,7 @@ var routeAtom = Object.assign(
       return linkedRoute(get, request.route).catch(() => ({ page: "splash" })).then((route) => {
         if (lookup !== linkLookups || get(currentRouteAtom) !== current)
           return;
-        navigate(get, set, { route, replace: true }, true);
+        navigate(get, set, { route, replace: true }, { sort: true, tab: true });
       });
     }
   ),
@@ -225,19 +227,23 @@ var routeAtom = Object.assign(
     }
   }
 );
-function navigate(get, set, request, sortGiven) {
+function navigate(get, set, request, given) {
   let { route } = request;
   const key = sortKey(get, request);
-  const explicit = request.browser || route.sort !== void 0 || sortGiven;
-  if (key && !explicit) {
+  if (key && !request.browser) {
     const sort = get(overviewSortMemoryAtom).get(key);
-    if (sort) route = { ...route, sort: formatOverviewSort(sort) };
+    if (sort && route.sort === void 0 && !given.sort)
+      route = { ...route, sort: formatOverviewSort(sort) };
+    const tab = get(overviewTabMemoryAtom).get(key);
+    if (tab && route.tab === void 0 && !given.tab) route = { ...route, tab };
   }
   const previous = get(currentRouteAtom);
   const commit = (replace = request.replace ?? false, syncLocation = !request.browser) => {
     set(currentRouteAtom, route);
-    if (key)
+    if (key) {
       set(overviewSortMemoryAtom, (memory) => remember(memory, key, route.sort));
+      set(overviewTabMemoryAtom, (memory) => rememberTab(memory, key, route.tab));
+    }
     if (!syncLocation) return;
     set(locationAtom, (location) => ({ ...location, hash: hashFromRoute(route) }), {
       replace
@@ -263,8 +269,29 @@ function navigate(get, set, request, sortGiven) {
   }
   commit();
 }
-async function linkedRoute(get, { url = "/", workspace, root }) {
+async function linkedRoute(get, route) {
+  const { url = "/", workspace, root } = route;
   const graph = get(graphAtom);
+  if (route.entry) {
+    const found2 = await graph.first({
+      id: route.entry,
+      status: "preferDraft",
+      select: {
+        workspace: Entry.workspace,
+        root: Entry.root,
+        locale: Entry.locale
+      }
+    });
+    if (!found2) return { page: "splash" };
+    return {
+      page: "entry",
+      workspace: found2.workspace,
+      root: found2.root,
+      entry: route.entry,
+      locale: route.locale ?? found2.locale ?? void 0,
+      view: route.view
+    };
+  }
   const query = {
     workspace,
     root,
@@ -308,6 +335,13 @@ function remember(memory, key, value) {
   else next.delete(key);
   return next;
 }
+function rememberTab(memory, key, value) {
+  if (memory.get(key) === value) return memory;
+  const next = new Map(memory);
+  if (value) next.set(key, value);
+  else next.delete(key);
+  return next;
+}
 var pageAtom = atom((get) => resolvePage(get, get(routeAtom)));
 function resolvePage(get, route) {
   if (route.page === "edit")
@@ -368,13 +402,39 @@ var overviewSortAtom = dispense(
     );
   }
 );
+var overviewTabAtom = dispense(
+  (workspace, root, entry) => {
+    const key = listKey(workspace, root, entry ?? void 0);
+    return atom(
+      (get) => get(overviewTabMemoryAtom).get(key),
+      (get, set, tab) => {
+        const page2 = get(pageAtom);
+        if (page2.type !== "entry" || listKey(page2.workspace, page2.root, page2.entry) !== key) {
+          set(overviewTabMemoryAtom, (memory) => rememberTab(memory, key, tab));
+          return;
+        }
+        set(routeAtom, {
+          workspace,
+          root,
+          entry: page2.entry,
+          locale: page2.locale ?? void 0,
+          view: page2.view,
+          tab,
+          replace: true
+        });
+      }
+    );
+  }
+);
 function page(render) {
   return render;
 }
 export {
   formatOverviewSort,
+  hashFromRoute,
   nav,
   overviewSortAtom,
+  overviewTabAtom,
   page,
   pageAtom,
   parseOverviewSort,

package/dist/dashboard/atoms/overview.d.ts

@@ -6,7 +6,7 @@ import type { Graph, Order, Projection } from 'alinea/core/Graph';
 import type { OrderBy } from 'alinea/core/OrderBy';
 import type { EntryFields } from 'alinea/core/EntryFields';
 import type { OpenFilter } from 'alinea/core/Filter';
-import { type OverviewActionProps, type OverviewCellProps, type OverviewColumnAlign, type OverviewColumnWidth, type OverviewEntry, type OverviewFormatContext, type OverviewOptions, type OverviewSort, type OverviewSortDirection } from 'alinea/core/Overview';
+import { type OverviewActionProps, type OverviewCellProps, type OverviewColumnAlign, type OverviewColumnWidth, type OverviewEntry, type OverviewFilterContext, type OverviewFilterOptions, type OverviewFormatContext, type OverviewHeaderProps, type OverviewOptions, type OverviewSort, type OverviewSortDirection } from 'alinea/core/Overview';
 import { type RootData } from 'alinea/core/Root';
 import { Type } from 'alinea/core/Type';
 import type { View } from 'alinea/core/View';
@@ -65,7 +65,16 @@ export interface OverviewFilterState {
     key: string;
     label: string;
     multiple: boolean;
+    /** The options, empty until `loadFilterOptions` loaded those of `load` */
     options: Array<OverviewFilterOptionState>;
+    /** Loads the options of filters that build them from the content */
+    load?: (context: OverviewFilterContext) => OverviewFilterOptions | Promise<OverviewFilterOptions>;
+}
+/** A tab of an overview */
+export interface OverviewTabState {
+    key: string;
+    label: string;
+    filter?: OpenFilter<EntryFields>;
 }
 /** The keys of the options editors picked, by the key of their filter */
 export interface OverviewFilterSelection {
@@ -82,11 +91,14 @@ export interface OverviewState {
     sorts: Array<OverviewSortState>;
     /** The filters editors can apply */
     filters: Array<OverviewFilterState>;
+    /** The tabs above the list, the first one is selected by default */
+    tabs: Array<OverviewTabState>;
     /** The order children are listed in when the editor did not sort */
     sort?: OrderBy | Array<OrderBy>;
     layout?: 'table' | 'cards';
     thumbnail?: OverviewSelection;
     actions: Array<View<OverviewActionProps>>;
+    header?: View<OverviewHeaderProps>;
     /** The names of the types the parent contains */
     types: Array<string>;
 }
@@ -119,6 +131,10 @@ export interface OverviewResolveOptions {
 export declare function resolveOverview(config: Config, parent: OverviewParent, options?: OverviewResolveOptions): OverviewState;
 /** Resolves an overview for a list of entries of the given types */
 export declare function resolveOverviewOptions(config: Config, overview: OverviewOptions | undefined, types: Array<string>, sort: OrderBy | Array<OrderBy> | undefined, options?: OverviewResolveOptions): OverviewState;
+/** Whether an overview has filters whose options load from the content */
+export declare function hasFilterLoaders(overview: OverviewState): boolean;
+/** Loads the options of the filters that build them from the content */
+export declare function loadFilterOptions(overview: OverviewState, context: OverviewFilterContext): Promise<OverviewState>;
 /** The projection a column selects for entries of a type */
 export declare function columnProjection(select: OverviewSelection | undefined, typeName: string): Projection | undefined;
 /**
@@ -146,10 +162,16 @@ export declare function sortedColumn(overview: OverviewState, sort: OverviewSort
  */
 export declare function pickedFilters(overview: OverviewState, selection: OverviewFilterSelection): OverviewFilterSelection;
 /**
- * The condition of the picked filters: entries match every filter, and any
- * of the options picked of a filter. Undefined when nothing is picked.
+ * The tab the editor picked, or the first tab when it is unknown. Undefined
+ * when the overview has no tabs.
+ */
+export declare function pickedTab(overview: OverviewState, tab: string | undefined): OverviewTabState | undefined;
+/**
+ * The condition of the selected tab and the picked filters: entries match
+ * the tab, every filter, and any of the options picked of a filter.
+ * Undefined when nothing applies.
  */
-export declare function overviewFilter(overview: OverviewState, selection: OverviewFilterSelection): OpenFilter<EntryFields> | undefined;
+export declare function overviewFilter(overview: OverviewState, selection: OverviewFilterSelection, tab?: string): OpenFilter<EntryFields> | undefined;
 /** The rows an overview renders, as loaded by the explorer or an EntryTable */
 export interface OverviewRow {
     id: string;