optikos 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,12 @@
+export type Handler = (...args: any[]) => unknown;
+/** Minimal observer. A handler that returns `false` makes `emit` return `false` (used by `before-*` events). */
+export declare class Emitter {
+    private handlers;
+    /** Subscribes; returns the unsubscribe function. */
+    on(name: string, fn: Handler): () => void;
+    once(name: string, fn: Handler): () => void;
+    off(name: string, fn?: Handler): void;
+    /** Returns `false` if any handler returned `false` (the event was cancelled). */
+    emit(name: string, ...args: unknown[]): boolean;
+    clearListeners(): void;
+}

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

@@ -0,0 +1,78 @@
+import { Component, type ComponentConfig } from './component.js';
+import type { Validator } from './validators.js';
+export interface FieldConfig<V = unknown> extends ComponentConfig {
+    name?: string;
+    label?: string;
+    labelPos?: 'top' | 'left';
+    value?: V;
+    required?: boolean;
+    readonly?: boolean;
+    help?: string;
+    validators?: Validator<V>[];
+    /** When to validate on its own. After the first error it revalidates on every change. Default `blur`. */
+    validateOn?: 'blur' | 'change' | 'submit';
+    /** ms of quiet after the last change before `settled` fires (0 = right away). `change` itself is never delayed. */
+    debounce?: number;
+}
+/**
+ * Base of every field: value, validation, dirty tracking, label and messages.
+ * Subclasses implement `createControl` (build the control, assign `inputEl`), `applyValue` (value → DOM)
+ * and call `commit` when the user edits (DOM → value).
+ */
+export declare abstract class Field<V = unknown, C extends FieldConfig<V> = FieldConfig<V>> extends Component<C> {
+    protected baseCls: string;
+    protected value: V;
+    protected original: V;
+    protected error: string;
+    /** The focusable control; `label for`, `aria-invalid` and `aria-describedby` point at it. */
+    protected inputEl: HTMLElement;
+    private labelEl;
+    private helpEl;
+    private errorEl;
+    private dirty;
+    private cancelSettle?;
+    constructor(config?: C);
+    get name(): string | undefined;
+    protected abstract createControl(): HTMLElement;
+    protected abstract applyValue(value: V): void;
+    protected emptyValue(): V;
+    protected isEmpty(v: V): boolean;
+    protected isEqual(a: V, b: V): boolean;
+    protected build(): HTMLElement;
+    protected onRender(): void;
+    protected focusEl(): HTMLElement;
+    getValue(): V;
+    /** Sets the value programmatically. `silent` skips the `change` event and validation. */
+    setValue(v: V, silent?: boolean): void;
+    /** For subclasses: the user edited the control and the DOM already shows `v`. */
+    protected commit(v: V): void;
+    private changed;
+    /** `settled(value)`: the value after the user stopped changing it for `debounce` ms (immediately without `debounce`). */
+    private queueSettled;
+    /** Fires a pending `settled` now (Enter, blur, end of a drag...). No-op when nothing is waiting. */
+    protected flushSettled(): void;
+    private updateDirty;
+    /** What the user sees as this field's value (a select's label, a formatted date); used by summaries such as the StepForm review. */
+    getDisplayText(): string;
+    /** Sets the empty value (`''`, `null`, `false`...) and emits `change`. */
+    clear(): void;
+    isDirty(): boolean;
+    /** The current value becomes the "original" (as after loading or saving). */
+    markClean(): void;
+    reset(): void;
+    /** Returns the error message for the current value, or `''`. No UI side effects. */
+    protected check(): string;
+    validate(): boolean;
+    isValid(): boolean;
+    getError(): string;
+    setError(msg: string): void;
+    clearError(): void;
+    private paintError;
+    private describe;
+    setLabel(label: string): void;
+    setHelp(help: string): void;
+    setRequired(required: boolean): void;
+    setReadonly(readonly: boolean): void;
+    setValidators(validators: Validator<V>[]): void;
+    protected onReadonly(_readonly: boolean): void;
+}

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

@@ -0,0 +1,18 @@
+export declare function focusables(root: HTMLElement): HTMLElement[];
+/** Keeps Tab inside `root`. Returns the release function. */
+export declare function trapFocus(root: HTMLElement): () => void;
+export interface RovingOptions {
+    /** Selector of the items inside the container. */
+    selector: string;
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    /** Wrap around at the ends. Default true. */
+    loop?: boolean;
+    /** Called when an arrow/Home/End key moves focus to an item. */
+    onMove?: (item: HTMLElement) => void;
+}
+/** Roving tabindex: one item is the Tab stop, arrows/Home/End move focus. Returns `{ sync, destroy }`. */
+export declare function roving(container: HTMLElement, o: RovingOptions): {
+    /** Re-evaluates the tab stop (after items change). Pass the item that should be the stop. */
+    sync: (target?: HTMLElement) => void;
+    destroy(): void;
+};

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

@@ -0,0 +1,12 @@
+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;
+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.
+ * Each component registers its own keys this way, so its messages only ship with it.
+ */
+export declare function addMessages(lang: string, messages: Locale): void;
+/** Translates a key, replacing `{name}` placeholders. */
+export declare function t(key: string, vars?: Record<string, string | number>): string;

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

@@ -0,0 +1,15 @@
+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 { 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 * as validators from './validators.js';
+export type { Validator } from './validators.js';
+export { layer, toLayer, lockModal } from './layer.js';
+export { place, track, type Placement, type PlaceOptions } from './position.js';
+export { trapFocus, roving, focusables } from './focus.js';
+export { virtualize, measure } from './virtual.js';
+export * as date from './date.js';

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

@@ -0,0 +1,6 @@
+/** The single `body > .op-layer` that holds every floating element (dropdowns, windows, tooltips, toasts). */
+export declare function layer(): HTMLElement;
+/** Moves `el` into the layer, keeping the theme scope of `from` (floating elements leave their themed ancestor). */
+export declare function toLayer(el: HTMLElement, from?: Element | null): void;
+/** Makes everything except `modal` inert (outside the layer and earlier layer children). Returns the release function. */
+export declare function lockModal(modal: HTMLElement): () => void;

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

@@ -0,0 +1,19 @@
+export type Side = 'top' | 'bottom' | 'left' | 'right';
+export type Placement = Side | `${Side}-start` | `${Side}-end`;
+export interface PlaceOptions {
+    placement?: Placement;
+    offset?: number;
+    flip?: boolean;
+    matchWidth?: boolean;
+    margin?: number;
+}
+/**
+ * Positions a floating element (`position: fixed`) next to an anchor element or a point, flipping and clamping to the viewport.
+ * Taller than the room on either side (a long menu, a big theme): it goes where there is more room, capped to it, and scrolls.
+ */
+export declare function place(el: HTMLElement, anchor: Element | {
+    x: number;
+    y: number;
+}, o?: PlaceOptions): void;
+/** Calls `fn` (throttled to a frame) on any scroll or resize. Returns the cleanup function. */
+export declare function track(fn: () => void): () => void;

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

@@ -0,0 +1,12 @@
+import type { Component, ComponentConfig } from './component.js';
+export type ComponentClass = {
+    new (config: any): Component<any>;
+    type?: string;
+};
+/** Config accepted by `create` and `items`: the base keys plus whatever the chosen `type` understands. */
+export type AnyConfig = ComponentConfig & Record<string, any>;
+/** Registers a component class under a `type`. Users register their own the same way. */
+export declare function register(type: string, cls: ComponentClass): void;
+export declare const getType: (type: string) => ComponentClass | undefined;
+/** Builds a component from a config (or passes an instance through). `renderTo` mounts it. */
+export declare function create<T extends Component = Component>(config: AnyConfig | Component): T;

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

@@ -0,0 +1,10 @@
+import type { Field } from './field.js';
+/** Returns an error message, or `true`/`undefined` when valid. Empty values are skipped (use `required`). */
+export type Validator<V = any> = (value: V, field: Field<V>) => string | true | undefined | void;
+export declare const minLength: (n: number, msg?: string) => Validator;
+export declare const maxLength: (n: number, msg?: string) => Validator;
+export declare const pattern: (re: RegExp, msg?: string) => Validator;
+export declare const email: (msg?: string) => Validator;
+export declare const min: (n: number, msg?: string) => Validator;
+export declare const max: (n: number, msg?: string) => Validator;
+export declare const range: (a: number, b: number, msg?: string) => Validator;

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

@@ -0,0 +1,24 @@
+export interface VirtualOptions {
+    /** Scrolling element. */
+    scroller: HTMLElement;
+    count: number;
+    rowHeight: number;
+    /** Extra rows rendered above/below the viewport. Default 6. */
+    overscan?: number;
+    /** Fills a pooled row element with the data of row `index`. */
+    render(row: HTMLElement, index: number): void;
+    rowCls?: string;
+}
+/** Fixed-height virtual list: only the visible rows exist in the DOM, reused as a pool. */
+export declare function virtualize(o: VirtualOptions): {
+    spacer: HTMLDivElement;
+    /** Rows currently in the DOM. */
+    rows: HTMLElement[];
+    refresh: () => void;
+    setCount(n: number): void;
+    setRowHeight(px: number): void;
+    scrollTo(index: number): void;
+    destroy(): void;
+};
+/** Resolves a CSS length (usually a token expression like `var(--op-row-height)`) to pixels in the context of `el`. Returns 0 when not laid out. */
+export declare function measure(el: HTMLElement, length: string): number;

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

@@ -0,0 +1,32 @@
+import { type Formatter } from './format.js';
+import type { Model } from './model.js';
+/** A grid/table column. `T` is the record shape: `field` then autocompletes its keys (any string still works). */
+export interface Column<T extends Record<string, any> = any> {
+    field: Extract<keyof T, string> | (string & {});
+    header?: string;
+    /** Fixed width in px. */
+    width?: number;
+    /** Share of the free space (like CSS `fr`). Default 1 when there is no `width`. */
+    flex?: number;
+    /** A label that groups columns ("Identification", "Values"...): a band over the header and sections in the column menu. */
+    group?: string;
+    minWidth?: number;
+    /** Upper bound when the user resizes it. */
+    maxWidth?: number;
+    /** `false` keeps a column's width fixed even when the grid has `resizableColumns`. */
+    resizable?: boolean;
+    align?: 'left' | 'center' | 'right';
+    sortable?: boolean;
+    hidden?: boolean;
+    /** 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. */
+    renderer?: (value: any, rec: Model<T>, col: Column<T>) => string | Node;
+    cls?: string;
+    /** With the `cellEditing()` grid plugin: `true` (an editor for the value's type), a field type (`'select'`) or a field config. */
+    editor?: boolean | string | Record<string, any>;
+    /** With `cellEditing()`: whether this record's cell can be edited (default: every record, when `editor` is set). */
+    editable?: (rec: Model<T>) => boolean;
+}
+/** Cell content for a record: `renderer` first, then `format`, then the plain value. */
+export declare function cellContent<T extends Record<string, any>>(col: Column<T>, rec: Model<T>): string | Node;

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

@@ -0,0 +1,4 @@
+export type Formatter = (value: any, options?: Record<string, any>) => string;
+/** Registers a named formatter, usable as `format: 'name'` in columns. */
+export declare function registerFormat(name: string, fn: Formatter): void;
+export declare function format(fmt: string | Formatter, value: unknown): string;

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

@@ -0,0 +1,5 @@
+export { Model, type ModelDef, type FieldDef } from './model.js';
+export { Store, matchFilter, type StoreConfig, type StoreProxy, 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

@@ -0,0 +1,28 @@
+export interface FieldDef {
+    type?: 'string' | 'number' | 'boolean';
+    default?: unknown;
+}
+export interface ModelDef {
+    idField?: string;
+    fields?: Record<string, FieldDef>;
+}
+export interface RecordOwner {
+    recordChanged(rec: Model, field: string): void;
+}
+/** One record. `data` holds the values; `set` tracks the original value of each changed field. */
+export declare class Model<T extends Record<string, any> = Record<string, any>> {
+    private def;
+    data: T;
+    phantom: boolean;
+    owner?: RecordOwner;
+    private readonly clientId;
+    private original;
+    constructor(raw?: Partial<T>, def?: ModelDef);
+    get id(): string | number;
+    get<K extends keyof T>(field: K): T[K];
+    set<K extends keyof T>(field: K, value: T[K]): void;
+    isDirty(): boolean;
+    getChanges(): Partial<T>;
+    commit(): void;
+    reject(): void;
+}

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

@@ -0,0 +1,61 @@
+export interface Sorter {
+    field: string;
+    dir: 'asc' | 'desc';
+}
+export type FilterOp = 'eq' | 'ne' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'gt' | 'ge' | 'lt' | 'le' | 'between' | 'notBetween' | 'in' | 'nin' | 'empty' | 'notEmpty';
+export interface FilterSpec {
+    field: string;
+    op?: FilterOp;
+    /** `between`/`notBetween`: `[from, to]`; `in`/`nin`: an array; `empty`/`notEmpty`: ignored. */
+    value?: unknown;
+}
+/** A group of filters joined by AND or OR; groups nest. */
+export interface FilterGroup {
+    op: 'and' | 'or';
+    filters: FilterNode[];
+}
+export type FilterNode = FilterSpec | FilterGroup;
+export interface ReadParams {
+    page?: number;
+    pageSize?: number;
+    sorters?: Sorter[];
+    filters?: FilterNode[];
+    [extra: string]: unknown;
+}
+export interface ReadResult<T = any> {
+    data: T[];
+    total?: number;
+}
+/** Where a Store gets (and writes) its data. Memory, function and REST implementations share this shape. */
+export interface Proxy<T = any> {
+    read(params: ReadParams, signal?: AbortSignal): Promise<ReadResult<T> | T[]> | ReadResult<T> | T[];
+    create?(data: T): Promise<Partial<T> | void>;
+    update?(data: T): Promise<Partial<T> | void>;
+    destroy?(data: T): Promise<void>;
+}
+export declare class MemoryProxy<T = any> implements Proxy<T> {
+    rows: T[];
+    constructor(rows?: T[]);
+    read(): ReadResult<T>;
+}
+export interface RestProxyConfig {
+    url: string;
+    idField?: string;
+    headers?: Record<string, string>;
+    /** Dotted path of the rows in the JSON when it is an object (`'items'`, `'data.rows'`). */
+    root?: string;
+    /** Dotted path of the total count in the JSON. Falls back to the `X-Total-Count` header, then to the row count. */
+    totalKey?: string;
+    fetch?: typeof fetch;
+}
+/** REST over `fetch`: `GET url?page&pageSize&sort=a:asc,b:desc&field=value`, `POST url`, `PUT url/:id`, `DELETE url/:id`. */
+export declare class RestProxy<T extends Record<string, any> = any> implements Proxy<T> {
+    private cfg;
+    constructor(cfg: RestProxyConfig);
+    private call;
+    private itemUrl;
+    read(params: ReadParams, signal?: AbortSignal): Promise<ReadResult<T>>;
+    create(d: T): Promise<Partial<T>>;
+    update(d: T): Promise<Partial<T> | undefined>;
+    destroy(d: T): Promise<void>;
+}

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

@@ -0,0 +1,94 @@
+import { Emitter } from '../core/emitter.js';
+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;
+export interface StoreConfig<T extends Record<string, any>> {
+    data?: Partial<T>[];
+    model?: ModelDef;
+    proxy?: StoreProxy<T>;
+    /** 0 = no paging. */
+    pageSize?: number;
+    /** Sort, filter and paging are done by the proxy (it receives them in `read`). Default false: done locally. */
+    remote?: boolean;
+    sorters?: Sorter[];
+    autoLoad?: boolean;
+    listeners?: Record<string, (...a: any[]) => unknown>;
+}
+/** Does a record's data satisfy a filter node? Groups are AND/OR; an empty group matches everything. */
+export declare function matchFilter(node: FilterNode, data: Record<string, any>): boolean;
+/**
+ * Records + a view over them (filtered, sorted, paged). Events: `load`, `before-load`, `load-error`, `add`, `remove`,
+ * `update`, `sort`, `filter`, `page`, `sync`, and `change` for any of them (payload `{ type }`).
+ */
+export declare class Store<T extends Record<string, any> = Record<string, any>> extends Emitter implements RecordOwner {
+    private cfg;
+    private all;
+    private rows;
+    private visible;
+    private removed;
+    private sorters;
+    private filters;
+    private params;
+    private proxy?;
+    private pageNo;
+    private pageLen;
+    private total;
+    private abort?;
+    loading: boolean;
+    constructor(cfg?: StoreConfig<T>);
+    private get remote();
+    private wrap;
+    private fire;
+    /** Number of records in the current view (the current page). */
+    get count(): number;
+    /** Records matching the filters, across pages (remote: what the server reported). */
+    get totalCount(): number;
+    /** Every record matching the filters, across pages (a remote store only knows the loaded page). */
+    getFiltered(): Model<T>[];
+    getAt(i: number): Model<T> | undefined;
+    getRange(start?: number, end?: number): Model<T>[];
+    getById(id: string | number): Model<T> | undefined;
+    indexOf(rec: Model<T>): number;
+    /** Plain data of the current view. */
+    getData(): T[];
+    each(fn: (rec: Model<T>, i: number) => void): void;
+    /** Replaces all records with local data. */
+    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>;
+    private setRecords;
+    /** Recomputes filtered/sorted/paged rows from `all`. */
+    private refreshView;
+    getSorters(): Sorter[];
+    /** `sort('name')` toggles asc/desc when already sorted by it; `sort('name', 'desc')` is explicit; `sort(null)` clears. */
+    sort(field: string | null, dir?: 'asc' | 'desc'): void;
+    /**
+     * Replaces the filters (top level = AND). Accepts specs, groups (`{ op: 'or', filters }`), or a predicate.
+     * Resolves when the view is up to date (for a remote store, after the reload).
+     */
+    filter(f: FilterNode | FilterNode[] | FilterFn<T>): Promise<void>;
+    clearFilter(): Promise<void>;
+    /** The active filter nodes (predicates are not included). */
+    getFilters(): FilterNode[];
+    private changeView;
+    get page(): number;
+    get pageSize(): number;
+    get pageCount(): number;
+    setPage(n: number): void;
+    setPageSize(n: number): void;
+    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;
+    clear(): void;
+    recordChanged(rec: Model, field: string): void;
+    getModified(): Model<T>[];
+    getRemoved(): Model<T>[];
+    commitChanges(): void;
+    /** Writes pending changes through the proxy: deletes, then creates and updates, one at a time. */
+    sync(): Promise<void>;
+    /** Observable interface used by `optikos/bind`: calls `fn` on any change; returns the unsubscribe function. */
+    subscribe(fn: (change: {
+        type: string;
+    }) => void): () => void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,67 @@
+export * from './core/index.js';
+export * from './data/index.js';
+export * from './themes/index.js';
+export * from './motion/index.js';
+export * from './ui/index.js';
+export * from './components/base/badge/badge.js';
+export * from './components/base/button/button.js';
+export * from './components/base/chip/chip.js';
+export * from './components/base/codeviewer/codeviewer.js';
+export * from './components/base/icon/icon.js';
+export * from './components/base/label/label.js';
+export * from './components/chat/chat/chat.js';
+export * from './components/data/cellediting/cellediting.js';
+export * from './components/data/dataview/dataview.js';
+export * from './components/data/filterbuilder/filterbuilder.js';
+export * from './components/data/grid/grid.js';
+export * from './components/data/pagination/pagination.js';
+export * from './components/data/searchgrid/searchgrid.js';
+export * from './components/data/table/table.js';
+export * from './components/data/tree/tree.js';
+export * from './components/data/viewmanager/viewmanager.js';
+export * from './components/dates/calendar/calendar.js';
+export * from './components/feedback/spinner/spinner.js';
+export * from './components/fields/checkbox/checkbox.js';
+export * from './components/fields/checkboxgroup/checkboxgroup.js';
+export * from './components/fields/combobox/combobox.js';
+export * from './components/fields/datefield/datefield.js';
+export * from './components/fields/daterangefield/daterangefield.js';
+export * from './components/fields/dial/dial.js';
+export * from './components/fields/listbox/listbox.js';
+export * from './components/fields/lookupfield/lookupfield.js';
+export * from './components/fields/numberfield/numberfield.js';
+export * from './components/fields/pickerfield/pickerfield.js';
+export * from './components/fields/radiogroup/radiogroup.js';
+export * from './components/fields/secretfield/secretfield.js';
+export * from './components/fields/select/select.js';
+export * from './components/fields/slider/slider.js';
+export * from './components/fields/suggestfield/suggestfield.js';
+export * from './components/fields/textarea/textarea.js';
+export * from './components/fields/textfield/textfield.js';
+export * from './components/fields/toggle/toggle.js';
+export * from './components/form/fieldgroup/fieldgroup.js';
+export * from './components/form/fieldlist/fieldlist.js';
+export * from './components/form/form/form.js';
+export * from './components/form/formactions/formactions.js';
+export * from './components/form/formerrors/formerrors.js';
+export * from './components/form/formsection/formsection.js';
+export * from './components/form/inputgroup/inputgroup.js';
+export * from './components/form/stepform/stepform.js';
+export * from './components/layout/container/container.js';
+export * from './components/layout/fieldset/fieldset.js';
+export * from './components/layout/panel/panel.js';
+export * from './components/layout/spacer/spacer.js';
+export * from './components/layout/toolbar/toolbar.js';
+export * from './components/layout/viewport/viewport.js';
+export * from './components/navigation/breadcrumb/breadcrumb.js';
+export * from './components/navigation/navmenu/navmenu.js';
+export * from './components/navigation/stepper/stepper.js';
+export * from './components/navigation/tabs/tabs.js';
+export * from './components/overlays/commandpalette/commandpalette.js';
+export * from './components/overlays/dropdown/dropdown.js';
+export * from './components/overlays/menu/menu.js';
+export * from './components/overlays/messagebox/messagebox.js';
+export * from './components/overlays/toast/toast.js';
+export * from './components/overlays/tooltip/tooltip.js';
+export * from './components/overlays/widget/widget.js';
+export * from './components/overlays/window/window.js';

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

@@ -0,0 +1,27 @@
+import type { Component } from '../core/component.js';
+import type { Container } from '../core/container.js';
+export interface Layout {
+    init(c: Container): void;
+    add?(c: Container, cmp: Component, index: number): void;
+    remove?(c: Container, cmp: Component, index: number): void;
+    /** Card only. */
+    activate?(c: Container, cmp: Component): void;
+    getActive?(c: Container): Component | undefined;
+    /** Border only: below `narrowBelow` the west/east regions become drawers; these open and close them. */
+    openRegion?(name: string): void;
+    closeRegion?(name?: string): void;
+    toggleRegion?(name: string): void;
+    isRegionOpen?(name: string): boolean;
+    /** Layouts that adapt to the width: whether the container is currently narrow, and a way to force it (tests, previews). */
+    isNarrow?(): boolean;
+    setNarrow?(narrow: boolean): void;
+}
+export type LayoutConfig = {
+    type: string;
+    [option: string]: unknown;
+};
+export type LayoutSpec = string | LayoutConfig | Layout;
+export type LayoutFactory = (config: Record<string, any>) => Layout;
+/** Registers a layout strategy under a name; users add their own the same way. */
+export declare function registerLayout(name: string, factory: LayoutFactory): void;
+export declare function createLayout(spec: LayoutSpec): Layout;

package/dist/types/motion/config.d.ts

@@ -0,0 +1,83 @@
+/** Global motion settings: one object, one switch. Defaults are the numbers of the 20 motion rules. */
+export interface MotionConfig {
+    enabled: boolean;
+    /** When true (default) a user who asked the OS for reduced motion gets none. */
+    respectReducedMotion: boolean;
+    ease: {
+        out: string;
+        in: string;
+        inOut: string;
+    };
+    /** Milliseconds. */
+    duration: {
+        dropdown: number;
+        popover: number;
+        modal: number;
+        press: number;
+        pulse: number;
+        reveal: number;
+        swap: number;
+        move: number;
+        enter: number;
+    };
+    /** The dropdown duration is clamped into this range (rule 2). */
+    dropdownRange: [number, number];
+    /** Exit duration = enter duration × this (rule 15). */
+    exitRatio: number;
+    stagger: {
+        step: number;
+        max: number;
+    };
+    press: {
+        scale: number;
+    };
+    popover: {
+        scale: number;
+    };
+    stretch: {
+        amount: number;
+    };
+    arc: {
+        bend: number;
+    };
+    /** Blur in px used by crossfades (rule 18). */
+    blur: number;
+    rubber: {
+        resistance: number;
+        settle: number;
+    };
+    /** Rule 13: easings that overshoot are refused unless this is true. */
+    allowBounce: boolean;
+    originFromTrigger: boolean;
+}
+export declare const DEFAULTS: MotionConfig;
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? (T[K] extends unknown[] ? T[K] : DeepPartial<T[K]>) : T[K];
+};
+/** A `cubic-bezier` whose control points leave [0, 1] on the y axis overshoots (bounces); springs always do. */
+export declare function isBouncy(easing: string): boolean;
+type Listener = (c: Readonly<MotionConfig>) => void;
+export declare const motion: {
+    get(): Readonly<MotionConfig>;
+    /**
+     * Changes the settings (deep merge). Easings that bounce are refused while `allowBounce` is false; the rest of the patch
+     * still applies. Returns what was refused.
+     */
+    set(patch: DeepPartial<MotionConfig>): {
+        rejected: string[];
+    };
+    reset(): void;
+    enable(): void;
+    disable(): void;
+    /** Motion is switched on and the user did not ask for reduced motion (unless `respectReducedMotion` is off). */
+    isOn(): boolean;
+    /** The dropdown duration, clamped into `dropdownRange`. */
+    dropdownMs(): number;
+    /** Duration for a kind of motion in a phase: exits are `exitRatio` times shorter (rule 15). */
+    ms(kind: keyof MotionConfig['duration'], phase?: 'enter' | 'exit'): number;
+    /** Easing for a phase: entrances ease-out, exits ease-in, movement ease-in-out. */
+    easing(phase: 'enter' | 'exit' | 'move'): string;
+    /** Subscribe to changes; returns the unsubscribe function. */
+    on(fn: Listener): () => void;
+};
+export {};