@formicoidea/labre-core 0.48.0 → 0.49.0

package/dist/_pkgs/affine-fragment-doc-title/title-band/title-band.js

@@ -44,7 +44,7 @@ import { css, html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { TITLE_BAND_ADD, TITLE_BAND_COLLAPSE, TITLE_BAND_EMPTY, TITLE_BAND_EXPAND, TITLE_BAND_LABEL, TITLE_BAND_LOADING, TITLE_BAND_NOT_SHOWN, TITLE_BAND_OPEN_PANEL, TITLE_BAND_SHOW_HERE, } from '../translations.js';
-import { bandCellData, bandCellMeta, bandCellValue, bandWriteValue, isBandReadonlyType, sameBandValue, } from './band-cell.js';
+import { bandCellData, bandCellMeta, bandCellValue, bandOptionsWritable, bandWriteValue, isBandReadonlyType, sameBandValue, } from './band-cell.js';
 import { formatPropertyValue, isPropertyValueEmpty } from './format.js';
 import { showPageHere } from './show-here.js';
 export const LABRE_TITLE_BAND = 'labre-title-band';
@@ -329,6 +329,31 @@ let TitleBand = (() => {
                 console.error('[title-band] set was refused', error);
             });
         }
+        /**
+         * A definition a select's tag menu commits (a created or renamed option):
+         * handed to the host's `setData`, never applied here.
+         */
+        _writeData(property, data) {
+            const service = this._sources?.service;
+            if (!service?.setData || this._isReadonlyChip(property))
+                return;
+            if (property.dataWritable !== true)
+                return;
+            let written;
+            try {
+                written = service.setData(this.docId, property.id, {
+                    ...property.data,
+                    options: data.options,
+                });
+            }
+            catch (error) {
+                console.error('[title-band] setData threw', error);
+                return;
+            }
+            Promise.resolve(written).catch((error) => {
+                console.error('[title-band] setData was refused', error);
+            });
+        }
         /** A value a cell commits: unchanged, nothing is written. */
         _commit(prop, cellType, value) {
             if (sameBandValue(cellType, prop.value, value))
@@ -351,11 +376,14 @@ let TitleBand = (() => {
             const meta = bandCellMeta(prop.type, cellType => std.getOptional(StandaloneCellMetaProvider(cellType)));
             if (!meta)
                 return null;
+            const cellType = meta.type;
+            const optionsWritable = bandOptionsWritable(cellType, prop, !!sources.service.setData) &&
+                !this._isReadonlyChip(prop);
             const cached = sources.cells.get(prop.id);
-            if (cached?.type === prop.type)
+            if (cached?.type === prop.type &&
+                cached.optionsWritable === optionsWritable)
                 return cached.cell;
             const { id, type } = prop;
-            const cellType = meta.type;
             const current$ = computed(() => {
                 const state = sources.sheet$.value;
                 if (state.status !== 'ready')
@@ -378,8 +406,20 @@ let TitleBand = (() => {
                 },
                 featureFlags$: this._featureFlags$,
                 serviceGet: key => std.getOptional(key),
+                // A chip creates and renames options only, never deletes, recolours
+                // or reorders one (product owner, 2026-10-14).
+                ...(optionsWritable
+                    ? {
+                        dataSet: (data) => {
+                            const current = current$.peek();
+                            if (current)
+                                this._writeData(current, data);
+                        },
+                        optionEdits: 'create-rename',
+                    }
+                    : {}),
             });
-            sources.cells.set(id, { type, cell });
+            sources.cells.set(id, { type, optionsWritable, cell });
             return cell;
         }
         _renderFallback(prop) {

package/dist/_pkgs/affine-model/blocks/database/types.d.ts

@@ -10,8 +10,24 @@ export type CellDataType<ValueType = unknown> = {
     value: ValueType;
 };
 export type SerializedCells = Record<string, Record<string, CellDataType>>;
+/**
+ * Where a row of a view opens (ADR 0035 §8). Append-only: a stored value is
+ * never renamed or removed. An absent `openIn` reads `side`.
+ */
+export declare const DATABASE_VIEW_OPEN_IN: readonly ["side", "center", "full"];
+export type DatabaseViewOpenIn = (typeof DATABASE_VIEW_OPEN_IN)[number];
+/**
+ * The stored shape every view in `props.views` shares; each mode adds its own
+ * data on top. `sourceId` and `openIn` arrived in 0.49 (ADR 0035 §8, red
+ * zone): optional, `undefined` by default and never written on load, so a
+ * view stored by 0.48 or earlier is still a valid view and a 0.48 client
+ * ignores them. `sourceId` absent means the block's own implicit source.
+ * Held by `view-basic-data.unit.spec.ts`.
+ */
 export type ViewBasicDataType = {
     id: string;
     name: string;
     mode: string;
+    sourceId?: string;
+    openIn?: DatabaseViewOpenIn;
 };

package/dist/_pkgs/affine-model/blocks/database/types.js

@@ -1 +1,5 @@
-export {};
+/**
+ * Where a row of a view opens (ADR 0035 §8). Append-only: a stored value is
+ * never renamed or removed. An absent `openIn` reads `side`.
+ */
+export const DATABASE_VIEW_OPEN_IN = ['side', 'center', 'full'];

package/dist/_pkgs/affine-shared/services/data-source-picker-service.d.ts

@@ -0,0 +1,139 @@
+import type { ExtensionType } from '../../store/index.js';
+import type { ReadonlySignal } from '@preact/signals-core';
+/** One source of a host database, as the picker lists it. */
+export interface DataSourcePickerSource {
+    /** What a view stores as its `sourceId` (ADR 0035 §8). */
+    id: string;
+    /** Display name, already localized by the host. */
+    title: string;
+}
+/** One database the host offers a view of. */
+export interface DataSourcePickerDatabase {
+    /**
+     * What a linked view stores as its block's `externalSourceId`: the value
+     * the host's `DatabaseDataSourceProvider` reads back to build the view's
+     * data source. Opaque to the library (the Labre app writes
+     * `labre-base:<uuid>`, labre ADR-0046).
+     */
+    id: string;
+    /** Display name, already localized by the host. */
+    title: string;
+    /** Its live sources, in the host's order; the first is the default. */
+    sources: readonly DataSourcePickerSource[];
+}
+/** A property of a source as a view refers to it (an import's correspondence). */
+export interface DataSourcePickerProperty {
+    /** The property id the views store. */
+    id: string;
+    name: string;
+    /** The property type (`title`, `select`, `number`…). */
+    type: string;
+    /** A select's options: a filter on it stores their ids. */
+    options?: readonly {
+        id: string;
+        value: string;
+    }[];
+}
+/**
+ * A view of another database, or a saved view template, to copy into this
+ * database: never linked, the copy is a new view of this database.
+ */
+export interface DataSourcePickerImportedView {
+    /** The stored view as read there (`props.views[i]`, or a template). */
+    view: Readonly<Record<string, unknown>>;
+    /** The properties of the source the view read there. */
+    properties: readonly DataSourcePickerProperty[];
+    /**
+     * Source property id → property of this database, or `null` to ignore
+     * it. An id left out is ignored. A filter or a sort on an ignored property
+     * is removed, a column of it is dropped, a grouping by it is undone.
+     */
+    mapping: Readonly<Record<string, string | null>>;
+}
+/** What `importView` hands the host: where the copy lands, and the verb. */
+export interface DataSourcePickerImportRequest {
+    /** The database the copy lands in, as `list()` names it. */
+    databaseId: string;
+    /** The source the copy reads (the current view's); absent, the implicit one. */
+    sourceId?: string;
+    /** The properties of that source, for the correspondence. */
+    properties: readonly DataSourcePickerProperty[];
+    /** The layouts this database can add (preset types). Any other is refused. */
+    layouts: readonly string[];
+    /**
+     * Add the copy as a new view and show it; its id, or `null` when nothing
+     * was added (the page turned read-only, a layout not offered). One undo
+     * step.
+     */
+    add(view: DataSourcePickerImportedView): string | null;
+}
+/**
+ * The current view as a template (labre PRD REQ-DB-4): its layout, where its
+ * pages open, its properties shown and their order, its grouping. Never its
+ * filters, its sorts or a manual order: those belong to one view.
+ */
+export interface DataSourcePickerViewTemplate {
+    databaseId: string;
+    sourceId?: string;
+    /** The view's name, as shown. */
+    name: string;
+    view: Readonly<Record<string, unknown>>;
+    properties: readonly DataSourcePickerProperty[];
+}
+/**
+ * The data-source picker (ADR 0035 §9c, issue B12): the host lists the
+ * databases and sources a view may read, and creates them. The library draws
+ * the picker (`@labre/affine-database-editor`), inserts the view and never
+ * learns where a database lives.
+ *
+ * The identifier lives in core, not in the bundle §9c named: core's own
+ * slash entries that create a database read `createDatabase` (§5), and a seam
+ * identifier lives in the lowest package that reads it (§3).
+ */
+export interface DataSourcePickerService {
+    /**
+     * The databases on offer. MUST return synchronously and MUST NOT throw: the
+     * signal may start empty and fill later, the picker redraws.
+     */
+    list(): ReadonlySignal<readonly DataSourcePickerDatabase[]>;
+    /**
+     * Create a database; it resolves to the new one, with at least one source,
+     * or `null` when nothing was created (the user cancelled, the host
+     * refused). Absent, nothing creates a database: this is the host's kill
+     * switch, and the creating slash entries ("Table View", "Kanban View")
+     * leave the menu.
+     */
+    createDatabase?(): Promise<DataSourcePickerDatabase | null>;
+    /**
+     * Create a source in `databaseId`; it resolves to the new source, or
+     * `null`. Absent, the picker offers no "New source".
+     */
+    createSource?(databaseId: string): Promise<DataSourcePickerSource | null>;
+    /**
+     * Import a view of another database into `request.databaseId` (labre PRD
+     * REQ-DB-2, ADR 0035 amendment of 2026-10-14): the host lets the reader
+     * pick a view it may read and map its properties, then calls
+     * `request.add`. Absent, "+ view" offers no import and the full page lists
+     * no "Import a view".
+     */
+    importView?(request: DataSourcePickerImportRequest): void;
+    /**
+     * Keep the current view as a template, where the host keeps templates
+     * (labre: the workspace's library, REQ-DB-15); a later `importView` may
+     * offer it. Resolves `true` once saved. Absent, no "Save as template".
+     */
+    saveViewTemplate?(template: DataSourcePickerViewTemplate): Promise<boolean>;
+}
+export declare const DataSourcePickerProvider: import("../../global/di/types.js").ServiceIdentifier<DataSourcePickerService> & (<U extends DataSourcePickerService = DataSourcePickerService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host seam: the host's databases and sources, or `null` to say it has none.
+ *
+ * Absent or `null`: no "Linked view of a database" entry, "+ view" offers
+ * only the sources the block already shows, and the slash entries create a
+ * native inline database as in 0.48. With a service but no `createDatabase`,
+ * no entry creates a database at all.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export declare function DataSourcePickerExtension(service: DataSourcePickerService | null): ExtensionType;

package/dist/_pkgs/affine-shared/services/data-source-picker-service.js

@@ -0,0 +1,22 @@
+import { createIdentifier } from '../../global/di/index.js';
+export const DataSourcePickerProvider = createIdentifier('LabreDataSourcePicker');
+/**
+ * Host seam: the host's databases and sources, or `null` to say it has none.
+ *
+ * Absent or `null`: no "Linked view of a database" entry, "+ view" offers
+ * only the sources the block already shows, and the slash entries create a
+ * native inline database as in 0.48. With a service but no `createDatabase`,
+ * no entry creates a database at all.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export function DataSourcePickerExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through on purpose: `getOptional` then reports no
+            // picker, which is the whole "0.48 entries" story.
+            di.override(DataSourcePickerProvider, () => service);
+        },
+    };
+}

package/dist/_pkgs/affine-shared/services/index.d.ts

@@ -7,6 +7,7 @@ export * from './canvas-local-visibility.js';
 export * from './citation-service/index.js';
 export * from './command-usage-service.js';
 export * from './comment-service/index.js';
+export * from './data-source-picker-service.js';
 export * from './doc-display-meta-service.js';
 export * from './doc-mode-service.js';
 export * from './drag-handle-config.js';

package/dist/_pkgs/affine-shared/services/index.js

@@ -7,6 +7,7 @@ export * from './canvas-local-visibility.js';
 export * from './citation-service/index.js';
 export * from './command-usage-service.js';
 export * from './comment-service/index.js';
+export * from './data-source-picker-service.js';
 export * from './doc-display-meta-service.js';
 export * from './doc-mode-service.js';
 export * from './drag-handle-config.js';

package/dist/_pkgs/affine-shared/services/telemetry-service/database.d.ts

@@ -1,3 +1,4 @@
+import type { TelemetryEvent } from './types.js';
 type OrderType = 'desc' | 'asc';
 export type WithParams<Map, T> = {
     [K in keyof Map]: Map[K] & T;
@@ -15,13 +16,50 @@ export type ViewParams = {
 export type DatabaseParams = {
     blockId: string;
 };
+/**
+ * Where a database row opened (ADR 0035 §8, §9a): the view's stored `openIn`
+ * (absent reads `side`), or `full` for a Ctrl/Cmd-click. Mirrors
+ * `DatabaseViewOpenIn` of `@labre/affine-model`, which this layer cannot
+ * import.
+ */
+export type DatabaseRowOpenMode = 'side' | 'center' | 'full';
 export type DatabaseViewEvents = {
     DatabaseSortClear: {
         rulesCount: number;
     };
+    /**
+     * The user picked another layout for a view (B17). Replaces the never
+     * emitted {@link DatabaseViewEvents.ChangeDatabaseLayout}.
+     */
+    DatabaseViewTypeChanged: TelemetryEvent & {
+        fromViewType: string;
+        toViewType: string;
+    };
+    /**
+     * The user grouped a view, changed its grain or removed the grouping (B17).
+     * `groupBy` is the group-by config name (`select`, `date-month`…), `none`
+     * once removed; `propertyType` the grouped property's type. Never the
+     * property's id or name. Replaces the never emitted `CreateDatabaseGroup`.
+     */
+    DatabaseGroupChanged: TelemetryEvent & {
+        groupBy: string;
+        propertyType?: string;
+    };
+    /**
+     * A row was opened from a view (B17). `rowKind` says whether the source's
+     * rows are documents (`rowsAreDocuments`) or blocks of the database. Never
+     * the row's id: a hosted row is a document id (ADR 0035 §12).
+     */
+    DatabaseRowOpened: TelemetryEvent & {
+        mode: DatabaseRowOpenMode;
+        newTab: boolean;
+        rowKind: 'document' | 'block';
+    };
+    /** @deprecated never emitted; `DatabaseViewAdded` reports a new view. */
     CreateDatabaseView: {
         viewType: string;
     };
+    /** @deprecated never emitted; see `DatabaseViewTypeChanged`. */
     ChangeDatabaseLayout: {
         fromViewType: string;
         toViewType: string;
@@ -36,15 +74,36 @@ export type DatabaseFilterEvents = {
     CreateDatabaseFilter: {};
 };
 export type DatabaseGroupEvents = {
+    /** @deprecated never emitted; see `DatabaseGroupChanged`. */
     CreateDatabaseGroup: {
         groupBy: string;
     };
 };
 export type DatabaseEvents = {
     AddDatabase: {};
+    /** @deprecated no longer emitted since 0.49; see `DatabaseViewAdded`. */
     AddDatabaseView: {
         type: string;
     };
+    /**
+     * A view was added by a user gesture (ADR 0035 §12, B17): `existing` when
+     * it reads a source the database already has (its own included), `new`
+     * when the gesture created the source with it, `import` when it is the
+     * copy of another database's view or of a view template (0.49, appended).
+     * A database created with its first view reports `BlockCreated`, not this.
+     */
+    DatabaseViewAdded: TelemetryEvent & {
+        viewType: string;
+        source: 'existing' | 'new' | 'import';
+    };
+    /**
+     * A hosted source's values could not be loaded (ADR 0035 §9e, B17): once
+     * per failure of a source, not per banner drawn. `retryable` says whether
+     * the source offers `retryValues`.
+     */
+    DatabaseValuesLoadFailed: TelemetryEvent & {
+        retryable: boolean;
+    };
 };
 export interface DatabaseAllSortEvents {
     DatabaseSortAdd: {};

package/dist/_pkgs/affine-shared/services/title-band-service.d.ts

@@ -47,6 +47,14 @@ export interface TitleBandProperty {
     value: unknown;
     /** A read-only property draws its chip and opens no editor. */
     readonly: boolean;
+    /**
+     * Whether the host takes a write of this property's definition (`data`)
+     * through {@link TitleBandService.setData}; absent means `false`. A select
+     * or multi-select whose options can be created and renamed from its chip
+     * says `true`; one whose option ids are its labels (the Labre app's
+     * `tags`) never does.
+     */
+    dataWritable?: boolean;
 }
 /**
  * The state of one page's sheet. Same four states as ADR 0006: the signal may
@@ -89,6 +97,22 @@ export interface TitleBandService {
      * clears its pending state. `value` is `null` to clear.
      */
     set(docId: string, propertyId: string, value: unknown): Promise<void>;
+    /**
+     * Write one property's definition, its `data` (a select's `options`): the
+     * band's one definition write, distinct from `set` (product owner,
+     * 2026-10-14). Called only for a property whose `dataWritable` is `true`
+     * on a chip that is not read-only, and only to create an option or rename
+     * one: the chip's tag menu offers no delete, no colour and no reordering.
+     * `data` is the whole new config, the option list in data-view's shape
+     * (`{ id, value, color }`, a created option first, its id minted by the
+     * library). The library never applies it: the option shows once it arrives
+     * through `sheet$`, so a host applies it to its sheet at once and owns the
+     * rollback. Creating an option is followed at once by a `set` that selects
+     * it: the host applies the two in the order it receives them. A rejection is
+     * the host's to report; the band logs it. Absent, every chip's options are
+     * fixed: no "Create", no option menu (the 0.48 band).
+     */
+    setData?(docId: string, propertyId: string, data: Record<string, unknown>): Promise<void>;
     /**
      * The band's "+" (REQ-PR-4): what it does is the host's (open the
      * workspace's property settings, or create a database property directly

package/dist/_pkgs/data-view/core/component/cell-status/cell-status-css.d.ts

@@ -0,0 +1,2 @@
+export declare const cellSkeletonStyle: string;
+export declare const cellEmptyStyle: string;

package/dist/_pkgs/data-view/core/component/cell-status/cell-status-css.js

@@ -0,0 +1,16 @@
+import { css } from '@emotion/css';
+// The title band's loading chip, in a cell (`labre-title-band-skeleton`):
+// same hover tone, same radius, no motion to honour or disable.
+export const cellSkeletonStyle = css({
+    display: 'block',
+    width: '60%',
+    maxWidth: '120px',
+    height: '16px',
+    margin: '8px',
+    borderRadius: '6px',
+    backgroundColor: 'var(--affine-hover-color)',
+});
+export const cellEmptyStyle = css({
+    display: 'block',
+    minHeight: '32px',
+});

package/dist/_pkgs/data-view/core/component/cell-status/cell-status.d.ts

@@ -0,0 +1,10 @@
+import { type TemplateResult } from 'lit';
+import type { Cell } from '../../view-manager/cell.js';
+/**
+ * What a cell container draws INSTEAD of its renderer while the cell is not
+ * `ready` (ADR 0035 §9e): a skeleton while `pending`, an empty cell on
+ * `error`. `undefined` when ready, so the container mounts its renderer as in
+ * 0.48. No renderer is mounted otherwise, which is what keeps a cell whose
+ * value never arrived from being edited over.
+ */
+export declare function renderCellStatus(cell: Cell | undefined): TemplateResult | undefined;

package/dist/_pkgs/data-view/core/component/cell-status/cell-status.js

@@ -0,0 +1,23 @@
+import { html } from 'lit';
+import { cellEmptyStyle, cellSkeletonStyle } from './cell-status-css.js';
+/**
+ * What a cell container draws INSTEAD of its renderer while the cell is not
+ * `ready` (ADR 0035 §9e): a skeleton while `pending`, an empty cell on
+ * `error`. `undefined` when ready, so the container mounts its renderer as in
+ * 0.48. No renderer is mounted otherwise, which is what keeps a cell whose
+ * value never arrived from being edited over.
+ */
+export function renderCellStatus(cell) {
+    const status = cell?.status$?.value ?? 'ready';
+    if (status === 'ready')
+        return undefined;
+    if (status === 'pending') {
+        return html `<span
+      class="${cellSkeletonStyle}"
+      data-testid="dv-cell-skeleton"
+      data-cell-status="pending"
+      aria-busy="true"
+    ></span>`;
+    }
+    return html `<span class="${cellEmptyStyle}" data-cell-status="error"></span>`;
+}

package/dist/_pkgs/data-view/core/component/index.d.ts

@@ -1,3 +1,4 @@
 export * from './button/button.js';
 export * from './overflow/overflow.js';
 export * from './tags/index.js';
+export * from './cell-status/cell-status.js';

package/dist/_pkgs/data-view/core/component/index.js

@@ -1,3 +1,4 @@
 export * from './button/button.js';
 export * from './overflow/overflow.js';
 export * from './tags/index.js';
+export * from './cell-status/cell-status.js';

package/dist/_pkgs/data-view/core/component/overflow/fit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Which items of an overflowing row are drawn, from measured widths (the
+ * view bar's tabs, ADR 0035 B11, labre PRD REQ-DB-7: "as many tabs as the
+ * width allows, the rest under N more").
+ *
+ * - Everything fits: every item is drawn and the trailing slot holds only
+ *   what it holds when nothing is hidden (`trailing`, the "+" of the view
+ *   bar).
+ * - Otherwise the trailing slot also holds the "N more" button
+ *   (`moreExtra` wider), and the items are drawn in order while they fit,
+ *   stopping at the first that does not: the order of the row is the order
+ *   of the views, never reshuffled to pack more in.
+ * - The `pinned` item (the current view) is always drawn, even alone and
+ *   wider than the room: a view you are looking at never hides under "more".
+ *   Its room is reserved first, so it takes the place of the last item that
+ *   would have fitted.
+ *
+ * Returns the drawn indices in ascending order.
+ */
+export declare function fitOverflow(input: {
+    widths: readonly number[];
+    container: number;
+    trailing: number;
+    moreExtra: number;
+    pinned?: number;
+}): number[];

package/dist/_pkgs/data-view/core/component/overflow/fit.js

@@ -0,0 +1,48 @@
+/**
+ * Which items of an overflowing row are drawn, from measured widths (the
+ * view bar's tabs, ADR 0035 B11, labre PRD REQ-DB-7: "as many tabs as the
+ * width allows, the rest under N more").
+ *
+ * - Everything fits: every item is drawn and the trailing slot holds only
+ *   what it holds when nothing is hidden (`trailing`, the "+" of the view
+ *   bar).
+ * - Otherwise the trailing slot also holds the "N more" button
+ *   (`moreExtra` wider), and the items are drawn in order while they fit,
+ *   stopping at the first that does not: the order of the row is the order
+ *   of the views, never reshuffled to pack more in.
+ * - The `pinned` item (the current view) is always drawn, even alone and
+ *   wider than the room: a view you are looking at never hides under "more".
+ *   Its room is reserved first, so it takes the place of the last item that
+ *   would have fitted.
+ *
+ * Returns the drawn indices in ascending order.
+ */
+export function fitOverflow(input) {
+    const { widths, container, trailing, moreExtra } = input;
+    const pinned = input.pinned !== undefined &&
+        input.pinned >= 0 &&
+        input.pinned < widths.length
+        ? input.pinned
+        : -1;
+    const total = widths.reduce((sum, width) => sum + width, 0);
+    if (total + trailing <= container) {
+        return widths.map((_, index) => index);
+    }
+    const budget = container - trailing - moreExtra;
+    const drawn = [];
+    let used = pinned >= 0 ? (widths[pinned] ?? 0) : 0;
+    for (let index = 0; index < widths.length; index++) {
+        if (index === pinned)
+            continue;
+        const width = widths[index] ?? 0;
+        if (used + width > budget)
+            break;
+        drawn.push(index);
+        used += width;
+    }
+    if (pinned >= 0) {
+        drawn.push(pinned);
+        drawn.sort((a, b) => a - b);
+    }
+    return drawn;
+}

package/dist/_pkgs/data-view/core/component/overflow/overflow.d.ts

@@ -1,19 +1,42 @@
 import { ShadowlessElement } from '../../../../std/index.js';
 import { type PropertyValues, type TemplateResult } from 'lit';
+/**
+ * Marks the element of the trailing slot that only exists while something is
+ * hidden (the "N more" button): the rest of the slot is what stays.
+ */
+export declare const OVERFLOW_MORE_ATTR = "data-overflow-more";
 declare const Overflow_base: typeof ShadowlessElement & import("../../../../global/utils/types.js").Constructor<import("../../../../global/lit/with-disposable.js").DisposableClass>;
+/**
+ * A row that draws as many items as its width allows and hands the rest to
+ * a trailing slot (`renderMore`). Every item stays in the DOM, a hidden one
+ * transparent and out of the flow, so its width is measured on each pass;
+ * which ones are drawn is `fitOverflow` (`./fit.ts`), `pinned` included.
+ * Until the first measure every item is drawn.
+ */
 export declare class Overflow extends Overflow_base {
     static styles: import("lit").CSSResult;
     protected frameId: number | undefined;
-    protected widthList: number[];
+    /** Last measured width of the slot's `OVERFLOW_MORE_ATTR` element. */
+    private moreExtraWidth;
     adjustStyle(): void;
     connectedCallback(): void;
     protected doAdjustStyle(): void;
+    /** The items `renderMore` holds, in order. */
+    get hiddenIndices(): number[];
     render(): TemplateResult<1>;
+    protected willUpdate(changed: PropertyValues<this>): void;
     protected updated(_changedProperties: PropertyValues): void;
     accessor items: HTMLDivElement[] & NodeList;
     accessor more: HTMLDivElement;
-    accessor renderCount: number;
+    /** The drawn items' indices, ascending; `undefined` (all) until measured. */
+    accessor drawn: readonly number[] | undefined;
+    /** The item that is always drawn (the current view); `-1` for none. */
+    accessor pinned: number;
     accessor renderItem: Array<() => TemplateResult>;
-    accessor renderMore: (count: number) => TemplateResult;
+    /**
+     * The trailing slot: `count` items are drawn and `hidden` are the indices
+     * it stands for, empty when everything fits.
+     */
+    accessor renderMore: (count: number, hidden: readonly number[]) => TemplateResult | undefined;
 }
 export {};