@fusion.dev/helix-headless 0.6.0 → 0.7.1

package/types/vue.d.ts

@@ -1985,6 +1985,20 @@ export type HelixHeadlessDataTableVueProps = {
   "default-sort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
   /** Order to open on, where nothing declared one. */
   defaultSort?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
+  /** How tall a row is taken to be before it has been drawn, in pixels.
+
+Only read while `windowed`, and a starting guess rather than a claim: a
+cell that wraps makes its row taller than its neighbors, and the window
+replaces this with what each row came to as it draws. It still has to be
+close, because it is what the scrollbar is built from before anything has
+been measured. */
+  estimate?: (HelixHeadlessDataTable["estimate"]) | undefined;
+  /** The order, as `field:direction`.
+
+Set it and this element defers: a reader's click fires `helix-sort` and
+changes nothing until a new value arrives. `default-sort` seeds an order this
+element then owns. */
+  sort?: (HelixHeadlessDataTable["sort"]) | undefined;
   /** The field naming a row's stable identity.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -1994,20 +2008,20 @@ attached to the row it belongs to. Left unset the index is the key, which is
 correct only while nothing reorders: it is why this defaults to something
 that works and is worth setting anyway. */
   key?: (HelixHeadlessDataTable["key"]) | undefined;
-  /** The order, as `field:direction`.
-
-Set it and this element defers: a reader's click fires `helix-sort` and
-changes nothing until a new value arrives. `default-sort` seeds an order this
-element then owns. */
-  sort?: (HelixHeadlessDataTable["sort"]) | undefined;
-  /** Accessible name for the grid. */
-  label?: (HelixHeadlessDataTable["label"]) | undefined;
   /** What the rows are narrowed to, as one query across every column.
 
 One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   filter?: (HelixHeadlessDataTable["filter"]) | undefined;
+  /** Accessible name for the grid. */
+  label?: (HelixHeadlessDataTable["label"]) | undefined;
+  /** The page on show, from 1.
+
+Clamped on the way out, so what this reports is the page it drew: a
+bookmarked link to page 99 of a result that has since shrunk reads back as
+the last page rather than as 99. */
+  page?: (HelixHeadlessDataTable["page"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -2017,12 +2031,6 @@ the client cannot hold the data, so this is not an optimization, it is the
 only mode that works, and it is here from the start because adding it later
 inverts the data flow. */
   mode?: (HelixHeadlessDataTable["mode"]) | undefined;
-  /** The page on show, from 1.
-
-Clamped on the way out, so what this reports is the page it drew: a
-bookmarked link to page 99 of a result that has since shrunk reads back as
-the last page rather than as 99. */
-  page?: (HelixHeadlessDataTable["page"]) | undefined;
   /** How many rows a page holds. Zero is every row, which is what "no paging" means.
 
 **It announces nothing, and that is not an omission.** Nothing in this
@@ -2046,6 +2054,24 @@ nothing about the result. Ignored in `client` mode rather than trusted,
 because two sources for one count is the mistake, and here the array is the
 one that cannot be stale. */
   total?: (HelixHeadlessDataTable["total"]) | undefined;
+  /** Draws the rows in view and stands empty space in for the rest.
+
+**Not a `mode`.** `mode` says where the rows come from and who filtered
+them; this says how many of the ones we hold get drawn. They are
+independent: a consumer fetching five thousand rows a chunk at a time wants
+`mode="server"` and this at once, and folding this into `mode` would be an
+API that forbids that combination for no reason.
+
+**Composes with `paginated` rather than excluding it.** A window over a
+page is coherent -- the page is the slice of the result, the window is the
+part of that slice on screen -- and the arithmetic is the same either way,
+so there is nothing to forbid. Together they suit a table paging at a
+thousand rows, where the page is a reasonable fetch and a poor render.
+
+Off by default. Windowing costs a scroll listener, a measurement per row
+drawn, and a `block-size` on the scrolling box, and a table of twenty rows
+should pay none of them. */
+  windowed?: (HelixHeadlessDataTable["windowed"]) | undefined;
   /** Whether to draw a pagination under the grid.
 
 On by default once a page size is set, because a paged table with no way to