zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/sidebar/query.ts

@@ -1,621 +0,0 @@
-/**
- * The sidebar's query layer: what extensions contribute to it (spaces with a
- * base query, filters, sorts, groupings, row decorations and items) and the
- * user's view on top, evaluated by zidane's one session-query evaluator
- * (`zidane/chat/pure`), so every app lists the same rows for the same view.
- *
- * - Spaces: the user's (Settings › Spaces, saved views among them) merged
- *   with the extensions' (`<extension>/<id>`, read-only base query), then the
- *   switcher's own order and hidden spaces on top.
- * - Membership: a session tagged with a space is in it; a space with a query
- *   also lists every session its query matches.
- * - Saving a view as a space builds its query with `viewQuery` (`zidane/chat/pure`),
- *   the builder the terminal app uses too.
- * - The view layer: the agent filter and the contributed filters narrow the
- *   space's rows; a contributed (or the space's) sort and grouping replace
- *   the built-in ones while chosen.
- *
- * React-free.
- */
-import {
-  compileQuery,
-  DEFAULT_SPACE_ID,
-  isExtensionSpaceId,
-  readField,
-  renderTemplate,
-  resolveSessionSpace,
-  validateGroupBy,
-  validateQuery,
-  validateSort,
-  type SessionGroupBy,
-  type SessionQuery,
-  type SessionQueryRow,
-  type SessionSort,
-  type Space,
-} from 'zidane/chat/pure';
-
-import type { ExtensionItemStores } from '../../../extensions/headless/host';
-import type { ComponentWire, ExtensionItem } from '../../../extensions/headless/wire';
-import type { Readable } from '../store';
-import type { SpaceSwitcherPrefs } from './view';
-import { VIEW_CHOICE, type SidebarGroupBy, type SidebarListSession, type SidebarView } from './types';
-
-/**
- * A space as the sidebar lists it: a user space, or an extension's (`extensionId`, read-only), with
- * the base query, grouping and sort a query space carries.
- */
-export interface SidebarSpace extends Space {
-  /** The sessions it lists besides those tagged with it. Absent: only those. */
-  query?: SessionQuery;
-  /** Its own grouping, the default of its view. */
-  groupBy?: SessionGroupBy;
-  /** Its own sort, the default of its view. */
-  sortBy?: SessionSort[];
-  /** The extension that adds it. Absent: the user's. */
-  extensionId?: string;
-  /** Its base (name, query, defaults) can't be edited here: an extension's. */
-  readonly?: boolean;
-  /** Left out of the switcher (its sessions stay in it). */
-  hidden?: boolean;
-  /** An icon class (an extension's `icon.gui`), drawn in place of `icon`. */
-  glyph?: string;
-  /** Extension items may list in it. */
-  items?: boolean;
-}
-
-/** What the extensions contribute to the sidebar, per token. */
-export interface SidebarContributions {
-  /** Spaces for the switcher. */
-  spaces: readonly ExtensionItem<'space'>[];
-  /** Filters for the filter menu. */
-  filters: readonly ExtensionItem<'sidebar-filter'>[];
-  /** Sorts for the filter menu. */
-  sorts: readonly ExtensionItem<'sidebar-sort'>[];
-  /** Groupings for the filter menu. */
-  groups: readonly ExtensionItem<'sidebar-group'>[];
-  /** Extra data on session rows. */
-  decorations: readonly ExtensionItem<'sidebar-decoration'>[];
-  /** Rows among the sessions. */
-  items: readonly ExtensionItem<'sidebar-row'>[];
-}
-
-/** Nothing contributed. */
-export const NO_SIDEBAR_CONTRIBUTIONS: SidebarContributions = {
-  spaces: [],
-  filters: [],
-  sorts: [],
-  groups: [],
-  decorations: [],
-  items: [],
-};
-
-const TOKENS = {
-  spaces: 'space',
-  filters: 'sidebar-filter',
-  sorts: 'sidebar-sort',
-  groups: 'sidebar-group',
-  decorations: 'sidebar-decoration',
-  items: 'sidebar-row',
-} as const satisfies Record<keyof SidebarContributions, keyof ExtensionItemStores>;
-
-/** The token stores {@link sidebarContributionsOf} reads. */
-export type SidebarContributionStores = Pick<ExtensionItemStores, (typeof TOKENS)[keyof typeof TOKENS]>;
-
-/**
- * The six sidebar token stores of an extensions host as one store: a new snapshot whenever one of them changes.
- *
- * @param items - The host's item stores (`ExtensionsHost.items`).
- */
-export function sidebarContributionsOf(items: SidebarContributionStores): Readable<SidebarContributions> {
-  const read = (): SidebarContributions => ({
-    spaces: items.space.get(),
-    filters: items['sidebar-filter'].get(),
-    sorts: items['sidebar-sort'].get(),
-    groups: items['sidebar-group'].get(),
-    decorations: items['sidebar-decoration'].get(),
-    items: items['sidebar-row'].get(),
-  });
-  let current = read();
-  const fresh = (): SidebarContributions => {
-    const next = read();
-    const same = (Object.keys(TOKENS) as (keyof SidebarContributions)[]).every((k) => next[k] === current[k]);
-    if (!same) current = next;
-    return current;
-  };
-  return {
-    get: fresh,
-    subscribe(onChange) {
-      const offs = Object.values(TOKENS).map((token) => items[token].subscribe(onChange));
-      return () => {
-        for (const off of offs) off();
-      };
-    },
-  };
-}
-
-/**
- * An extension's space as the sidebar lists it: read-only, its `newSession` defaults as the space's.
- *
- * @param entry - The space item.
- */
-export function extensionSpaceOf(entry: ExtensionItem<'space'>): SidebarSpace {
-  const wire = entry.item;
-  const defaults = wire.newSession ?? {};
-  const emoji = !wire.icon?.gui && wire.icon?.tui ? wire.icon.tui : undefined;
-  return {
-    id: wire.id,
-    name: wire.name,
-    query: wire.query,
-    extensionId: entry.extension,
-    readonly: true,
-    items: wire.items,
-    ...(wire.icon?.gui ? { glyph: wire.icon.gui } : {}),
-    ...(emoji ? { icon: { kind: 'emoji' as const, value: emoji } } : {}),
-    ...(wire.groupBy ? { groupBy: wire.groupBy } : {}),
-    ...(wire.sortBy ? { sortBy: [...wire.sortBy] } : {}),
-    ...(defaults.providerKey && defaults.modelId
-      ? { providerKey: defaults.providerKey, modelId: defaults.modelId }
-      : {}),
-    ...(defaults.effort ? { effort: defaults.effort } : {}),
-    ...(defaults.agentId ? { agentId: defaults.agentId } : {}),
-  };
-}
-
-const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
-
-/** A saved view's query, grouping and sort as stored in the settings' space list, each checked. */
-function storedQueryFields(raw: unknown): Pick<SidebarSpace, 'query' | 'groupBy' | 'sortBy' | 'hidden'> {
-  if (!isRecord(raw)) return {};
-  const out: Pick<SidebarSpace, 'query' | 'groupBy' | 'sortBy' | 'hidden'> = {};
-  if (raw.query !== undefined && validateQuery(raw.query).length === 0) out.query = raw.query as SessionQuery;
-  if (raw.groupBy !== undefined && validateGroupBy(raw.groupBy).length === 0)
-    out.groupBy = raw.groupBy as SessionGroupBy;
-  if (Array.isArray(raw.sortBy) && raw.sortBy.length > 0 && validateSort(raw.sortBy).length === 0)
-    out.sortBy = raw.sortBy as SessionSort[];
-  if (raw.hidden === true) out.hidden = true;
-  return out;
-}
-
-/**
- * The spaces the sidebar knows: the user's in their order (a saved view's query kept), then the
- * extensions' by `order`. A space the host already lists under an extension's id takes the
- * extension's base and keeps its place; one with an extension space's id (`<extension>/<id>`) whose
- * extension contributes it no more is dropped, as core and the terminal app drop it.
- *
- * @param user - The user's spaces, normalized (`normalizeSpaces`).
- * @param stored - The settings' space list as stored, for what normalizing dropped (a saved view's query).
- * @param extension - The extensions' space items.
- */
-export function mergeSidebarSpaces(
-  user: readonly Space[],
-  stored: unknown,
-  extension: readonly ExtensionItem<'space'>[],
-): SidebarSpace[] {
-  const raw = new Map<string, unknown>();
-  for (const entry of Array.isArray(stored) ? stored : []) {
-    if (isRecord(entry) && typeof entry.id === 'string' && !raw.has(entry.id.trim())) raw.set(entry.id.trim(), entry);
-  }
-  const fromExtensions = new Map(
-    [...extension]
-      .map((entry, index) => ({ entry, index }))
-      .sort((a, b) => a.entry.item.order - b.entry.item.order || a.index - b.index)
-      .map(({ entry }) => [entry.item.id, extensionSpaceOf(entry)] as const),
-  );
-  const out: SidebarSpace[] = [];
-  const placed = new Set<string>();
-  for (const space of user) {
-    const stub = raw.get(space.id);
-    const own = fromExtensions.get(space.id);
-    const fields = storedQueryFields(stub);
-    if (own) {
-      out.push(fields.hidden ? { ...own, hidden: true } : own);
-      placed.add(space.id);
-    } else if (isExtensionSpaceId(space.id) || (isRecord(stub) && typeof stub.extensionId === 'string')) {
-      continue;
-    } else {
-      out.push({ ...space, ...fields });
-    }
-  }
-  for (const [id, space] of fromExtensions) if (!placed.has(id)) out.push(space);
-  return out;
-}
-
-/**
- * The switcher's spaces: the user's order first (ids it names), the rest in their own order, the
- * hidden ones left out. The default space never hides, so the switcher always has one.
- *
- * @param spaces - Every space.
- * @param prefs - The switcher's order and hidden spaces.
- */
-export function switcherSpaces<T extends SidebarSpace>(spaces: readonly T[], prefs: SpaceSwitcherPrefs): T[] {
-  const byId = new Map(spaces.map((s) => [s.id, s]));
-  const named = prefs.order.flatMap((id) => (byId.has(id) ? [byId.get(id)!] : []));
-  const seen = new Set(named.map((s) => s.id));
-  const ordered = [...named, ...spaces.filter((s) => !seen.has(s.id))];
-  const hidden = new Set(prefs.hidden);
-  return ordered.filter((s) => s.id === DEFAULT_SPACE_ID || !(s.hidden || hidden.has(s.id)));
-}
-
-/** A query that throws (an invalid one past validation) matches nothing rather than taking the list down. */
-function safeCompile<R extends SessionQueryRow>(query: SessionQuery, now?: number): (row: R) => boolean {
-  try {
-    return compileQuery<R>(query, now === undefined ? {} : { now });
-  } catch {
-    return () => false;
-  }
-}
-
-/**
- * Which sessions a space lists, or `null` while spaces are off (every session). A session tagged
- * with the space is in it (an unknown tag reads as the default space); a space with a query also
- * lists the sessions it matches. The orchestration Main is in every space.
- *
- * @param space - The space shown.
- * @param spaces - Every space.
- * @param spacesOn - Spaces are on.
- * @param now - Clock for relative times in the query.
- */
-export function spaceMembership<S extends SidebarListSession>(
-  space: SidebarSpace,
-  spaces: readonly Space[],
-  spacesOn: boolean,
-  now?: number,
-): ((row: S) => boolean) | null {
-  if (!spacesOn) return null;
-  const target = resolveSessionSpace(space.id, spaces);
-  const tagged = (row: S) => row.isMain === true || resolveSessionSpace(row.spaceId, spaces) === target;
-  if (!space.query) return tagged;
-  const matches = safeCompile<S & SessionQueryRow>(space.query, now);
-  return (row) => tagged(row) || matches(row as S & SessionQueryRow);
-}
-
-/**
- * The contributed filters a space offers: those for every space and those naming it.
- *
- * @param filters - Every filter item.
- * @param spaceId - The space shown.
- */
-export function filtersForSpace(
-  filters: readonly ExtensionItem<'sidebar-filter'>[],
-  spaceId: string,
-): readonly ExtensionItem<'sidebar-filter'>[] {
-  return filters.filter((f) => f.item.spaces === 'all' || f.item.spaces.includes(spaceId));
-}
-
-/**
- * The query one contributed filter applies at the value the user picked, or `null` (off, or an
- * option no longer offered). A multi filter keeps a session one of its picked options matches.
- *
- * @param filter - The filter's wire form.
- * @param value - What the user picked.
- */
-export function filterQueryOf(
-  filter: ExtensionItem<'sidebar-filter'>['item'],
-  value: boolean | string | readonly string[] | undefined,
-): SessionQuery | null {
-  if (value === undefined || value === false) return null;
-  if (filter.kind === 'toggle') return value === true && filter.query ? filter.query : null;
-  const options = filter.options ?? [];
-  if (filter.kind === 'select') {
-    const option = typeof value === 'string' ? options.find((o) => o.id === value) : undefined;
-    return option ? option.query : null;
-  }
-  const picked = Array.isArray(value) ? options.filter((o) => value.includes(o.id)) : [];
-  return picked.length > 0 ? { any: picked.map((o) => o.query) } : null;
-}
-
-/**
- * The view layer's own narrowing: the agent and the contributed filters the space offers. `null`
- * when none applies.
- *
- * @param view - The space's view.
- * @param filters - The filters the space offers ({@link filtersForSpace}).
- * @param now - Clock for relative times.
- */
-export function viewFilterOf<S extends SidebarListSession>(
-  view: SidebarView,
-  filters: readonly ExtensionItem<'sidebar-filter'>[],
-  now?: number,
-): ((row: S) => boolean) | null {
-  const tests: ((row: S) => boolean)[] = [];
-  const agent = view.agent ?? null;
-  if (agent !== null) tests.push((row) => row.agentId === agent);
-  const values = view.extension?.filters ?? {};
-  for (const { item } of filters) {
-    const query = filterQueryOf(item, values[item.id]);
-    if (query) {
-      const test = safeCompile<S & SessionQueryRow>(query, now);
-      tests.push((row) => test(row as S & SessionQueryRow));
-    }
-  }
-  if (tests.length === 0) return null;
-  return (row) => tests.every((t) => t(row));
-}
-
-/** How the rows group: one of the built-in groupings, or a query grouping (a space's, an extension's, the agents'). */
-export type SidebarGrouping =
-  | { kind: 'builtin'; groupBy: Exclude<SidebarGroupBy, 'agent'> }
-  | { kind: 'query'; groupBy: SessionGroupBy; source: 'space' | 'extension' | 'agent'; id?: string };
-
-/** The agent grouping as a query grouping. */
-export const AGENT_GROUPING: SessionGroupBy = { field: 'agentId' };
-
-/**
- * The grouping that applies: a contributed one the user picked, else the space's own (unless the
- * user picked a built-in one, {@link VIEW_CHOICE}), else the view's `groupBy` ('agent' as a query grouping).
- *
- * @param view - The space's view.
- * @param space - The space shown.
- * @param groups - Every contributed grouping.
- */
-export function resolveGrouping(
-  view: SidebarView,
-  space: SidebarSpace,
-  groups: readonly ExtensionItem<'sidebar-group'>[],
-): SidebarGrouping {
-  const picked = view.extension?.group;
-  const contributed = picked ? groups.find((g) => g.item.id === picked) : undefined;
-  if (contributed) {
-    return { kind: 'query', groupBy: contributed.item.groupBy, source: 'extension', id: contributed.item.id };
-  }
-  if (space.groupBy && picked !== VIEW_CHOICE) return { kind: 'query', groupBy: space.groupBy, source: 'space' };
-  if (view.groupBy === 'agent') return { kind: 'query', groupBy: AGENT_GROUPING, source: 'agent' };
-  return { kind: 'builtin', groupBy: view.groupBy };
-}
-
-/**
- * The sort that applies: a contributed one the user picked, else the space's own (unless the user
- * picked a built-in one, {@link VIEW_CHOICE}). `null`: the view's `sortBy`.
- *
- * @param view - The space's view.
- * @param space - The space shown.
- * @param sorts - Every contributed sort.
- */
-export function resolveSort(
-  view: SidebarView,
-  space: SidebarSpace,
-  sorts: readonly ExtensionItem<'sidebar-sort'>[],
-): readonly SessionSort[] | null {
-  const picked = view.extension?.sort;
-  const contributed = picked ? sorts.find((s) => s.item.id === picked) : undefined;
-  if (contributed) return contributed.item.sortBy;
-  if (space.sortBy && picked !== VIEW_CHOICE) return space.sortBy;
-  return null;
-}
-
-/**
- * The query layer of the space shown, as the sidebar's parts read it: the space, the view, the
- * grouping and sort that apply, and what the extensions contribute to this space.
- */
-export interface SidebarQueryLayer {
-  /** The space shown. */
-  space: SidebarSpace;
-  /** Its view. */
-  view: SidebarView;
-  /** The grouping that applies ({@link resolveGrouping}). */
-  grouping: SidebarGrouping;
-  /** The sort that applies ({@link resolveSort}); `null`: the view's `sortBy`. */
-  sort: readonly SessionSort[] | null;
-  /** The contributed filters this space offers. */
-  filters: readonly ExtensionItem<'sidebar-filter'>[];
-  /** The contributed sorts. */
-  sorts: readonly ExtensionItem<'sidebar-sort'>[];
-  /** The contributed groupings. */
-  groups: readonly ExtensionItem<'sidebar-group'>[];
-  /** The row decorations. */
-  decorations: readonly ExtensionItem<'sidebar-decoration'>[];
-  /** The items listed in this space. */
-  items: readonly ExtensionItem<'sidebar-row'>[];
-  /** The agents the space's sessions run, sorted (before the agent filter). */
-  agents: readonly string[];
-}
-
-/** A chip a decoration puts on a row, its template rendered. */
-export interface SidebarRowChip {
-  /** What it says. */
-  text: string;
-  /** Its tint. */
-  tone?: ExtensionItem<'sidebar-decoration'>['item']['tone'];
-  /** Its icon class. */
-  icon?: string;
-}
-
-/** What the decorations matching one session put on its row. */
-export interface SidebarRowDecoration {
-  /** An icon class beside the title (the first decoration's that has one). */
-  icon?: string;
-  /** The tint of that icon and of chips without their own. */
-  tone?: ExtensionItem<'sidebar-decoration'>['item']['tone'];
-  /** A line under the title. */
-  subtitle?: string;
-  /** Chips, at most {@link MAX_ROW_CHIPS}. */
-  chips: readonly SidebarRowChip[];
-  /**
-   * A component drawn where the app can, in place of the icon and chips of the decoration that
-   * names it (`icon`, `chips`: its fallback). The other decorations' chips draw beside it.
-   */
-  component?: { extension: string; component: ComponentWire; icon?: string; chips: readonly SidebarRowChip[] };
-}
-
-/** The most chips a row shows, whatever the decorations add. */
-export const MAX_ROW_CHIPS = 8;
-
-/** One chip per value: a list facet gives one per element; nothing for a missing value. */
-function chipTexts(value: unknown): string[] {
-  const list = Array.isArray(value) ? value : [value];
-  return list.flatMap((v) =>
-    v === null || v === undefined || v === '' ? [] : [typeof v === 'object' ? JSON.stringify(v) : String(v)],
-  );
-}
-
-/**
- * The decorator for a set of decorations: each session's merged decoration, or `null` when none
- * matches. The first matching decoration gives the icon, tone, subtitle and component; every one
- * adds its chips. Templates render with `renderTemplate`.
- *
- * The output is cached per session object: the same row object gets the same decoration object
- * back, so a row whose session didn't change keeps its memo. A row patched with new facets is a
- * new object and is decorated again. Relative times in `where` are read when a row is first
- * decorated: a new decorator (new decorations) reads them again.
- *
- * @param decorations - Every decoration item, in the host's order.
- * @param now - Clock for relative times in `where`.
- */
-export function createDecorator<S extends SidebarListSession>(
-  decorations: readonly ExtensionItem<'sidebar-decoration'>[],
-  now?: number,
-): (row: S) => SidebarRowDecoration | null {
-  if (decorations.length === 0) return () => null;
-  const compiled = decorations.map((entry) => ({
-    entry,
-    match: entry.item.where ? safeCompile<SessionQueryRow>(entry.item.where, now) : () => true,
-  }));
-  const cache = new WeakMap<S, SidebarRowDecoration | null>();
-  return (session) => {
-    if (cache.has(session)) return cache.get(session)!;
-    const decoration = decorate(session);
-    cache.set(session, decoration);
-    return decoration;
-  };
-
-  function decorate(session: S): SidebarRowDecoration | null {
-    const row = session as unknown as SessionQueryRow;
-    let out: { -readonly [K in keyof SidebarRowDecoration]: SidebarRowDecoration[K] } | null = null;
-    const chips: SidebarRowChip[] = [];
-    for (const { entry, match } of compiled) {
-      if (!match(row)) continue;
-      const { item } = entry;
-      out ??= { chips };
-      const ownIcon = item.icon?.gui && out.icon === undefined ? item.icon.gui : undefined;
-      if (ownIcon) {
-        out.icon = ownIcon;
-        if (item.tone) out.tone = item.tone;
-      }
-      if (item.tone && out.tone === undefined) out.tone = item.tone;
-      if (item.subtitle && out.subtitle === undefined) {
-        const text = typeof item.subtitle === 'string' ? item.subtitle : renderTemplate(item.subtitle.template, row);
-        if (text) out.subtitle = text;
-      }
-      const start = chips.length;
-      for (const chip of item.chips ?? []) {
-        const texts =
-          'text' in chip
-            ? [chip.text]
-            : 'template' in chip
-              ? [renderTemplate(chip.template, row)].filter(Boolean)
-              : chipTexts(readField(row, chip.facet));
-        const tone = chip.tone ?? item.tone;
-        for (const text of texts) {
-          if (chips.length >= MAX_ROW_CHIPS) break;
-          chips.push({ text, ...(tone ? { tone } : {}), ...(chip.icon?.gui ? { icon: chip.icon.gui } : {}) });
-        }
-      }
-      if (item.component && !out.component) {
-        out.component = {
-          extension: entry.extension,
-          component: item.component,
-          ...(ownIcon ? { icon: ownIcon } : {}),
-          chips: chips.slice(start),
-        };
-      }
-    }
-    if (!out) return null;
-    return out.icon || out.subtitle || out.component || chips.length > 0 ? out : null;
-  }
-}
-
-/**
- * The items listed in a space: those naming it, where the space allows items (the default space
- * and user spaces always; an extension's when it says so).
- *
- * @param items - Every item.
- * @param space - The space shown.
- */
-export function itemsForSpace(
-  items: readonly ExtensionItem<'sidebar-row'>[],
-  space: SidebarSpace,
-): readonly ExtensionItem<'sidebar-row'>[] {
-  if (space.extensionId && space.items !== true) return [];
-  return items.filter((e) => e.item.space === space.id);
-}
-
-/** Extension items grouped with their child sessions, as the rows place them. */
-export interface SidebarItemEntry<S extends SidebarListSession> {
-  /** The item. */
-  entry: ExtensionItem<'sidebar-row'>;
-  /** The listed sessions its `children` query matches, in list order. */
-  children: readonly S[];
-}
-
-/**
- * Each item with its child sessions (a session goes to the first item that claims it), and the
- * sessions no item claims.
- *
- * @param items - The space's items.
- * @param sessions - The sessions the space lists.
- * @param now - Clock for relative times.
- */
-export function claimChildSessions<S extends SidebarListSession>(
-  items: readonly ExtensionItem<'sidebar-row'>[],
-  sessions: readonly S[],
-  now?: number,
-): { items: SidebarItemEntry<S>[]; rest: S[] } {
-  const claimed = new Set<string>();
-  const out = items.map((entry) => {
-    const query = entry.item.children;
-    if (!query) return { entry, children: [] as S[] };
-    const match = safeCompile<SessionQueryRow>(query, now);
-    const children = sessions.filter((s) => !claimed.has(s.id) && match(s as unknown as SessionQueryRow));
-    for (const s of children) claimed.add(s.id);
-    return { entry, children };
-  });
-  return { items: out, rest: claimed.size === 0 ? [...sessions] : sessions.filter((s) => !claimed.has(s.id)) };
-}
-
-/** A contributed filter's value that applies something (not off, not an empty pick). */
-const filterValueOn = (value: boolean | string | readonly string[] | undefined): boolean =>
-  value !== undefined && value !== false && value !== '' && !(Array.isArray(value) && value.length === 0);
-
-/**
- * Whether the view narrows the space's sessions: an archive axis other than `active`, a project,
- * an activity window, an agent, or a contributed filter the space offers turned on. Grouping and
- * sort don't count.
- *
- * @param view - The space's view.
- * @param filters - The filters the space offers ({@link filtersForSpace}); a value kept for another one doesn't count.
- */
-export function viewFiltersOn(view: SidebarView, filters: readonly ExtensionItem<'sidebar-filter'>[]): boolean {
-  if (view.archive !== 'active' || view.project !== null || view.activity !== 'all') return true;
-  if (view.agent) return true;
-  const values = view.extension?.filters ?? {};
-  return filters.some(({ item }) => filterValueOn(values[item.id]));
-}
-
-/**
- * The patch that turns every filter of a view off ({@link viewFiltersOn}), keeping its grouping,
- * sort and the contributed grouping and sort picked.
- *
- * @param view - The space's view.
- */
-export function clearedViewFilters(view: SidebarView): Partial<SidebarView> {
-  return {
-    archive: 'active',
-    project: null,
-    activity: 'all',
-    agent: null,
-    extension: { ...view.extension, filters: {} },
-  };
-}
-
-/**
- * The first saved-view name no space has yet: `nameOf(1)`, `nameOf(2)`…
- *
- * @param spaces - Every space.
- * @param nameOf - The name of the n-th saved view (`labels.savedViewName`).
- */
-export function nextSavedViewName(spaces: readonly Pick<Space, 'name'>[], nameOf: (n: number) => string): string {
-  const taken = new Set(spaces.map((s) => s.name));
-  let n = 1;
-  while (taken.has(nameOf(n))) n += 1;
-  return nameOf(n);
-}