@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-menu.d.ts

@@ -0,0 +1,448 @@
+import * as _slotted_angular_menu from '@slotted/angular/menu';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { PositionerAnchor } from '@slotted/core/positioner';
+import { ChangeRequest } from '@slotted/core/state';
+import { KbdPlatform, KeysTranslator } from '@slotted/core/keys';
+
+/** The surface's measure and the geometry of its items. */
+type MenuSize = 'sm' | 'md' | 'lg';
+/** Where the surface hangs. The two logical values mirror; the rest do not. */
+type MenuSide = 'top' | 'bottom' | 'inline-start' | 'inline-end' | 'left' | 'right';
+type MenuAlign = 'start' | 'center' | 'end';
+/** When the layer exists, as `tooltip`, `popover` and `collapsible` declare it. */
+type MenuMount = 'active' | 'lazy' | 'eager';
+type MenuStrategy = 'absolute' | 'fixed';
+/** The five semantic tones. A command that destroys something takes `danger`. */
+type MenuTone = 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+/** Why the surface opened or closed. */
+type MenuOpenReason = 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'select' | 'dismiss' | 'programmatic';
+/** Why a checkbox item or a radio group moved: the device, and nothing else. */
+type MenuValueReason = 'pointer' | 'keyboard';
+interface MenuDefaults {
+    align: MenuAlign;
+    alignOffset: number;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    closeOnSelect: boolean;
+    collisionPadding: number;
+    disabled: boolean;
+    flip: boolean;
+    hideWhenDetached: boolean;
+    loop: boolean;
+    mount: MenuMount;
+    openOnHover: boolean;
+    portal: boolean;
+    shift: boolean;
+    side: MenuSide;
+    sideOffset: number;
+    size: MenuSize;
+    strategy: MenuStrategy;
+    submenuCloseDelay: number;
+    submenuOpenDelay: number;
+    typeahead: boolean;
+    typeaheadTimeout: number;
+}
+declare const MENU_DEFAULTS: InjectionToken<MenuDefaults>;
+/**
+ * An application decides once how its menus open, where they hang and how long
+ * a submenu waits. A menu that states any of them itself still wins.
+ */
+declare function provideMenuDefaults(defaults: Partial<MenuDefaults>): {
+    provide: InjectionToken<MenuDefaults>;
+    useFactory: () => MenuDefaults;
+};
+/** What a menu renders as here, before it states anything of its own. */
+declare function injectMenuDefaults(): MenuDefaults;
+
+/**
+ * What a bar offers the menus on it.
+ *
+ * Declared here rather than in the menubar entry point, so the menu family
+ * depends on nothing above it: `@slotted/angular/menubar` imports this token
+ * and provides itself against it, and the dependency runs one way.
+ */
+interface MenubarSurface {
+    /** The name of the menu now open, or `undefined`. */
+    readonly value: () => string | undefined;
+    /** Where focus goes when the bar opens one of its menus. */
+    readonly entry: {
+        current: 'first' | 'last' | 'trigger';
+    };
+    open(value: string, reason: MenuOpenReason, source?: Event): void;
+    close(reason: MenuOpenReason, source?: Event): void;
+    /** Moves to the neighbouring trigger, and opens its menu when asked. */
+    step(direction: 1 | -1, options?: {
+        open?: boolean;
+    }): void;
+    register(value: string, trigger: HTMLElement | null): void;
+    readonly orientation: () => 'horizontal' | 'vertical';
+    readonly disabled: () => boolean;
+    readonly size: () => MenuSize;
+}
+declare const MENUBAR_SURFACE: InjectionToken<MenubarSurface>;
+
+/** Every item of a surface, in the order the document holds them. */
+declare const MENU_ITEM_SELECTOR = "[data-part='item']";
+/**
+ * A list of commands on a layer.
+ *
+ * The component renders **nothing where it is written**: its content lives in a
+ * template, and the layer is built into the portal when the menu opens. Angular
+ * Material's menu is built the same way and for the same reason — a surface
+ * that has to escape its parent's clipping cannot be rendered where it was
+ * declared.
+ *
+ * Where it sits decides what it is. On its own it hangs from the control that
+ * carries `slMenuTrigger`. Inside another menu it is a submenu, and its trigger
+ * becomes an item of the surface above. Inside `sl-menubar` it is one of the
+ * bar's menus, and the bar holds which one is open — a bar has at most one, and
+ * a boolean on each could represent two.
+ */
+declare class SlMenu {
+    /** The name this menu answers to on a bar. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** The accessible name, for a menu opened from a control with no words. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** The ids of what describes the menu, written on the element that carries `role="menu"`. */
+    readonly ariaDescribedBy: _angular_core.InputSignal<string | undefined>;
+    /** Written by `slMenuHeader`: the block the surface is described by. */
+    readonly headerId: _angular_core.WritableSignal<string | null>;
+    /** The consumer's description and the header's, joined. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly align: _angular_core.InputSignal<MenuAlign | undefined>;
+    readonly side: _angular_core.InputSignal<MenuSide | undefined>;
+    readonly size: _angular_core.InputSignal<MenuSize | undefined>;
+    readonly mount: _angular_core.InputSignal<MenuMount | undefined>;
+    readonly strategy: _angular_core.InputSignal<MenuStrategy | undefined>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly collisionPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly submenuOpenDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly submenuCloseDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly typeaheadTimeout: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    private static readonly flag;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly typeahead: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly openOnHover: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnOutsidePress: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly flip: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly shift: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly portal: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * The surface is waiting for its items. It keeps its measure, says so with
+     * `aria-busy`, and shows whatever the consumer put in `slMenuEmpty`.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly defaults;
+    private readonly viewContainer;
+    private readonly template;
+    /** The surface above this one, when this menu is a submenu of it. */
+    readonly parent: SlMenu | null;
+    /** The bar in scope. A submenu of a bar's menu still sees it. */
+    readonly bar: _slotted_angular_menu.MenubarSurface | null;
+    /** Whether this menu is one of the bar's own rather than nested in one. */
+    readonly onBar: boolean;
+    private readonly identifier;
+    readonly contentId: string;
+    readonly triggerId: string;
+    /** The control that opens this menu, given by `slMenuTrigger`. */
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | null>;
+    /**
+     * What the layer is positioned against when it is not the trigger: a row the
+     * menu hangs from, or the point a context menu was opened at, which
+     * `slContextMenuTriggerFor` writes here. Positioning only — the trigger stays
+     * the portal origin, the branch of the layer and the element focus returns
+     * to. Written by a directive, as `trigger` is, rather than bound in a
+     * template.
+     */
+    readonly anchor: _angular_core.WritableSignal<PositionerAnchor | null>;
+    /**
+     * Where focus lands when the surface closes, for a trigger that is gone by
+     * then or one that never held focus — a context menu's target. `null` means
+     * the trigger.
+     */
+    readonly finalFocus: _angular_core.WritableSignal<HTMLElement | null>;
+    /** Where focus lands when the surface opens. */
+    readonly entry: {
+        current: 'first' | 'last' | 'trigger';
+    };
+    private view;
+    private layerNode;
+    private surfaceNode;
+    private portalRoot;
+    private positioner;
+    private layer;
+    private navigation;
+    private presence;
+    private typeaheadHandle;
+    readonly name: _angular_core.Signal<string>;
+    readonly resolvedAlign: _angular_core.Signal<MenuAlign>;
+    readonly resolvedSide: _angular_core.Signal<MenuSide>;
+    readonly resolvedSize: _angular_core.Signal<MenuSize>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    readonly resolvedTypeahead: _angular_core.Signal<boolean>;
+    readonly resolvedOpenOnHover: _angular_core.Signal<boolean>;
+    readonly resolvedCloseOnSelect: _angular_core.Signal<boolean>;
+    readonly resolvedSubmenuOpenDelay: _angular_core.Signal<number>;
+    readonly resolvedSubmenuCloseDelay: _angular_core.Signal<number>;
+    /**
+     * A menu on a bar reads its own state from the bar, so the two models compose
+     * rather than compete: the bar holds the identity of the open menu, and this
+     * menu is open when that identity is its own.
+     */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    constructor();
+    /** The painted surface, once it exists. The grace area is measured off it. */
+    surface(): HTMLElement | null;
+    /** Asks to open or close, and reports the reason before anything moves. */
+    toggle(next: boolean, reason: MenuOpenReason, source?: Event): void;
+    /** Closes this surface and every surface above it. */
+    closeAll(reason: MenuOpenReason, source?: Event): void;
+    /** Moves focus onto an item of this surface. */
+    focusItem(index: number): void;
+    items(): HTMLElement[];
+    readonly resolvedMount: _angular_core.Signal<MenuMount>;
+    private show;
+    /**
+     * The layer, built once. `active` drops it again when the menu closes,
+     * `lazy` keeps it from the first open and `eager` builds it up front — the
+     * same axis `tooltip`, `popover` and `collapsible` declare. A layer kept
+     * while closed carries `inert`, so its items are in neither the tab order
+     * nor the accessibility tree.
+     */
+    private build;
+    private position;
+    private bind;
+    /** Focus enters the surface as it opens, and the pattern says which item. */
+    private enter;
+    private hide;
+    /** The listeners a closed surface has no use for. */
+    private unbind;
+    private teardown;
+    protected onKeyDown(event: KeyboardEvent): void;
+    /** The control that opened the outermost surface of this stack. */
+    private rootTrigger;
+    rootTriggerOf(): HTMLElement | null;
+    /**
+     * Where `Tab` goes once every menu has closed: on down the page from the
+     * control that opened the outermost surface. The pattern binds the key and
+     * says no more, and a layer portalled to the end of the document has no next
+     * element a reader would recognise.
+     */
+    private moveOut;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMenu, "sl-menu", ["slMenu"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaDescribedBy": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "strategy": { "alias": "strategy"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "submenuOpenDelay": { "alias": "submenuOpenDelay"; "required": false; "isSignal": true; }; "submenuCloseDelay": { "alias": "submenuCloseDelay"; "required": false; "isSignal": true; }; "typeaheadTimeout": { "alias": "typeaheadTimeout"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "typeahead": { "alias": "typeahead"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePress": { "alias": "closeOnOutsidePress"; "required": false; "isSignal": true; }; "flip": { "alias": "flip"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "portal": { "alias": "portal"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openChangeRequest": "openChangeRequest"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The control that opens a menu.
+ *
+ * It is put on the consumer's own control — `@slotted/angular` composes with a
+ * directive where React composes with a `render` prop, because that is what
+ * each ecosystem writes. The three places it can sit decide what it becomes: a
+ * plain control on its own, one of a bar's `menuitem`s inside `sl-menubar`, and
+ * an item of the surface above when the control also carries `slMenuItem`.
+ */
+declare class SlMenuTrigger {
+    /** The menu this control opens. */
+    readonly menu: _angular_core.InputSignal<SlMenu>;
+    private readonly element;
+    private readonly bar;
+    /** The surface above, when this control is an item of one. */
+    private readonly item;
+    private readonly parent;
+    protected readonly isButton: boolean;
+    protected readonly onBar: boolean;
+    private timer;
+    private intent;
+    private readonly isSubmenu;
+    constructor();
+    private cancelPending;
+    private openWith;
+    protected onClick(event: Event): void;
+    protected onKeyDown(source: Event): void;
+    /**
+     * Hover opens a submenu, and opens a bar's menu only once the bar already has
+     * one open: moving the pointer along a closed bar opens nothing, and along an
+     * open one switches menus.
+     */
+    protected onPointerEnter(event: Event): void;
+    /**
+     * The grace area: the submenu stays open while the pointer's own path still
+     * points into it, so the diagonal from this item to the surface may cross
+     * three items it has no interest in.
+     */
+    protected onPointerLeave(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuTrigger, "[slMenuTriggerFor]", ["slMenuTrigger"], { "menu": { "alias": "slMenuTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The shortcut as `aria-keyshortcuts` states it, or nothing.
+ *
+ * A sequence has no syntax in the attribute, whose separator means *or* rather
+ * than *then*, so a sequence is printed and left unannounced instead of being
+ * announced as something it is not.
+ */
+declare function announceShortcut(keys: string, platform: KbdPlatform): string | undefined;
+/** The legends a reader sees, in the order the platform writes them, in the language of `t`. */
+declare function shortcutLegends(keys: string, platform: KbdPlatform, t: KeysTranslator): string;
+/** What an item reports when it runs. */
+interface MenuSelectEvent {
+    readonly reason: MenuValueReason;
+    readonly source: Event | undefined;
+    readonly defaultPrevented: boolean;
+    preventDefault: () => void;
+}
+/**
+ * One command, one option, or one choice among others.
+ *
+ * A native `button` carrying `role="menuitem"`: the platform gives the press,
+ * the `Enter` and `Space` handling and the pointer semantics, and the role
+ * replaces `button` so a reader hears an item. Which of the three roles it
+ * takes is decided by the attribute the consumer wrote, read once through
+ * `HostAttributeToken`, because one element cannot carry two components.
+ *
+ * A disabled item keeps its place in the ring and takes `aria-disabled`: the
+ * pattern asks that disabled items stay focusable, and the native attribute
+ * would remove them.
+ */
+declare class SlMenuItem {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** What typeahead matches on, when the visible label is not the word. */
+    readonly textValue: _angular_core.InputSignal<string | undefined>;
+    readonly tone: _angular_core.InputSignal<MenuTone | undefined>;
+    /**
+     * A shortcut in this library's own notation — `Mod+K`. It is printed with the
+     * platform's legends and announced with `aria-keyshortcuts`; the family does
+     * not listen for it, because a menu that bound keys would fire commands while
+     * it was closed.
+     */
+    readonly shortcut: _angular_core.InputSignal<string | undefined>;
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** The value this item stands for inside a radio group. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly checkedChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly select: _angular_core.OutputEmitterRef<MenuSelectEvent>;
+    /** The line under the label, which describes the item rather than naming it. */
+    readonly describedBy: _angular_core.WritableSignal<string | null>;
+    private readonly menu;
+    private readonly group;
+    private readonly element;
+    private readonly platform;
+    /** The words a shortcut's keys are written in, from the `keys` catalog of the language in force. */
+    private readonly keysT;
+    private readonly isCheckbox;
+    private readonly isRadio;
+    protected readonly isLink: boolean;
+    /**
+     * Set by `slMenuTriggerFor` on the same element: an item that opens a
+     * submenu ends in a chevron that points along the reading direction.
+     */
+    readonly opensSubmenu: _angular_core.WritableSignal<boolean>;
+    protected readonly role: string;
+    protected readonly isChecked: _angular_core.Signal<boolean>;
+    protected readonly legend: _angular_core.Signal<string | undefined>;
+    protected readonly announced: _angular_core.Signal<string | null>;
+    /**
+     * The host is a `button` or an `a`, so the template compiler types the event
+     * as the one thing both have in common and the narrowing happens here.
+     */
+    protected onClick(event: Event): void;
+    protected onKeyDown(source: Event): void;
+    /**
+     * The pointer moving over an item focuses it, which keeps exactly one item
+     * highlighted whichever device is driving — and is what lets the stylesheet
+     * paint the highlight on `:focus` rather than splitting it in two.
+     */
+    protected onPointerMove(): void;
+    private commit;
+    private run;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMenuItem, "button[slMenuItem], a[slMenuItem], button[slMenuCheckboxItem], button[slMenuRadioItem]", ["slMenuItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "textValue": { "alias": "textValue"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "checkedChangeRequest": "checkedChangeRequest"; "select": "select"; }, never, ["[slMenuItemIcon]", "*", "[slMenuItemDescription]", "[slMenuItemMeta]"], true, never>;
+}
+/** The mark in the item's first column: the consumer's own element. */
+declare class SlMenuItemIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuItemIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuItemIcon, "[slMenuItemIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The second line, under the label.
+ *
+ * It describes the item rather than naming it: the item points at it with
+ * `aria-describedby`, so a reader hears "Delete document" and then the warning,
+ * instead of one name with a sentence stuck to it.
+ */
+declare class SlMenuItemDescription {
+    protected readonly id: string;
+    private readonly item;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuItemDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuItemDescription, "[slMenuItemDescription]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * What the item holds or counts — a number, a status, the value a submenu is
+ * set to — in a column of its own before the shortcut or the chevron. It reads
+ * as part of the item's name; typeahead matches the label alone.
+ */
+declare class SlMenuItemMeta {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuItemMeta, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuItemMeta, "[slMenuItemMeta]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Who the menu belongs to: an avatar, a name, a line under it, above the
+ * commands. Not an item — the arrows and typeahead never reach it, because a
+ * `menu` owns only items, groups and separators — so the surface names it as
+ * its description and a reader hears it once, as the menu opens. The name is a
+ * `data-part="label"` element and the line under it `slMenuItemDescription`;
+ * any other child is the media, set beside both.
+ */
+declare class SlMenuHeader {
+    protected readonly id: string;
+    private readonly menu;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuHeader, "[slMenuHeader]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A set of items with a name. The label is inside the group and named by it,
+ * because a heading outside one belongs to nothing a reader can hear.
+ */
+declare class SlMenuGroup {
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    protected readonly labelId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMenuGroup, "sl-menu-group", ["slMenuGroup"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/** One value, chosen among the items inside it. */
+declare class SlMenuRadioGroup {
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    choose(next: string, reason: MenuValueReason, source: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMenuRadioGroup, "sl-menu-radio-group", ["slMenuRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChangeRequest": "valueChangeRequest"; }, never, ["*"], true, never>;
+}
+/** Not focusable and not interactive, which is what the pattern asks of it. */
+declare class SlMenuSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuSeparator, "hr[slMenuSeparator]", never, {}, {}, never, never, true, never>;
+}
+/** What a menu whose items were all filtered away says instead of nothing. */
+declare class SlMenuEmpty {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenuEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlMenuEmpty, "[slMenuEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+export { MENUBAR_SURFACE, MENU_DEFAULTS, MENU_ITEM_SELECTOR, SlMenu, SlMenuEmpty, SlMenuGroup, SlMenuHeader, SlMenuItem, SlMenuItemDescription, SlMenuItemIcon, SlMenuItemMeta, SlMenuRadioGroup, SlMenuSeparator, SlMenuTrigger, announceShortcut, injectMenuDefaults, provideMenuDefaults, shortcutLegends };
+export type { MenuAlign, MenuDefaults, MenuMount, MenuOpenReason, MenuSelectEvent, MenuSide, MenuSize, MenuStrategy, MenuTone, MenuValueReason, MenubarSurface };
+//# sourceMappingURL=slotted-angular-menu.d.ts.map

package/types/slotted-angular-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-menu.d.ts","sources":["../../menu/src/menu-defaults.ts","../../menu/src/menu-context.ts","../../menu/src/menu.ts","../../menu/src/menu-trigger.ts","../../menu/src/menu-items.ts"],"mappings":"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","names":[]}

package/types/slotted-angular-menubar.d.ts

@@ -0,0 +1,90 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { MenuSize, MenubarSurface, MenuOpenReason } from '@slotted/angular/menu';
+
+type MenubarOrientation = 'horizontal' | 'vertical';
+interface MenubarDefaults {
+    disabled: boolean;
+    loop: boolean;
+    orientation: MenubarOrientation;
+    size: MenuSize;
+    typeahead: boolean;
+}
+declare const MENUBAR_DEFAULTS: InjectionToken<MenubarDefaults>;
+/** The decisions an application takes once, in its bootstrap. */
+declare function provideMenubarDefaults(defaults: Partial<MenubarDefaults>): {
+    provide: InjectionToken<MenubarDefaults>;
+    useFactory: () => MenubarDefaults;
+};
+declare function injectMenubarDefaults(): MenubarDefaults;
+
+/**
+ * A row of triggers with one tab stop, each opening a `menu`.
+ *
+ * The bar holds which menu is open and nothing else: every part inside it
+ * belongs to the `menu` family and is imported from `@slotted/angular/menu`.
+ * The CDK's menubar and Radix's each restate the whole menu API a second time,
+ * which is two copies of one machine and one place for a later capability to go
+ * missing.
+ */
+declare class SlMenubar implements MenubarSurface {
+    /**
+     * The menu now open, named by its own `value`. A bar has at most one, so its
+     * state is that name rather than a boolean on each menu — the one model that
+     * cannot represent two open menus at once.
+     */
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly valueChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    /**
+     * The inputs a consumer writes are stated as they are written and read as
+     * what they resolve to: `orientation()`, `size()` and `disabled()` answer the
+     * bar's actual decision, which is what a menu on the bar reads through
+     * `MENUBAR_SURFACE`. The unresolved value belongs to nobody outside.
+     */
+    protected readonly orientationInput: _angular_core.InputSignal<MenubarOrientation | undefined>;
+    protected readonly sizeInput: _angular_core.InputSignal<MenuSize | undefined>;
+    protected readonly disabledInput: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly typeahead: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    private readonly defaults;
+    private readonly element;
+    private readonly registry;
+    private typeaheadHandle;
+    /** Where focus goes when the bar opens one of its menus. */
+    readonly entry: {
+        current: 'first' | 'last' | 'trigger';
+    };
+    readonly orientation: _angular_core.Signal<MenubarOrientation>;
+    readonly size: _angular_core.Signal<MenuSize>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly resolvedLoop: _angular_core.Signal<boolean>;
+    readonly resolvedTypeahead: _angular_core.Signal<boolean>;
+    protected readonly ariaOrientation: _angular_core.Signal<"vertical" | null>;
+    constructor();
+    /** Opens the menu that answers to this name. */
+    open(value: string, reason: MenuOpenReason, source?: Event): void;
+    close(reason: MenuOpenReason, source?: Event): void;
+    register(value: string, trigger: HTMLElement | null): void;
+    /**
+     * The pattern's three-step rule for the inline axis: close what is open, move
+     * to the neighbouring trigger, and open its menu. Focus stays on the trigger
+     * — the recommended half of the pattern's choice — so the next arrow keeps
+     * moving along the bar rather than walking into a list nobody asked for.
+     */
+    step(direction: 1 | -1, options?: {
+        open?: boolean;
+    }): void;
+    private triggers;
+    private nameOf;
+    private move;
+    /** The pattern asks for typeahead on a menubar as well as inside a menu. */
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlMenubar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlMenubar, "sl-menubar", ["slMenubar"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "orientationInput": { "alias": "orientation"; "required": false; "isSignal": true; }; "sizeInput": { "alias": "size"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "typeahead": { "alias": "typeahead"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChangeRequest": "valueChangeRequest"; }, never, ["*"], true, never>;
+}
+
+export { MENUBAR_DEFAULTS, SlMenubar, injectMenubarDefaults, provideMenubarDefaults };
+export type { MenubarDefaults, MenubarOrientation };
+//# sourceMappingURL=slotted-angular-menubar.d.ts.map

package/types/slotted-angular-menubar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-menubar.d.ts","sources":["../../menubar/src/menubar-defaults.ts","../../menubar/src/menubar.ts"],"mappings":";;;;;KAGY,kBAAkB;UAEb,eAAe;;;iBAGjB,kBAAkB;UACzB,QAAQ;;AAEf;AAeD,cAAa,gBAAgB,EAAA,cAAA,CAAA,eAAA;AAK7B;AACA,iBAAgB,sBAAsB,WAAW,OAAO,CAAC,eAAe;;sBAGpD,eAAe;AAElC;AAED,iBAAgB,qBAAqB,IAAI,eAAe;;ACRxD;;;;;;;;AAQG;AACH,cAqBa,SAAU,YAAW,cAAc;AAC9C;;;;AAIG;oBACW,aAAA,CAAA,WAAA;;iCAEa,aAAA,CAAA,gBAAA,CAAA,aAAA;AAE3B;;;;;AAKG;AACH,yCAAmC,aAAA,CAAA,WAAA,CAAA,kBAAA;AAGnC,kCAA4B,aAAA,CAAA,WAAA,CAAA,QAAA;AAC5B,sCAAgC,aAAA,CAAA,wBAAA;mBAKnB,aAAA,CAAA,wBAAA;wBAIK,aAAA,CAAA,wBAAA;AAKlB;AACA;AACA;;;;AAIkB;;0BAEE,aAAA,CAAA,MAAA,CAAA,kBAAA;mBACP,aAAA,CAAA,MAAA,CAAA,QAAA;uBACI,aAAA,CAAA,MAAA;2BACI,aAAA,CAAA,MAAA;gCACK,aAAA,CAAA,MAAA;AAE1B,wCAAkC,aAAA,CAAA,MAAA;;;AAyClC,gCAA4B,cAAc,WAAW,KAAK;kBAI5C,cAAc,WAAW,KAAK;qCAIX,WAAW;AAK5C;;;;;AAKG;;;AACiD;AAqBpD;AAIA;AAMA;;AAiBA,+BAA2B,aAAa;oDA5J7B,SAAS;sDAAT,SAAS;AAkLrB;;","names":[]}