Docs API reference Headlessmenubar

menubar headless API

The core connector and vanilla mount are always visible. Use the framework choice to inspect native composition, props, outputs, context and hooks for the selected adapter.

Machine API

@grassroot/ui-headless-core/menubar

Core connector and vanilla API

29 exports

View source packages/ui-headless/core/src/menubar/index.ts

Install npm i @grassroot/ui-headless-core

activateMenubarLayer

function

activateMenubarLayerts

declare function activateMenubarLayer(service: MenubarService, scope: PartScope, doc: Document): () => void;

Name

Kind

Type

Requirement

service

parameter

MenubarService

required

scope

parameter

PartScope

required

doc

parameter

Document

required

return

return value

() => void

n/a

Name: service
Kind: parameter
Type: MenubarService
Requirement: required

Name: scope
Kind: parameter
Type: PartScope
Requirement: required

Name: doc
Kind: parameter
Type: Document
Requirement: required

Name: return
Kind: return value
Type: () => void
Requirement: n/a

connectMenubar

function

connectMenubarts

declare function connectMenubar(service: MenubarService, scope: PartScope, options?: MenubarConnectOptions): MenubarApi;

Name

Kind

Type

Requirement

service

parameter

MenubarService

required

scope

parameter

PartScope

required

options

parameter

MenubarConnectOptions

optional

return

return value

MenubarApi

n/a

Name: service
Kind: parameter
Type: MenubarService
Requirement: required

Name: scope
Kind: parameter
Type: PartScope
Requirement: required

Name: options
Kind: parameter
Type: MenubarConnectOptions
Requirement: optional

Name: return
Kind: return value
Type: MenubarApi
Requirement: n/a

MenubarActionable

interface

MenubarActionablets

interface MenubarActionable {
  readonly id: string;
  readonly disabled?: boolean;
  readonly textValue?: string;
}

Name

Kind

Type

Requirement

disabled

property

boolean

optional

id

property

string

required

textValue

property

string

optional

Name: disabled
Kind: property
Type: boolean
Requirement: optional

Name: id
Kind: property
Type: string
Requirement: required

Name: textValue
Kind: property
Type: string
Requirement: optional

menubarAnatomy

value

menubarAnatomyts

export declare const menubarAnatomy: {
  readonly scope: "menubar";
  readonly parts: readonly ["root", "trigger", "content", "item", "separator", "sub-trigger", "sub-content"];
};

Name

Kind

Type

Requirement

parts

property

readonly ["root", "trigger", "content", "item", "separator", "sub-trigger", "sub-content"]

required

scope

property

"menubar"

required

Name: parts
Kind: property
Type: readonly ["root", "trigger", "content", "item", "separator", "sub-trigger", "sub-content"]
Requirement: required

Name: scope
Kind: property
Type: "menubar"
Requirement: required

MenubarApi

interface

MenubarApits

interface MenubarApi {
  rootProps(): PartProps;
  triggerProps(menu: MenubarMenu): PartProps;
  contentProps(menuValue: string): PartProps;
  itemProps(menuValue: string, item: MenubarActionable): PartProps;
  separatorProps(menuValue?: string): PartProps;
  subTriggerProps(key?: string): PartProps;
  subContentProps(key?: string): PartProps;
  resolveSubmenuPointerIntent(input: SubmenuPointerIntentInput): ReturnType<typeof resolveSubmenuPointerIntent>;
  readonly open: boolean;
  readonly value: string | null;
}

Name

Kind

Type

Requirement

contentProps

method

(menuValue: string) => PartProps

required

itemProps

method

(menuValue: string, item: MenubarActionable) => PartProps

required

open

property

boolean

required

resolveSubmenuPointerIntent

method

(input: SubmenuPointerIntentInput) => ReturnType<typeof resolveSubmenuPointerIntent>

required

rootProps

method

() => PartProps

required

separatorProps

method

(menuValue?: string) => PartProps

required

subContentProps

method

(key?: string) => PartProps

required

subTriggerProps

method

(key?: string) => PartProps

required

triggerProps

method

(menu: MenubarMenu) => PartProps

required

value

property

string | null

required

Name: contentProps
Kind: method
Type: (menuValue: string) => PartProps
Requirement: required

Name: itemProps
Kind: method
Type: (menuValue: string, item: MenubarActionable) => PartProps
Requirement: required

Name: open
Kind: property
Type: boolean
Requirement: required

Name: resolveSubmenuPointerIntent
Kind: method
Type: (input: SubmenuPointerIntentInput) => ReturnType<typeof resolveSubmenuPointerIntent>
Requirement: required

Name: rootProps
Kind: method
Type: () => PartProps
Requirement: required

Name: separatorProps
Kind: method
Type: (menuValue?: string) => PartProps
Requirement: required

Name: subContentProps
Kind: method
Type: (key?: string) => PartProps
Requirement: required

Name: subTriggerProps
Kind: method
Type: (key?: string) => PartProps
Requirement: required

Name: triggerProps
Kind: method
Type: (menu: MenubarMenu) => PartProps
Requirement: required

Name: value
Kind: property
Type: string | null
Requirement: required

MenubarChangeReason

type

MenubarChangeReasonts

type MenubarChangeReason = MenubarOpenReason | MenubarCloseReason;

MenubarCommand

type

MenubarCommandts

type MenubarCommand = CommandObject & ({
  readonly type: "VALUE_CHANGE_REQUEST";
  readonly value: string | null;
  readonly reason: MenubarChangeReason;
} | {
  readonly type: "SELECT_ITEM";
  readonly menuValue: string;
  readonly id: string;
} | {
  readonly type: "FOCUS_TRIGGER";
  readonly key: string;
});

MenubarConnectOptions

interface

MenubarConnectOptionsts

interface MenubarConnectOptions {
  readonly dir?: "ltr" | "rtl";
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

MenubarContext

type

MenubarContextts

type MenubarContext = {
  readonly mode: "controlled" | "uncontrolled";
  /** The one committed open-menu binding; null means all menus are closed. */
  readonly value: string | null;
  /** Original index into the current menu's item list. */
  readonly highlightedIndex: number;
  /** Roving-focus target among top-level triggers. */
  readonly focusedValue: string | null;
};

Name

Kind

Type

Requirement

Description

focusedValue

property

string | null

required

Roving-focus target among top-level triggers.

highlightedIndex

property

number

required

Original index into the current menu's item list.

mode

property

"controlled" | "uncontrolled"

required

—

value

property

string | null

required

The one committed open-menu binding; null means all menus are closed.

Name: focusedValue
Kind: property
Type: string | null
Requirement: required
Description: Roving-focus target among top-level triggers.

Name: highlightedIndex
Kind: property
Type: number
Requirement: required
Description: Original index into the current menu's item list.

Name: mode
Kind: property
Type: "controlled" | "uncontrolled"
Requirement: required
Description: —

Name: value
Kind: property
Type: string | null
Requirement: required
Description: The one committed open-menu binding; null means all menus are closed.

MenubarDivider

interface

MenubarDividerts

interface MenubarDivider {
  readonly divider: true;
}

Name

Kind

Type

Requirement

divider

property

true

required

Name: divider
Kind: property
Type: true
Requirement: required

MenubarEvent

type

MenubarEventts

type MenubarEvent = {
  readonly type: "OPEN_MENU";
  readonly value: string;
  readonly reason: MenubarOpenReason;
} | {
  readonly type: "TOGGLE_MENU";
  readonly value: string;
  readonly reason: "trigger";
} | {
  readonly type: "CLOSE";
  readonly reason: MenubarCloseReason;
} | {
  readonly type: "MOVE_TRIGGER";
  readonly direction: -1 | 1;
} | {
  readonly type: "MOVE_ITEM";
  readonly direction: -1 | 1;
} | {
  readonly type: "HIGHLIGHT";
  readonly index: number;
} | {
  readonly type: "SELECT";
} | {
  readonly type: "FOCUS_TRIGGER";
  readonly value: string;
};

MenubarInput

type

MenubarInputts

type MenubarInput = {
  readonly menus: readonly MenubarMenu[];
  /** Controlled open-menu value. Defining it fixes controlled mode at start. */
  readonly value?: string | null;
  /** Uncontrolled initial open-menu value. */
  readonly defaultValue?: string | null;
};

Name

Kind

Type

Requirement

Description

defaultValue

property

string | null

optional

Uncontrolled initial open-menu value.

menus

property

readonly MenubarMenu[]

required

—

value

property

string | null

optional

Controlled open-menu value. Defining it fixes controlled mode at start.

Name: defaultValue
Kind: property
Type: string | null
Requirement: optional
Description: Uncontrolled initial open-menu value.

Name: menus
Kind: property
Type: readonly MenubarMenu[]
Requirement: required
Description: —

Name: value
Kind: property
Type: string | null
Requirement: optional
Description: Controlled open-menu value. Defining it fixes controlled mode at start.

MenubarItem

type

MenubarItemts

type MenubarItem = MenubarActionable | MenubarDivider;

menubarMachine

value

menubarMachinets

export declare const menubarMachine: MenubarMachine;

MenubarMenu

interface

MenubarMenuts

interface MenubarMenu {
  readonly value: string;
  readonly items: readonly MenubarItem[];
}

Name

Kind

Type

Requirement

items

property

readonly MenubarItem[]

required

value

property

string

required

Name: items
Kind: property
Type: readonly MenubarItem[]
Requirement: required

Name: value
Kind: property
Type: string
Requirement: required

MenubarMount

interface

MenubarMountts

interface MenubarMount {
  readonly service: MenubarService;
  readonly connector: MenubarApi;
  readonly root: HTMLElement;
  destroy(): void;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

destroy

method

() => void

required

root

property

HTMLElement

required

service

property

MenubarService

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: destroy
Kind: method
Type: () => void
Requirement: required

Name: root
Kind: property
Type: HTMLElement
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

menubarNavigableIndices

function

Equivalent to the frozen `menubarNavigableIndices` helper.

menubarNavigableIndicests

declare function menubarNavigableIndices(items: readonly MenubarItem[]): readonly number[];

Name

Kind

Type

Requirement

items

parameter

readonly MenubarItem[]

required

return

return value

readonly number[]

n/a

Name: items
Kind: parameter
Type: readonly MenubarItem[]
Requirement: required

Name: return
Kind: return value
Type: readonly number[]
Requirement: n/a

MenubarOpenChangeDetail

interface

MenubarOpenChangeDetailts

interface MenubarOpenChangeDetail {
  readonly value: string | null;
  readonly reason: MenubarChangeReason;
}

Name

Kind

Type

Requirement

reason

property

MenubarChangeReason

required

value

property

string | null

required

Name: reason
Kind: property
Type: MenubarChangeReason
Requirement: required

Name: value
Kind: property
Type: string | null
Requirement: required

MenubarOpenReason

type

MenubarOpenReasonts

type MenubarOpenReason = "trigger" | "pointer" | "keyboard" | "programmatic";

MenubarPart

type

MenubarPartts

type MenubarPart = (typeof parts)[number];

menubarSelectors

value

menubarSelectorsts

export declare const menubarSelectors: {
  value: (snapshot: MenubarSnapshot) => string | null;
  open: (snapshot: MenubarSnapshot) => boolean;
  highlightedIndex: (snapshot: MenubarSnapshot) => number;
  focusedValue: (snapshot: MenubarSnapshot) => string | null;
  isOpen: (snapshot: MenubarSnapshot, value: string) => boolean;
};

Name

Kind

Type

Requirement

focusedValue

property

(snapshot: MenubarSnapshot) => string | null

required

highlightedIndex

property

(snapshot: MenubarSnapshot) => number

required

isOpen

property

(snapshot: MenubarSnapshot, value: string) => boolean

required

open

property

(snapshot: MenubarSnapshot) => boolean

required

value

property

(snapshot: MenubarSnapshot) => string | null

required

Name: focusedValue
Kind: property
Type: (snapshot: MenubarSnapshot) => string | null
Requirement: required

Name: highlightedIndex
Kind: property
Type: (snapshot: MenubarSnapshot) => number
Requirement: required

Name: isOpen
Kind: property
Type: (snapshot: MenubarSnapshot, value: string) => boolean
Requirement: required

Name: open
Kind: property
Type: (snapshot: MenubarSnapshot) => boolean
Requirement: required

Name: value
Kind: property
Type: (snapshot: MenubarSnapshot) => string | null
Requirement: required

MenubarService

type

MenubarServicets

type MenubarService = Service<MenubarInput, MenubarStateValue, MenubarContext, MenubarEvent, MenubarCommand>;

MenubarSnapshot

type

MenubarSnapshotts

type MenubarSnapshot = Snapshot<MenubarStateValue, MenubarContext>;

MenubarStateValue

type

MenubarStateValuets

type MenubarStateValue = "ready";

mountMenubar

function

mountMenubarts

declare function mountMenubar(container: HTMLElement, options: MountMenubarOptions): MenubarMount;

Name

Kind

Type

Requirement

container

parameter

HTMLElement

required

options

parameter

MountMenubarOptions

required

return

return value

MenubarMount

n/a

Name: container
Kind: parameter
Type: HTMLElement
Requirement: required

Name: options
Kind: parameter
Type: MountMenubarOptions
Requirement: required

Name: return
Kind: return value
Type: MenubarMount
Requirement: n/a

MountMenubarOptions

interface

MountMenubarOptionsts

interface MountMenubarOptions extends MenubarInput {
  readonly dir?: "ltr" | "rtl";
  readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
  readonly onSelect?: (id: string, menuValue: string) => void;
  readonly scheduler?: Scheduler;
  readonly renderTrigger?: (element: HTMLElement, menu: MenubarMenu) => void;
  readonly renderItem?: (element: HTMLElement, item: MenubarActionable, menuValue: string) => void;
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

onOpenChange

property

(detail: MenubarOpenChangeDetail) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

renderItem

property

(element: HTMLElement, item: MenubarActionable, menuValue: string) => void

optional

renderTrigger

property

(element: HTMLElement, menu: MenubarMenu) => void

optional

scheduler

property

Scheduler

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: renderItem
Kind: property
Type: (element: HTMLElement, item: MenubarActionable, menuValue: string) => void
Requirement: optional

Name: renderTrigger
Kind: property
Type: (element: HTMLElement, menu: MenubarMenu) => void
Requirement: optional

Name: scheduler
Kind: property
Type: Scheduler
Requirement: optional

Returns `preserve` while the pointer travels through the corridor between a submenu trigger and its content. The corridor interpolates the two rectangles' top/bottom edges and includes a small eight-pixel tolerance so browser pointer sampling cannot close a submenu between adjacent samples.

resolveSubmenuPointerIntentts

declare function resolveSubmenuPointerIntent(input: SubmenuPointerIntentInput): SubmenuPointerIntent;

Name

Kind

Type

Requirement

input

parameter

SubmenuPointerIntentInput

required

return

return value

SubmenuPointerIntent

n/a

Name: input
Kind: parameter
Type: SubmenuPointerIntentInput
Requirement: required

Name: return
Kind: return value
Type: SubmenuPointerIntent
Requirement: n/a

runMenubarCommand

function

runMenubarCommandts

declare function runMenubarCommand(command: MenubarCommand, scope: PartScope, options?: {
  readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
  readonly onSelect?: (id: string, menuValue: string) => void;
}): void;

Name

Kind

Type

Requirement

command

parameter

MenubarCommand

required

scope

parameter

PartScope

required

options

parameter

{
  readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
  readonly onSelect?: (id: string, menuValue: string) => void;
}

optional

return

return value

void

n/a

Name: command
Kind: parameter
Type: MenubarCommand
Requirement: required

Name: scope
Kind: parameter
Type: PartScope
Requirement: required

Name: options
Kind: parameter
Type: { readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void; readonly onSelect?: (id: string, menuValue: string) => void; }
Requirement: optional

Name: return
Kind: return value
Type: void
Requirement: n/a

SubmenuPointerIntentInput

interface

SubmenuPointerIntentInputts

interface SubmenuPointerIntentInput {
  readonly previousPoint: SubmenuPoint | null;
  readonly currentPoint: SubmenuPoint;
  readonly triggerRect: SubmenuRect;
  readonly contentRect: SubmenuRect;
}

Name

Kind

Type

Requirement

contentRect

property

SubmenuRect

required

currentPoint

property

SubmenuPoint

required

previousPoint

property

SubmenuPoint | null

required

triggerRect

property

SubmenuRect

required

Name: contentRect
Kind: property
Type: SubmenuRect
Requirement: required

Name: currentPoint
Kind: property
Type: SubmenuPoint
Requirement: required

Name: previousPoint
Kind: property
Type: SubmenuPoint | null
Requirement: required

Name: triggerRect
Kind: property
Type: SubmenuRect
Requirement: required

Framework adapters

Each panel keeps its adapter's public vocabulary. React compound exports, Vue composables, standalone Angular declarations, Svelte components, and Solid hooks stay native to their framework.

React imports

@grassroot/ui-headless-react/menubarts

import { Content, Item, Menubar, MenubarContextProvider, Root, Separator, SubContent, SubTrigger } from "@grassroot/ui-headless-react/menubar"; // +1 more exports

Vue imports

@grassroot/ui-headless-vue/menubarts

<script setup lang="ts">
import { MenubarContent, MenubarItem, MenubarRoot, MenubarSeparator, MenubarSubContent, MenubarSubTrigger, MenubarTrigger } from "@grassroot/ui-headless-vue/menubar";
</script>

Angular imports

@grassroot/ui-headless-angular/menubarts

import { Component } from "@angular/core";
import { GR_MENUBAR_DECLARATIONS } from "@grassroot/ui-headless-angular/menubar";
 
@Component({ standalone: true, imports: [GR_MENUBAR_DECLARATIONS], template: `<!-- compose the menubar parts here -->` })
export class Example {}

Svelte imports

@grassroot/ui-headless-svelte/menubarts

<script lang="ts">
  import { MenubarContent, MenubarItem, MenubarRoot, MenubarSeparator, MenubarSubContent, MenubarSubTrigger, MenubarTrigger } from "@grassroot/ui-headless-svelte/menubar";
</script>

Solid imports

@grassroot/ui-headless-solid/menubarts

import { MenubarContent, MenubarContextProvider, MenubarItem, MenubarRoot, MenubarSeparator, MenubarSubContent, MenubarSubTrigger, MenubarTrigger } from "@grassroot/ui-headless-solid/menubar";

@grassroot/ui-headless-react/menubar

React adapter

22 exports

View source packages/ui-headless/react/src/menubar/index.ts

Install npm i @grassroot/ui-headless-react

Content

value

Contentts

export declare const Content: import("react").ForwardRefExoticComponent<MenubarContentProps & import("react").RefAttributes<HTMLDivElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

Item

value

Itemts

export declare const Item: import("react").ForwardRefExoticComponent<MenubarItemProps & import("react").RefAttributes<HTMLDivElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

Menubar

value

Menubarts

export declare const Menubar: {
  Root: import("react").ForwardRefExoticComponent<MenubarRootProps & import("react").RefAttributes<HTMLDivElement>>;
  Trigger: import("react").ForwardRefExoticComponent<MenubarTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
  Content: import("react").ForwardRefExoticComponent<MenubarContentProps & import("react").RefAttributes<HTMLDivElement>>;
  Item: import("react").ForwardRefExoticComponent<MenubarItemProps & import("react").RefAttributes<HTMLDivElement>>;
  Separator: import("react").ForwardRefExoticComponent<MenubarSeparatorProps & import("react").RefAttributes<HTMLDivElement>>;
  SubTrigger: import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>;
  SubContent: import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>;
};

Name

Kind

Type

Requirement

Content

property

import("react").ForwardRefExoticComponent<MenubarContentProps & import("react").RefAttributes<HTMLDivElement>>

required

Item

property

import("react").ForwardRefExoticComponent<MenubarItemProps & import("react").RefAttributes<HTMLDivElement>>

required

Root

property

import("react").ForwardRefExoticComponent<MenubarRootProps & import("react").RefAttributes<HTMLDivElement>>

required

Separator

property

import("react").ForwardRefExoticComponent<MenubarSeparatorProps & import("react").RefAttributes<HTMLDivElement>>

required

SubContent

property

import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>

required

SubTrigger

property

import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>

required

Trigger

property

import("react").ForwardRefExoticComponent<MenubarTriggerProps & import("react").RefAttributes<HTMLButtonElement>>

required

Name: Content
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarContentProps & import("react").RefAttributes<HTMLDivElement>>
Requirement: required

Name: Item
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarItemProps & import("react").RefAttributes<HTMLDivElement>>
Requirement: required

Name: Root
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarRootProps & import("react").RefAttributes<HTMLDivElement>>
Requirement: required

Name: Separator
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarSeparatorProps & import("react").RefAttributes<HTMLDivElement>>
Requirement: required

Name: SubContent
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>
Requirement: required

Name: SubTrigger
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>
Requirement: required

Name: Trigger
Kind: property
Type: import("react").ForwardRefExoticComponent<MenubarTriggerProps & import("react").RefAttributes<HTMLButtonElement>>
Requirement: required

MenubarContentProps

interface

MenubarContentPropsts

interface MenubarContentProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly value: string;
}

Name

Kind

Type

Requirement

asChild

property

boolean

optional

value

property

string

required

Name: asChild
Kind: property
Type: boolean
Requirement: optional

Name: value
Kind: property
Type: string
Requirement: required

MenubarContext

value

MenubarContextts

export declare const MenubarContext: import("react").Context<MenubarContextValue | null>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

MenubarContextProvider

function

MenubarContextProviderts

declare function MenubarContextProvider(props: {
  value: MenubarContextValue;
  children?: ReactNode;
}): import("react").JSX.Element;

Name

Kind

Type

Requirement

props

parameter

{
  value: MenubarContextValue;
  children?: ReactNode;
}

required

return

return value

import("react").JSX.Element

n/a

Name: props
Kind: parameter
Type: { value: MenubarContextValue; children?: ReactNode; }
Requirement: required

Name: return
Kind: return value
Type: import("react").JSX.Element
Requirement: n/a

MenubarContextValue

interface

MenubarContextValuets

interface MenubarContextValue {
  readonly service: MenubarService;
  readonly connector: MenubarApi;
  readonly scope: PartScope;
  readonly snapshot: MenubarSnapshot;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

snapshot

property

MenubarSnapshot

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: snapshot
Kind: property
Type: MenubarSnapshot
Requirement: required

MenubarItemProps

interface

MenubarItemPropsts

interface MenubarItemProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly menuValue: string;
  readonly item: MenubarActionable;
}

Name

Kind

Type

Requirement

asChild

property

boolean

optional

item

property

MenubarActionable

required

menuValue

property

string

required

Name: asChild
Kind: property
Type: boolean
Requirement: optional

Name: item
Kind: property
Type: MenubarActionable
Requirement: required

Name: menuValue
Kind: property
Type: string
Requirement: required

MenubarOpenChangeDetail

interface

MenubarOpenChangeDetailts

interface MenubarOpenChangeDetail {
  readonly value: string | null;
  readonly reason: MenubarChangeReason;
}

Name

Kind

Type

Requirement

reason

property

MenubarChangeReason

required

value

property

string | null

required

Name: reason
Kind: property
Type: MenubarChangeReason
Requirement: required

Name: value
Kind: property
Type: string | null
Requirement: required

MenubarRootProps

interface

MenubarRootPropsts

interface MenubarRootProps extends Omit<ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "dir" | "onSelect"> {
  readonly asChild?: boolean;
  readonly menus: MenubarInput["menus"];
  readonly value?: MenubarInput["value"];
  readonly defaultValue?: MenubarInput["defaultValue"];
  readonly dir?: "ltr" | "rtl";
  readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
  readonly onSelect?: UseMenubarOptions["onSelect"];
  readonly scheduler?: UseMenubarOptions["scheduler"];
  readonly children?: ReactNode;
}

Name

Kind

Type

Requirement

asChild

property

boolean

optional

children

property

ReactNode

optional

defaultValue

property

MenubarInput["defaultValue"]

optional

dir

property

"ltr" | "rtl"

optional

menus

property

MenubarInput["menus"]

required

onOpenChange

property

(detail: MenubarOpenChangeDetail) => void

optional

onSelect

property

UseMenubarOptions["onSelect"]

optional

scheduler

property

UseMenubarOptions["scheduler"]

optional

value

property

MenubarInput["value"]

optional

Name: asChild
Kind: property
Type: boolean
Requirement: optional

Name: children
Kind: property
Type: ReactNode
Requirement: optional

Name: defaultValue
Kind: property
Type: MenubarInput["defaultValue"]
Requirement: optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: menus
Kind: property
Type: MenubarInput["menus"]
Requirement: required

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail) => void
Requirement: optional

Name: onSelect
Kind: property
Type: UseMenubarOptions["onSelect"]
Requirement: optional

Name: scheduler
Kind: property
Type: UseMenubarOptions["scheduler"]
Requirement: optional

Name: value
Kind: property
Type: MenubarInput["value"]
Requirement: optional

MenubarSeparatorProps

interface

MenubarSeparatorPropsts

interface MenubarSeparatorProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly menuValue?: string;
}

Name

Kind

Type

Requirement

asChild

property

boolean

optional

menuValue

property

string

optional

Name: asChild
Kind: property
Type: boolean
Requirement: optional

Name: menuValue
Kind: property
Type: string
Requirement: optional

MenubarSubPartProps

interface

MenubarSubPartPropsts

interface MenubarSubPartProps extends ComponentPropsWithoutRef<"div"> {
  readonly asChild?: boolean;
  readonly itemKey?: string;
}

Name

Kind

Type

Requirement

asChild

property

boolean

optional

itemKey

property

string

optional

Name: asChild
Kind: property
Type: boolean
Requirement: optional

Name: itemKey
Kind: property
Type: string
Requirement: optional

MenubarTriggerProps

interface

MenubarTriggerPropsts

interface MenubarTriggerProps extends ComponentPropsWithoutRef<"button"> {
  readonly asChild?: boolean;
  readonly menu: MenubarMenu;
}

Name

Kind

Type

Requirement

asChild

property

boolean

optional

Name: asChild
Kind: property
Type: boolean
Requirement: optional

Name: menu
Kind: property
Type: MenubarMenu
Requirement: required

Root

value

Rootts

export declare const Root: import("react").ForwardRefExoticComponent<MenubarRootProps & import("react").RefAttributes<HTMLDivElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

Separator

value

Separatorts

export declare const Separator: import("react").ForwardRefExoticComponent<MenubarSeparatorProps & import("react").RefAttributes<HTMLDivElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

SubContent

value

SubContentts

export declare const SubContent: import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

SubTrigger

value

SubTriggerts

export declare const SubTrigger: import("react").ForwardRefExoticComponent<MenubarSubPartProps & import("react").RefAttributes<HTMLDivElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

Trigger

value

Triggerts

export declare const Trigger: import("react").ForwardRefExoticComponent<MenubarTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;

Name

Kind

Type

Requirement

props

parameter

P

required

return

return value

ReactNode

n/a

Name: props
Kind: parameter
Type: P
Requirement: required

Name: return
Kind: return value
Type: ReactNode
Requirement: n/a

useMenubar

function

useMenubarts

declare function useMenubar(input: MenubarInput, options?: UseMenubarOptions): UseMenubarResult;

Name

Kind

Type

Requirement

input

parameter

MenubarInput

required

options

parameter

UseMenubarOptions

optional

return

return value

UseMenubarResult

n/a

Name: input
Kind: parameter
Type: MenubarInput
Requirement: required

Name: options
Kind: parameter
Type: UseMenubarOptions
Requirement: optional

Name: return
Kind: return value
Type: UseMenubarResult
Requirement: n/a

useMenubarContext

function

useMenubarContextts

declare function useMenubarContext(partName: string): MenubarContextValue;

Name

Kind

Type

Requirement

partName

parameter

string

required

return

return value

MenubarContextValue

n/a

Name: partName
Kind: parameter
Type: string
Requirement: required

Name: return
Kind: return value
Type: MenubarContextValue
Requirement: n/a

UseMenubarOptions

interface

UseMenubarOptionsts

interface UseMenubarOptions {
  readonly dir?: "ltr" | "rtl";
  readonly onOpenChange?: (detail: MenubarOpenChangeDetail$1) => void;
  readonly onSelect?: (id: string, menuValue: string) => void;
  readonly scheduler?: Scheduler;
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

onOpenChange

property

(detail: MenubarOpenChangeDetail$1) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

scheduler

property

Scheduler

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail$1) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: scheduler
Kind: property
Type: Scheduler
Requirement: optional

UseMenubarResult

interface

UseMenubarResultts

interface UseMenubarResult {
  readonly service: MenubarService;
  readonly connector: MenubarApi;
  readonly scope: PartScope;
  readonly snapshot: MenubarSnapshot;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

snapshot

property

MenubarSnapshot

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: snapshot
Kind: property
Type: MenubarSnapshot
Requirement: required

@grassroot/ui-headless-vue/menubar

Vue adapter

14 exports

View source packages/ui-headless/vue/src/menubar/index.ts

Install npm i @grassroot/ui-headless-vue

MenubarContent

value

MenubarContentts

export declare const MenubarContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  value: {
    type: StringConstructor;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

MenubarContextKey

value

MenubarContextKeyts

export declare const MenubarContextKey: InjectionKey<MenubarContextValue>;

MenubarContextValue

interface

MenubarContextValuets

interface MenubarContextValue {
  readonly service: MenubarService;
  readonly connector: MenubarApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<MenubarSnapshot>;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

snapshot

property

ShallowRef<MenubarSnapshot>

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: snapshot
Kind: property
Type: ShallowRef<MenubarSnapshot>
Requirement: required

MenubarItem

value

MenubarItemts

export declare const MenubarItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menuValue: {
    type: StringConstructor;
    required: true;
  };
  item: {
    type: PropType<MenubarActionable>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menuValue: {
    type: StringConstructor;
    required: true;
  };
  item: {
    type: PropType<MenubarActionable>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

MenubarOpenChangeDetail

interface

MenubarOpenChangeDetailts

interface MenubarOpenChangeDetail {
  readonly value: string | null;
  readonly reason: MenubarChangeReason;
}

Name

Kind

Type

Requirement

reason

property

MenubarChangeReason

required

value

property

string | null

required

Name: reason
Kind: property
Type: MenubarChangeReason
Requirement: required

Name: value
Kind: property
Type: string | null
Requirement: required

MenubarRoot

value

MenubarRootts

export declare const MenubarRoot: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menus: {
    type: PropType<MenubarInput["menus"]>;
    required: true;
  };
  value: {
    type: PropType<string | null | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | null | undefined>;
    default: undefined;
  };
  dir: {
    type: PropType<"ltr" | "rtl" | undefined>;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  openChange: (_detail: MenubarOpenChangeDetail) => true;
  select: (_id: string, _menuValue: string) => true;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menus: {
    type: PropType<MenubarInput["menus"]>;
    required: true;
  };
  value: {
    type: PropType<string | null | undefined>;
    default: undefined;
  };
  defaultValue: {
    type: PropType<string | null | undefined>;
    default: undefined;
  };
  dir: {
    type: PropType<"ltr" | "rtl" | undefined>;
    default: undefined;
  };
}>> & Readonly<{
  onOpenChange?: ((_detail: MenubarOpenChangeDetail) => any) | undefined;
  onSelect?: ((_id: string, _menuValue: string) => any) | undefined;
}>, {
  asChild: boolean;
  value: string | null | undefined;
  defaultValue: string | null | undefined;
  dir: "ltr" | "rtl" | undefined;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

MenubarSeparator

value

MenubarSeparatorts

export declare const MenubarSeparator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menuValue: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menuValue: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  menuValue: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

MenubarSubContent

value

MenubarSubContentts

export declare const MenubarSubContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  itemKey: {
    type: StringConstructor;
    default: string;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  itemKey: {
    type: StringConstructor;
    default: string;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  itemKey: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

MenubarSubTrigger

value

MenubarSubTriggerts

export declare const MenubarSubTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  itemKey: {
    type: StringConstructor;
    default: string;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  itemKey: {
    type: StringConstructor;
    default: string;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
  itemKey: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

MenubarTrigger

value

MenubarTriggerts

export declare const MenubarTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menu: {
    type: PropType<MenubarMenu>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  asChild: {
    type: BooleanConstructor;
    default: boolean;
  };
  menu: {
    type: PropType<MenubarMenu>;
    required: true;
  };
}>> & Readonly<{}>, {
  asChild: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

useMenubar

function

useMenubarts

declare function useMenubar(input: MenubarInput | (() => MenubarInput), options?: UseMenubarOptions): UseMenubarResult;

Name

Kind

Type

Requirement

input

parameter

MenubarInput | (() => MenubarInput)

required

options

parameter

UseMenubarOptions

optional

return

return value

UseMenubarResult

n/a

Name: input
Kind: parameter
Type: MenubarInput | (() => MenubarInput)
Requirement: required

Name: options
Kind: parameter
Type: UseMenubarOptions
Requirement: optional

Name: return
Kind: return value
Type: UseMenubarResult
Requirement: n/a

useMenubarContext

function

useMenubarContextts

declare function useMenubarContext(partName: string): MenubarContextValue;

Name

Kind

Type

Requirement

partName

parameter

string

required

return

return value

MenubarContextValue

n/a

Name: partName
Kind: parameter
Type: string
Requirement: required

Name: return
Kind: return value
Type: MenubarContextValue
Requirement: n/a

UseMenubarOptions

interface

UseMenubarOptionsts

interface UseMenubarOptions {
  readonly dir?: "ltr" | "rtl";
  readonly onOpenChange?: (detail: MenubarOpenChangeDetail$1) => void;
  readonly onSelect?: (id: string, menuValue: string) => void;
  readonly scheduler?: Scheduler;
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

onOpenChange

property

(detail: MenubarOpenChangeDetail$1) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

scheduler

property

Scheduler

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail$1) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: scheduler
Kind: property
Type: Scheduler
Requirement: optional

UseMenubarResult

interface

UseMenubarResultts

interface UseMenubarResult {
  readonly service: MenubarService;
  readonly connector: MenubarApi;
  readonly scope: PartScope;
  readonly snapshot: ShallowRef<MenubarSnapshot>;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

snapshot

property

ShallowRef<MenubarSnapshot>

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: snapshot
Kind: property
Type: ShallowRef<MenubarSnapshot>
Requirement: required

@grassroot/ui-headless-angular/menubar

Angular adapter

13 exports

View source packages/ui-headless/angular/src/menubar/index.ts

Install npm i @grassroot/ui-headless-angular

createMenubarStore

function

createMenubarStorets

export declare function createMenubarStore(initialInput: MenubarInput, options?: CreateMenubarStoreOptions): MenubarStore;

Name

Kind

Type

Requirement

initialInput

parameter

MenubarInput

required

options

parameter

CreateMenubarStoreOptions

optional

return

return value

MenubarStore

n/a

Name: initialInput
Kind: parameter
Type: MenubarInput
Requirement: required

Name: options
Kind: parameter
Type: CreateMenubarStoreOptions
Requirement: optional

Name: return
Kind: return value
Type: MenubarStore
Requirement: n/a

CreateMenubarStoreOptions

interface

CreateMenubarStoreOptionsts

export interface CreateMenubarStoreOptions {
    readonly dir?: "ltr" | "rtl";
    readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
    readonly onSelect?: (id: string, menuValue: string) => void;
    readonly onCommit?: () => void;
    readonly scheduler?: Scheduler;
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

onCommit

property

() => void

optional

onOpenChange

property

(detail: MenubarOpenChangeDetail) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

scheduler

property

Scheduler

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: onCommit
Kind: property
Type: () => void
Requirement: optional

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: scheduler
Kind: property
Type: Scheduler
Requirement: optional

GR_MENUBAR_DECLARATIONS

value

GR_MENUBAR_DECLARATIONSts

export declare const GR_MENUBAR_DECLARATIONS: readonly [typeof GrMenubarRoot, typeof GrMenubarTrigger, typeof GrMenubarOpen, typeof GrMenubarContent, typeof GrMenubarItem, typeof GrMenubarSeparator, typeof GrMenubarSubTrigger, typeof GrMenubarSubContent];

GrMenubarContent

class

GrMenubarContentts

export declare class GrMenubarContent implements OnDestroy {
    readonly value: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private key;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarContent, "[grMenubarContent]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

element

property

any

required

key

property

any

required

listeners

property

any

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarContent, "[grMenubarContent]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarContent, never>

required

store

property

any

required

value

property

import("@angular/core").InputSignal<string>

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: key
Kind: property
Type: any
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarContent, "[grMenubarContent]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarContent, never>
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

Name: value
Kind: property
Type: import("@angular/core").InputSignal<string>
Requirement: required

GrMenubarItem

class

GrMenubarItemts

export declare class GrMenubarItem implements OnDestroy {
    readonly menuValue: import("@angular/core").InputSignal<string>;
    readonly item: import("@angular/core").InputSignal<MenubarActionable>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private key;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarItem, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarItem, "[grMenubarItem]", never, { "menuValue": { "alias": "menuValue"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

element

property

any

required

item

property

import("@angular/core").InputSignal<MenubarActionable>

required

key

property

any

required

listeners

property

any

required

menuValue

property

import("@angular/core").InputSignal<string>

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarItem, "[grMenubarItem]", never, { "menuValue": { "alias": "menuValue"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarItem, never>

required

store

property

any

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: item
Kind: property
Type: import("@angular/core").InputSignal<MenubarActionable>
Requirement: required

Name: key
Kind: property
Type: any
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: menuValue
Kind: property
Type: import("@angular/core").InputSignal<string>
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarItem, "[grMenubarItem]", never, { "menuValue": { "alias": "menuValue"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarItem, never>
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

GrMenubarOpen

class

GrMenubarOpents

export declare class GrMenubarOpen implements OnDestroy {
    private readonly store;
    private readonly template;
    private readonly view;
    private hasView;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarOpen, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarOpen, "[grMenubarOpen]", never, {}, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

hasView

property

any

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarOpen, "[grMenubarOpen]", never, {}, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarOpen, never>

required

store

property

any

required

template

property

any

required

view

property

any

required

Name: hasView
Kind: property
Type: any
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarOpen, "[grMenubarOpen]", never, {}, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarOpen, never>
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

Name: template
Kind: property
Type: any
Requirement: required

Name: view
Kind: property
Type: any
Requirement: required

GrMenubarRoot

class

GrMenubarRootts

export declare class GrMenubarRoot implements OnDestroy {
    readonly menus: import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/menubar").MenubarMenu[]>;
    readonly value: import("@angular/core").InputSignal<string | null | undefined>;
    readonly defaultValue: import("@angular/core").InputSignal<string | null | undefined>;
    readonly dir: import("@angular/core").InputSignal<"rtl" | "ltr" | undefined>;
    readonly openChange: import("@angular/core").OutputEmitterRef<MenubarOpenChangeDetail>;
    readonly select: import("@angular/core").OutputEmitterRef<{
        id: string;
        menuValue: string;
    }>;
    readonly store: MenubarStore;
    private lastInput;
    private release;
    private wasOpen;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarRoot, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarRoot, "[grMenubarRoot]", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; "select": "select"; }, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

defaultValue

property

import("@angular/core").InputSignal<string | null | undefined>

required

dir

property

import("@angular/core").InputSignal<"rtl" | "ltr" | undefined>

required

element

property

any

required

lastInput

property

any

required

listeners

property

any

required

menus

property

import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/menubar").MenubarMenu[]>

required

ngOnDestroy

method

() => void

required

openChange

property

import("@angular/core").OutputEmitterRef<MenubarOpenChangeDetail>

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarRoot, "[grMenubarRoot]", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; "select": "select"; }, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarRoot, never>

required

release

property

any

required

select

property

import("@angular/core").OutputEmitterRef<{
        id: string;
        menuValue: string;
    }>

required

store

property

MenubarStore

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: defaultValue
Kind: property
Type: import("@angular/core").InputSignal<string | null | undefined>
Requirement: required

Name: dir
Kind: property
Type: import("@angular/core").InputSignal<"rtl" | "ltr" | undefined>
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: lastInput
Kind: property
Type: any
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: menus
Kind: property
Type: import("@angular/core").InputSignal<readonly import("@grassroot/ui-machines/menubar").MenubarMenu[]>
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: openChange
Kind: property
Type: import("@angular/core").OutputEmitterRef<MenubarOpenChangeDetail>
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarRoot, "[grMenubarRoot]", never, { "menus": { "alias": "menus"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; "select": "select"; }, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarRoot, never>
Requirement: required

Name: release
Kind: property
Type: any
Requirement: required

Name: select
Kind: property
Type: import("@angular/core").OutputEmitterRef<{ id: string; menuValue: string; }>
Requirement: required

Name: store
Kind: property
Type: MenubarStore
Requirement: required

Name: value
Kind: property
Type: import("@angular/core").InputSignal<string | null | undefined>
Requirement: required

Name: wasOpen
Kind: property
Type: any
Requirement: required

GrMenubarSeparator

class

GrMenubarSeparatorts

export declare class GrMenubarSeparator implements OnDestroy {
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarSeparator, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarSeparator, "[grMenubarSeparator]", never, {}, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

element

property

any

required

listeners

property

any

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarSeparator, "[grMenubarSeparator]", never, {}, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarSeparator, never>

required

store

property

any

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarSeparator, "[grMenubarSeparator]", never, {}, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarSeparator, never>
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

GrMenubarSubContent

class

GrMenubarSubContentts

export declare class GrMenubarSubContent implements OnDestroy {
    readonly itemKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registeredKey;
    private registeredRef;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarSubContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarSubContent, "[grMenubarSubContent]", never, { "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

element

property

any

required

itemKey

property

import("@angular/core").InputSignal<string>

required

listeners

property

any

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarSubContent, "[grMenubarSubContent]", never, { "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarSubContent, never>

required

registeredKey

property

any

required

registeredRef

property

any

required

store

property

any

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: itemKey
Kind: property
Type: import("@angular/core").InputSignal<string>
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarSubContent, "[grMenubarSubContent]", never, { "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarSubContent, never>
Requirement: required

Name: registeredKey
Kind: property
Type: any
Requirement: required

Name: registeredRef
Kind: property
Type: any
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

GrMenubarSubTrigger

class

GrMenubarSubTriggerts

export declare class GrMenubarSubTrigger implements OnDestroy {
    readonly itemKey: import("@angular/core").InputSignal<string>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private registeredKey;
    private registeredRef;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarSubTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarSubTrigger, "[grMenubarSubTrigger]", never, { "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

element

property

any

required

itemKey

property

import("@angular/core").InputSignal<string>

required

listeners

property

any

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarSubTrigger, "[grMenubarSubTrigger]", never, { "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarSubTrigger, never>

required

registeredKey

property

any

required

registeredRef

property

any

required

store

property

any

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: itemKey
Kind: property
Type: import("@angular/core").InputSignal<string>
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarSubTrigger, "[grMenubarSubTrigger]", never, { "itemKey": { "alias": "itemKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarSubTrigger, never>
Requirement: required

Name: registeredKey
Kind: property
Type: any
Requirement: required

Name: registeredRef
Kind: property
Type: any
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

GrMenubarTrigger

class

GrMenubarTriggerts

export declare class GrMenubarTrigger implements OnDestroy {
    readonly menu: import("@angular/core").InputSignal<MenubarMenu>;
    private readonly store;
    private readonly element;
    private readonly listeners;
    private readonly consumer;
    private key;
    private pointerDown;
    private pointerTimer;
    private resetPointerTimer;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMenubarTrigger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GrMenubarTrigger, "[grMenubarTrigger]", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

Name

Kind

Type

Requirement

consumer

property

any

required

element

property

any

required

key

property

any

required

listeners

property

any

required

ngOnDestroy

method

() => void

required

ɵdir

property

i0.ɵɵDirectiveDeclaration<GrMenubarTrigger, "[grMenubarTrigger]", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>

required

ɵfac

property

i0.ɵɵFactoryDeclaration<GrMenubarTrigger, never>

required

pointerDown

property

any

required

pointerTimer

property

any

required

resetPointerTimer

property

any

required

store

property

any

required

Name: consumer
Kind: property
Type: any
Requirement: required

Name: element
Kind: property
Type: any
Requirement: required

Name: key
Kind: property
Type: any
Requirement: required

Name: listeners
Kind: property
Type: any
Requirement: required

Name: menu
Kind: property
Type: import("@angular/core").InputSignal<MenubarMenu>
Requirement: required

Name: ngOnDestroy
Kind: method
Type: () => void
Requirement: required

Name: ɵdir
Kind: property
Type: i0.ɵɵDirectiveDeclaration<GrMenubarTrigger, "[grMenubarTrigger]", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>
Requirement: required

Name: ɵfac
Kind: property
Type: i0.ɵɵFactoryDeclaration<GrMenubarTrigger, never>
Requirement: required

Name: pointerDown
Kind: property
Type: any
Requirement: required

Name: pointerTimer
Kind: property
Type: any
Requirement: required

Name: resetPointerTimer
Kind: property
Type: any
Requirement: required

Name: store
Kind: property
Type: any
Requirement: required

MENUBAR_STORE

value

MENUBAR_STOREts

export declare const MENUBAR_STORE: InjectionToken<MenubarStore>;

MenubarStore

interface

MenubarStorets

export interface MenubarStore {
    readonly service: MenubarService;
    readonly connector: MenubarApi;
    readonly scope: PartScope;
    readonly version: WritableSignal<number>;
    start(): void;
    stop(): void;
    sync(input: import("@grassroot/ui-machines/menubar").MenubarInput): void;
    setDir(dir: "ltr" | "rtl" | undefined): void;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

setDir

method

(dir: "ltr" | "rtl" | undefined) => void

required

start

method

() => void

required

stop

method

() => void

required

sync

method

(input: import("@grassroot/ui-machines/menubar").MenubarInput) => void

required

version

property

WritableSignal<number>

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: setDir
Kind: method
Type: (dir: "ltr" | "rtl" | undefined) => void
Requirement: required

Name: start
Kind: method
Type: () => void
Requirement: required

Name: stop
Kind: method
Type: () => void
Requirement: required

Name: sync
Kind: method
Type: (input: import("@grassroot/ui-machines/menubar").MenubarInput) => void
Requirement: required

Name: version
Kind: property
Type: WritableSignal<number>
Requirement: required

@grassroot/ui-headless-svelte/menubar

Svelte adapter

14 exports

View source packages/ui-headless/svelte/src/menubar/index.ts

Install npm i @grassroot/ui-headless-svelte

createMenubar

function

createMenubarts

export declare function createMenubar(inputGetter: () => MenubarInput, options?: UseMenubarOptions): UseMenubarResult;

Name

Kind

Type

Requirement

inputGetter

parameter

() => MenubarInput

required

options

parameter

UseMenubarOptions

optional

return

return value

UseMenubarResult

n/a

Name: inputGetter
Kind: parameter
Type: () => MenubarInput
Requirement: required

Name: options
Kind: parameter
Type: UseMenubarOptions
Requirement: optional

Name: return
Kind: return value
Type: UseMenubarResult
Requirement: n/a

MenubarContent

value

MenubarContentts

export declare const MenubarContent: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

MenubarContextValue

interface

MenubarContextValuets

export interface MenubarContextValue {
    readonly service: MenubarService;
    readonly connector: MenubarApi;
    readonly scope: PartScope;
    readonly version: () => number;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

version

property

() => number

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: version
Kind: property
Type: () => number
Requirement: required

MenubarItem

value

MenubarItemts

export declare const MenubarItem: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

MenubarOpenChangeDetail

interface

MenubarOpenChangeDetailts

interface MenubarOpenChangeDetail {
  readonly value: string | null;
  readonly reason: MenubarChangeReason;
}

Name

Kind

Type

Requirement

reason

property

MenubarChangeReason

required

value

property

string | null

required

Name: reason
Kind: property
Type: MenubarChangeReason
Requirement: required

Name: value
Kind: property
Type: string | null
Requirement: required

MenubarRoot

value

MenubarRootts

export declare const MenubarRoot: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

MenubarSeparator

value

MenubarSeparatorts

export declare const MenubarSeparator: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

MenubarSubContent

value

MenubarSubContentts

export declare const MenubarSubContent: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

MenubarSubTrigger

value

MenubarSubTriggerts

export declare const MenubarSubTrigger: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

MenubarTrigger

value

MenubarTriggerts

export declare const MenubarTrigger: LegacyComponentType;

Name

Kind

Type

Requirement

args

parameter

Parameters<Component<Record<string, any>>>

optional

return

return value

ReturnType<Component<Record<string, any>, Record<string, any>>>

n/a

Name: args
Kind: parameter
Type: Parameters<Component<Record<string, any>>>
Requirement: optional

Name: return
Kind: return value
Type: ReturnType<Component<Record<string, any>, Record<string, any>>>
Requirement: n/a

provideMenubarContext

function

provideMenubarContextts

export declare function provideMenubarContext(value: MenubarContextValue): void;

Name

Kind

Type

Requirement

value

parameter

MenubarContextValue

required

return

return value

void

n/a

Name: value
Kind: parameter
Type: MenubarContextValue
Requirement: required

Name: return
Kind: return value
Type: void
Requirement: n/a

useMenubarContext

function

useMenubarContextts

export declare function useMenubarContext(partName: string): MenubarContextValue;

Name

Kind

Type

Requirement

partName

parameter

string

required

return

return value

MenubarContextValue

n/a

Name: partName
Kind: parameter
Type: string
Requirement: required

Name: return
Kind: return value
Type: MenubarContextValue
Requirement: n/a

UseMenubarOptions

interface

UseMenubarOptionsts

export interface UseMenubarOptions {
    readonly dir?: "ltr" | "rtl";
    readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
    readonly onSelect?: (id: string, menuValue: string) => void;
    readonly scheduler?: Scheduler;
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

onOpenChange

property

(detail: MenubarOpenChangeDetail) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

scheduler

property

Scheduler

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: scheduler
Kind: property
Type: Scheduler
Requirement: optional

UseMenubarResult

interface

UseMenubarResultts

export interface UseMenubarResult {
    readonly service: MenubarService;
    readonly connector: MenubarApi;
    readonly scope: PartScope;
    readonly version: () => number;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

version

property

() => number

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: version
Kind: property
Type: () => number
Requirement: required

@grassroot/ui-headless-solid/menubar

Solid adapter

21 exports

View source packages/ui-headless/solid/src/menubar/index.ts

Install npm i @grassroot/ui-headless-solid

MenubarContent

function

MenubarContentts

export declare function MenubarContent(props: MenubarContentProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarContentProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarContentProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarContentProps

interface

MenubarContentPropsts

export interface MenubarContentProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
    readonly value: string;
}

Name

Kind

Type

Requirement

as

property

AsProp

optional

value

property

string

required

Name: as
Kind: property
Type: AsProp
Requirement: optional

Name: value
Kind: property
Type: string
Requirement: required

MenubarContext

value

MenubarContextts

export declare const MenubarContext: import("solid-js").Context<MenubarContextValue | undefined>;

MenubarContextProvider

function

MenubarContextProviderts

export declare function MenubarContextProvider(props: {
    value: MenubarContextValue;
    children: JSX.Element;
}): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

{
    value: MenubarContextValue;
    children: JSX.Element;
}

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: { value: MenubarContextValue; children: JSX.Element; }
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarContextValue

interface

MenubarContextValuets

export interface MenubarContextValue {
    readonly service: MenubarService;
    readonly connector: MenubarApi;
    readonly scope: PartScope;
    readonly snapshot: Accessor<MenubarSnapshot>;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

snapshot

property

Accessor<MenubarSnapshot>

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: snapshot
Kind: property
Type: Accessor<MenubarSnapshot>
Requirement: required

MenubarItem

function

MenubarItemts

export declare function MenubarItem(props: MenubarItemProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarItemProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarItemProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarItemProps

interface

MenubarItemPropsts

export interface MenubarItemProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
    readonly menuValue: string;
    readonly item: MenubarActionable;
}

Name

Kind

Type

Requirement

as

property

AsProp

optional

item

property

MenubarActionable

required

menuValue

property

string

required

Name: as
Kind: property
Type: AsProp
Requirement: optional

Name: item
Kind: property
Type: MenubarActionable
Requirement: required

Name: menuValue
Kind: property
Type: string
Requirement: required

MenubarOpenChangeDetail

interface

MenubarOpenChangeDetailts

interface MenubarOpenChangeDetail {
  readonly value: string | null;
  readonly reason: MenubarChangeReason;
}

Name

Kind

Type

Requirement

reason

property

MenubarChangeReason

required

value

property

string | null

required

Name: reason
Kind: property
Type: MenubarChangeReason
Requirement: required

Name: value
Kind: property
Type: string | null
Requirement: required

MenubarRoot

function

MenubarRootts

export declare function MenubarRoot(props: MenubarRootProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarRootProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarRootProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarRootProps

interface

MenubarRootPropsts

export interface MenubarRootProps extends Omit<JSX.HTMLAttributes<HTMLDivElement>, "onSelect"> {
    readonly as?: AsProp;
    readonly menus: MenubarInput["menus"];
    readonly value?: MenubarInput["value"];
    readonly defaultValue?: MenubarInput["defaultValue"];
    readonly dir?: "ltr" | "rtl";
    readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
    readonly onSelect?: (id: string, menuValue: string) => void;
}

Name

Kind

Type

Requirement

as

property

AsProp

optional

defaultValue

property

MenubarInput["defaultValue"]

optional

dir

property

"ltr" | "rtl"

optional

menus

property

MenubarInput["menus"]

required

onOpenChange

property

(detail: MenubarOpenChangeDetail) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

value

property

MenubarInput["value"]

optional

Name: as
Kind: property
Type: AsProp
Requirement: optional

Name: defaultValue
Kind: property
Type: MenubarInput["defaultValue"]
Requirement: optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: menus
Kind: property
Type: MenubarInput["menus"]
Requirement: required

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: value
Kind: property
Type: MenubarInput["value"]
Requirement: optional

MenubarSeparator

function

MenubarSeparatorts

export declare function MenubarSeparator(props: MenubarSeparatorProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarSeparatorProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarSeparatorProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarSeparatorProps

interface

MenubarSeparatorPropsts

export interface MenubarSeparatorProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
    readonly menuValue?: string;
}

Name

Kind

Type

Requirement

as

property

AsProp

optional

menuValue

property

string

optional

Name: as
Kind: property
Type: AsProp
Requirement: optional

Name: menuValue
Kind: property
Type: string
Requirement: optional

MenubarSubContent

function

MenubarSubContentts

export declare function MenubarSubContent(props: MenubarSubPartProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarSubPartProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarSubPartProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarSubPartProps

interface

MenubarSubPartPropsts

export interface MenubarSubPartProps extends JSX.HTMLAttributes<HTMLDivElement> {
    readonly as?: AsProp;
    readonly itemKey?: string;
}

Name

Kind

Type

Requirement

as

property

AsProp

optional

itemKey

property

string

optional

Name: as
Kind: property
Type: AsProp
Requirement: optional

Name: itemKey
Kind: property
Type: string
Requirement: optional

MenubarSubTrigger

function

MenubarSubTriggerts

export declare function MenubarSubTrigger(props: MenubarSubPartProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarSubPartProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarSubPartProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarTrigger

function

MenubarTriggerts

export declare function MenubarTrigger(props: MenubarTriggerProps): JSX.Element;

Name

Kind

Type

Requirement

props

parameter

MenubarTriggerProps

required

return

return value

JSX.Element

n/a

Name: props
Kind: parameter
Type: MenubarTriggerProps
Requirement: required

Name: return
Kind: return value
Type: JSX.Element
Requirement: n/a

MenubarTriggerProps

interface

MenubarTriggerPropsts

export interface MenubarTriggerProps extends JSX.ButtonHTMLAttributes<HTMLButtonElement> {
    readonly as?: AsProp;
    readonly menu: MenubarMenu;
}

Name

Kind

Type

Requirement

as

property

AsProp

optional

Name: as
Kind: property
Type: AsProp
Requirement: optional

Name: menu
Kind: property
Type: MenubarMenu
Requirement: required

useMenubar

function

useMenubarts

export declare function useMenubar(input: () => MenubarInput, options?: UseMenubarOptions): UseMenubarResult;

Name

Kind

Type

Requirement

input

parameter

() => MenubarInput

required

options

parameter

UseMenubarOptions

optional

return

return value

UseMenubarResult

n/a

Name: input
Kind: parameter
Type: () => MenubarInput
Requirement: required

Name: options
Kind: parameter
Type: UseMenubarOptions
Requirement: optional

Name: return
Kind: return value
Type: UseMenubarResult
Requirement: n/a

useMenubarContext

function

useMenubarContextts

export declare function useMenubarContext(partName: string): MenubarContextValue;

Name

Kind

Type

Requirement

partName

parameter

string

required

return

return value

MenubarContextValue

n/a

Name: partName
Kind: parameter
Type: string
Requirement: required

Name: return
Kind: return value
Type: MenubarContextValue
Requirement: n/a

UseMenubarOptions

interface

UseMenubarOptionsts

export interface UseMenubarOptions {
    readonly dir?: "ltr" | "rtl";
    readonly onOpenChange?: (detail: MenubarOpenChangeDetail) => void;
    readonly onSelect?: (id: string, menuValue: string) => void;
    readonly scheduler?: Scheduler;
}

Name

Kind

Type

Requirement

dir

property

"ltr" | "rtl"

optional

onOpenChange

property

(detail: MenubarOpenChangeDetail) => void

optional

onSelect

property

(id: string, menuValue: string) => void

optional

scheduler

property

Scheduler

optional

Name: dir
Kind: property
Type: "ltr" | "rtl"
Requirement: optional

Name: onOpenChange
Kind: property
Type: (detail: MenubarOpenChangeDetail) => void
Requirement: optional

Name: onSelect
Kind: property
Type: (id: string, menuValue: string) => void
Requirement: optional

Name: scheduler
Kind: property
Type: Scheduler
Requirement: optional

UseMenubarResult

interface

UseMenubarResultts

export interface UseMenubarResult {
    readonly service: MenubarService;
    readonly connector: MenubarApi;
    readonly scope: PartScope;
    readonly snapshot: () => MenubarSnapshot;
}

Name

Kind

Type

Requirement

connector

property

MenubarApi

required

scope

property

PartScope

required

service

property

MenubarService

required

snapshot

property

() => MenubarSnapshot

required

Name: connector
Kind: property
Type: MenubarApi
Requirement: required

Name: scope
Kind: property
Type: PartScope
Requirement: required

Name: service
Kind: property
Type: MenubarService
Requirement: required

Name: snapshot
Kind: property
Type: () => MenubarSnapshot
Requirement: required

Framework adapters

React imports

Vue imports

Angular imports

Svelte imports

Solid imports

Related references