@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1,5 @@
+export { Tooltip } from './Tooltip';
+export { addTooltip } from './add-tooltip';
+export type { TooltipProps } from './tooltip-props';
+export type { TooltipShowOn } from './tooltip-show-on';
+export type { TooltipTarget } from './tooltip-target';

package/dist/components/tooltip/tooltip-hub.d.ts

@@ -0,0 +1,12 @@
+import type { Tooltip } from './Tooltip';
+type Source = Tooltip | (() => Tooltip);
+type Cause = 'pointer' | 'focus' | 'code';
+export declare const tooltipTiming: {
+    skipDelay: number;
+};
+export declare function linkTooltip(element: Element, source: Source): void;
+export declare function unlinkTooltip(element: Element, source: Source): void;
+export declare function isTooltipShown(tooltip: Tooltip): boolean;
+export declare function showTooltip(tooltip: Tooltip, anchor: Element, cause: Cause, described?: Element): void;
+export declare function hideTooltip(tooltip: Tooltip): void;
+export {};

package/dist/components/tooltip/tooltip-props.d.ts

@@ -0,0 +1,25 @@
+import type { Bind, ComponentBase } from '@motifx/core';
+import type { ControlProps } from '../../core/control';
+import type { PopupPlacement } from '../../parts/popup/popup-placement';
+import type { TooltipShowOn } from './tooltip-show-on';
+import type { TooltipTarget } from './tooltip-target';
+/**
+ * Props of `Tooltip`: the shared `ControlProps` (`text` is what it says) plus its own. Each one is
+ * also a settable, reactive property.
+ */
+export interface TooltipProps extends ControlProps {
+    /** The element or component it describes. */
+    target?: Bind<TooltipTarget | null | undefined>;
+    /** Any content, after `text`. Nothing interactive: a tooltip never takes focus. */
+    content?: Bind<ComponentBase | null | undefined>;
+    /** Default `'top'`. It opens on the other side when there is no room. */
+    placement?: Bind<PopupPlacement>;
+    /** Milliseconds the pointer rests on the target before it shows. Default 500. */
+    delay?: Bind<number>;
+    /** Milliseconds it stays after the pointer leaves, so the pointer can move onto it. Default 150. */
+    hideDelay?: Bind<number>;
+    /** Default `'hover-focus'`. */
+    showOn?: Bind<TooltipShowOn>;
+    onOpened?: () => void;
+    onClosed?: () => void;
+}

package/dist/components/tooltip/tooltip-show-on.d.ts

@@ -0,0 +1,2 @@
+/** What shows a tooltip: pointer hover and keyboard focus, keyboard focus only, or only code (`open()`). */
+export type TooltipShowOn = 'hover-focus' | 'focus' | 'manual';

package/dist/components/tooltip/tooltip-target.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentBase } from '@motifx/core';
+/** What a tooltip describes: an element, or a component (its element). */
+export type TooltipTarget = Element | ComponentBase;

package/dist/components/treeview/TreeModel.d.ts

@@ -0,0 +1,43 @@
+import type { TreeCheckState } from './tree-check-state';
+import type { TreeFields } from './tree-fields';
+import type { TreeNode } from './tree-node';
+import type { TreeRow } from './tree-row';
+/**
+ * The nodes of a tree read from its items, nested (a `children` array) or flat (a `parentId` on
+ * each item). Children loaded on demand are kept here and survive the next read. It knows which
+ * nodes are on screen and how check boxes add up; it draws nothing.
+ */
+export declare class TreeModel<T> {
+    roots: TreeNode<T>[];
+    /** Children that loaded on demand, by their parent's key. */
+    readonly loaded: Map<unknown, readonly T[]>;
+    private byKey;
+    private fields;
+    private lazy;
+    /** Reads the items again; `lazy`: a node without children may load them. */
+    read(items: readonly T[], fields: TreeFields<T>, flat: boolean, lazy: boolean): void;
+    /** Children that just loaded. */
+    setChildren(node: TreeNode<T>, given: readonly T[]): void;
+    node(key: unknown): TreeNode<T> | undefined;
+    /** Every known node, parents before their children. */
+    walk(nodes?: readonly TreeNode<T>[]): Generator<TreeNode<T>>;
+    /** Whether `node` has children to show (or may load some). */
+    hasChildren(node: TreeNode<T>, shown: Set<TreeNode<T>> | null): boolean;
+    /** The nodes on screen, in order: the roots, and the children of the open ones. */
+    rows(isOpen: (node: TreeNode<T>) => boolean, shown: Set<TreeNode<T>> | null): TreeRow<T>[];
+    /** The nodes that pass `test`, with their ancestors. */
+    match(test: (node: TreeNode<T>) => boolean): Set<TreeNode<T>>;
+    /** `keys` in tree order; keys of nodes not known (yet) come last. */
+    inOrder(keys: Set<unknown>): unknown[];
+    /**
+     * Brings the checked keys in step with the tree and returns each node's state. With
+     * `recursive`, the children of a checked node are checked and a parent is checked when all its
+     * children are, mixed when some are.
+     */
+    checkStates(checked: Set<unknown>, recursive: boolean): Map<TreeNode<T>, TreeCheckState>;
+    /** Checks or unchecks a node; with `recursive`, its children go with it and its parents follow. */
+    setChecked(node: TreeNode<T>, on: boolean, checked: Set<unknown>, recursive: boolean): void;
+    private create;
+    private readNested;
+    private readFlat;
+}

package/dist/components/treeview/TreeView.d.ts

@@ -0,0 +1,218 @@
+import { type Bind, type Event as MotifEvent, type IBaseProp } from '@motifx/core';
+import { Control } from '../../core/control';
+import type { ControlSize } from '../../core/control-size';
+import type { ItemField } from '../../parts/list/item-field';
+import type { TreeViewCheckChangedEventArgs } from './tree-view-check-changed-event-args';
+import type { TreeViewExpandOn } from './tree-view-expand-on';
+import type { TreeViewExpandedEventArgs } from './tree-view-expanded-event-args';
+import type { TreeViewExpandingEventArgs } from './tree-view-expanding-event-args';
+import type { TreeViewItemClickEventArgs } from './tree-view-item-click-event-args';
+import type { TreeViewItemTemplate } from './tree-view-item-template';
+import type { TreeViewLoadChildren } from './tree-view-load-children';
+import type { TreeViewProps } from './tree-view-props';
+import type { TreeViewSelectionChangedEventArgs } from './tree-view-selection-changed-event-args';
+import type { TreeViewSelectionMode } from './tree-view-selection-mode';
+/**
+ * Hierarchical items (the APG tree view pattern): rows open and close, are selected one or many
+ * at a time, can carry tri-state check boxes, can be searched, and children can load when a row
+ * is first opened. Items are nested (`children`) or flat (`parentId`), read through the `…Field`
+ * props. One Tab stop; the arrow keys move, open and close. Long trees draw only the rows in view.
+ *
+ * @example
+ * <TreeView label="Files" items={() => this.files} x-model={() => this.state.file} />
+ * <TreeView items={() => this.rights} showCheckBoxes selectionMode="none" onCheckChanged={(e) => this.save(e.keys)} />
+ *
+ * const tree = new TreeView({ items: folders, loadChildren: (f) => api.list(f.path) });
+ * tree.expand('docs');
+ */
+export declare class TreeView<T = unknown> extends Control<HTMLDivElement, TreeViewProps<T>> {
+    constructor(props?: IBaseProp<TreeViewProps<T>>);
+    get items(): readonly T[];
+    set items(value: Bind<readonly T[]>);
+    get textField(): ItemField<T> | undefined;
+    set textField(value: Bind<ItemField<T>>);
+    get keyField(): ItemField<T> | undefined;
+    set keyField(value: Bind<ItemField<T>>);
+    get childrenField(): ItemField<T> | undefined;
+    set childrenField(value: Bind<ItemField<T>>);
+    get parentField(): ItemField<T> | undefined;
+    set parentField(value: Bind<ItemField<T>>);
+    get iconField(): ItemField<T> | undefined;
+    set iconField(value: Bind<ItemField<T>>);
+    get enabledField(): ItemField<T> | undefined;
+    set enabledField(value: Bind<ItemField<T>>);
+    get expandedField(): ItemField<T> | undefined;
+    set expandedField(value: Bind<ItemField<T>>);
+    get hasChildrenField(): ItemField<T> | undefined;
+    set hasChildrenField(value: Bind<ItemField<T>>);
+    get loadChildren(): TreeViewLoadChildren<T> | null;
+    set loadChildren(value: Bind<TreeViewLoadChildren<T> | null>);
+    get itemTemplate(): TreeViewItemTemplate<T> | null;
+    set itemTemplate(value: Bind<TreeViewItemTemplate<T> | null>);
+    get selectionMode(): TreeViewSelectionMode;
+    set selectionMode(value: Bind<TreeViewSelectionMode>);
+    /** The selected key (`single`, `null` when none) or keys (`multiple`). Reactive. */
+    get value(): unknown;
+    set value(value: Bind<unknown>);
+    /** The selected items, in tree order. Reactive. */
+    get selectedItems(): T[];
+    /** The open rows' keys, in tree order. Reactive. */
+    get expandedKeys(): unknown[];
+    set expandedKeys(value: Bind<readonly unknown[]>);
+    get showCheckBoxes(): boolean;
+    set showCheckBoxes(value: Bind<boolean>);
+    get checkRecursive(): boolean;
+    set checkRecursive(value: Bind<boolean>);
+    /** The checked keys, in tree order (a parent is in it when all its children are). Reactive. */
+    get checkedKeys(): unknown[];
+    set checkedKeys(value: Bind<readonly unknown[]>);
+    /** The checked items, in tree order. Reactive. */
+    get checkedItems(): T[];
+    get searchEnabled(): boolean;
+    set searchEnabled(value: Bind<boolean>);
+    get searchMode(): 'contains' | 'startswith';
+    set searchMode(value: Bind<'contains' | 'startswith'>);
+    get searchValue(): string;
+    set searchValue(value: Bind<string>);
+    get expandOn(): TreeViewExpandOn;
+    set expandOn(value: Bind<TreeViewExpandOn>);
+    get showLines(): boolean;
+    set showLines(value: Bind<boolean>);
+    get size(): ControlSize;
+    set size(value: Bind<ControlSize>);
+    get label(): string;
+    set label(value: Bind<string>);
+    get virtualFrom(): number;
+    set virtualFrom(value: Bind<number>);
+    /** The element with `role="tree"`. */
+    get treeElement(): HTMLDivElement;
+    /** A branch is about to open; `e.cancel = true` keeps it closed. */
+    get onExpanding(): MotifEvent<TreeViewExpandingEventArgs<T>>;
+    /** A branch is about to close; `e.cancel = true` keeps it open. */
+    get onCollapsing(): MotifEvent<TreeViewExpandingEventArgs<T>>;
+    get onExpanded(): MotifEvent<TreeViewExpandedEventArgs<T>>;
+    get onCollapsed(): MotifEvent<TreeViewExpandedEventArgs<T>>;
+    get onSelectionChanged(): MotifEvent<TreeViewSelectionChangedEventArgs<T>>;
+    get onCheckChanged(): MotifEvent<TreeViewCheckChangedEventArgs<T>>;
+    get onItemClick(): MotifEvent<TreeViewItemClickEventArgs<T>>;
+    /** The item with this key, if the tree knows it. */
+    itemOf(key: unknown): T | undefined;
+    /** Opens a row (its children load first if they have to); the cancelable event runs. */
+    expand(key: unknown): boolean;
+    collapse(key: unknown): boolean;
+    /** Opens every row whose children are known (children not loaded yet are not loaded). */
+    expandAll(): void;
+    collapseAll(): void;
+    /** Selects a row from code (`multiple`: adds it to the selection). */
+    select(key: unknown): void;
+    unselect(key: unknown): void;
+    /** With `multiple`: every known row that can be selected. */
+    selectAll(): void;
+    clearSelection(): void;
+    check(key: unknown, checked?: boolean): void;
+    uncheck(key: unknown): void;
+    checkAll(): void;
+    uncheckAll(): void;
+    /** Filters the rows by `text` (empty: all rows), as the search box does. */
+    filter(text: string): void;
+    /** Opens the row's parents and scrolls it into view; `false` when it is not shown (filtered out, unknown). */
+    scrollTo(key: unknown): boolean;
+    /** Opens the row's parents, scrolls to it and focuses it. */
+    focusNode(key: unknown): boolean;
+    /**
+     * Reads the items again after they were changed in place: which there are, their children, texts and states.
+     * Children that loaded stay. Your items may be plain or reactive; the tree reads them as they are.
+     */
+    refresh(): void;
+    /** Draws one row again after its item was changed in place: its text, icon and state (`refresh` for its children). */
+    refreshItem(key: unknown): void;
+    /** Loads a row's children again (all loaded children without a key) and reads the items again. */
+    reload(key?: unknown): void;
+    /** Focuses the row Tab reaches. */
+    protected get focusElement(): HTMLElement;
+    protected applyProperty(name: string, value: unknown): void;
+    private get parts();
+    private fields;
+    private textOf;
+    private iconOf;
+    private enabledOf;
+    /** Changes are reported once the tree is built; what it is given before is its start. */
+    private get live();
+    private get recursive();
+    private itemsOf;
+    private valueNow;
+    private isOpen;
+    /** The tree follows the items, every field it reads of them and the props that say how. */
+    private watchItems;
+    /** Reads the items and every field of them, tracked; returns the `expanded` fields. */
+    private readItems;
+    private touch;
+    private itemsChanged;
+    /** Follows the children that loaded until the next read of the items does. */
+    private watch;
+    /** Writes the selection to `x-model`, if there is one. */
+    private writeBack;
+    /** The value just written, handed back by a reactive model as its own copy: the selection stays. */
+    private isEcho;
+    private takeValue;
+    private takeExpanded;
+    private takeChecked;
+    /** Whether a key list holds exactly the keys checked now. */
+    private isChecked;
+    /** Brings a key list's storage in step, without dropping a bound getter. */
+    private sync;
+    private syncKeys;
+    private setOpen;
+    /** Many rows opened or closed at once: drawn again, no events per row. */
+    private expansionChanged;
+    private load;
+    private loaded;
+    /** Open rows whose children are not known yet load them. */
+    private loadOpen;
+    private setSelection;
+    private selectByUser;
+    private selectRange;
+    private selectAllBy;
+    private setCheck;
+    private checksChanged;
+    /** Opens the parents of a row; its index on screen, -1 when it is not shown. */
+    private reveal;
+    /** Filters, counts the rows on screen and draws them all again. */
+    private redraw;
+    private computeRows;
+    private get windowFrom();
+    private drawAll;
+    /** Builds the rows from `from` on that sit at `level`, their open children nested in groups. */
+    private buildBranch;
+    /** A row opened or closed: only its children are drawn again. */
+    private drawBranch;
+    /** In a long tree: the rows in view (and the one Tab reaches), two empty blocks for the rest. */
+    private drawWindow;
+    private space;
+    private measure;
+    private itemElement;
+    /** A row's states: level and place, open, selected, checked, enabled, loading. */
+    private renderItem;
+    private renderError;
+    private fillError;
+    private renderNode;
+    private renderStates;
+    /** The row Tab reaches: the focused one, else the first selected, else the first. */
+    private stopNode;
+    private renderRoving;
+    private renderLook;
+    private renderSearch;
+    /** The search box sits above the rows; building the tree places its controls again, so it is put back. */
+    private placeSearch;
+    private forget;
+    private releaseAll;
+    private scrollToRow;
+    private focusRow;
+    private listen;
+    private nodeOf;
+    private clicked;
+    private doubleClicked;
+    private keyDown;
+    /** The next row whose text starts with what was typed lately; -1 when none. */
+    private typeAhead;
+}

package/dist/components/treeview/index.d.ts

@@ -0,0 +1,16 @@
+export { TreeView } from './TreeView';
+export { TreeModel } from './TreeModel';
+export type { TreeViewProps } from './tree-view-props';
+export type { TreeViewSelectionMode } from './tree-view-selection-mode';
+export type { TreeViewExpandOn } from './tree-view-expand-on';
+export type { TreeViewLoadChildren } from './tree-view-load-children';
+export type { TreeViewItemTemplate } from './tree-view-item-template';
+export type { TreeViewExpandingEventArgs } from './tree-view-expanding-event-args';
+export type { TreeViewExpandedEventArgs } from './tree-view-expanded-event-args';
+export type { TreeViewSelectionChangedEventArgs } from './tree-view-selection-changed-event-args';
+export type { TreeViewCheckChangedEventArgs } from './tree-view-check-changed-event-args';
+export type { TreeViewItemClickEventArgs } from './tree-view-item-click-event-args';
+export type { TreeCheckState } from './tree-check-state';
+export type { TreeNode } from './tree-node';
+export type { TreeRow } from './tree-row';
+export type { TreeFields } from './tree-fields';

package/dist/components/treeview/tree-check-state.d.ts

@@ -0,0 +1,2 @@
+/** A check box's state; `mixed` is a parent with some of its children checked. */
+export type TreeCheckState = 'checked' | 'unchecked' | 'mixed';

package/dist/components/treeview/tree-fields.d.ts

@@ -0,0 +1,7 @@
+/** How a tree reads its items. */
+export interface TreeFields<T> {
+    key: (item: T) => unknown;
+    children: (item: T) => unknown;
+    parent: (item: T) => unknown;
+    hasChildren: (item: T) => unknown;
+}

package/dist/components/treeview/tree-node.d.ts

@@ -0,0 +1,12 @@
+/** One item of a tree, as the tree knows it after reading its fields. */
+export interface TreeNode<T> {
+    item: T;
+    key: unknown;
+    parent: TreeNode<T> | null;
+    /** 1 for a root. */
+    level: number;
+    /** `null` while the children are not known yet (they load on the first expand). */
+    children: TreeNode<T>[] | null;
+    /** Its children load on demand. */
+    lazy: boolean;
+}

package/dist/components/treeview/tree-row.d.ts

@@ -0,0 +1,9 @@
+import type { TreeNode } from './tree-node';
+/** A node on screen: where it sits among the siblings shown with it. */
+export interface TreeRow<T> {
+    node: TreeNode<T>;
+    /** How many siblings are shown, itself included. */
+    size: number;
+    /** 1-based. */
+    position: number;
+}

package/dist/components/treeview/tree-view-check-changed-event-args.d.ts

@@ -0,0 +1,13 @@
+import type { TreeCheckState } from './tree-check-state';
+import type { TreeView } from './TreeView';
+export interface TreeViewCheckChangedEventArgs<T> {
+    /** The item that was pressed; `null` when many changed at once (`checkAll`, `checkedKeys`). */
+    item: T | null;
+    key: unknown;
+    state: TreeCheckState;
+    /** Every checked key after the change. */
+    keys: unknown[];
+    /** `true` when the user checked, `false` when code did. */
+    byUser: boolean;
+    source: TreeView<T>;
+}

package/dist/components/treeview/tree-view-expand-on.d.ts

@@ -0,0 +1,2 @@
+/** What opens and closes a branch besides its arrow and the keys: nothing, a press on the row, or a double press. */
+export type TreeViewExpandOn = 'expander' | 'click' | 'dblclick';

package/dist/components/treeview/tree-view-expanded-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { TreeView } from './TreeView';
+export interface TreeViewExpandedEventArgs<T> {
+    item: T;
+    key: unknown;
+    /** `true` when the user did it, `false` when code did. */
+    byUser: boolean;
+    source: TreeView<T>;
+}

package/dist/components/treeview/tree-view-expanding-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { EventArgs } from '@motifx/core';
+import type { TreeView } from './TreeView';
+/** A branch is about to open (or close); `cancel = true` leaves it as it is. */
+export interface TreeViewExpandingEventArgs<T> extends EventArgs {
+    item: T;
+    key: unknown;
+    /** `true` when the user did it, `false` when code did. */
+    byUser: boolean;
+    source: TreeView<T>;
+    event?: Event;
+}

package/dist/components/treeview/tree-view-item-click-event-args.d.ts

@@ -0,0 +1,8 @@
+import type { TreeView } from './TreeView';
+/** A row was pressed, or Enter was pressed on it. */
+export interface TreeViewItemClickEventArgs<T> {
+    item: T;
+    key: unknown;
+    source: TreeView<T>;
+    event: Event;
+}

package/dist/components/treeview/tree-view-item-template.d.ts

@@ -0,0 +1,2 @@
+/** Draws a row's content into `host`; may return a cleanup. */
+export type TreeViewItemTemplate<T> = (item: T, host: HTMLElement) => (() => void) | void;

package/dist/components/treeview/tree-view-load-children.d.ts

@@ -0,0 +1,2 @@
+/** Loads the children of an item the first time it opens. */
+export type TreeViewLoadChildren<T> = (item: T) => Promise<readonly T[]>;

package/dist/components/treeview/tree-view-props.d.ts

@@ -0,0 +1,75 @@
+import type { Bind } from '@motifx/core';
+import type { ControlProps } from '../../core/control';
+import type { ControlSize } from '../../core/control-size';
+import type { ItemField } from '../../parts/list/item-field';
+import type { TreeViewCheckChangedEventArgs } from './tree-view-check-changed-event-args';
+import type { TreeViewExpandOn } from './tree-view-expand-on';
+import type { TreeViewExpandedEventArgs } from './tree-view-expanded-event-args';
+import type { TreeViewExpandingEventArgs } from './tree-view-expanding-event-args';
+import type { TreeViewItemClickEventArgs } from './tree-view-item-click-event-args';
+import type { TreeViewItemTemplate } from './tree-view-item-template';
+import type { TreeViewLoadChildren } from './tree-view-load-children';
+import type { TreeViewSelectionChangedEventArgs } from './tree-view-selection-changed-event-args';
+import type { TreeViewSelectionMode } from './tree-view-selection-mode';
+/** Props of `TreeView`: the shared `ControlProps` plus its own. Each one is also a settable, reactive property. */
+export interface TreeViewProps<T> extends ControlProps {
+    /** Nested items (a `children` array) or flat ones (a `parentId`). A function is followed; a reactive array is followed in place. */
+    items?: Bind<readonly T[]>;
+    /** Default `'text'` of an object item, the item itself otherwise. */
+    textField?: Bind<ItemField<T>>;
+    /** What names an item in `value`, `expandedKeys` and `checkedKeys`. Default `'id'`, the item itself without one. */
+    keyField?: Bind<ItemField<T>>;
+    /** Default `'children'`. */
+    childrenField?: Bind<ItemField<T>>;
+    /** Flat items: the key of the parent. Default `'parentId'`; giving it, or items with a `parentId`, makes the list flat. */
+    parentField?: Bind<ItemField<T>>;
+    /** Default `'icon'`: an image address, an element or a component. */
+    iconField?: Bind<ItemField<T>>;
+    /** Default `'enabled'`; `false` there: the row cannot be selected or checked. */
+    enabledField?: Bind<ItemField<T>>;
+    /** Default `'expanded'`; a change there opens or closes the row. */
+    expandedField?: Bind<ItemField<T>>;
+    /** With `loadChildren`: default `'hasChildren'`; `false` there means a leaf. */
+    hasChildrenField?: Bind<ItemField<T>>;
+    /** Loads the children of an item when it is first opened. */
+    loadChildren?: Bind<TreeViewLoadChildren<T> | null>;
+    /** Default `'single'`. */
+    selectionMode?: Bind<TreeViewSelectionMode>;
+    /** The selected key (`single`) or keys (`multiple`). `x-model` binds it two-way. */
+    value?: Bind<unknown>;
+    /** The open rows' keys. The change events report the new ones. */
+    expandedKeys?: Bind<readonly unknown[]>;
+    /** A check box on every row. */
+    showCheckBoxes?: Bind<boolean>;
+    /** Checking a parent checks its children; a parent is mixed when some are. Default `true`. */
+    checkRecursive?: Bind<boolean>;
+    /** The checked keys. `onCheckChanged` reports the new ones. */
+    checkedKeys?: Bind<readonly unknown[]>;
+    /** A search box at the top. */
+    searchEnabled?: Bind<boolean>;
+    /** Default `'contains'`. */
+    searchMode?: Bind<'contains' | 'startswith'>;
+    /** The text the rows are filtered by: matches show with their parents, opened. */
+    searchValue?: Bind<string>;
+    /** Default `'expander'`: only the arrow and the keys open a branch. */
+    expandOn?: Bind<TreeViewExpandOn>;
+    /** Lines from each parent down to its children. */
+    showLines?: Bind<boolean>;
+    /** Default `'md'`. */
+    size?: Bind<ControlSize>;
+    /** The tree's accessible name. */
+    label?: Bind<string>;
+    /** More rows on screen than this: only the ones in view are drawn. Default 500. */
+    virtualFrom?: Bind<number>;
+    /** Draws a row's content; may return a cleanup. */
+    itemTemplate?: Bind<TreeViewItemTemplate<T> | null>;
+    /** About to open a branch; cancelable. */
+    onExpanding?: (e: TreeViewExpandingEventArgs<T>) => void;
+    /** About to close a branch; cancelable. */
+    onCollapsing?: (e: TreeViewExpandingEventArgs<T>) => void;
+    onExpanded?: (e: TreeViewExpandedEventArgs<T>) => void;
+    onCollapsed?: (e: TreeViewExpandedEventArgs<T>) => void;
+    onSelectionChanged?: (e: TreeViewSelectionChangedEventArgs<T>) => void;
+    onCheckChanged?: (e: TreeViewCheckChangedEventArgs<T>) => void;
+    onItemClick?: (e: TreeViewItemClickEventArgs<T>) => void;
+}

package/dist/components/treeview/tree-view-selection-changed-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { TreeView } from './TreeView';
+export interface TreeViewSelectionChangedEventArgs<T> {
+    /** The selected key (`single`) or keys (`multiple`). */
+    value: unknown;
+    items: T[];
+    /** `true` when the user selected, `false` when code did. */
+    byUser: boolean;
+    source: TreeView<T>;
+    event?: Event;
+}

package/dist/components/treeview/tree-view-selection-mode.d.ts

@@ -0,0 +1,2 @@
+/** `none`: rows are not selected; `single`: one at a time; `multiple`: any number. */
+export type TreeViewSelectionMode = 'none' | 'single' | 'multiple';

package/dist/core/UiLocale.d.ts

@@ -0,0 +1,52 @@
+import { type Event as MotifEvent } from '@motifx/core';
+import type { UiLocaleChangedEventArgs } from './ui-locale-changed-event-args';
+import type { UiPack } from './ui-pack';
+import type { UiPackModule } from './ui-pack-module';
+import type { UiStrings } from './ui-strings';
+/**
+ * The language of the kit's controls: their texts, the locale their dates and numbers are written in, the direction.
+ * A language is switched with `use`, its pack loaded first when it is not there yet; then `onChanged` is raised once
+ * and every control draws its texts and formats again. Nothing follows it: a control listens to `onChanged`.
+ */
+export declare class UiLocale {
+    private readonly builtIn;
+    /** Loads the pack of a language (`'tr'`, `'pt-br'`); a pack it does not have is a rejected promise. */
+    loader: (language: string) => Promise<UiPackModule>;
+    /** Settles once the starting language is in. */
+    readonly ready: Promise<void>;
+    private current;
+    private readonly packs;
+    private readonly loading;
+    /** Languages the loader has no pack for: not asked again. */
+    private readonly missing;
+    private readonly changed;
+    private turn;
+    constructor(builtIn: UiStrings, loader: (language: string) => Promise<UiPackModule>, locale: string);
+    /** The locale in use (`'tr-TR'`). A change is told by `onChanged`; nothing follows it. */
+    get locale(): string;
+    /** `'rtl'` or `'ltr'` for the locale in use. */
+    get dir(): 'ltr' | 'rtl';
+    /**
+     * The texts in use. Assigning a set changes the texts and keeps the locale: for an app's own wording
+     * (`uiLocale.strings = { ...uiLocale.strings, close: 'Kapat' }`). The set is kept as given.
+     */
+    get strings(): UiStrings;
+    set strings(value: UiStrings);
+    /** Raised once the language changed, with the locale before. */
+    get onChanged(): MotifEvent<UiLocaleChangedEventArgs>;
+    /**
+     * Switches to `locale`: its pack (`tr-TR`, else `tr`) is loaded first when it is not there, so no control shows
+     * half its texts in the old language; until then the old one stays. A later call wins over one still loading.
+     * A language without a pack keeps the built-in texts and still writes dates and numbers its way.
+     */
+    use(locale: string): Promise<void>;
+    /** Adds the pack of a language, or more texts to it; a language in use shows them at once. */
+    add(language: string, pack: UiPack): void;
+    /** A text of the kit with its values filled in (ICU: `{count, plural, one {# row} other {# rows}}`). */
+    text(key: keyof UiStrings, values?: Record<string, unknown>): string;
+    private apply;
+    /** The pack of the most precise language that has one; `null` for the built-in language or none. */
+    private packOf;
+    private builtInLanguage;
+    private load;
+}

package/dist/core/access-key.d.ts

@@ -0,0 +1,32 @@
+/** A control text with its access key: `&Dosya` → text `Dosya`, key `D` at index 0. */
+export interface ParsedAccessKey {
+    /** The text without the marker (`&&` becomes `&`). */
+    text: string;
+    /** The access key as written (`D`), or `null` when the text has none. */
+    key: string | null;
+    /** Index of the access key in `text`, -1 when there is none. */
+    index: number;
+}
+/**
+ * Parses a control text: the character after a single `&` is the access key
+ * (`&File` → F), `&&` is a literal ampersand. Only the first marker counts.
+ */
+export declare function parseAccessKey(source: string): ParsedAccessKey;
+/**
+ * Renders a parsed text into `host` (replacing its content): the access key
+ * is wrapped in `<span class="mx-access-key">`, underlined while the access
+ * key modifiers are held (or always, with `data-mx-access-keys="always"` on
+ * <html>). The accessible name stays the plain text.
+ */
+export declare function renderAccessKey(host: Element, parsed: ParsedAccessKey): void;
+/**
+ * The modifiers that press an access key on this platform, as written in
+ * `aria-keyshortcuts`: `Alt`, or `Control+Alt` (Control + Option) on Apple
+ * platforms, where Option alone types characters. Browsers use the same keys
+ * for HTML `accesskey`.
+ */
+export declare function accessKeyModifiers(): string;
+/** The `aria-keyshortcuts` token for an access key: `Alt+D`, or `Control+Alt+D` on Apple platforms. */
+export declare function accessKeyToken(key: string): string;
+/** Adds or replaces this package's access key token in an element's `aria-keyshortcuts`, keeping the app's own. */
+export declare function setAccessKeyAttribute(el: Element, previous: string | null, next: string | null): void;

package/dist/core/after-press.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runs `work` now, or after the press in progress has ended and its click has run: something that
+ * moves the layout (an error line appearing) must not move a button away from under the pointer.
+ */
+export declare function afterPress(work: () => void): void;

package/dist/core/back-button.d.ts

@@ -0,0 +1,15 @@
+/** What `holdBackButton` returns: lets go (taking its history entry back), or `raise()` makes it the last one held. */
+export type BackButtonHold = (() => void) & {
+    raise(): void;
+};
+/**
+ * Lets the browser's back close something: `onBack` runs when the user goes back while it is the
+ * holder of the highest `layer` (the last one held, or raised, among equals). Returns the function
+ * that lets go when it closes some other way: its history entry is taken back. A page whose address
+ * changed in the meantime keeps the entry (going back then just returns to it).
+ */
+export declare function holdBackButton(view: Window | null, onBack: () => void, layer?: number): BackButtonHold;
+/** How many holders there are now in a window: for tests and diagnostics. */
+export declare function backButtonHolders(view: Window): number;
+/** Whether every history move of ours in a window has come back (none taken back or waiting): for tests and diagnostics. */
+export declare function backButtonSettled(view: Window): boolean;