@optionfactory/fml 9.0.0-rc31 → 9.0.0-rc32

package/dist/ful.d.mts

@@ -2075,6 +2075,12 @@ export type TablePageResponse = {
     data: any[];
     size: number;
 };
+export type TableStatus = {
+    count: Element;
+    appending: Element;
+    failure: Element;
+    error: Element;
+};
 export type TableRowLoader = {
     load(pageRequest: TablePageRequest, sortRequest: TableSortRequest | null, filterRequest: Record<string, any>): Promise<TablePageResponse>;
 };
@@ -2090,6 +2096,10 @@ export type TableRowLoader = {
  * @typedef {{ data: any[], size: number }} TablePageResponse the rows of the
  * requested page and the total number of rows across every page
  */
+/**
+ * @typedef {{ count: Element, appending: Element, failure: Element, error: Element }} TableStatus the pieces
+ * of the status bar `paging="infinite"` and `paging="virtual"` show in place of the pager
+ */
 /**
  * @typedef {{ load(pageRequest: TablePageRequest, sortRequest: TableSortRequest|null, filterRequest: Record<string, any>): Promise<TablePageResponse> }} TableRowLoader
  */
@@ -2287,6 +2297,21 @@ declare class TableLoader {
  * for it. Without it the table shows an initial panel until `load`,
  * `reload` or `resetWithFilter` is called.
  *
+ * `paging="infinite"`, read once at the upgrade, replaces the pager with a
+ * status bar saying how many rows of how many are shown, with a reload
+ * button. A load still replaces the rows with one page, scrolling the rows
+ * back to the top; from then on, whenever a row of the last half page
+ * comes into view, the next page is asked with the same size, sort and
+ * filters and appended (see `load`). `reload`, a sort, a filter submit and a
+ * size change start over from the first page.
+ *
+ * `paging="virtual"` shows the same status bar, saying which rows of how many
+ * are in view, and keeps in the page only the page in view and one on either
+ * side of it, the others standing in as empty space sized on the height of
+ * the rows. The rows must scroll inside the table, as `ful-fill` makes them:
+ * a table whose rows the page scrolls appends as `paging="infinite"` does,
+ * and warns. See `load` and `reload`.
+ *
  * Inside the table, and not inside a `ful-table` nested in it, a
  * `page:requested` loads that page with the current size,
  * sort and filters; a `sort:requested` loads the current page with the new
@@ -2310,6 +2335,7 @@ declare class Table extends ParsedElement {
     static config: {
         searchIcon: string;
         emptyIcon: string;
+        reloadIcon: string;
     };
     static template: string;
     static templates: {
@@ -2400,6 +2426,14 @@ declare class Table extends ParsedElement {
      * `submit` listeners as the later ones, and the load its `submit:success`
      * starts is the one awaited. A filter submit that is cancelled, fails or
      * is dropped for one in flight loads nothing, and the promise resolves.
+     *
+     * Under `paging="virtual"`, once rows show, it asks again for the pages in
+     * the page, with the same size, sort and filters, and shows them where
+     * they are, the scroll position and the widths of the columns kept; the
+     * table is busy and settles, fails and dispatches as a load does, one
+     * `load:success` per page. When the answers report fewer rows than the
+     * window starts at, it loads the first page instead. A `src` or `method`
+     * write still starts over from the first page.
      * @returns {Promise<void>} as `load`
      */
     reload(): Promise<void>;
@@ -2435,6 +2469,40 @@ declare class Table extends ParsedElement {
      * failure arrives it changes nothing, dispatches nothing and resolves;
      * superseded while its rows render, it leaves them to the newer load and
      * dispatches nothing.
+     *
+     * Under `paging="infinite"` the status bar takes the pager's place, and
+     * once the load has dispatched `load:success` the next page is awaited:
+     * when a row of the last half page comes into view, through
+     * whatever scrolls it, the following page is asked for with the same
+     * size, sort and filters and its rows are appended. An append runs
+     * without `aria-busy`, a spinner in the status bar standing in, and
+     * dispatches `load:success` or `load:failure` as a load does, its
+     * `pageRequest` naming the appended page. A failed append keeps the
+     * rows, shows the error in the status bar with a retry button and
+     * rejects to nobody, nothing awaiting it. Appending stops once the rows
+     * shown reach the total the last answer reported, or an answer carries
+     * no rows. A load supersedes an append in flight; `reload` repeats this
+     * load, not the pages appended to it.
+     *
+     * Under `paging="virtual"` the load shows its page as the window, scrolled
+     * to where it sits among the total, and measures two things on its rows:
+     * the height the empty space standing in for the other rows is sized on,
+     * and the width of the columns, which then stay as they are, in
+     * proportion, until the next load, so that the pages coming and going do
+     * not move them. From then on the window follows the scroll: the page in
+     * view and one on either side stay in the page and the others are dropped,
+     * the page holding the focus kept while it is within two pages of them. A
+     * page next to the window is asked for at once; a scroll landing farther
+     * waits for the scroll to rest. Window pages are asked for without
+     * `aria-busy`, a spinner in the status bar standing in, and dispatch
+     * `load:success` or `load:failure` per page as appends do; a failure keeps
+     * the rows and offers a retry. The row in view stays where it is as pages
+     * come and go above it: the table measures it before and after and
+     * corrects the scroll by whatever the browser's own scroll anchoring has
+     * not kept, which is all of it where the browser anchors no table rows
+     * (Firefox), has no scroll anchoring or the rows' container declares
+     * `overflow-anchor: none`, and nothing where it has. The table carries
+     * `aria-rowcount` and each row its `aria-rowindex`.
      * @param {TablePageRequest} pageRequest
      * @param {TableSortRequest|null} sortRequest
      * @param {Record<string, any>} filterRequest