@antadesign/anta 0.2.0 → 0.2.2

package/dist/elements/a-menu.d.ts

@@ -1,120 +0,0 @@
-import { HTMLElementBase } from '../anta_helpers';
-import './a-menu.css';
-export declare class AMenuElement extends HTMLElementBase {
-    static observedAttributes: string[];
-    /** Shadow-internal popover surface — the only thing we ever mutate. */
-    surface: HTMLDivElement;
-    listening: boolean;
-    private _shown;
-    private teardown?;
-    private openTimer?;
-    private closeTimer?;
-    private typeBuffer;
-    private typeTimer?;
-    constructor();
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    attributeChangedCallback(name: string): void;
-    /** Apply the controlled `state` attribute to actual visibility, silently.
-     *  Absent → uncontrolled (no-op here; triggers manage it). */
-    private syncState;
-    /** Controlled iff the consumer is managing the `state` attribute. */
-    get isControlled(): boolean;
-    private get view();
-    private get doc();
-    get isSubmenu(): boolean;
-    private get isContext();
-    private get isCoord();
-    private get isHover();
-    private get offset();
-    private get placement();
-    /** Root menu: the previous element sibling is the trigger. Submenu: the
-     *  enclosing menu item. One deterministic rule per case — no ambiguity. */
-    get triggerAnchor(): HTMLElement | null;
-    /** For a submenu: the menu that contains its anchor item. */
-    private get ownerMenu();
-    get isOpen(): boolean;
-    /** Skip elements that can't actually take focus — `display:none` (incl. a
-     *  closed submenu's contents), `visibility:hidden`, `content-visibility`
-     *  skipped — so navigation never lands on a hidden node (programmatic
-     *  `.focus()` on one silently fails). `getClientRects` is the fallback where
-     *  `checkVisibility` isn't available. */
-    private isVisible;
-    private focusableItems;
-    /** Every tabbable element belonging to THIS menu (items + nested controls
-     *  like inputs / sliders / buttons), in DOM order, visible and enabled —
-     *  used to trap Tab within the open menu. Submenu contents are excluded
-     *  (their nearest `a-menu` is the submenu). */
-    private focusables;
-    private focusFirstItem;
-    /** Public imperative API. Routes through the same intent path as the
-     *  triggers, so it emits `openchange` and respects controlled mode. */
-    open(opts?: {
-        coord?: [number, number];
-        viaKeyboard?: boolean;
-        originEvent?: Event;
-    }): void;
-    close(originEvent?: Event): void;
-    toggle(opts?: {
-        coord?: [number, number];
-        viaKeyboard?: boolean;
-        originEvent?: Event;
-    }): void;
-    /** Dispatch the single `openchange` event (new state + old state). */
-    emitChange(next: boolean, opts?: {
-        coord?: [number, number];
-        originEvent?: Event;
-    }): void;
-    /** Intent to open (trigger / method / keyboard). Emits `openchange`; applies
-     *  the visibility itself ONLY when uncontrolled — a controlled menu waits for
-     *  the consumer to flip `state` (strict). */
-    requestOpen(opts?: {
-        coord?: [number, number];
-        viaKeyboard?: boolean;
-        originEvent?: Event;
-    }): void;
-    /** Intent to close. Emits `openchange`; hides itself only when uncontrolled. */
-    requestClose(originEvent?: Event): void;
-    /** Apply OPEN to the DOM (no event) — used by uncontrolled intent and by the
-     *  controlled `state` sync. */
-    private show;
-    /** Apply CLOSE to the DOM (no event). Closes this menu and everything stacked
-     *  above it (its submenus). */
-    private hide;
-    /** Shadow-only show: open the popover and position it. `instant` skips the
-     *  enter-fade and positions synchronously, so a menu opening over an
-     *  already-visible one snaps in without a blink. */
-    _doShow(coord?: [number, number], instant?: boolean): void;
-    /** Shadow-only hide. */
-    _doHide(): void;
-    private position;
-    /**
-     * Fully declarative close contract — decided synchronously from the DOM, so
-     * it never depends on the consumer's click handler (which in a worker-thread
-     * runtime can't `preventDefault` on the UI thread). The menu never
-     * stops/prevents the click, so the consumer's selection handler always runs.
-     *
-     * Walk the click's composedPath outward to the surface; the NEAREST marker
-     * wins:
-     *   - `data-menu-open`  → keep the menu open (a Done button can still close
-     *                          from inside such a region — it's hit first).
-     *   - `a-menu-item` (a choice) or `data-menu-close` → close the menu.
-     *   - nothing → keep open (plain custom content doesn't dismiss).
-     */
-    private onSurfaceClick;
-    /** Close the whole open menu system from the root down. */
-    private closeSystem;
-    /** Called by the coordinator on the topmost open menu. Handles navigation;
-     *  Enter / Space activation is handled by a-menu-item's own global keydown
-     *  (which synthesizes a click → routed through onSurfaceClick). */
-    handleKey(e: KeyboardEvent): void;
-    private submenuOf;
-    private typeahead;
-    setupListeners(): void;
-    teardownListeners(): void;
-    private scheduleOpen;
-    private scheduleClose;
-    private cancelOpenTimer;
-    private cancelCloseTimer;
-}
-export declare function register_a_menu(): void;