@svgrid/grid 2.6.19 → 2.6.21

package/dist/core.d.ts

@@ -1,35 +1,74 @@
 import type { SparklineConfig } from './sparkline.js';
+/**
+ * The constraint every row type satisfies: an object keyed by string. Your own
+ * row type (`type Person = { name: string }`) is what flows through the generics
+ * below; this is only the lower bound they are declared against.
+ */
 export type RowData = Record<string, unknown>;
+/**
+ * A new value, or a function that derives it from the previous one - the shape
+ * every `set*` on the grid accepts, so callers can update state without first
+ * reading it.
+ *
+ *   api.setSorting([{ id: 'name', desc: false }])
+ *   api.setSorting((prev) => [...prev, { id: 'age', desc: true }])
+ */
 export type Updater<T> = T | ((prev: T) => T);
+/** Active sort clauses, outermost first. `desc: false` is ascending. */
 export type SortingState = Array<{
     id: string;
     desc: boolean;
 }>;
+/**
+ * One column's filter: the column `id`, the `value` being matched, and
+ * optionally which comparison to use. `fn` defaults to the column's own type -
+ * see {@link filterFns} for the available names.
+ */
 export type ColumnFilter = {
     id: string;
     value: unknown;
     fn?: keyof typeof filterFns;
 };
+/** Every active column filter. A column with no entry here is unfiltered. */
 export type ColumnFiltersState = Array<ColumnFilter>;
+/** Current page position. `pageIndex` is 0-based, so page 1 is index 0. */
 export type PaginationState = {
     pageIndex: number;
     pageSize: number;
 };
+/** Column ids the rows are grouped by, outermost first. */
 export type GroupingState = Array<string>;
+/** Which rows are expanded, keyed by row id. Absent means collapsed. */
 export type ExpandedState = Record<string, boolean>;
+/** Which rows are selected, keyed by row id. Absent means unselected. */
 export type RowSelectionState = Record<string, boolean>;
+/**
+ * Where keyboard focus sits. The indices address the *displayed* grid (after
+ * sorting, filtering and paging), not the source data.
+ */
 export type ActiveCellState = {
     rowIndex: number;
     colIndex: number;
     cellId: string | null;
 };
+/**
+ * The set of features a grid has registered, as built by {@link tableFeatures}.
+ * Deliberately open: a feature is identified by its key, so the type carries
+ * which ones are on without enumerating them.
+ */
 export type TableFeatures = Record<string, unknown>;
+/** A cell's value. Unconstrained - a column can hold anything. */
 export type CellData = unknown;
+/** What a column's `header` render function receives. */
 export type HeaderContext<TData extends RowData> = {
     header: Header<TData>;
     column: Column<TData>;
     table: SvGrid<TData>;
 };
+/**
+ * What a column's `cell` render function receives. `getValue()` applies the
+ * column's accessor (`field` or `fieldFn`); `row.original` is the raw object.
+ */
 export type CellContext<TData extends RowData> = {
     cell: Cell<TData>;
     row: Row<TData>;
@@ -86,6 +125,11 @@ export type EditorContext<TData extends RowData> = CellContext<TData> & {
     commit: (next?: unknown) => void;
     cancel: () => void;
 };
+/**
+ * Declarative cell formatting, applied through `Intl` - number, currency,
+ * percent, date and datetime. Prefer this over a `formatter` function: it is
+ * locale-aware, and export and the clipboard reuse the same configuration.
+ */
 export type CellFormatConfig = {
     type: 'number';
     locales?: string | Array<string>;
@@ -116,12 +160,17 @@ export type CellFormatConfig = {
     pattern?: string;
     options?: Intl.DateTimeFormatOptions;
 };
+/**
+ * A column's custom display function, for anything {@link CellFormatConfig}
+ * cannot express. Returns a string - to render markup, use `cell` instead.
+ */
 export type CellFormatter<TData extends RowData> = (context: {
     value: unknown;
     row: Row<TData>;
     column: Column<TData>;
     table: SvGrid<TData>;
 }) => string;
+/** A header or cell slot: a literal string, or a function returning renderable content. */
 export type ColumnDefTemplate<TContext> = string | ((context: TContext) => unknown);
 /**
  * How a column's value is aggregated for a group row when `columnGrouping`
@@ -310,6 +359,20 @@ export type ColumnDef<TFeatures extends TableFeatures, TData extends RowData> =
      * is formatted with this column's `format` and shown in the group header.
      */
     aggregate?: GroupAggregator<TData>;
+    /**
+     * What this column contributes to the grid's footer summary row (the one
+     * turned on with `summary` / `enableRowSummaries`). Takes the same
+     * aggregators as {@link aggregate}, and the result is formatted with this
+     * column's `format`.
+     *
+     * Without it the footer falls back to its default: the sum of a numeric
+     * column, `Count: N` otherwise. Set `false` to leave the cell blank, which is
+     * usually what an actions or checkbox column wants.
+     *
+     *   { field: 'amount', summary: 'avg' }
+     *   { id: 'actions', summary: false }
+     */
+    summary?: GroupAggregator<TData> | false;
     /**
      * Render the cell as an in-cell sparkline chart. The cell value should be
      * an array of numbers (or a comma/space separated string). Mutually
@@ -371,6 +434,12 @@ export type ColumnDef<TFeatures extends TableFeatures, TData extends RowData> =
 export type GridColumnDef<TData extends RowData = RowData> = ColumnDef<TableFeatures, TData>;
 /** An array of {@link GridColumnDef} - what you pass to `<SvGrid columns={...}>`. */
 export type GridColumns<TData extends RowData = RowData> = Array<GridColumnDef<TData>>;
+/**
+ * A resolved column: your {@link ColumnDef} plus everything the grid computed
+ * from it - its id, its depth under any group header, and the sort handlers a
+ * header needs. This is what you receive in render contexts; the `ColumnDef`
+ * is what you wrote.
+ */
 export type Column<TData extends RowData> = {
     id: string;
     columnDef: ColumnDef<any, TData>;
@@ -381,6 +450,11 @@ export type Column<TData extends RowData> = {
     getIsSorted: () => false | 'asc' | 'desc';
     getToggleSortingHandler: () => () => void;
 };
+/**
+ * One header cell. `colSpan` is how many leaf columns it covers, and
+ * `isPlaceholder` marks the empty cells that pad a group-header row so the
+ * levels line up.
+ */
 export type Header<TData extends RowData> = {
     id: string;
     isPlaceholder: boolean;
@@ -388,10 +462,12 @@ export type Header<TData extends RowData> = {
     column: Column<TData>;
     getContext: () => HeaderContext<TData>;
 };
+/** One row of header cells. A grid with grouped columns has several, outermost first. */
 export type HeaderGroup<TData extends RowData> = {
     id: string;
     headers: Array<Header<TData>>;
 };
+/** One cell: the intersection of a {@link Row} and a {@link Column}. */
 export type Cell<TData extends RowData> = {
     id: string;
     row: Row<TData>;
@@ -399,6 +475,13 @@ export type Cell<TData extends RowData> = {
     getValue: () => unknown;
     getContext: () => CellContext<TData>;
 };
+/**
+ * A row in the display model. `original` is your untouched data object;
+ * everything else is grid-computed. `index` is the position in the displayed
+ * set, so it shifts as sorting and filtering change - key on `id`, not index.
+ *
+ * Group rows and tree parents carry `subRows`; a plain data row does not.
+ */
 export type Row<TData extends RowData> = {
     id: string;
     index: number;
@@ -415,50 +498,126 @@ export type Row<TData extends RowData> = {
     getAllCells: () => Array<Cell<TData>>;
     getCellValueByColumnId: (columnId: string) => unknown;
 };
+/** The output of the row pipeline: the rows to display, in order. */
 export type RowModel<TData extends RowData> = {
     rows: Array<Row<TData>>;
 };
+/**
+ * The minimal reactive store behind the headless core - read `state`, write
+ * through `setState`, and `subscribe` for changes. Deliberately framework
+ * free, which is what lets the core run under plain Node.
+ *
+ * In Svelte you rarely touch this: `subscribeGrid` wraps it with fine-grained
+ * selectors so a component only re-runs for the slice it read.
+ */
 export type Store<T> = {
     readonly state: T;
     setState: (updater: (prev: T) => T) => void;
     subscribe: (listener: () => void) => () => void;
 };
+/**
+ * Click-to-sort. Injected by the `sortable` shortcut.
+ *
+ * This and the five features below are opaque markers: pass the ones you want
+ * to {@link tableFeatures} and the grid wires up the matching row model. With
+ * `<SvGrid>` you rarely name them - the boolean shortcuts (`sortable`,
+ * `filterable`, `pageable`, `groupable`) inject them for you. Reach for them
+ * directly when driving the headless core, or when you want a feature on
+ * without its UI.
+ *
+ * The names match TanStack Table v9, so a features object written for it works
+ * here unchanged.
+ */
 export declare const rowSortingFeature: {
     key: string;
 };
+/** Per-column filtering. Injected by the `filterable` shortcut. */
 export declare const columnFilteringFeature: {
     key: string;
 };
+/** Paging of the row model. Injected by the `pageable` shortcut. */
 export declare const rowPaginationFeature: {
     key: string;
 };
+/** Row grouping with aggregation. Injected by the `groupable` shortcut. */
 export declare const columnGroupingFeature: {
     key: string;
 };
+/** Row selection state (the checkbox column reads it). */
 export declare const rowSelectionFeature: {
     key: string;
 };
+/** Expand / collapse, for tree rows and master-detail. */
 export declare const rowExpandingFeature: {
     key: string;
 };
+/**
+ * Declare which features a grid uses. Identity at runtime - its whole job is to
+ * capture the exact set in the type, so `ColumnDef<typeof features, Row>` knows
+ * what is registered and anything you did not register is tree-shaken out.
+ *
+ * ```ts
+ * const features = tableFeatures({ rowSortingFeature, columnFilteringFeature })
+ * ```
+ *
+ * Same call signature as TanStack Table v9, so a features object written for it
+ * transfers unchanged.
+ */
 export declare function tableFeatures<T extends TableFeatures>(features: T): T;
+/**
+ * Built-in comparators, chosen per column by its data type. `auto` compares as
+ * text; set a column's type or supply your own comparator to override.
+ */
 export declare const sortFns: {
     auto: (a: unknown, b: unknown) => number;
     number: (a: unknown, b: unknown) => number;
     date: (a: unknown, b: unknown) => number;
 };
+/**
+ * Built-in match functions, named by {@link ColumnFilter}'s `fn`.
+ * `includesString` is case-insensitive substring; `equals` is strict identity.
+ */
 export declare const filterFns: {
     includesString: (value: unknown, query: string) => boolean;
     equals: (value: unknown, query: unknown) => boolean;
 };
+/**
+ * One stage of the row pipeline: takes the rows produced so far and returns the
+ * next set. Stages compose in the order given to `_rowModels`, so filtering
+ * before sorting sorts only what survived the filter.
+ */
 export type RowModelFactory<TData extends RowData> = (args: {
     table: SvGrid<TData>;
     rows: Array<Row<TData>>;
 }) => Array<Row<TData>>;
+/**
+ * The identity stage that starts every pipeline. Always required, even when no
+ * other stage is: it is what turns your data into rows.
+ */
 export declare function createCoreRowModel<TData extends RowData>(): RowModelFactory<TData>;
+/**
+ * Drops rows that fail the active {@link ColumnFiltersState}. Pairs with
+ * `columnFilteringFeature`; without it there are no filters to apply.
+ */
 export declare function createFilteredRowModel<TData extends RowData>(): RowModelFactory<TData>;
+/**
+ * Narrows the rows to the current page. Put it LAST: anything after it would
+ * only ever see one page of data.
+ */
 export declare function createPaginatedRowModel<TData extends RowData>(): RowModelFactory<TData>;
+/**
+ * Buckets rows by the active {@link GroupingState} and inserts a group row
+ * ahead of each bucket, carrying that bucket's aggregates.
+ */
 export declare function createGroupedRowModel<TData extends RowData>(): RowModelFactory<TData>;
+/**
+ * How to read a hierarchy out of FLAT rows: each row names its parent, and the
+ * grid reconstructs the tree. Rows whose parent id matches nothing become roots
+ * rather than disappearing.
+ *
+ * For nested source data (`children: [...]`), flatten it first with
+ * {@link flattenTreeData}.
+ */
 export type TreeRowModelOptions = {
     /** Field holding each row's parent id. Rows with no parent are roots. */
     parentField: string;
@@ -481,6 +640,11 @@ export type TreeRowModelOptions = {
  * data row for a full-width group banner.
  */
 export declare function createTreeRowModel<TData extends RowData>(options: TreeRowModelOptions): RowModelFactory<TData>;
+/**
+ * How to flatten NESTED source data into the parent-id shape tree rows need.
+ * `parentField` is written onto each row, so point `treeData.parentField` at
+ * the same name afterwards.
+ */
 export type FlattenTreeOptions = {
     /** Field holding an array of child objects. */
     childrenField: string;
@@ -498,8 +662,25 @@ export type FlattenTreeOptions = {
  * (harmless, and callers often still want it); only the parent link is added.
  */
 export declare function flattenTreeData<T extends RowData>(data: ReadonlyArray<T>, options: FlattenTreeOptions): T[];
+/**
+ * Hides the descendants of collapsed rows. Needed for grouping, tree data and
+ * master-detail alike - all three are the same expand/collapse mechanism.
+ */
 export declare function createExpandedRowModel<TData extends RowData>(): RowModelFactory<TData>;
+/**
+ * Orders rows by the active {@link SortingState}. Pass your own comparators to
+ * override the built-in {@link sortFns} - useful for locale-aware or
+ * domain-specific ordering.
+ */
 export declare function createSortedRowModel<TData extends RowData>(localSortFns?: typeof sortFns): RowModelFactory<TData>;
+/**
+ * Everything {@link createSvGridCore} accepts: the data and columns, the
+ * features and row models that make up the pipeline, and an `on*Change`
+ * callback per piece of state for controlled use.
+ *
+ * `<SvGrid>` builds this for you from its props - you only construct it
+ * directly when driving the headless core.
+ */
 export type SvGridOptions<TFeatures extends TableFeatures, TData extends RowData> = {
     _features: TFeatures;
     _rowModels?: {
@@ -528,6 +709,13 @@ export type SvGridOptions<TFeatures extends TableFeatures, TData extends RowData
     onRowSelectionChange?: (updater: Updater<RowSelectionState>) => void;
     onActiveCellChange?: (updater: Updater<ActiveCellState>) => void;
 };
+/**
+ * The headless grid instance: the state stores plus the read methods a renderer
+ * needs (`getHeaderGroups()`, `getRowModel()`, the `set*` writers).
+ *
+ * Framework free by design - `<SvGrid>` is one renderer over this, and you can
+ * write another. See the "Why headless?" guide.
+ */
 export type SvGrid<TData extends RowData> = {
     store: Store<Record<string, any>>;
     optionsStore: Store<Record<string, any>>;
@@ -549,5 +737,14 @@ export type SvGrid<TData extends RowData> = {
     getFooterGroups: () => Array<HeaderGroup<TData>>;
     getRowModel: () => RowModel<TData>;
 };
+/**
+ * Build a headless grid: state, the row pipeline, and the read methods, with no
+ * DOM and no Svelte. This is the engine `<SvGrid>` renders.
+ *
+ * Most callers want `createSvGrid` (the runes-aware wrapper) or the component
+ * itself; reach for this when you are writing your own renderer or running the
+ * pipeline outside a browser.
+ */
 export declare function createSvGridCore<TFeatures extends TableFeatures, TData extends RowData>(options: SvGridOptions<TFeatures, TData>): SvGrid<TData>;
+/** Narrowing helper for the many options that accept a value or a function. */
 export declare function isFunction(value: unknown): value is (...args: Array<any>) => any;

package/dist/core.js

@@ -47,15 +47,49 @@ function createStore(initial) {
         },
     };
 }
+/**
+ * Click-to-sort. Injected by the `sortable` shortcut.
+ *
+ * This and the five features below are opaque markers: pass the ones you want
+ * to {@link tableFeatures} and the grid wires up the matching row model. With
+ * `<SvGrid>` you rarely name them - the boolean shortcuts (`sortable`,
+ * `filterable`, `pageable`, `groupable`) inject them for you. Reach for them
+ * directly when driving the headless core, or when you want a feature on
+ * without its UI.
+ *
+ * The names match TanStack Table v9, so a features object written for it works
+ * here unchanged.
+ */
 export const rowSortingFeature = { key: 'rowSortingFeature' };
+/** Per-column filtering. Injected by the `filterable` shortcut. */
 export const columnFilteringFeature = { key: 'columnFilteringFeature' };
+/** Paging of the row model. Injected by the `pageable` shortcut. */
 export const rowPaginationFeature = { key: 'rowPaginationFeature' };
+/** Row grouping with aggregation. Injected by the `groupable` shortcut. */
 export const columnGroupingFeature = { key: 'columnGroupingFeature' };
+/** Row selection state (the checkbox column reads it). */
 export const rowSelectionFeature = { key: 'rowSelectionFeature' };
+/** Expand / collapse, for tree rows and master-detail. */
 export const rowExpandingFeature = { key: 'rowExpandingFeature' };
+/**
+ * Declare which features a grid uses. Identity at runtime - its whole job is to
+ * capture the exact set in the type, so `ColumnDef<typeof features, Row>` knows
+ * what is registered and anything you did not register is tree-shaken out.
+ *
+ * ```ts
+ * const features = tableFeatures({ rowSortingFeature, columnFilteringFeature })
+ * ```
+ *
+ * Same call signature as TanStack Table v9, so a features object written for it
+ * transfers unchanged.
+ */
 export function tableFeatures(features) {
     return features;
 }
+/**
+ * Built-in comparators, chosen per column by its data type. `auto` compares as
+ * text; set a column's type or supply your own comparator to override.
+ */
 export const sortFns = {
     auto: (a, b) => String(a).localeCompare(String(b)),
     number: (a, b) => Number(a ?? 0) - Number(b ?? 0),
@@ -65,13 +99,25 @@ export const sortFns = {
         return aa - bb;
     },
 };
+/**
+ * Built-in match functions, named by {@link ColumnFilter}'s `fn`.
+ * `includesString` is case-insensitive substring; `equals` is strict identity.
+ */
 export const filterFns = {
     includesString: (value, query) => String(value).toLowerCase().includes(query.toLowerCase()),
     equals: (value, query) => value === query,
 };
+/**
+ * The identity stage that starts every pipeline. Always required, even when no
+ * other stage is: it is what turns your data into rows.
+ */
 export function createCoreRowModel() {
     return ({ rows }) => rows;
 }
+/**
+ * Drops rows that fail the active {@link ColumnFiltersState}. Pairs with
+ * `columnFilteringFeature`; without it there are no filters to apply.
+ */
 export function createFilteredRowModel() {
     return ({ table, rows }) => {
         const filters = table.getState().columnFilters ?? [];
@@ -89,6 +135,10 @@ export function createFilteredRowModel() {
         });
     };
 }
+/**
+ * Narrows the rows to the current page. Put it LAST: anything after it would
+ * only ever see one page of data.
+ */
 export function createPaginatedRowModel() {
     return ({ table, rows }) => {
         const pagination = table.getState().pagination ?? { pageIndex: 0, pageSize: rows.length || 10 };
@@ -96,6 +146,10 @@ export function createPaginatedRowModel() {
         return rows.slice(start, start + pagination.pageSize);
     };
 }
+/**
+ * Buckets rows by the active {@link GroupingState} and inserts a group row
+ * ahead of each bucket, carrying that bucket's aggregates.
+ */
 export function createGroupedRowModel() {
     return ({ table, rows }) => {
         const grouping = table.getState().grouping ?? [];
@@ -282,6 +336,10 @@ export function flattenTreeData(data, options) {
     walk(data, null);
     return out;
 }
+/**
+ * Hides the descendants of collapsed rows. Needed for grouping, tree data and
+ * master-detail alike - all three are the same expand/collapse mechanism.
+ */
 export function createExpandedRowModel() {
     return ({ table, rows }) => {
         const expanded = table.getState().expanded ?? {};
@@ -298,6 +356,11 @@ export function createExpandedRowModel() {
         return flattened;
     };
 }
+/**
+ * Orders rows by the active {@link SortingState}. Pass your own comparators to
+ * override the built-in {@link sortFns} - useful for locale-aware or
+ * domain-specific ordering.
+ */
 export function createSortedRowModel(localSortFns = sortFns) {
     return ({ table, rows }) => {
         const sorting = table.getState().sorting ?? [];
@@ -323,6 +386,14 @@ export function createSortedRowModel(localSortFns = sortFns) {
         return sorted;
     };
 }
+/**
+ * Build a headless grid: state, the row pipeline, and the read methods, with no
+ * DOM and no Svelte. This is the engine `<SvGrid>` renders.
+ *
+ * Most callers want `createSvGrid` (the runes-aware wrapper) or the component
+ * itself; reach for this when you are writing your own renderer or running the
+ * pipeline outside a browser.
+ */
 export function createSvGridCore(options) {
     const internalState = {
         sorting: [],
@@ -653,6 +724,7 @@ export function createSvGridCore(options) {
     };
     return grid;
 }
+/** Narrowing helper for the many options that accept a value or a function. */
 export function isFunction(value) {
     return typeof value === 'function';
 }

package/dist/createTree.svelte.d.ts

@@ -30,6 +30,7 @@ export type TreeNode = {
      *  even with no children yet; the renderer loads them on first expand). */
     lazy?: boolean;
 };
+/** A node's checkbox state. `'indeterminate'` means some but not all descendants are checked. */
 export type CheckState = 'checked' | 'indeterminate' | 'unchecked';
 /** A single visible (flattened) tree row. */
 export type TreeRow = {
@@ -73,6 +74,7 @@ export type TreeConfig = {
     /** Filter query: show only matching nodes + their ancestors, auto-expanded. */
     filter?: () => string | undefined;
 };
+/** Build the headless tree model: expansion, selection and checkbox cascading, with no markup. */
 export declare function createTree(config: TreeConfig): {
     /** Internally-managed set of expanded node ids. */
     readonly expanded: Set<string>;
@@ -113,4 +115,5 @@ export declare function createTree(config: TreeConfig): {
         onkeydown: (e: KeyboardEvent) => void;
     };
 };
+/** The headless tree instance returned by {@link createTree}. */
 export type Tree = ReturnType<typeof createTree>;

package/dist/createTree.svelte.js

@@ -87,6 +87,7 @@ export function sortTreeNodes(nodes, compare) {
         .sort(compare)
         .map((n) => (n.children ? { ...n, children: sortTreeNodes(n.children, compare) } : n));
 }
+/** Build the headless tree model: expansion, selection and checkbox cascading, with no markup. */
 export function createTree(config) {
     const nodes = () => config.nodes();
     const checkable = () => config.checkable?.() ?? false;

package/dist/datetime/date-core.d.ts

@@ -9,6 +9,7 @@
  * - `firstDayOfWeek` is 0-6 (0 = Sunday), matching `Date.getDay()` and Smart's
  *   `firstDayOfWeek`.
  */
+/** Anything the date helpers accept: a `Date`, epoch milliseconds, or a parseable string. */
 export type DateLike = Date | number | string;
 /** Coerce a Date | epoch-ms | parseable string to a Date, or null if invalid. */
 export declare function toDate(value: DateLike | null | undefined): Date | null;
@@ -63,6 +64,7 @@ export declare function centuryRange(year: number): {
     start: number;
     end: number;
 };
+/** One cell of a month grid, including the leading and trailing days from adjacent months. */
 export type MonthMatrixCell = {
     date: Date;
     /** In the displayed month (vs. leading/trailing days of adjacent months). */

package/dist/datetime/date-restrict.d.ts

@@ -4,6 +4,7 @@
  * still selectable). Mirrors Smart's calendar constraint model. Framework-free.
  */
 import { type DateLike } from './date-core.js';
+/** Which dates a picker allows: bounds, an explicit disabled set, and disabled weekdays. */
 export type RestrictOptions = {
     min?: DateLike | null;
     max?: DateLike | null;

package/dist/datetime/timezone.d.ts

@@ -11,6 +11,7 @@
  * These functions are DST-aware and take no ambient "now" (safe for the model /
  * headless contexts that forbid `Date.now()`).
  */
+/** A wall-clock time broken into fields, as it reads in a specific time zone. */
 export type ZoneParts = {
     year: number;
     month: number;

package/dist/dock-manager-model.d.ts

@@ -16,6 +16,7 @@
  * painting; all the surgery lives here and is unit-tested without a browser.
  */
 import { type DockNode, type DockTabs, type DockPane, type DockZone, type IdGen } from './dock-model.js';
+/** Which edge a pane docks against when dropped. */
 export type DockSide = Exclude<DockZone, 'center'>;
 /** A floating window: one tabs leaf shown in a movable/resizable frame. */
 export type FloatWindow = {
@@ -40,6 +41,7 @@ export type AutoHideEntry = {
     /** Fly-out panel size in px along the reveal axis. */
     size: number;
 };
+/** The whole dock manager: its layout tree plus floating and pinned panes. */
 export type DockManagerState = {
     main: DockNode | null;
     floating: FloatWindow[];
@@ -57,6 +59,7 @@ export type PaneLocation = {
     kind: 'autoHide';
     entryId: string;
 };
+/** Find a pane in the layout tree by id, returning it with its parent for mutation. */
 export declare function locatePane(state: DockManagerState, paneId: string): PaneLocation | null;
 /** Which surface holds a tabs leaf: 'main', a window id, or null. */
 export declare function surfaceOfTabs(state: DockManagerState, tabsId: string): 'main' | string | null;

package/dist/dock-manager-model.js

@@ -16,6 +16,7 @@
  * painting; all the surgery lives here and is unit-tested without a browser.
  */
 import { tabs, dockInto, removePane as removePaneFromTree, removeLeaf, dockLeafToEdge, reorderPane, findTabsWithPane, allPaneIds, } from './dock-model.js';
+/** Find a pane in the layout tree by id, returning it with its parent for mutation. */
 export function locatePane(state, paneId) {
     if (state.main && findTabsWithPane(state.main, paneId))
         return { kind: 'main' };

package/dist/dock-model.d.ts

@@ -12,6 +12,7 @@
  * the drag gestures; all the tree surgery lives here so it is unit-testable
  * without a browser. Modelled on Smart's `smart-layout` group/item structure.
  */
+/** One dockable pane: its id, title, and the state a tab needs to render. */
 export type DockPane = {
     id: string;
     title: string;
@@ -36,14 +37,19 @@ export type DockGroup = {
     /** Size weight per child; parallel to `children`, normalized to sum ~1. */
     sizes: number[];
 };
+/** A node in the layout tree - either a split group or a tabbed leaf. */
 export type DockNode = DockGroup | DockTabs;
 /** Where a dragged pane lands relative to a target leaf. */
 export type DockZone = 'left' | 'right' | 'top' | 'bottom' | 'center';
+/** Supplies ids for newly created nodes, so layouts stay deterministic in tests. */
 export type IdGen = () => string;
+/** Build a {@link DockPane}. */
 export declare function pane(id: string, title: string, closable?: boolean): DockPane;
 /** Largest per-pane `minSize` in a leaf (0 if none). Used by splitter clamping. */
 export declare function leafMinSize(node: DockTabs): number;
+/** Build a tabbed leaf holding the given panes. */
 export declare function tabs(genId: IdGen, panes: DockPane[], active?: number): DockTabs;
+/** Build a split group: panes or nested groups laid out in a row or column. */
 export declare function group(genId: IdGen, direction: 'row' | 'column', children: DockNode[], sizes?: number[]): DockGroup;
 /** Return sizes summing to 1, padded/trimmed to `count`. Even split when absent. */
 export declare function normalizeSizes(sizes: number[] | undefined, count: number): number[];

package/dist/dock-model.js

@@ -13,6 +13,7 @@
  * without a browser. Modelled on Smart's `smart-layout` group/item structure.
  */
 // ---- construction helpers -------------------------------------------------
+/** Build a {@link DockPane}. */
 export function pane(id, title, closable = true) {
     return { id, title, closable };
 }
@@ -20,9 +21,11 @@ export function pane(id, title, closable = true) {
 export function leafMinSize(node) {
     return node.panes.reduce((m, p) => Math.max(m, p.minSize ?? 0), 0);
 }
+/** Build a tabbed leaf holding the given panes. */
 export function tabs(genId, panes, active = 0) {
     return { type: 'tabs', id: genId(), panes, active: clampIndex(active, panes.length) };
 }
+/** Build a split group: panes or nested groups laid out in a row or column. */
 export function group(genId, direction, children, sizes) {
     return { type: 'group', id: genId(), direction, children, sizes: normalizeSizes(sizes, children.length) };
 }

package/dist/editor-contract.d.ts

@@ -9,6 +9,7 @@
  *
  * Framework-free (no Svelte, no DOM) so it can be unit-tested and reused.
  */
+/** How much room a cell editor asks for, so the grid can size its overlay. */
 export type EditorSize = 'sm' | 'md' | 'lg';
 /**
  * A small action button rendered inside a framed field (via `SvField`'s

package/dist/list-option.d.ts

@@ -48,6 +48,7 @@ export type VirtualListRow = {
     opt: IndexedOption;
     size: number;
 };
+/** A flattened option list plus its measurements, for virtualizing long dropdowns. */
 export type FlatVirtualModel = {
     /** Group headings + options in render order, each with its px height. */
     entries: VirtualListRow[];