@startsimpli/ui 0.4.110 → 0.4.112

package/src/components/facet-tree/__tests__/facet-tree.test.tsx

@@ -0,0 +1,228 @@
+/**
+ * The facet tree engine (bd startsim-6fceh).
+ *
+ * These pin the two properties that are not obvious from the render: it asks the
+ * server for ONE LEVEL at a time, and it draws each level from that level's own
+ * response and nothing else. The second one is the security property — a tree
+ * that merged responses, or kept a flat set of every node seen, would put on
+ * screen a node the server never returned for this reader.
+ */
+import * as React from 'react'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+
+import { FacetTree } from '../FacetTree'
+import { useFacetLevels } from '../useFacetLevels'
+import { facetName, facetTrail, FACET_ROOT } from '../path'
+import type { FacetLevelLoader, FacetLevelQuery, FacetNode, Paginated } from '../types'
+
+function node(path: string, count: number, hasChildren = false): FacetNode {
+  return { path, name: facetName(path), count, hasChildren }
+}
+
+function page(results: FacetNode[], count = results.length): Paginated<FacetNode> {
+  return { count, next: null, previous: null, results }
+}
+
+/** The fixture tree. `/Clients-old` is a SIBLING of `/Clients`, not a child. */
+const TREE: Record<string, Paginated<FacetNode>> = {
+  '/': page([
+    node('/Clients', 1204, true),
+    node('/Clients-old', 3),
+    node('/Internal', 12),
+  ]),
+  '/Clients': page([node('/Clients/Acme', 900, true), node('/Clients/Globex', 300)]),
+  '/Clients/Acme': page([node('/Clients/Acme/GCC Weekly', 41)]),
+}
+
+function loaderFor(tree = TREE): jest.MockedFunction<FacetLevelLoader> {
+  return jest.fn(async (query: FacetLevelQuery) => tree[query.under] ?? page([]))
+}
+
+function Harness({
+  load,
+  pageSize,
+  onUnavailable,
+}: {
+  load?: FacetLevelLoader
+  pageSize?: number
+  onUnavailable?: () => void
+}) {
+  const [selected, setSelected] = React.useState<string | null>(null)
+  const levels = useFacetLevels({ load, pageSize, onUnavailable })
+  return (
+    <>
+      <span data-testid="selected">{selected ?? 'none'}</span>
+      <FacetTree
+        levels={levels.levels}
+        expanded={levels.expanded}
+        selected={selected}
+        onSelect={setSelected}
+        onToggle={levels.toggle}
+        onMore={levels.loadMore}
+        countNoun="record"
+        nodeNoun="scope"
+      />
+    </>
+  )
+}
+
+describe('useFacetLevels — one level per request', () => {
+  it('asks for the root and nothing else on mount', async () => {
+    const load = loaderFor()
+    render(<Harness load={load} />)
+
+    await screen.findByRole('button', { name: /^Clients, 1,204 records inside$/ })
+    expect(load).toHaveBeenCalledTimes(1)
+    expect(load).toHaveBeenCalledWith(expect.objectContaining({ under: FACET_ROOT, page: 1 }))
+  })
+
+  it('draws the disclosure triangle from has_children, with no probe request', async () => {
+    const load = loaderFor()
+    render(<Harness load={load} />)
+
+    await screen.findByRole('button', { name: 'Expand Clients' })
+    // `/Internal` and `/Clients-old` said hasChildren:false, so they get no control.
+    expect(screen.queryByRole('button', { name: 'Expand Internal' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Expand Clients-old' })).toBeNull()
+    // Still exactly the one root request — the triangles cost nothing.
+    expect(load).toHaveBeenCalledTimes(1)
+  })
+
+  it('fetches a child level only when it is expanded, and only once', async () => {
+    const user = userEvent.setup()
+    const load = loaderFor()
+    render(<Harness load={load} />)
+
+    await user.click(await screen.findByRole('button', { name: 'Expand Clients' }))
+    await screen.findByRole('button', { name: /^Acme, 900 records inside$/ })
+    expect(load).toHaveBeenCalledWith(expect.objectContaining({ under: '/Clients', page: 1 }))
+    expect(load).toHaveBeenCalledTimes(2)
+
+    // Collapse and re-expand: the level is already known.
+    await user.click(screen.getByRole('button', { name: 'Collapse Clients' }))
+    await user.click(await screen.findByRole('button', { name: 'Expand Clients' }))
+    await screen.findByRole('button', { name: /^Acme, 900 records inside$/ })
+    expect(load).toHaveBeenCalledTimes(2)
+  })
+
+  it('never draws a sibling under the node it merely shares a prefix with', async () => {
+    const user = userEvent.setup()
+    render(<Harness load={loaderFor()} />)
+
+    await user.click(await screen.findByRole('button', { name: 'Expand Clients' }))
+    await screen.findByRole('button', { name: /^Acme, 900 records inside$/ })
+
+    // `/Clients-old` is at the ROOT level and stays there. A prefix match would
+    // have pulled it under `/Clients`; a level cache keyed by `under=` cannot.
+    const clientsList = screen
+      .getByRole('button', { name: /^Acme, 900 records inside$/ })
+      .closest('ul') as HTMLElement
+    expect(clientsList).toBeTruthy()
+    expect(
+      Array.from(clientsList.querySelectorAll('button')).map((b) => b.getAttribute('title')),
+    ).toEqual(expect.not.arrayContaining(['/Clients-old']))
+    expect(screen.getByRole('button', { name: /^Clients-old, 3 records inside$/ })).toBeTruthy()
+  })
+
+  it('hands back the full path the server returned, verbatim', async () => {
+    const user = userEvent.setup()
+    render(<Harness load={loaderFor()} />)
+
+    await user.click(await screen.findByRole('button', { name: 'Expand Clients' }))
+    await user.click(await screen.findByRole('button', { name: /^Acme, 900 records inside$/ }))
+    expect(screen.getByTestId('selected')).toHaveTextContent('/Clients/Acme')
+  })
+
+  it('goes three levels deep, one request per level', async () => {
+    const user = userEvent.setup()
+    const load = loaderFor()
+    render(<Harness load={load} />)
+
+    await user.click(await screen.findByRole('button', { name: 'Expand Clients' }))
+    await user.click(await screen.findByRole('button', { name: 'Expand Acme' }))
+    await screen.findByRole('button', { name: /^GCC Weekly, 41 records inside$/ })
+    expect(load).toHaveBeenCalledTimes(3)
+  })
+})
+
+describe('useFacetLevels — paging', () => {
+  it('offers the server’s remaining count and appends the next page', async () => {
+    const user = userEvent.setup()
+    const first = page([node('/A', 1), node('/B', 2)], 4)
+    const second = page([node('/C', 3), node('/D', 4)], 4)
+    const load = jest.fn(async (query: FacetLevelQuery) => (query.page === 1 ? first : second))
+
+    render(<Harness load={load} pageSize={2} />)
+
+    const more = await screen.findByRole('button', { name: 'Show 2 more scopes' })
+    expect(load).toHaveBeenCalledWith({ under: '/', page: 1, pageSize: 2 })
+
+    await user.click(more)
+    await screen.findByRole('button', { name: /^D, 4 records inside$/ })
+    // APPENDED, not replaced.
+    expect(screen.getByRole('button', { name: /^A, 1 record inside$/ })).toBeTruthy()
+    expect(screen.queryByRole('button', { name: /Show .* more/ })).toBeNull()
+    expect(load).toHaveBeenLastCalledWith({ under: '/', page: 2, pageSize: 2 })
+  })
+
+  it('says "1 more scope" rather than "1 more scopes"', async () => {
+    const load = jest.fn(async () => page([node('/A', 1)], 2))
+    render(<Harness load={load} />)
+    expect(await screen.findByRole('button', { name: 'Show 1 more scope' })).toBeTruthy()
+  })
+})
+
+describe('useFacetLevels — a deployment that cannot answer', () => {
+  it.each([404, 400, 501])('treats %s as "no tree here" and says so once', async (status) => {
+    const onUnavailable = jest.fn()
+    const load = jest.fn(async () => {
+      throw Object.assign(new Error('nope'), { status })
+    })
+    render(<Harness load={load} onUnavailable={onUnavailable} />)
+
+    await waitFor(() => expect(onUnavailable).toHaveBeenCalledTimes(1))
+    expect(screen.queryByRole('alert')).toBeNull()
+  })
+
+  it('reports a real failure on screen instead of pretending there is no tree', async () => {
+    const onUnavailable = jest.fn()
+    const load = jest.fn(async () => {
+      throw Object.assign(new Error('Boom'), { status: 500 })
+    })
+    render(<Harness load={load} onUnavailable={onUnavailable} />)
+
+    expect(await screen.findByRole('alert')).toHaveTextContent('Boom')
+    expect(onUnavailable).not.toHaveBeenCalled()
+  })
+
+  it('names the 401 and 403 cases in words a reader can act on', async () => {
+    const load = jest.fn(async () => {
+      throw Object.assign(new Error('x'), { status: 401 })
+    })
+    render(<Harness load={load} />)
+    expect(await screen.findByRole('alert')).toHaveTextContent(/session has expired/i)
+  })
+
+  it('reports unavailable when the client has no loader at all', async () => {
+    const onUnavailable = jest.fn()
+    render(<Harness onUnavailable={onUnavailable} />)
+    await waitFor(() => expect(onUnavailable).toHaveBeenCalledTimes(1))
+  })
+})
+
+describe('path helpers', () => {
+  it('names a node by its last segment only', () => {
+    expect(facetName('/Clients/Acme/GCC Weekly')).toBe('GCC Weekly')
+    expect(facetName('/Clients')).toBe('Clients')
+    expect(facetName('/')).toBe('/')
+  })
+
+  it('builds a trail of ancestors, each carrying a whole path', () => {
+    expect(facetTrail('/A/B/C')).toEqual([
+      { path: '/A', name: 'A' },
+      { path: '/A/B', name: 'B' },
+      { path: '/A/B/C', name: 'C' },
+    ])
+  })
+})

package/src/components/facet-tree/index.ts

@@ -0,0 +1,26 @@
+/**
+ * @startsimpli/ui/facet-tree — a lazily-paged, server-navigable tree over a
+ * materialized path attribute.
+ *
+ * DATA-AGNOSTIC ON PURPOSE. It knows about `{path, name, count, hasChildren}`
+ * and an injected `load({under, page, pageSize})`, and nothing else — not what a
+ * scope is, not what a document is. `ScopeSwitcher` (`../scope`) is the first
+ * consumer; the Library folder tree in `@startsimpli/integrations` is the second
+ * one waiting to converge onto it (bd startsim-6fceh's notes carry that bead).
+ */
+export { FACET_ROOT, PATH_SEPARATOR, facetName, facetTrail } from './path'
+export { FacetTree, type FacetTreeProps, type FacetTreeSlot } from './FacetTree'
+export {
+  useFacetLevels,
+  isTreeUnsupported,
+  type FacetLevels,
+  type UseFacetLevelsOptions,
+} from './useFacetLevels'
+export {
+  EMPTY_LEVEL,
+  type FacetNode,
+  type FacetLevelQuery,
+  type FacetLevelLoader,
+  type FacetLevelState,
+  type Paginated,
+} from './types'

package/src/components/facet-tree/path.ts

@@ -0,0 +1,55 @@
+/**
+ * Path arithmetic for a materialized-path tree — the ONLY file in this folder
+ * allowed to take a path apart, and only ever for DISPLAY.
+ *
+ * The rule the rest of the tree obeys: a path the server returned goes back out
+ * VERBATIM as the next `under=` and as the next `?attr.<name>=`. A client that
+ * re-joins segments has a small escaping bug in it, and the server returns whole
+ * paths precisely so that nobody has to. Both helpers below take apart a string
+ * the server already handed to THIS reader, purely to label a control; neither
+ * synthesizes a node, and nothing here is ever sent back to the server.
+ */
+
+/** The separator the tenant declares at `/api/v1/capabilities/#path_separator`. */
+export const PATH_SEPARATOR = '/'
+
+/**
+ * The root of any materialized-path tree.
+ *
+ * `under=/` means EVERYTHING, not "the top-level rows": the server's
+ * `subtree_bound()` makes the root's descendant prefix `/`, which every stored
+ * path begins with. It is the reading a person expects from the top of a file
+ * browser.
+ */
+export const FACET_ROOT = PATH_SEPARATOR
+
+/** The last segment of a full path, for display. `/A/B` -> `B`. */
+export function facetName(path: string): string {
+  const segments = String(path ?? '')
+    .split(PATH_SEPARATOR)
+    .filter(Boolean)
+  return segments.length > 0 ? segments[segments.length - 1] : String(path ?? '')
+}
+
+/**
+ * The ancestors of a path, for a breadcrumb — `/A/B/C` -> `/A`, `/A/B`, `/A/B/C`.
+ *
+ * SPLITTING IS SAFE HERE and the module header's rule still holds, because this
+ * is not the act that rule forbids. It puts no node on screen that the server did
+ * not already name to this reader, and fills no level from another level's
+ * response. The forbidden act is SYNTHESISING a node — deciding that a container
+ * exists, or what is in it, from data the server did not return about it — and a
+ * breadcrumb over a path the reader is already holding does none of that.
+ */
+export function facetTrail(path: string): Array<{ path: string; name: string }> {
+  const segments = String(path ?? '')
+    .split(PATH_SEPARATOR)
+    .filter(Boolean)
+  const trail: Array<{ path: string; name: string }> = []
+  let at = ''
+  for (const segment of segments) {
+    at = `${at}${PATH_SEPARATOR}${segment}`
+    trail.push({ path: at, name: segment })
+  }
+  return trail
+}

package/src/components/facet-tree/types.ts

@@ -0,0 +1,89 @@
+/**
+ * The wire shape of a lazily-paged, server-navigable tree over a materialized
+ * path attribute — `GET /api/v1/entities/facets/?type=<t>&attr=<a>&under=/x`.
+ *
+ * DELIBERATELY FIELD-IDENTICAL TO `CorpusFolder` / `FolderQuery` / `CorpusPage`
+ * in `@startsimpli/integrations` (bd startsim-ei8gm.5). That package built the
+ * first consumer of this API — the Library folder tree — and it cannot import
+ * this one (neither package depends on the other today, see bd startsim-6fceh's
+ * notes). Keeping the field names identical means the day the two converge is a
+ * rename and a re-export, not a redesign.
+ *
+ * `Paginated<T>` is reused from `../collection/types` rather than minted a third
+ * time: the server hands back one DRF envelope and this package should describe
+ * it once.
+ */
+import type { Paginated } from '../collection/types'
+
+export type { Paginated }
+
+/**
+ * ONE NODE of the tree, exactly as `/entities/facets/` describes it.
+ *
+ * Every field here is answered by the SAME response that listed the node, which
+ * is what makes a lazy tree cost one request per expanded level and no probe
+ * request per node.
+ */
+export interface FacetNode {
+  /**
+   * The FULL path, as the server returned it — `/Clients/Acme`, never `Acme`.
+   *
+   * It goes straight back out unmodified as the next `under=` and as the value
+   * a consumer filters by. The client never joins segments; see `./path.ts`.
+   */
+  path: string
+  /** The last segment, for display only. Derived from `path`, never sent back. */
+  name: string
+  /**
+   * DESCENDANT records, not direct children — `/Clients` counts the rows under
+   * `/Clients/Acme/GCC` too. That is the number a person reading a collapsed
+   * node wants, and it is why a node can say 1,204 and open onto nothing of its
+   * own.
+   */
+  count: number
+  /**
+   * Whether anything sits BELOW this node. The disclosure control, answered by
+   * the response that listed the node — so drawing a triangle costs no extra
+   * request.
+   */
+  hasChildren: boolean
+}
+
+/**
+ * ONE LEVEL of the tree. `under` is a path the server previously returned, or
+ * `FACET_ROOT` (`/`) for the top, which means everything.
+ */
+export interface FacetLevelQuery {
+  under: string
+  page?: number
+  pageSize?: number
+}
+
+/**
+ * The single read a tree needs, injected. A caller hands in a method off its own
+ * authed client; this package never constructs a request of its own.
+ *
+ * IT MUST BE REFERENTIALLY STABLE across renders. Its identity is the reset key:
+ * a new loader means a new principal or a new workspace, and everything already
+ * fetched was gated for the OLD one, so it is dropped rather than reused.
+ */
+export type FacetLevelLoader = (query: FacetLevelQuery) => Promise<Paginated<FacetNode>>
+
+/** What is known about ONE container's children. Keyed by that container's path. */
+export interface FacetLevelState {
+  rows: FacetNode[]
+  /** The server's own total for this container, so "is there more" is not guessed. */
+  total: number
+  /** Highest page fetched for THIS container. */
+  page: number
+  loading: boolean
+  error: string
+}
+
+export const EMPTY_LEVEL: FacetLevelState = {
+  rows: [],
+  total: 0,
+  page: 0,
+  loading: false,
+  error: '',
+}

package/src/components/facet-tree/useFacetLevels.ts

@@ -0,0 +1,197 @@
+'use client'
+
+/**
+ * THE LEVEL CACHE — the whole state machine of a lazily-paged tree, with no
+ * opinion about what the tree is a tree OF.
+ *
+ * ONE LEVEL PER REQUEST, PAGED (CLAUDE.md rule 8). Expanding a node asks the
+ * server for that node's children and nothing else. The alternative — read every
+ * record's path and assemble the tree in the browser — works on today's rows and
+ * expires in the low thousands, and it is the failure `/entities/facets/`
+ * (start-simpli-api#391) was shipped to end.
+ *
+ * THE SECURITY PROPERTY IS THE SHAPE OF THE STATE, and it is why `levels` is a
+ * map keyed by `under=` rather than a flat set of nodes seen. The facet read is
+ * gated server-side out of `EntityViewSet.get_queryset()` itself, so a member is
+ * shown the containers their own readable rows are in — and a container name
+ * leaks plenty on its own (`/Clients/Acquisition-TargetCo`). So every
+ * container's children are stored under that container's OWN key and rendered
+ * from that key alone. Nothing here merges two responses, fills one level from
+ * another level's answer, or infers a parent from a child: each of those would
+ * put on screen a node the server never returned for THIS reader, which is the
+ * leak rebuilt in the browser out of rows the server was careful about.
+ */
+
+import * as React from 'react'
+import { FACET_ROOT } from './path'
+import { EMPTY_LEVEL } from './types'
+import type { FacetLevelLoader, FacetLevelState } from './types'
+
+export interface UseFacetLevelsOptions {
+  /**
+   * The injected read. OPTIONAL because a client can legitimately not offer one
+   * — an older fork has no facet route at all — and the honest response to that
+   * is the same as to a 404: no tree.
+   *
+   * MUST BE STABLE. See `FacetLevelLoader`; its identity is the reset key.
+   */
+  load?: FacetLevelLoader
+  /** Nodes per request. The server pages; this is the page size it is asked for. */
+  pageSize?: number
+  /** The top of the tree. `/` means everything. */
+  root?: string
+  /**
+   * Set false to hold every request. A switcher that has never been opened needs
+   * no data — its label comes from the URL — so a closed one costs no round trip.
+   */
+  enabled?: boolean
+  /**
+   * Told once when this data source cannot enumerate the tree at all — a fork
+   * that predates the facet route 404s, an older one 400s. A consumer uses it to
+   * stop reserving space for a tree that will never draw.
+   */
+  onUnavailable?: () => void
+}
+
+export interface FacetLevels {
+  levels: Record<string, FacetLevelState>
+  expanded: Record<string, boolean>
+  /** True once the source has said, in any of its several dialects, "no tree here". */
+  unavailable: boolean
+  levelOf: (under: string) => FacetLevelState
+  toggle: (path: string) => void
+  loadMore: (under: string, page: number) => void
+  /** Fetch a container's first page if it has never been asked for. Idempotent. */
+  ensure: (under: string) => void
+}
+
+function failure(err: unknown): string {
+  const status = (err as { status?: number })?.status
+  if (status === 401) return 'Your session has expired. Sign in again.'
+  if (status === 403) return 'You do not have access to these.'
+  return (err as { message?: string })?.message || 'Could not load.'
+}
+
+/**
+ * A 404/400 means "this deployment has no tree enumeration", not "no nodes".
+ *
+ * BOTH CODES, because both are real deployments. A fork built before
+ * start-simpli-api#391 has no `/entities/facets/` route and answers 404; one
+ * built before the parameters were in its vocabulary screens `attr`/`under` as
+ * unknown and answers 400. To a reader they mean the same thing.
+ */
+export function isTreeUnsupported(err: unknown): boolean {
+  const status = (err as { status?: number })?.status
+  return status === 404 || status === 400 || status === 501
+}
+
+export function useFacetLevels({
+  load,
+  pageSize = 100,
+  root = FACET_ROOT,
+  enabled = true,
+  onUnavailable,
+}: UseFacetLevelsOptions): FacetLevels {
+  const [levels, setLevels] = React.useState<Record<string, FacetLevelState>>({})
+  const [expanded, setExpanded] = React.useState<Record<string, boolean>>({})
+  const [unavailable, setUnavailable] = React.useState(false)
+
+  /** Containers already asked for, so a re-render or a re-open costs nothing. */
+  const requested = React.useRef<Set<string>>(new Set())
+  const told = React.useRef(false)
+
+  // A new loader means a new principal or a new workspace. Everything already
+  // fetched was gated for the OLD one, so it is dropped rather than reused — a
+  // stale level is exactly the leak this file is careful about.
+  React.useEffect(() => {
+    requested.current = new Set()
+    told.current = false
+    setLevels({})
+    setExpanded({})
+    setUnavailable(false)
+  }, [load])
+
+  const fetchLevel = React.useCallback(
+    async (under: string, page: number) => {
+      if (!load) {
+        setUnavailable(true)
+        return
+      }
+      setLevels((prev) => ({
+        ...prev,
+        [under]: { ...(prev[under] ?? EMPTY_LEVEL), loading: true, error: '' },
+      }))
+      try {
+        const result = await load({ under, page, pageSize })
+        setLevels((prev) => {
+          const before = prev[under] ?? EMPTY_LEVEL
+          return {
+            ...prev,
+            [under]: {
+              // APPEND, and only ever within this same `under=`. Page 2 of a
+              // container is more of the answer the server already gave about
+              // that container; it is not evidence about any other one.
+              rows: page > 1 ? [...before.rows, ...result.results] : result.results,
+              total: result.count,
+              page,
+              loading: false,
+              error: '',
+            },
+          }
+        })
+      } catch (err) {
+        if (isTreeUnsupported(err)) {
+          setUnavailable(true)
+          return
+        }
+        setLevels((prev) => ({
+          ...prev,
+          [under]: { ...(prev[under] ?? EMPTY_LEVEL), loading: false, error: failure(err) },
+        }))
+      }
+    },
+    [load, pageSize],
+  )
+
+  /**
+   * The ref rather than a check on `levels`, because the guard has to hold
+   * BETWEEN renders — two clicks in the same tick, or a StrictMode
+   * double-invoke, would otherwise both see an empty map and both fetch.
+   */
+  const ensure = React.useCallback(
+    (under: string) => {
+      if (requested.current.has(under)) return
+      requested.current.add(under)
+      void fetchLevel(under, 1)
+    },
+    [fetchLevel],
+  )
+
+  React.useEffect(() => {
+    if (enabled && !unavailable) ensure(root)
+  }, [ensure, enabled, unavailable, root])
+
+  React.useEffect(() => {
+    if (unavailable && !told.current) {
+      told.current = true
+      onUnavailable?.()
+    }
+  }, [unavailable, onUnavailable])
+
+  const toggle = React.useCallback(
+    (path: string) => {
+      setExpanded((prev) => ({ ...prev, [path]: !prev[path] }))
+      // Idempotent, so calling it on a COLLAPSE is free — and calling it here
+      // rather than inside the updater above keeps the updater pure.
+      ensure(path)
+    },
+    [ensure],
+  )
+
+  const levelOf = React.useCallback(
+    (under: string) => levels[under] ?? EMPTY_LEVEL,
+    [levels],
+  )
+
+  return { levels, expanded, unavailable, levelOf, toggle, loadMore: fetchLevel, ensure }
+}

package/src/components/index.ts

@@ -190,3 +190,50 @@ export * from './validation'
 // scorecard) + ReviewNotes (critique thread). Controlled + presentational; light
 // (React + lucide only), so they ride the main barrel like health / validation.
 export * from './review'
+
+// Scope switcher (bd startsim-6fceh) + the data-agnostic facet tree it is built
+// on. Named exports rather than `export *` so the DRF `Paginated` envelope does
+// not enter the main barrel — it belongs to the '@startsimpli/ui/collection'
+// contract and re-exporting it here would give it two homes.
+export {
+  ScopeSwitcher,
+  ScopeSwitcherControlled,
+  useScopeParam,
+  useScopedCollectionClient,
+  createScopeClient,
+  SCOPE_PARAM,
+  SCOPE_ALL,
+} from './scope'
+export type {
+  ScopeSwitcherProps,
+  ScopeSwitcherControlledProps,
+  ScopeSwitcherBaseProps,
+  ScopeSwitcherLabels,
+  ScopeParam,
+  UseScopeParamOptions,
+  ScopeClient,
+  ScopeNode,
+  ScopeMatch,
+  ScopeSearchQuery,
+  ScopeHttp,
+  CreateScopeClientOptions,
+} from './scope'
+export {
+  FacetTree,
+  useFacetLevels,
+  isTreeUnsupported,
+  facetName,
+  facetTrail,
+  FACET_ROOT,
+  PATH_SEPARATOR,
+} from './facet-tree'
+export type {
+  FacetTreeProps,
+  FacetTreeSlot,
+  FacetLevels,
+  UseFacetLevelsOptions,
+  FacetNode,
+  FacetLevelQuery,
+  FacetLevelLoader,
+  FacetLevelState,
+} from './facet-tree'