@qualcomm-ui/angular-core 1.0.2 → 1.0.3

package/menu/index.d.ts

@@ -1,24 +1,476 @@
-export * from "./base-menu-item.directive";
-export * from "./core-menu-checkbox-item.directive";
-export * from "./core-menu-content.directive";
-export * from "./core-menu-context-trigger.directive";
-export * from "./core-menu-item-group-label.directive";
-export * from "./core-menu-item-group.directive";
-export * from "./core-menu-item-indicator.directive";
-export * from "./core-menu-item-label.directive";
-export * from "./core-menu-item-root.directive";
-export * from "./core-menu-positioner.directive";
-export * from "./core-menu-radio-item-group.directive";
-export * from "./core-menu-radio-item.directive";
-export * from "./core-menu-root.directive";
-export * from "./core-menu-separator.directive";
-export * from "./core-menu-trigger-item.directive";
-export * from "./core-menu-trigger.directive";
-export * from "./menu-context.service";
-export * from "./menu-item-context.service";
-export * from "./menu-item-group-context.service";
-export * from "./menu-machine-context.service";
-export * from "./menu-option-item-context.service";
-export * from "./menu-radio-item-group-context.service";
-export * from "./menu-trigger-context.service";
-//# sourceMappingURL=index.d.ts.map
+import * as _qualcomm_ui_core_menu from '@qualcomm-ui/core/menu';
+import { ItemProps, ItemState, OptionItemProps, ItemGroupContext, RadioItemGroupContext, MenuApi, MenuSchema, MenuTriggerContextValue, MenuApiProps, MenuNavigateDetails } from '@qualcomm-ui/core/menu';
+import * as _angular_core from '@angular/core';
+import { OnInit, ElementRef, Injector } from '@angular/core';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+import { Explicit } from '@qualcomm-ui/utils/guard';
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+import { PresenceContextService, CorePresenceDirective } from '@qualcomm-ui/angular-core/presence';
+import * as _qualcomm_ui_angular_core_state from '@qualcomm-ui/angular-core/state';
+import * as _qualcomm_ui_utils_machine from '@qualcomm-ui/utils/machine';
+import { Machine } from '@qualcomm-ui/utils/machine';
+import { PresenceApiProps } from '@qualcomm-ui/core/presence';
+import { LayerDismissEvent } from '@qualcomm-ui/dom/dismissable';
+import { PositioningOptions } from '@qualcomm-ui/dom/floating-ui';
+import { FocusOutsideEvent, InteractOutsideEvent, PointerDownOutsideEvent } from '@qualcomm-ui/dom/interact-outside';
+import { Point } from '@qualcomm-ui/dom/rect-utils';
+import { Direction } from '@qualcomm-ui/utils/direction';
+
+type MenuItemContext = ItemProps & ItemState;
+declare class MenuItemContextService extends BaseApiContextService<MenuItemContext> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuItemContextService>;
+}
+declare const MENU_ITEM_CONTEXT: _angular_core.InjectionToken<() => MenuItemContext>;
+declare const useMenuItemContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => MenuItemContext) | null : () => MenuItemContext;
+declare const provideMenuItemContext: () => _angular_core.Provider[];
+
+/**
+ * Each menu item type shares the same base properties.
+ *
+ * @public
+ */
+declare class BaseMenuItemDirective implements SignalifyInput<ItemProps> {
+    /**
+     * Whether the menu should be closed when the option is selected.
+     */
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether the menu item is disabled
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The unique value of the menu item option.
+     */
+    readonly value: _angular_core.InputSignal<string>;
+    /**
+     * The textual value of the option. Used in typeahead navigation of the menu.
+     * If not provided, the text content of the menu item will be used.
+     */
+    readonly valueText: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Emitted when the item is selected
+     */
+    readonly selected: _angular_core.OutputEmitterRef<void>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly menuItemService: MenuItemContextService;
+    readonly itemProps: _angular_core.Signal<Explicit<ItemProps>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseMenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseMenuItemDirective, never, never, { "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "valueText": { "alias": "valueText"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+
+type MenuOptionItemContext = OptionItemProps & ItemState;
+declare class MenuOptionItemContextService extends BaseApiContextService<MenuOptionItemContext> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuOptionItemContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuOptionItemContextService>;
+}
+declare const MENU_OPTION_ITEM_CONTEXT: _angular_core.InjectionToken<() => MenuOptionItemContext>;
+declare const useMenuOptionItemContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => MenuOptionItemContext) | null : () => MenuOptionItemContext;
+declare const provideMenuOptionItemContext: () => _angular_core.Provider[];
+
+declare class CoreMenuCheckboxItemDirective extends BaseMenuItemDirective implements SignalifyInput<Omit<OptionItemProps, "type">>, OnInit {
+    readonly checked: _angular_core.InputSignal<boolean | undefined>;
+    readonly defaultChecked: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    readonly checkedChanged: _angular_core.OutputEmitterRef<boolean | undefined>;
+    protected readonly menuOptionItemService: MenuOptionItemContextService;
+    readonly optionItemProps: _angular_core.Signal<OptionItemProps>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly checkedState;
+    readonly optionItemState: _angular_core.Signal<{
+        checked?: boolean | undefined;
+        onCheckedChange?: ((checked: boolean) => void) | undefined;
+        type: "radio" | "checkbox";
+        value: string;
+        closeOnSelect?: boolean | undefined | undefined;
+        disabled: boolean;
+        onSelect?: (() => void) | undefined | undefined;
+        valueText?: string | undefined | undefined;
+        highlighted: boolean;
+        id: string;
+    }>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuCheckboxItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuCheckboxItemDirective, never, never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; }, { "checkedChanged": "checkedChanged"; }, never, never, true, never>;
+}
+
+declare class CoreMenuContentDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly presenceService: PresenceContextService;
+    readonly elementRef: ElementRef<any>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly onDestroy: (callback: () => void) => void;
+    protected presenceEffect: _angular_core.EffectRef;
+    private readonly hostId;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuContentDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreMenuContextTriggerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuContextTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuContextTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreMenuItemGroupLabelDirective implements OnInit {
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly menuItemGroupContext: (() => _qualcomm_ui_core_menu.ItemGroupContext) | null;
+    protected readonly menuRadioItemGroupContext: (() => _qualcomm_ui_core_menu.RadioItemGroupContext) | null;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuItemGroupLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuItemGroupLabelDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class MenuItemGroupContextService extends BaseApiContextService<ItemGroupContext> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemGroupContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuItemGroupContextService>;
+}
+declare const MENU_ITEM_GROUP_CONTEXT: _angular_core.InjectionToken<() => ItemGroupContext>;
+declare const useMenuItemGroupContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => ItemGroupContext) | null : () => ItemGroupContext;
+declare const provideMenuItemGroupContext: () => _angular_core.Provider[];
+
+declare class CoreMenuItemGroupDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly menuItemGroupService: MenuItemGroupContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuItemGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuItemGroupDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreMenuItemIndicatorDirective implements OnInit {
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly menuItemContext: (() => _qualcomm_ui_core_menu.ItemProps & _qualcomm_ui_core_menu.ItemState) | null;
+    protected readonly menuOptionItemContext: (() => _qualcomm_ui_core_menu.OptionItemProps & _qualcomm_ui_core_menu.ItemState) | null;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuItemIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuItemIndicatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreMenuItemLabelDirective implements OnInit {
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly menuItemContext: (() => _qualcomm_ui_core_menu.ItemProps & _qualcomm_ui_core_menu.ItemState) | null;
+    protected readonly menuOptionItemContext: (() => _qualcomm_ui_core_menu.OptionItemProps & _qualcomm_ui_core_menu.ItemState) | null;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuItemLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuItemLabelDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreMenuItemRootDirective extends BaseMenuItemDirective implements OnInit {
+    readonly itemState: _angular_core.Signal<_qualcomm_ui_core_menu.ItemState>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly onDestroy: (callback: () => void) => void;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuItemRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuItemRootDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreMenuPositionerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly presenceService: PresenceContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuPositionerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuPositionerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MenuRadioItemGroupContextService extends BaseApiContextService<RadioItemGroupContext> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioItemGroupContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuRadioItemGroupContextService>;
+}
+declare const MENU_RADIO_ITEM_GROUP_CONTEXT: _angular_core.InjectionToken<() => RadioItemGroupContext>;
+declare const useMenuRadioItemGroupContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => RadioItemGroupContext) | null : () => RadioItemGroupContext;
+declare const provideMenuRadioItemGroupContext: () => _angular_core.Provider[];
+
+declare class CoreMenuRadioItemGroupDirective implements SignalifyInput<Partial<ItemGroupContext>>, OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly radioItemGroupService: MenuRadioItemGroupContextService;
+    /**
+     * The initial value of the radio item group.
+     * Use when you don't need to control the state of the group.
+     */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The controlled value of the radio item group.
+     */
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    readonly valueState: _angular_core.Signal<_qualcomm_ui_angular_core_state.ControlledState<string | undefined>>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuRadioItemGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuRadioItemGroupDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class CoreMenuRadioItemDirective extends BaseMenuItemDirective implements OnInit {
+    protected readonly menuOptionItemService: MenuOptionItemContextService;
+    protected readonly menuRadioItemGroupContext: () => _qualcomm_ui_core_menu.RadioItemGroupContext;
+    readonly optionItemProps: _angular_core.Signal<OptionItemProps>;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuRadioItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuRadioItemDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class MenuContextService extends BaseApiContextService<MenuApi> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuContextService>;
+}
+declare const MENU_CONTEXT: _angular_core.InjectionToken<() => MenuApi>;
+declare const useMenuContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => MenuApi) | null : () => MenuApi;
+declare const provideMenuContext: () => _angular_core.Provider[];
+
+declare class MenuMachineContextService extends BaseApiContextService<Machine<MenuSchema>> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuMachineContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuMachineContextService>;
+}
+declare const MENU_MACHINE_CONTEXT: _angular_core.InjectionToken<() => Machine<MenuSchema>>;
+declare const useMenuMachineContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => Machine<MenuSchema>) | null : () => Machine<MenuSchema>;
+declare const provideMenuMachineContext: () => _angular_core.Provider[];
+
+declare class MenuTriggerContextService extends BaseApiContextService<MenuTriggerContextValue> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuTriggerContextService>;
+}
+declare const MENU_TRIGGER_CONTEXT: _angular_core.InjectionToken<() => MenuTriggerContextValue>;
+declare const useMenuTriggerContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => MenuTriggerContextValue) | null : () => MenuTriggerContextValue;
+declare const provideMenuTriggerContext: () => _angular_core.Provider[];
+
+declare class CoreMenuRootDirective extends CorePresenceDirective implements OnInit, SignalifyInput<Omit<MenuApiProps, "id" | "navigate"> & PresenceApiProps> {
+    /**
+     * The positioning point for the menu. Can be set by the context menu trigger or
+     * the button trigger.
+     */
+    readonly anchorPoint: _angular_core.InputSignal<Point | null | undefined>;
+    /**
+     * Whether to close the menu when an option is selected
+     * @default true
+     */
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Whether the menu is composed with other composite widgets like a combobox or tabs
+     * @default true
+     */
+    readonly composite: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The initial highlighted value of the menu item when rendered.
+     * Use when you don't need to control the highlighted value of the menu item.
+     */
+    readonly defaultHighlightedValue: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * The initial open state of the menu when rendered.
+     * Use when you don't need to control the open state of the menu.
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The document's text/writing direction.
+     *
+     * @default "ltr"
+     */
+    readonly dir: _angular_core.InputSignal<Direction | undefined>;
+    /**
+     * A root node to correctly resolve the Document in custom environments. i.e.,
+     * Iframes, Electron.
+     */
+    readonly getRootNode: _angular_core.InputSignal<(() => ShadowRoot | Document | Node) | undefined>;
+    /**
+     * The controlled highlighted value of the menu item.
+     */
+    readonly highlightedValue: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.)
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether to loop the keyboard navigation.
+     * @default false
+     */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The controlled open state of the menu
+     */
+    readonly open: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * The options used to dynamically position the menu
+     * @inheritDoc
+     */
+    readonly positioning: _angular_core.InputSignal<PositioningOptions | undefined>;
+    /**
+     * Whether the pressing printable characters should trigger typeahead navigation
+     * @default true
+     */
+    readonly typeahead: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Function called when the highlighted menu item changes.
+     */
+    highlightChanged: _angular_core.OutputEmitterRef<string | null>;
+    /**
+     * Function to navigate to the selected item if it's an anchor element
+     */
+    readonly navigate: _angular_core.OutputEmitterRef<MenuNavigateDetails>;
+    /**
+     * Function called when the escape key is pressed
+     */
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    /**
+     * Function called when the focus is moved outside the component
+     */
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusOutsideEvent>;
+    /**
+     * Function called when an interaction happens outside the component
+     */
+    readonly interactOutside: _angular_core.OutputEmitterRef<InteractOutsideEvent>;
+    /**
+     * Function called when the open state changes
+     */
+    readonly openChanged: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Function called when the pointer is pressed down outside the component
+     */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerDownOutsideEvent>;
+    /**
+     * Function called when this layer is closed due to a parent layer being closed
+     */
+    readonly requestDismissed: _angular_core.OutputEmitterRef<LayerDismissEvent>;
+    /**
+     * Function called when a menu item is selected.
+     */
+    readonly selected: _angular_core.OutputEmitterRef<string>;
+    protected readonly document: Document;
+    protected readonly isMounted: () => boolean;
+    protected readonly menuService: MenuContextService;
+    protected readonly menuMachineService: MenuMachineContextService;
+    protected readonly menuTriggerService: MenuTriggerContextService;
+    protected readonly presenceService: PresenceContextService;
+    protected readonly injector: Injector;
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly parentMachineContext: (() => _qualcomm_ui_utils_machine.Machine<_qualcomm_ui_core_menu.MenuSchema>) | null;
+    protected readonly parentMenuContext: (() => _qualcomm_ui_core_menu.MenuApi) | null;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuRootDirective, never, never, { "anchorPoint": { "alias": "anchorPoint"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "composite": { "alias": "composite"; "required": false; "isSignal": true; }; "defaultHighlightedValue": { "alias": "defaultHighlightedValue"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "getRootNode": { "alias": "getRootNode"; "required": false; "isSignal": true; }; "highlightedValue": { "alias": "highlightedValue"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "positioning": { "alias": "positioning"; "required": false; "isSignal": true; }; "typeahead": { "alias": "typeahead"; "required": false; "isSignal": true; }; }, { "highlightChanged": "highlightChanged"; "navigate": "navigate"; "escapeKeyDown": "escapeKeyDown"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openChanged": "openChanged"; "pointerDownOutside": "pointerDownOutside"; "requestDismissed": "requestDismissed"; "selected": "selected"; }, never, never, true, never>;
+}
+
+declare class CoreMenuSeparatorDirective implements OnInit {
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuSeparatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuSeparatorDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreMenuTriggerItemDirective extends BaseMenuItemDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuTriggerContext: () => _qualcomm_ui_core_menu.MenuTriggerContextValue;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuTriggerItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuTriggerItemDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreMenuTriggerDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    protected readonly menuContext: () => _qualcomm_ui_core_menu.MenuApi;
+    protected readonly presenceService: PresenceContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly hostId: _angular_core.Signal<string>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreMenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreMenuTriggerDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BaseMenuItemDirective, CoreMenuCheckboxItemDirective, CoreMenuContentDirective, CoreMenuContextTriggerDirective, CoreMenuItemGroupDirective, CoreMenuItemGroupLabelDirective, CoreMenuItemIndicatorDirective, CoreMenuItemLabelDirective, CoreMenuItemRootDirective, CoreMenuPositionerDirective, CoreMenuRadioItemDirective, CoreMenuRadioItemGroupDirective, CoreMenuRootDirective, CoreMenuSeparatorDirective, CoreMenuTriggerDirective, CoreMenuTriggerItemDirective, MENU_CONTEXT, MENU_ITEM_CONTEXT, MENU_ITEM_GROUP_CONTEXT, MENU_MACHINE_CONTEXT, MENU_OPTION_ITEM_CONTEXT, MENU_RADIO_ITEM_GROUP_CONTEXT, MENU_TRIGGER_CONTEXT, MenuContextService, MenuItemContextService, MenuItemGroupContextService, MenuMachineContextService, MenuOptionItemContextService, MenuRadioItemGroupContextService, MenuTriggerContextService, provideMenuContext, provideMenuItemContext, provideMenuItemGroupContext, provideMenuMachineContext, provideMenuOptionItemContext, provideMenuRadioItemGroupContext, provideMenuTriggerContext, useMenuContext, useMenuItemContext, useMenuItemGroupContext, useMenuMachineContext, useMenuOptionItemContext, useMenuRadioItemGroupContext, useMenuTriggerContext };
+//# sourceMappingURL=index.d.ts.map

package/menu/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/menu/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qCAAqC,CAAA;AACnD,cAAc,+BAA+B,CAAA;AAC7C,cAAc,uCAAuC,CAAA;AACrD,cAAc,wCAAwC,CAAA;AACtD,cAAc,kCAAkC,CAAA;AAChD,cAAc,sCAAsC,CAAA;AACpD,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,kCAAkC,CAAA;AAChD,cAAc,wCAAwC,CAAA;AACtD,cAAc,kCAAkC,CAAA;AAChD,cAAc,4BAA4B,CAAA;AAC1C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,+BAA+B,CAAA;AAC7C,cAAc,wBAAwB,CAAA;AACtC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oCAAoC,CAAA;AAClD,cAAc,yCAAyC,CAAA;AACvD,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/menu/menu-item-context.service.ts","../../src/menu/base-menu-item.directive.ts","../../src/menu/menu-option-item-context.service.ts","../../src/menu/core-menu-checkbox-item.directive.ts","../../src/menu/core-menu-content.directive.ts","../../src/menu/core-menu-context-trigger.directive.ts","../../src/menu/core-menu-item-group-label.directive.ts","../../src/menu/menu-item-group-context.service.ts","../../src/menu/core-menu-item-group.directive.ts","../../src/menu/core-menu-item-indicator.directive.ts","../../src/menu/core-menu-item-label.directive.ts","../../src/menu/core-menu-item-root.directive.ts","../../src/menu/core-menu-positioner.directive.ts","../../src/menu/menu-radio-item-group-context.service.ts","../../src/menu/core-menu-radio-item-group.directive.ts","../../src/menu/core-menu-radio-item.directive.ts","../../src/menu/menu-context.service.ts","../../src/menu/menu-machine-context.service.ts","../../src/menu/menu-trigger-context.service.ts","../../src/menu/core-menu-root.directive.ts","../../src/menu/core-menu-separator.directive.ts","../../src/menu/core-menu-trigger-item.directive.ts","../../src/menu/core-menu-trigger.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAYA;AAEA;;;AACqF;AAErF;AACmB;AACC;;ACCpB;;;;AAIG;AACH;AAEE;;AAEG;;AAKH;;AAEG;;AAKH;;AAEG;;AAGH;;;AAGG;;AAGH;;AAEG;;AAGH;AACA;;;;AASD;;ACvDD;AAEA;;;AACiG;AAEjG;AAC0B;AACA;;ACG1B;;;;AAaE;;;;;AAgBE;AAEF;AAMA;;;;;;;;;;;AAME;;;;AAQH;;ACnDD;AAEE;;;AAGG;;AAGH;AACA;;;;;AAYE;AAEF;;AAIA;;;;;AAmBD;;AC1DD;AAEE;;;AAGG;;AAGH;;;;AAOE;AAEF;AAEA;;;;AAKD;;ACvBD;AAEE;AACA;AAGA;;;;AAUE;;;;AAKH;;ACpBD;;;AAC2F;AAE3F;AACyB;AACA;;ACNzB;AAEE;;;AAGG;;AAGH;AACA;;;;AAME;AAEF;;;;AAMD;;ACvBD;AAEE;AACA;AACA;;;;AAUE;;;;AAKH;;ACnBD;AAEE;AACA;AACA;;;;AAaE;;;;AAKH;;ACvBD;;;;;AAaI;AAEF;;;;;AAgCD;;AC9CD;AAEE;;;AAGG;;AAGH;AACA;;;;AAOE;AAEF;AAEA;;;;AAKD;;ACxBD;;;AACqG;AAErG;AAC+B;AACD;;ACI9B;AAIE;;;AAGG;;AAGH;AACA;AAIA;;;AAGG;;AAGH;;AAEG;;;;;;AAaD;AAEF;;;;AAaD;;AC5DD;AAKE;AAGA;;;;;AAeE;;;;AAeH;;ACtCD;;;AACyE;AAEzE;AACc;AACE;;ACJhB;;;AAGI;AAEJ;AACsB;AACC;;ACRvB;;;AACgG;AAEhG;AACsB;AACC;;ACqCvB;AAOE;;;AAGG;;AAGH;;;AAGG;;AAKH;;;AAGG;;AAKH;;;AAGG;;AAGH;;;AAGG;;AAKH;;;;AAIG;;AAGH;;;AAGG;;AAKH;;AAEG;;AAGH;;;AAGG;;AAGH;;;AAGG;;AAKH;;AAEG;;AAGH;;;AAGG;;AAGH;;;AAGG;;AAKH;;AAEG;AACH;AAEA;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAIA;;;;AAyHD;;AChUD;AAEE;;;;AAIE;;;;AAKH;;ACTD;AAKE;;;AAGG;;AAGH;;;;AASE;AAEF;AAEA;;;;AAKD;;AC7BD;AAEE;;;AAGG;;AAGH;AACA;;;;AAOE;AAEF;AAEA;;;;AAKD;;"}