@zeyos/zx 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -8,6 +8,45 @@ and friends remain the complete record.
 
 ## Unreleased
 
+## 2.2.0 — 2026-08-21
+
+### Added
+- **TypeScript definitions**, generated from the JSDoc and shipped in the package. `exports` now
+  carries a `types` condition for every entry point, so `@zeyos/zx`, `/zeyos`, and `/compat` all
+  resolve. `Component` became generic over its options type and every component binds its own
+  typedef, which is what makes `new Slider(null, { value: 20 })` check against `SliderOptions`
+  rather than accept any object at all.
+- **Table growing** — `growing: <number>` renders a first batch of rows and offers a control for
+  the next, for the result sets an ERP query returns happily and nobody scrolls through.
+- **Responsive tables** — `Table` gained `responsive` and a per-column `popin`. Below the given
+  width each row stacks into a card of label/value pairs, measured on the table's own container
+  rather than the viewport, so it triggers inside a narrow split pane on a wide screen.
+- **`Table.emptyText` accepts a Node or a factory**, so an empty table can carry an icon, an
+  explanation, and the action that resolves it instead of one line of grey text.
+- **Per-component imports** — `src/` and `styles/` now ship, and `@zeyos/zx/src/components/…` is a
+  supported subpath carrying its own type declarations. An application using two components bundles
+  26 kB minified that way against 157 kB through the package entry point. Nothing changes for
+  existing imports.
+- **Component styling hooks** — a short, published set of custom properties for restyling one
+  component without reaching into its selectors: `--zx-table-header-bg`, `--zx-table-row-hover-bg`,
+  `--zx-table-row-selected-bg`, `--zx-table-border-color`, `--zx-button-radius`,
+  `--zx-panel-header-bg`. Each falls back to the semantic token it replaces.
+
+### Fixed
+
+- `onBreakpoint()` treated an element that had not been laid out yet — width 0 — as the `xs` band,
+  so the first real width silently never notified if it landed in the same band. It also answered
+  resize notifications inside the observer callback, which the browser reports as a
+  "ResizeObserver loop" whenever the handler changes layout, and rejected nothing when handed a
+  target it could not measure.
+- The type declarations describe the kernel accurately now: every module in `src/core/` is type
+  checked on each build, which corrected a set of JSDoc inaccuracies that had been flowing into the
+  published `.d.ts` — among them `Component.cssName`, and the `response` the HTTP helpers attach to
+  the errors they throw, which TypeScript had been told did not exist.
+- Two static-field type conflicts in the compatibility layer (`SelectBase.filterMode`,
+  `PickerBase.Picker`) that made the emitted declarations fail to compile for consumers who do not
+  set `skipLibCheck`.
+
 ## 2.1.0 — 2026-08-19
 
 ### Added

package/README.md

@@ -38,6 +38,21 @@ For an application built from classic scripts, the IIFE bundle exposes the same
 </script>
 ```
 
+Import one component instead of the library when a bundler is doing the work:
+
+```js
+import { Slider } from '@zeyos/zx/src/components/slider/slider.js';
+```
+
+An application using two components bundles 26 kB minified this way against 157 kB through the
+package entry point. Load the one stylesheet either way — it is 13 kB gzipped whole, and splitting
+it per component costs more than it saves.
+
+TypeScript definitions ship with the package. They are generated from the JSDoc that documents
+every option, method, and event, so `new Slider(null, { … })` is checked against `SliderOptions`
+and an unknown option or a wrong literal is an error in the editor. There is no TypeScript in the
+library itself and no compile step for consumers who do not want one.
+
 Components accept an existing element or selector as their first argument. Passing `null` makes
 the component create and own its root. Call `destroy()` when a component is no longer needed; an
 owned root is removed, while an enhanced target is restored.

package/dist/types/compat/base.d.ts

@@ -0,0 +1,156 @@
+export type LegacyArgumentMapper = (detail: Record<string, any>, event: Event) => unknown[];
+export type LegacyEventMapping = {
+    /**
+     * Zx event name.
+     */
+    type: string;
+    /**
+     * Legacy positional argument adapter.
+     */
+    args?: LegacyArgumentMapper;
+    /**
+     * Optional event filter.
+     */
+    filter?: (detail: Record<string, any>, event: Event) => boolean;
+};
+export type LegacyEventMap = Record<string, string | LegacyEventMapping>;
+export type WrapperConfiguration = {
+    events?: LegacyEventMap;
+    ui?: Record<string, string | Element | (() => Element | null)>;
+    setters?: Record<string, string | ((value: unknown) => void)>;
+};
+/** @typedef {(detail: Record<string, any>, event: Event) => unknown[]} LegacyArgumentMapper */
+/**
+ * @typedef {Object} LegacyEventMapping
+ * @property {string} type Zx event name.
+ * @property {LegacyArgumentMapper} [args] Legacy positional argument adapter.
+ * @property {(detail: Record<string, any>, event: Event) => boolean} [filter] Optional event filter.
+ */
+/** @typedef {Record<string, string|LegacyEventMapping>} LegacyEventMap */
+/**
+ * @typedef {Object} WrapperConfiguration
+ * @property {LegacyEventMap} [events]
+ * @property {Record<string, string|Element|(() => Element|null)>} [ui]
+ * @property {Record<string, string|((value: unknown) => void)>} [setters]
+ */
+/**
+ * MooTools-flavoured façade shared by compatibility component wrappers.
+ * @fires GxWrapper#legacy-event
+ */
+export declare class GxWrapper {
+    gx: any;
+    options: {
+        [x: string]: any;
+    };
+    _events: Map<any, any>;
+    _mappedListeners: any[];
+    _domAbort: AbortController;
+    _zx: any;
+    _ui: {};
+    _display: {};
+    _uiMap: {};
+    _optionSetters: {};
+    _destroyed: boolean;
+    /** Fully qualified legacy class name shown in migration warnings. */
+    static legacyName: string;
+    /**
+     * Initializes legacy options and callback-style `onEvent` options.
+     * Subclasses call `_attach()` after constructing their Zx implementation.
+     * @param {Record<string, any>} [options={}] Legacy options.
+     * @param {Record<string, any>} [defaults={}] Legacy defaults.
+     */
+    constructor(options?: Record<string, any>, defaults?: Record<string, any>);
+    /**
+     * Subscribes a legacy callback.
+     * @param {string} type Legacy event name, with or without an `on` prefix.
+     * @param {Function} fn Callback receiving legacy positional arguments.
+     * @returns {this}
+     */
+    addEvent(type: string, fn: Function): this;
+    /**
+     * Removes one callback, or all callbacks of a type when omitted.
+     * @param {string} type Legacy event name.
+     * @param {Function} [fn] Callback to remove.
+     * @returns {this}
+     */
+    removeEvent(type: string, fn?: Function): this;
+    /**
+     * Fires a legacy event synchronously.
+     * @param {string} type Legacy event name.
+     * @param {unknown|unknown[]} [args=[]] Positional argument array or one argument.
+     * @returns {this}
+     * @fires GxWrapper#legacy-event
+     */
+    fireEvent(type: string, args?: unknown | unknown[]): this;
+    /**
+     * Applies multiple post-construction legacy options.
+     * @param {Record<string, unknown>} options Option values.
+     * @returns {this}
+     */
+    setOptions(options: Record<string, unknown>): this;
+    /**
+     * Applies one post-construction option through a declared setter.
+     * Unsupported dynamic options are retained on `options` and warn once per class/key.
+     * @param {string} option Legacy option name.
+     * @param {unknown} value New value.
+     * @returns {this}
+     */
+    setOption(option: string, value: unknown): this;
+    /**
+     * Returns the wrapped component root.
+     * @returns {Element|null}
+     */
+    toElement(): Element | null;
+    /**
+     * Resolves a legacy `_ui` key, falling back to the component root.
+     * @param {string} [key='root'] Legacy display key.
+     * @returns {Element|null}
+     */
+    display(key?: string): Element | null;
+    /**
+     * Returns the supported legacy coordinate subset.
+     * @returns {{width: number, height: number, top: number, left: number}}
+     */
+    getCoordinates(): {
+        width: number;
+        height: number;
+        top: number;
+        left: number;
+    };
+    /**
+     * Updates one root style property.
+     * @param {string} property CSS property.
+     * @param {unknown} value CSS value.
+     * @returns {this}
+     */
+    setStyle(property: string, value: unknown): this;
+    /**
+     * Updates supported root coordinates.
+     * @param {Record<string, unknown>} coordinates Coordinate styles.
+     * @returns {this}
+     */
+    setCoordinates(coordinates?: Record<string, unknown>): this;
+    /**
+     * Destroys the wrapped component and legacy event subscriptions.
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Attaches a constructed Zx component and its translation metadata.
+     * @param {any} component Wrapped Zx component.
+     * @param {WrapperConfiguration} [configuration={}] Event, display, and setter maps.
+     * @returns {this}
+     */
+    _attach(component: any, configuration?: WrapperConfiguration): this;
+    /**
+     * Adds a DOM listener owned by this wrapper.
+     * @param {EventTarget} target Event target.
+     * @param {string} type Event type.
+     * @param {EventListenerOrEventListenerObject} listener Listener.
+     * @param {AddEventListenerOptions} [options={}] Listener options.
+     * @returns {this}
+     */
+    _listen(target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions): this;
+    /** @param {Element|null} element @param {boolean} active @returns {void} */
+    _mirrorAct(element: Element | null, active: boolean): void;
+}

package/dist/types/compat/globals.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Installs the small WeakMap-backed MooTools Element storage surface.
+ * Existing implementations are never overwritten.
+ * @param {typeof globalThis} [host=globalThis] Realm whose Element prototype is extended.
+ * @returns {void}
+ */
+export declare function installElementStorage(host?: typeof globalThis): void;
+/**
+ * Parses the legacy gx object-literal DOM dialect.
+ * `html` is intentionally treated as trusted legacy markup via `h.raw()`.
+ * @param {unknown} source Legacy tree value.
+ * @returns {Node|false} Parsed node, or false for unsupported input.
+ */
+export declare function parse(source: unknown): Node | false;
+/**
+ * Explicitly installs legacy globals and prototype conveniences.
+ * @param {typeof globalThis} [host=globalThis] Realm to modify.
+ * @returns {typeof globalThis} The supplied realm.
+ */
+export declare function installGlobals(host?: typeof globalThis): typeof globalThis;

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

@@ -0,0 +1,128 @@
+import { GxWrapper } from './base.js';
+import { installElementStorage, installGlobals, parse } from './globals.js';
+import { BootstrapMessage, BootstrapPopup, CheckButton, Dialog, Dropdown, MenuButton, Msgbox, Popup, PopupAlert, PopupConfirm, Toggle } from './map/basic.js';
+import { BootstrapChecklist, BootstrapTable, Checklist, DataFilter, Permission, SimpleTable, Table } from './map/data.js';
+import { BootstrapTimebox, CoreTimebox, Datebox, DatePicker, MonthPicker, Timebox, TimePicker } from './map/date-time.js';
+import { Field, Fieldset, FieldUpload, Form, MultiValueEditor, ValueList } from './map/form.js';
+import { Client, Request } from './map/http.js';
+import { BootstrapTabbox, Groupbox, MasterPanel, NavigationBar, Panel, Search, Tabbox } from './map/layout.js';
+import { BootstrapSelect, BootstrapSelectDyn, BootstrapSelectFilter, BootstrapSelectPrio, Select, SelectDyn, SelectDynREST, SelectFilter, SelectPrio } from './map/select.js';
+/** Window-independent legacy gx namespace. */
+export declare const gx: {
+    core: {
+        Settings: {
+            new (): {};
+        };
+    };
+    ui: {
+        Container: {
+            new (): {};
+        };
+        SimpleTable: typeof SimpleTable;
+        Timebox: typeof CoreTimebox;
+        Collapse: {
+            new (): {};
+        };
+        Blend: {
+            new (): {};
+        };
+        Hud: {
+            new (): {};
+        };
+        Toggling: {
+            new (): {};
+        };
+        HGroup: {
+            new (): {};
+        };
+        Templates: {
+            new (): {};
+        };
+    };
+    util: Readonly<{
+        initValue: typeof import("./map/utilities.js").initValue;
+        initNum: typeof import("./map/utilities.js").initNum;
+        formatTime: typeof import("./map/utilities.js").formatTime;
+        getMinutes: typeof import("./map/utilities.js").getMinutes;
+        formatNum: typeof import("./map/utilities.js").formatNum;
+        getNumber: typeof import("./map/utilities.js").getNumber;
+        printf: typeof import("./map/utilities.js").printf;
+        parseResult: typeof import("./map/utilities.js").parseResult;
+        Parse: typeof parse;
+        isArray: (arg: any) => arg is any[];
+        isObject: (value: any) => boolean;
+        isFunction: (value: any) => boolean;
+        isString: (value: any) => value is string;
+        isNumber: (value: any) => boolean;
+        isElement: (value: any) => boolean;
+        isNode: (value: any) => boolean;
+        Console: (source: any, message: any) => void;
+    }>;
+    zeyos: {
+        Toggle: typeof Toggle;
+        Msgbox: typeof Msgbox;
+        Popup: typeof Popup;
+        Dialog: typeof Dialog;
+        Dropdown: typeof Dropdown;
+        Select: typeof Select;
+        SelectFilter: typeof SelectFilter;
+        SelectDyn: typeof SelectDyn;
+        SelectPrio: typeof SelectPrio;
+        Checklist: typeof Checklist;
+        Permission: typeof Permission;
+        Table: typeof Table;
+        Tabbox: typeof Tabbox;
+        Panel: typeof Panel;
+        MasterPanel: typeof MasterPanel;
+        Groupbox: typeof Groupbox;
+        Search: typeof Search;
+        Datebox: typeof Datebox;
+        DatePicker: typeof DatePicker;
+        TimePicker: typeof TimePicker;
+        MonthPicker: typeof MonthPicker;
+        Timebox: typeof Timebox;
+        Client: typeof Client;
+        Request: typeof Request;
+        Factory: Readonly<{
+            Icon(name: string): SVGSVGElement;
+            Button(text: string, type?: string, iconName?: string, options?: Record<string, any>): HTMLButtonElement;
+            ButtonsGroup(buttons: HTMLButtonElement[]): HTMLDivElement;
+        }>;
+    };
+    bootstrap: {
+        Message: typeof BootstrapMessage;
+        Popup: typeof BootstrapPopup;
+        PopupAlert: typeof PopupAlert;
+        PopupConfirm: typeof PopupConfirm;
+        PopupConfirmCanceled: Readonly<{}>;
+        MenuButton: typeof MenuButton;
+        CheckButton: typeof CheckButton;
+        Select: typeof BootstrapSelect;
+        SelectFilter: typeof BootstrapSelectFilter;
+        SelectDyn: typeof BootstrapSelectDyn;
+        SelectDynREST: typeof SelectDynREST;
+        SelectPrio: typeof BootstrapSelectPrio;
+        Checklist: typeof BootstrapChecklist;
+        Table: typeof BootstrapTable;
+        Tabbox: typeof BootstrapTabbox;
+        NavigationBar: typeof NavigationBar;
+        Timebox: typeof BootstrapTimebox;
+        Form: typeof Form;
+        Fieldset: typeof Fieldset;
+        Field: typeof Field;
+        ValueList: typeof ValueList;
+        MultiValueEditor: typeof MultiValueEditor;
+        FieldUpload: typeof FieldUpload;
+        DataFilter: typeof DataFilter;
+    };
+    compat: Readonly<{
+        installGlobals: typeof installGlobals;
+        installElementStorage: typeof installElementStorage;
+        parse: typeof parse;
+        GxWrapper: typeof GxWrapper;
+    }>;
+};
+/** Assigns the compatibility namespace to a browser-like host without installing optional globals. @param {typeof globalThis} [host=globalThis] @returns {typeof gx} */
+export declare function install(host?: typeof globalThis): typeof gx;
+export { GxWrapper, installElementStorage, installGlobals, parse };
+export default gx;

package/dist/types/compat/map/basic.d.ts

@@ -0,0 +1,175 @@
+import { GxWrapper } from '../base.js';
+/** Legacy ZeyOS switch. */
+export declare class Toggle extends GxWrapper {
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @returns {boolean} */
+    getState(): boolean;
+    /** @returns {unknown} */
+    getValue(): unknown;
+    /** @returns {this} */
+    toggle(): this;
+    /** @param {boolean} [suppress=false] @returns {this} */
+    setChecked(suppress?: boolean): this;
+    /** @param {boolean} [suppress=false] @returns {this} */
+    setUnchecked(suppress?: boolean): this;
+    /** @returns {void} */
+    _syncAct(): void;
+}
+/** Legacy ZeyOS floating message box. */
+export declare class Msgbox extends GxWrapper {
+    _handle: any;
+    _content: any;
+    static legacyName: string;
+    /** @param {Record<string, any>} [options={}] */
+    constructor(options?: Record<string, any>);
+    /** @param {unknown} content @returns {this} */
+    setContent(content: unknown): this;
+    /** @param {unknown} [message] @param {string} [className='info'] @returns {this} */
+    show(message?: unknown, className?: string): this;
+    /** @returns {this} */
+    hide(): this;
+}
+/** Legacy bootstrap message/status service. */
+export declare class BootstrapMessage extends GxWrapper {
+    _handles: Map<any, any>;
+    _progress: import("../../components/message/message.js").ProgressHandle;
+    _progressValue: number;
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @param {unknown} message @param {string} [iconClass='info'] @param {boolean} [closable=true] @param {boolean} [_blend=false] @param {boolean} [autoclose=true] @returns {Element} */
+    addMessage(message: unknown, iconClass?: string, closable?: boolean, _blend?: boolean, autoclose?: boolean): Element;
+    /** @param {Element} marker @returns {this} */
+    closeMessage(marker: Element): this;
+    /** @returns {this} */
+    clear(): this;
+    /** @param {number} progress @param {string} [message=''] @param {boolean} [_blend=false] @returns {this} */
+    showStatus(progress: number, message?: string, _blend?: boolean): this;
+    /** @param {number} progress @param {string} [message] @returns {this} */
+    incProgress(progress: number, message?: string): this;
+    /** @param {number} progress @param {string} [message] @param {unknown} [_tween] @returns {this} */
+    setProgress(progress: number, message?: string, _tween?: unknown): this;
+    /** @returns {this} */
+    hideStatus(): this;
+}
+/** Shared Dialog-backed popup behavior. */
+declare class PopupBase extends GxWrapper {
+    isOpen: boolean;
+    _showArgument: unknown;
+    /** @param {Record<string, any>} options */
+    constructor(options?: Record<string, any>);
+    /** @param {unknown} [argument] @returns {this} */
+    show(argument?: unknown): this;
+    /** @param {unknown} [argument] @returns {this} */
+    hide(argument?: unknown): this;
+    /** @param {unknown} content @returns {this} */
+    setContent(content: unknown): this;
+    /** @param {string} title @returns {this} */
+    setTitle(title: string): this;
+    /** @returns {Element} */
+    getContent(): Element;
+    /** @param {unknown} [_x] @param {unknown} [_y] @returns {this} */
+    setPosition(_x?: unknown, _y?: unknown): this;
+}
+/** Legacy ZeyOS popup. */
+export declare class Popup extends PopupBase {
+    static legacyName: string;
+}
+/** Legacy bootstrap popup. */
+export declare class BootstrapPopup extends PopupBase {
+    static legacyName: string;
+}
+/** Sentinel returned when a legacy confirmation is canceled. */
+export declare const PopupConfirmCanceled: Readonly<{}>;
+/** @param {string} title @param {unknown} message @param {Record<string, any>|string} [options={}] @returns {Promise<void>} */
+export declare function PopupAlert(title: string, message: unknown, options?: Record<string, any> | string): Promise<void>;
+/** @param {string} title @param {unknown} message @param {Record<string, any>|string} [options={}] @returns {Promise<void|typeof PopupConfirmCanceled>} */
+export declare function PopupConfirm(title: string, message: unknown, options?: Record<string, any> | string): Promise<void | typeof PopupConfirmCanceled>;
+/** Legacy multi-frame ZeyOS dialog. */
+export declare class Dialog extends GxWrapper {
+    _frames: {};
+    _current: any;
+    static legacyName: string;
+    /** @param {Element|string|null} _display @param {Record<string, any>} [options={}] */
+    constructor(_display: Element | string | null, options?: Record<string, any>);
+    /** @param {string} title @returns {this} */
+    setTitle(title: string): this;
+    /** @param {string} key @param {Record<string, any>} options @param {boolean} [open] @returns {this} */
+    addFrame(key: string, options: Record<string, any>, open?: boolean): this;
+    /** @param {string} key @returns {Record<string, any>} */
+    openFrame(key: string): Record<string, any>;
+    /** @param {string} key @returns {Record<string, any>|null} */
+    getFrame(key: string): Record<string, any> | null;
+    /** @param {string} key @param {unknown} content @param {Function} onSubmit @param {boolean} [open] @returns {unknown} */
+    addSubmitFrame(key: string, content: unknown, onSubmit: Function, open?: boolean): unknown;
+    /** @param {string} key @param {Record<string, [unknown, unknown]>} form @param {Function} onSubmit @param {boolean} [open] @returns {Record<string, unknown>} */
+    addFormFrame(key: string, form: Record<string, [unknown, unknown]>, onSubmit: Function, open?: boolean): Record<string, unknown>;
+    /** @param {string} key @param {unknown} message @param {string} [link] @param {boolean} [open] @returns {this} */
+    addSuccessFrame(key: string, message: unknown, link?: string, open?: boolean): this;
+    /** @param {Record<string, any>} form @returns {Record<string, unknown>} */
+    getFormValues(form: Record<string, any>): Record<string, unknown>;
+}
+/** Legacy object-backed dropdown. */
+export declare class Dropdown extends GxWrapper {
+    _items: Record<string, any>[];
+    _selected: any;
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @param {Record<string, unknown>} items @returns {this} */
+    setItems(items: Record<string, unknown>): this;
+    /** @param {unknown} value @param {string} [text] @returns {this} */
+    selectItem(value: unknown, text?: string): this;
+    /** @returns {this} */
+    reset(): this;
+    /** @returns {{value: unknown, label: string}|null} */
+    getSelected(): {
+        value: unknown;
+        label: string;
+    } | null;
+    /** @returns {unknown} */
+    getValue(): unknown;
+    /** @returns {this} */
+    show(): this;
+    /** @returns {this} */
+    close(): this;
+    /** @returns {this} */
+    toggle(): this;
+}
+/** Legacy bootstrap menu button. */
+export declare class MenuButton extends GxWrapper {
+    _entries: any[];
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @param {string|false|null} label @param {string} [icon] @returns {Element|null} */
+    add(label: string | false | null, icon?: string): Element | null;
+    /** @returns {this} */
+    divider(): this;
+    /** @returns {this} */
+    toggle(): this;
+    /** @returns {this} */
+    open(): this;
+    /** @returns {this} */
+    close(): this;
+    /** @param {string} label @returns {this} */
+    setLabel(label: string): this;
+    /** @param {string} style @returns {this} */
+    setStyle(style: string): this;
+}
+/** Legacy bootstrap two-state check button. */
+export declare class CheckButton extends GxWrapper {
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @returns {boolean} */ get(): boolean;
+    /** @param {boolean} [suppress=false] @returns {false} */ toggle(suppress?: boolean): false;
+    /** @param {boolean} [suppress=false] @returns {this} */ check(suppress?: boolean): this;
+    /** @param {boolean} [suppress=false] @returns {this} */ uncheck(suppress?: boolean): this;
+    /** @param {boolean} value @returns {this} */ set(value: boolean): this;
+    /** @param {boolean} disabled @returns {this} */ setDisabled(disabled: boolean): this;
+    /** @param {string|string[]} label @returns {this} */ setLabel(label: string | string[]): this;
+}
+export {};

package/dist/types/compat/map/data.d.ts

@@ -0,0 +1,102 @@
+import { GxWrapper } from '../base.js';
+/** Shared Checklist wrapper. */
+declare class ChecklistBase extends GxWrapper {
+    _http: any;
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @returns {unknown[]} */
+    getValues(key: any): unknown[];
+    /** @param {unknown[]} values @returns {unknown[]} */
+    setValues(values: unknown[]): unknown[];
+    /** @returns {this} */
+    reset(): this;
+    /** @param {string} query @returns {this} */
+    search(query: string): this;
+    /** @param {unknown[]} rows @returns {this} */
+    setData(rows: unknown[]): this;
+    /** @param {string} [url] @param {Record<string, unknown>} [data] @returns {Promise<this>} */
+    load(url?: string, data?: Record<string, unknown>): Promise<this>;
+    /** Bootstrap alias. @param {string} [url] @param {Record<string, unknown>} [data] @param {Function} [callback] @returns {Promise<this>} */
+    loadFromURL(url?: string, data?: Record<string, unknown>, callback?: Function): Promise<this>;
+    /** @param {string} url @param {Record<string, unknown>} data @returns {Promise<unknown[]>} */
+    _load(url: string, data: Record<string, unknown>): Promise<unknown[]>;
+}
+/** Legacy ZeyOS checklist. */
+export declare class Checklist extends ChecklistBase {
+    static legacyName: string;
+}
+/** Legacy bootstrap checklist. */
+export declare class BootstrapChecklist extends ChecklistBase {
+    static legacyName: string;
+}
+/** Legacy permission selector. */
+export declare class Permission extends GxWrapper {
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @returns {unknown} */ get(): unknown;
+    /** @param {unknown} value @param {boolean} [silent=false] @returns {this} */ set(value: unknown, silent?: boolean): this;
+}
+/** Shared full Table wrapper. */
+declare class TableBase extends GxWrapper {
+    _cols: any[];
+    _filter: Record<string, any>;
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @param {unknown[]} data @returns {this} */ setData(data: unknown[]): this;
+    /** @param {unknown[]|unknown} data @returns {this} */ addData(data: unknown[] | unknown): this;
+    /** @returns {this} */ empty(): this;
+    /** @param {Record<string, any>|string} column @param {'asc'|'desc'} [mode] @param {boolean} [noEvent=false] @returns {this} */
+    setSort(column: Record<string, any> | string, mode?: 'asc' | 'desc', noEvent?: boolean): this;
+    /** @returns {Record<string, any>|false} */ getFilter(): Record<string, any> | false;
+    /** @returns {unknown[]} */ getData(): unknown[];
+    /** @param {unknown} height @returns {this} */ setHeight(height: unknown): this;
+    /** @param {string} id @returns {Record<string, any>} */ _legacyColumn(id: string): Record<string, any>;
+}
+/** Legacy ZeyOS table. */
+export declare class Table extends TableBase {
+    static legacyName: string;
+}
+/** Legacy bootstrap table. */
+export declare class BootstrapTable extends TableBase {
+    static legacyName: string;
+}
+/** Legacy SimpleTable data facade. */
+export declare class SimpleTable extends GxWrapper {
+    static legacyName: string;
+    /** @param {Element|string|Record<string, any>|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | Record<string, any> | null, options?: Record<string, any>);
+    /** @param {unknown[]} data @returns {this} */ setData(data: unknown[]): this;
+    /** @param {unknown[]} data @returns {this} */ addData(data: unknown[]): this;
+    /** @param {unknown} row @param {number} [index] @returns {HTMLTableRowElement|null} */
+    createRow(row: unknown, index?: number): HTMLTableRowElement | null;
+    /** @param {unknown} row @param {number} [index] @returns {HTMLTableRowElement|null} */ addRow(row: unknown, index?: number): HTMLTableRowElement | null;
+    /** @param {unknown} row @param {number} index @returns {HTMLTableRowElement|null} */
+    updateRow(row: unknown, index: number): HTMLTableRowElement | null;
+    /** @param {number} index @returns {this} */ removeRow(index: number): this;
+    /** @returns {unknown[]} */ getRows(): unknown[];
+    /** @returns {this} */ empty(): this;
+}
+/** Legacy bootstrap client-side filter bar. */
+export declare class DataFilter extends GxWrapper {
+    origin: any[];
+    filtered: any[];
+    filter: any[];
+    static legacyName: string;
+    /** @param {Element|string|null} display @param {Record<string, any>} [options={}] */
+    constructor(display: Element | string | null, options?: Record<string, any>);
+    /** @param {string} identifier @param {string} label @param {string|string[]|Function} fields @param {unknown} [_width] @param {Function} [method] @returns {this} */
+    addSelectFilter(identifier: string, label: string, fields: string | string[] | Function, _width?: unknown, method?: Function): this;
+    /** @param {string} identifier @param {string|string[]|Function} fields @param {string} label @param {unknown} [_width] @param {Function} [method] @returns {this} */
+    addFulltextFilter(identifier: string, fields: string | string[] | Function, label: string, _width?: unknown, method?: Function): this;
+    /** @param {Element} element @returns {this} */ addCustomElement(element: Element): this;
+    /** @param {unknown[]} data @returns {this} */ initData(data: unknown[]): this;
+    /** @returns {unknown[]} */ doFilter(): unknown[];
+    /** @returns {this} */ clearFilter(): this;
+    /** @param {string} identifier @returns {Record<string, any>|null} */ getFilter(identifier: string): Record<string, any> | null;
+    /** @param {unknown} filterValue @param {unknown} fieldValue @returns {boolean} */ fulltextFilter(filterValue: unknown, fieldValue: unknown): boolean;
+    /** @param {unknown} filterValue @param {unknown} fieldValue @returns {boolean} */ selectFilter(filterValue: unknown, fieldValue: unknown): boolean;
+}
+export {};