optikos 0.3.0 → 0.4.0

package/dist/types/components/fields/datetimefield/datetimefield.d.ts

@@ -0,0 +1,28 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export interface DateTimeFieldConfig extends FieldConfig<string | null> {
+    /** Earliest and latest date, `YYYY-MM-DD`. */
+    min?: string;
+    max?: string;
+    /** Minutes moved by ↑/↓ in the time part. */
+    step?: number;
+    /** The value is the ISO instant (`2026-11-10T17:30:00.000Z`) of what the user typed, in their time zone. Default: the local `YYYY-MM-DDTHH:mm`. */
+    utc?: boolean;
+}
+/** A date and a time of day side by side. The value is one ISO string (local, or UTC with `utc`) or null. */
+export declare class DateTimeField extends Field<string | null, DateTimeFieldConfig> {
+    protected baseCls: string;
+    private date;
+    private time;
+    protected emptyValue(): null;
+    protected isEmpty(v: string | null): boolean;
+    protected createControl(): HTMLDivElement;
+    /** Both parts → the value. One part alone is not a value yet (`check` says so). */
+    private compose;
+    protected applyValue(v: string | null): void;
+    getDisplayText(): string;
+    protected check(): string;
+    protected onDisabled(disabled: boolean): void;
+    protected onReadonly(readonly: boolean): void;
+    setMin(min: string | undefined): void;
+    setMax(max: string | undefined): void;
+}

package/dist/types/components/fields/imagefield/imagefield.d.ts

@@ -0,0 +1,48 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+/** A new `File`, or the URL (string) of an image already saved. */
+export type ImageItem = File | string;
+export type ImageValue = ImageItem | ImageItem[] | null;
+export interface ImageFieldConfig extends FieldConfig<ImageValue> {
+    /** The input's `accept` (also checked on dropped files). Default `image/*`. */
+    accept?: string;
+    /** Bytes. */
+    maxSize?: number;
+    multiple?: boolean;
+    /** With `multiple`. */
+    maxFiles?: number;
+    placeholder?: string;
+}
+/** Picks images by click or drop, with a preview. Holds the files; sending them is up to the app. */
+export declare class ImageField extends Field<ImageValue, ImageFieldConfig> {
+    protected baseCls: string;
+    private zone;
+    private picker;
+    private list;
+    private urls;
+    protected emptyValue(): ImageValue;
+    protected isEmpty(v: ImageValue): boolean;
+    protected isEqual(a: ImageValue, b: ImageValue): boolean;
+    private itemsOf;
+    private items;
+    protected createControl(): HTMLDivElement;
+    protected onRender(): void;
+    protected applyValue(v: ImageValue): void;
+    private url;
+    private revoke;
+    /** The zone is there only while there is room for another image and the user may edit. */
+    private sync;
+    protected onDisabled(): void;
+    protected onReadonly(): void;
+    /** Opens the browser's file picker. */
+    open(): void;
+    private accepts;
+    /** Adds files with the same checks as a drop. Without `multiple` the first valid file replaces the image. */
+    add(files: File[]): void;
+    /** Removes the image at `index`. */
+    remove(index: number): void;
+    protected commit(v: ImageValue): void;
+    private holdsFocus;
+    /** The button the keyboard user was on may be gone: move to the one that is left. */
+    private refocus;
+    getDisplayText(): string;
+}

package/dist/types/components/fields/maskfield/maskfield.d.ts

@@ -0,0 +1,28 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface MaskFieldConfig extends TextFieldConfig {
+    /**
+     * The pattern: `0` a digit, `A` a letter, `*` any character, `\` makes the next character a literal. A list picks the
+     * pattern by length: `['000.000.000-00', '00.000.000/0000-00']` is a CPF until the 12th digit, then a CNPJ.
+     * The core knows no country: formats like these belong to the app.
+     */
+    mask: string | string[];
+    /** The value is only what was typed into the slots (`12345678900`), not the formatted text (`123.456.789-00`). Default false. */
+    raw?: boolean;
+}
+/** A text field that formats what is typed into a pattern (phone, tax id, postal code, plate...). */
+export declare class MaskField extends TextField<string, MaskFieldConfig> {
+    protected baseCls: string;
+    private masks;
+    private compiled;
+    /** What was typed into the slots: the literals of the patterns are dropped (with a `*` slot, only where the text repeats one). */
+    private extract;
+    private pick;
+    private format;
+    private norm;
+    protected display(v: string): string;
+    setValue(v: string, silent?: boolean): void;
+    protected createControl(): HTMLDivElement;
+    protected onInput(): void;
+    protected check(): string;
+    setMask(mask: string | string[]): void;
+}

package/dist/types/components/fields/numberfield/numberfield.d.ts

@@ -5,6 +5,14 @@ export interface NumberFieldConfig extends TextFieldConfig<number | null> {
     step?: number;
     /** Fixed decimals shown (and applied when the user leaves the field). */
     decimals?: number;
+    /** `currency` and `percent` show through `Intl` (`R$ 1.234,56`, `$1,234.56`, `15%`). Default: plain number. */
+    format?: 'decimal' | 'currency' | 'percent';
+    /** ISO 4217 code for `format: 'currency'`. Default: the locale's (`setCurrency`). */
+    currency?: string;
+    /** BCP 47 tag for this field's separators. Default: the active locale. */
+    locale?: string;
+    /** The value is the shown number times `scale`: `scale: 100` with currency keeps cents as an integer (`123456` shows `1.234,56`). */
+    scale?: number;
 }
 export declare class NumberField extends TextField<number | null, NumberFieldConfig> {
     protected baseCls: string;
@@ -12,6 +20,7 @@ export declare class NumberField extends TextField<number | null, NumberFieldCon
     private garbage;
     protected emptyValue(): null;
     protected isEmpty(v: number | null): v is null;
+    private get lang();
     private get decimalSep();
     protected parse(text: string): number | null;
     protected display(v: number | null): string;

package/dist/types/components/fields/pickerfield/pickerfield.d.ts

@@ -47,6 +47,9 @@ export declare abstract class PickerField<V = unknown, C extends PickerConfig<V>
     private bindStore;
     protected findItem(value: unknown): ListItem | undefined;
     getSelection(): ListItem | undefined;
+    /** Also takes `{ value, label }`: the value with the text to show, for a record that is not in the list. */
+    setValue(v: V, silent?: boolean): void;
+    fillFrom(record: Record<string, any>): void;
     /** Selects an item object directly (needed when the list does not contain it, e.g. a remote value). */
     setSelection(item: ListItem | undefined, silent?: boolean): void;
     /** The items to display for the current search state. Default: all. */

package/dist/types/components/fields/timefield/timefield.d.ts

@@ -0,0 +1,24 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface TimeFieldConfig extends TextFieldConfig<string | null> {
+    /** Earliest and latest time, `'HH:mm'`. */
+    min?: string;
+    max?: string;
+    /** Minutes moved by ↑/↓ (PageUp/PageDown move an hour). Default 1. */
+    step?: number;
+}
+/** A time of day. The value is `'HH:mm'` (24 h) or `null`. Type `930`, `9:30` or `09:30`; ↑/↓ step it. */
+export declare class TimeField extends TextField<string | null, TimeFieldConfig> {
+    protected baseCls: string;
+    private garbage;
+    protected emptyValue(): null;
+    protected isEmpty(v: string | null): v is null;
+    protected parse(text: string): string | null;
+    protected createControl(): HTMLDivElement;
+    protected onInput(): void;
+    protected applyValue(v: string | null): void;
+    protected check(): string;
+    protected onKey(e: KeyboardEvent): void;
+    private bump;
+    setMin(min: string | undefined): void;
+    setMax(max: string | undefined): void;
+}

package/dist/types/components/form/fieldlist/fieldlist.d.ts

@@ -42,6 +42,8 @@ export declare class FieldList extends Field<Row[], FieldListConfig> {
     moveRow(from: number, to: number): void;
     getRows(): Container[];
     getRowFields(index: number): Field<any>[];
+    /** The field of a row by path (`'0.name'` → field `name` of the first row): where a server error lands. */
+    fieldAt(path: string): Field<any> | undefined;
     setAddText(text: string): void;
     setMin(min: number): void;
     setMax(max: number): void;

package/dist/types/components/form/form/form.d.ts

@@ -61,6 +61,11 @@ export declare class Form extends Container<FormConfig> {
     clearErrors(): void;
     /** Validates every field that counts (marks errors) and focuses the first invalid one. */
     validate(): boolean;
+    /**
+     * Marks server-side errors by dotted path (`slug`, `items.0.name` for a row of a FieldList), brings the first into
+     * view (its tab or step) and focuses it. Returns the paths that matched no field, for the caller to show some other way.
+     */
+    setErrors(errors: Record<string, string>): string[];
     submit(): boolean;
     /** Width of the labels on the left (number = px); they line up in a column. */
     setLabelWidth(width: number | string): void;

package/dist/types/components/form/stepform/stepform.d.ts

@@ -79,7 +79,7 @@ export declare class StepForm extends Form {
     /** The card layout changed the visible step (by `goTo`, or because `validate` brought an invalid field into view). */
     private onActivate;
     private refreshReview;
-    /** What the user sees for a field (its display text; ticks for booleans, dots for passwords). */
+    /** What the user sees for a field (its display text; ticks for booleans, dots for passwords; one line per FieldList row). */
     private show_;
     /** Enter and the Finish button: Next on every step but the last; on the last, validate everything and `finish`. */
     submit(): boolean;

package/dist/types/components/gridexport.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/gridexport/gridexport.js';

package/dist/types/components/gridstate.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/gridstate/gridstate.js';

package/dist/types/components/grouping.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/grouping/grouping.js';

package/dist/types/components/image.d.ts

@@ -0,0 +1 @@
+export * from '../components/base/image/image.js';

package/dist/types/components/imagecanvas.d.ts

@@ -0,0 +1 @@
+export * from '../components/base/imagecanvas/imagecanvas.js';

package/dist/types/components/imagefield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/imagefield/imagefield.js';

package/dist/types/components/layout/carousel/carousel.d.ts

@@ -0,0 +1,58 @@
+import { Container, type ContainerConfig } from '../../../core/container.js';
+export interface CarouselConfig extends ContainerConfig {
+    /** Items shown together. Default 1. */
+    perView?: number;
+    /** Space between items (px or CSS length). */
+    gap?: number | string;
+    /** Past the last item goes to the first (and the other way). */
+    loop?: boolean;
+    /** ms between items; 0 (default) is off. */
+    autoplay?: number;
+    /** Default `true`. */
+    dots?: boolean;
+    /** Default `true`. */
+    arrows?: boolean;
+    active?: number;
+}
+/** Pages through its items on a scroll-snap row: images, cards or any component. */
+export declare class Carousel extends Container<CarouselConfig> {
+    protected baseCls: string;
+    private track;
+    private prevBtn;
+    private nextBtn;
+    private dotsEl;
+    private toggleBtn;
+    private index;
+    private stopped;
+    private scrollTimer?;
+    private playTimer?;
+    private get perView();
+    /** Positions the row can rest on: it moves one item at a time. */
+    private get last();
+    protected build(): HTMLElement;
+    getBody(): HTMLElement;
+    protected onRender(): void;
+    protected onMount(): void;
+    /** Reads the item at the left edge from the scroll position (after a swipe or a trackpad scroll). */
+    private settle;
+    private stride;
+    private align;
+    private set;
+    /** Slides, dots, arrows: everything that follows the item count or the active one. */
+    private refresh;
+    getActive(): number;
+    /** Goes to item `i` (kept between 0 and the last position). `before-change` can cancel. */
+    goTo(i: number): void;
+    setActive(i: number): void;
+    private step;
+    next(): void;
+    prev(): void;
+    isPlaying(): boolean;
+    private reduced;
+    play(): void;
+    pause(): void;
+    /** Any use of the controls ends autoplay for good (WCAG 2.2.2). */
+    private interact;
+    /** Runs the timer only while playing and nothing holds the pointer or the focus. */
+    private tick;
+}

package/dist/types/components/maskfield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/maskfield/maskfield.js';

package/dist/types/components/navigation/navmenu/navmenu.d.ts

@@ -7,6 +7,8 @@ export interface NavItem {
     items?: NavItem[];
     disabled?: boolean;
     hidden?: boolean;
+    /** Hidden (or disabled) while `setPermissionResolver` denies it. */
+    permission?: string;
     /** Groups: start open. */
     expanded?: boolean;
     data?: unknown;

package/dist/types/components/overlays/commandpalette/commandpalette.d.ts

@@ -1,6 +1,8 @@
 import { Component, type ComponentConfig } from '../../../core/component.js';
 export interface Command {
     id: string;
+    /** The command is left out while `setPermissionResolver` denies it. */
+    permission?: string;
     title: string;
     /** Groups the command and gives it a filter chip. */
     category?: string;

package/dist/types/components/overlays/menu/menu.d.ts

@@ -12,8 +12,11 @@ export interface MenuItem {
     group?: string;
     /** A count or short label at the end of the row. */
     badge?: string | number;
+    /** Hidden (or disabled) while `setPermissionResolver` denies it. */
+    permission?: string;
 }
-export type MenuEntry = MenuItem | '-';
+/** An item, or `'-'` for a separator (typed `string` so an array built in a variable still fits). */
+export type MenuEntry = MenuItem | string;
 export interface MenuConfig extends ComponentConfig {
     items?: MenuEntry[];
     /** A search field over the items: filters as you type; a search that names a group shows the whole group. */

package/dist/types/components/overlays/shortcuts/shortcuts.d.ts

@@ -0,0 +1,27 @@
+export interface Shortcut {
+    /** `mod+s` (Ctrl, or ⌘ on a Mac), `shift+?`, `alt+n`, `g`. Several keys in a row are not supported. */
+    keys: string;
+    title: string;
+    handler: (e: KeyboardEvent) => void | false;
+    /** The screen it belongs to (`setScope`). Default `global`: active on every screen. */
+    scope?: string;
+    /** Heading in the help panel. Default: the scope. */
+    group?: string;
+    /** Checked on every press: the shortcut only runs while this returns true. */
+    when?: () => boolean;
+    /** A shortcut without Ctrl/⌘/Alt is ignored while typing in a field, unless this is true. */
+    inInputs?: boolean;
+}
+/** How a combination reads on this keyboard: `⌘S`, `Ctrl+S`. */
+export declare function formatKeys(keys: string): string;
+export declare const shortcuts: {
+    /** Adds shortcuts; returns the function that removes them. The same keys twice in one scope warn in dev, and the newest wins. */
+    register(list: Shortcut | Shortcut[]): () => void;
+    /** The screen whose shortcuts are active besides the global ones (`undefined`: only global). */
+    setScope(name: string | undefined): void;
+    getScope: () => string | undefined;
+    /** What is active now: the global shortcuts and the current scope's. */
+    list: () => Shortcut[];
+    /** Opens (or closes) the help panel, grouped. `?` does it from anywhere but a text field. */
+    help(): void;
+};

package/dist/types/components/overlays/window/window.d.ts

@@ -11,6 +11,8 @@ export interface WindowConfig extends PanelConfig {
      * pop up. `true` focuses its first field instead. Default false.
      */
     autoFocus?: boolean;
+    /** Closing while a field inside is changed asks first. `true` uses a standard text; a string is the question. */
+    confirmDiscard?: boolean | string;
 }
 /** Floating dialog. Modal by default: the page behind becomes inert and Tab stays inside. */
 export declare class Window extends Panel<WindowConfig> {
@@ -27,10 +29,21 @@ export declare class Window extends Panel<WindowConfig> {
     /** Dims (true) or not (false) the page behind the modal window. */
     setMask(mask: boolean): void;
     isVisible(): boolean;
-    /** Centers in the viewport (also done on show and on resize until the user drags it). */
+    /** Centers in the viewport (also done on show, on resize and when the content grows, until the user drags it). */
     center(): void;
+    /** Keeps the window on screen: centered, or (once dragged) pulled up just enough to fit. */
+    private keepInView;
     show(): void;
     private focusFirst;
+    /**
+     * How `confirmDiscard` asks. MessageBox sets it when it is loaded (it needs Window itself, so Window cannot import it);
+     * without MessageBox the browser's own `confirm` is used.
+     */
+    static ask?: (text: string, o: {
+        okText: string;
+        cancelText: string;
+    }) => Promise<boolean>;
+    close(): void;
     hide(): void;
     /** Cleans up at once (the page is usable again) and takes the window off the screen: shrinking toward its opener, 20 % faster than it came. */
     private release;

package/dist/types/components/rowediting.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/rowediting/rowediting.js';

package/dist/types/components/shortcuts.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/shortcuts/shortcuts.js';

package/dist/types/components/stat.d.ts

@@ -0,0 +1 @@
+export * from '../components/charts/stat/stat.js';

package/dist/types/components/timefield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/timefield/timefield.js';

package/dist/types/components/timeline.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/timeline/timeline.js';

package/dist/types/components/treegrid.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/treegrid/treegrid.js';

package/dist/types/core/component.d.ts

@@ -14,6 +14,9 @@ export interface ComponentConfig {
     showIf?: (values: Record<string, any>) => boolean;
     /** Inside a Form: enabled only while this returns true (given the form values). */
     enableIf?: (values: Record<string, any>) => boolean;
+    /** A permission name: without it (per `setPermissionResolver`) the component is hidden, or disabled with `permissionMode: 'disable'`. */
+    permission?: string;
+    permissionMode?: 'hide' | 'disable';
     /** Component-scoped tokens: `{ radius: '0' }` on a button sets `--op-button-radius`. Keys starting with `--` are used as is. */
     theme?: Record<string, string | number>;
     /**
@@ -40,6 +43,8 @@ export interface Parent {
 }
 export declare class Component<C extends ComponentConfig = ComponentConfig> extends Emitter {
     static type?: string;
+    /** Called with every new component, config in hand: `optikos/dev` uses it to warn about options nobody reads. */
+    static onCreate?: (c: Component<any>) => void;
     config: C;
     readonly id: string;
     parent?: Component & Parent;
@@ -74,6 +79,8 @@ export declare class Component<C extends ComponentConfig = ComponentConfig> exte
     later(fn: () => void, ms: number): () => void;
     protected onDisabled(_disabled: boolean): void;
     setDisabled(disabled: boolean): void;
+    /** The user lacks `config.permission` and the way to deal with it is `mode`. */
+    private denied;
     show(): void;
     hide(): void;
     isHidden(): boolean;

package/dist/types/core/container.d.ts

@@ -1,7 +1,16 @@
 import { Component, type ComponentConfig, type Parent } from './component.js';
 import { type AnyConfig } from './registry.js';
 import { type Layout, type LayoutSpec } from '../layout/layout.js';
-export interface ContainerConfig extends ComponentConfig {
+/** What a Tabs header reads from its panel (any Container, not just Panel). */
+export interface TabPanelConfig {
+    title?: string;
+    icon?: string;
+    closable?: boolean;
+    reloadable?: boolean;
+    /** Called by the tab's ↻; a returned Promise keeps the tab busy until it settles. */
+    onReload?: (panel: any) => void | Promise<unknown>;
+}
+export interface ContainerConfig extends ComponentConfig, TabPanelConfig {
     items?: Array<AnyConfig | Component | string>;
     layout?: LayoutSpec;
     /** Config merged into every item that does not set the key itself. */

package/dist/types/core/dev.d.ts

@@ -0,0 +1,2 @@
+/** True while developing: on localhost, or when `globalThis.__OPTIKOS_DEV__` says so. Dev-only warnings follow it. */
+export declare const isDev: () => boolean;

package/dist/types/core/field.d.ts

@@ -11,6 +11,8 @@ export interface FieldConfig<V = unknown> extends ComponentConfig {
     validators?: Validator<V>[];
     /** When to validate on its own. After the first error it revalidates on every change. Default `blur`. */
     validateOn?: 'blur' | 'change' | 'submit';
+    /** Lookups and pickers: the key of the loaded record that holds the text to show for the value (`evento` + `displayFrom: 'eventoNome'`). */
+    displayFrom?: string;
     /** ms of quiet after the last change before `settled` fires (0 = right away). `change` itself is never delayed. */
     debounce?: number;
 }
@@ -44,6 +46,8 @@ export declare abstract class Field<V = unknown, C extends FieldConfig<V> = Fiel
     getValue(): V;
     /** Sets the value programmatically. `silent` skips the `change` event and validation. */
     setValue(v: V, silent?: boolean): void;
+    /** Silently takes this field's value from a record (by `name`); does nothing when the record lacks the key. */
+    fillFrom(record: Record<string, any>): void;
     /** For subclasses: the user edited the control and the DOM already shows `v`. */
     protected commit(v: V): void;
     private changed;

package/dist/types/core/i18n.d.ts

@@ -2,6 +2,8 @@ export type Locale = Record<string, string>;
 export declare const locales: Record<string, Locale>;
 /** Picks a registered locale by name (`'pt-BR'`, or `'pt'` as a prefix) or merges a custom object over English. */
 export declare function setLocale(l: string | Locale): void;
+/** The ISO 4217 code that `money` columns and currency fields use (each locale brings its own default). */
+export declare function setCurrency(code: string): void;
 export declare const getLocale: () => Locale;
 /**
  * Adds messages to a locale (created if missing). Keys already there are kept, so an app's own overrides win.

package/dist/types/core/index.d.ts

@@ -1,11 +1,14 @@
 export { Emitter, type Handler } from './emitter.js';
 export { h, attr, uid, kebab, px, clamp, type Attrs, type Child } from './dom.js';
-export { t, setLocale, getLocale, addMessages, locales, type Locale } from './i18n.js';
+export { t, setLocale, setCurrency, getLocale, addMessages, locales, type Locale } from './i18n.js';
 export { Component, type ComponentConfig, type Parent } from './component.js';
 export { Container, type ContainerConfig } from './container.js';
 export { register, create, getType, type AnyConfig, type ComponentClass } from './registry.js';
 export { registerLayout, createLayout, type Layout, type LayoutSpec, type LayoutFactory } from '../layout/layout.js';
 export { Field, type FieldConfig } from './field.js';
+export { setStateStorage, loadState, saveState, type StateStorage } from './state.js';
+export { getPath, setPath } from './path.js';
+export { setPermissionResolver, setPermissionMode, allowed, gate, type PermissionMode } from './permission.js';
 export * as validators from './validators.js';
 export type { Validator } from './validators.js';
 export { layer, toLayer, lockModal } from './layer.js';

package/dist/types/core/path.d.ts

@@ -0,0 +1,2 @@
+export declare const getPath: (o: any, path: string) => any;
+export declare function setPath(o: any, path: string, value: unknown): void;

package/dist/types/core/permission.d.ts

@@ -0,0 +1,11 @@
+export type PermissionMode = 'hide' | 'disable';
+/** The app's answer to "may the user do this?". Without one, every `permission` is granted. */
+export declare function setPermissionResolver(fn: ((permission: string) => boolean) | undefined): void;
+/** What a component without access does by default: `hide` (default) or `disable`. A component's `permissionMode` wins. */
+export declare function setPermissionMode(m: PermissionMode): void;
+export declare const allowed: (permission?: string) => boolean;
+export declare const permissionMode: () => PermissionMode;
+/** Applies each item's `permission` to a list: denied items are dropped (`hide`) or come back `disabled` (`disable`). Nested `items` too. */
+export declare function gate<T extends {
+    permission?: string;
+}>(list: T[] | undefined): T[] | undefined;

package/dist/types/core/state.d.ts

@@ -0,0 +1,9 @@
+/** Where per-user UI state (column widths, filters, density...) is kept. Both calls may be async (a REST endpoint). */
+export interface StateStorage {
+    get(key: string): unknown | Promise<unknown>;
+    set(key: string, value: unknown): void | Promise<void>;
+}
+/** Replaces the default (`localStorage`) for every `persist`: send it to your API to follow the user across devices. */
+export declare function setStateStorage(storage: StateStorage | undefined): void;
+export declare const loadState: <T = unknown>(key: string) => Promise<T | null>;
+export declare const saveState: (key: string, value: unknown) => Promise<void>;

package/dist/types/data/column.d.ts

@@ -18,6 +18,14 @@ export interface Column<T extends Record<string, any> = any> {
     align?: 'left' | 'center' | 'right';
     sortable?: boolean;
     hidden?: boolean;
+    /** Pinned to the start or the end while the body scrolls sideways (give it a `width`; default 140). The columns of one edge stay together. */
+    locked?: 'start' | 'end';
+    /** With the `grouping()` plugin: what the total row shows for this column. */
+    summary?: 'sum' | 'avg' | 'min' | 'max' | 'count' | ((values: any[], recs: Model<T>[]) => unknown);
+    /** Text for the total of this column (default: the column's `format`, else the plain value). */
+    summaryRenderer?: (value: any, col: Column<T>) => string | Node;
+    /** Left out while `setPermissionResolver` denies it. */
+    permission?: string;
     /** Name registered with `registerFormat` (`money`, `date`, `number`, `percent`, `bool`) or a function. */
     format?: string | Formatter;
     /** Full control over the cell content. Text is escaped; return a Node for markup. */

package/dist/types/data/index.d.ts

@@ -1,5 +1,5 @@
 export { Model, type ModelDef, type FieldDef } from './model.js';
-export { Store, matchFilter, type StoreConfig, type StoreProxy, type FilterFn } from './store.js';
+export { Store, matchFilter, type StoreConfig, type StoreProxy, type Patch, type LiveSource, type FilterFn } from './store.js';
 export { MemoryProxy, RestProxy, type Proxy, type RestProxyConfig, type ReadParams, type ReadResult, type Sorter, type FilterSpec, type FilterOp, type FilterGroup, type FilterNode } from './proxy.js';
 export { format, registerFormat, type Formatter } from './format.js';
 export { cellContent, type Column } from './column.js';

package/dist/types/data/model.d.ts

@@ -21,6 +21,8 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     get id(): string | number;
     get<K extends keyof T>(field: K): T[K];
     set<K extends keyof T>(field: K, value: T[K]): void;
+    /** Applies values that came from the server. It is not an edit (nothing becomes dirty), and a field the user already changed keeps their value. */
+    patch(raw: Partial<T>): boolean;
     isDirty(): boolean;
     getChanges(): Partial<T>;
     commit(): void;

package/dist/types/data/store.d.ts

@@ -3,6 +3,21 @@ import { Model, type ModelDef, type RecordOwner } from './model.js';
 import type { FilterNode, Proxy, ReadParams, ReadResult, Sorter } from './proxy.js';
 export type StoreProxy<T> = Proxy<T> | ((params: ReadParams, signal?: AbortSignal) => Promise<ReadResult<T> | T[]> | ReadResult<T> | T[]);
 export type FilterFn<T extends Record<string, any>> = (rec: Model<T>) => boolean;
+/** One live change: `upsert` merges `data` into the record with the same id (or adds it), `remove` drops the record with `id`. */
+export interface Patch<T> {
+    op?: 'upsert' | 'remove';
+    data?: Partial<T>;
+    id?: string | number;
+}
+/** What `connect` needs from a source: an `EventSource` or a `WebSocket` both fit. */
+export interface LiveSource {
+    addEventListener(type: 'message', fn: (e: {
+        data: any;
+    }) => void): void;
+    removeEventListener(type: 'message', fn: (e: {
+        data: any;
+    }) => void): void;
+}
 export interface StoreConfig<T extends Record<string, any>> {
     data?: Partial<T>[];
     model?: ModelDef;
@@ -57,6 +72,8 @@ export declare class Store<T extends Record<string, any> = Record<string, any>>
     loadData(data: Partial<T>[]): void;
     /** Reads through the proxy. Extra `params` are sent to it and remembered for later reloads. A newer load cancels the older one. */
     load(params?: Record<string, unknown>): Promise<void>;
+    /** Every record that matches the current sort and filters: a local store has them; a remote one is read page by page through its proxy. */
+    fetchAll(pageSize?: number): Promise<Model<T>[]>;
     private setRecords;
     /** Recomputes filtered/sorted/paged rows from `all`. */
     private refreshView;
@@ -80,6 +97,10 @@ export declare class Store<T extends Record<string, any> = Record<string, any>>
     add(raw: Partial<T> | Partial<T>[]): Model<T>[];
     insert(index: number, raw: Partial<T>): Model<T>;
     remove(target: Model<T> | number | Array<Model<T>>): void;
+    /** Applies live changes in place, with one repaint: known ids are patched (not marked as edits), unknown ones are added, `remove` drops. */
+    applyPatches(patches: Array<Patch<T>>): void;
+    /** Applies what a source sends as it arrives (`{ op, data, id }`, or an array of them; text is parsed as JSON). Returns the function that stops it. */
+    connect(source: LiveSource, parse?: (data: any) => Patch<T> | Array<Patch<T>>): () => void;
     clear(): void;
     recordChanged(rec: Model, field: string): void;
     getModified(): Model<T>[];

package/dist/types/dev/index.d.ts

@@ -0,0 +1,2 @@
+/** Starts warning; returns the function that stops it. Each type/option pair warns once. */
+export declare function enableConfigWarnings(): () => void;

package/dist/types/dev/keys.d.ts

@@ -0,0 +1 @@
+export declare const keys: Record<string, string>;