@zag-js/menubar 2.0.0-next.1

package/dist/menubar.machine.js

@@ -0,0 +1,253 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/menubar.machine.ts
+var menubar_machine_exports = {};
+__export(menubar_machine_exports, {
+  machine: () => machine
+});
+module.exports = __toCommonJS(menubar_machine_exports);
+var import_core = require("@zag-js/core");
+var import_dom_query = require("@zag-js/dom-query");
+var dom = __toESM(require("./menubar.dom.js"));
+var machine = (0, import_core.createMachine)({
+  props({ props }) {
+    return {
+      orientation: "horizontal",
+      loopFocus: true,
+      ...props
+    };
+  },
+  initialState() {
+    return "idle";
+  },
+  context({ bindable }) {
+    return {
+      activeId: bindable(() => ({ defaultValue: null })),
+      hasOpenMenu: bindable(() => ({ defaultValue: false }))
+    };
+  },
+  refs() {
+    return {
+      typeaheadState: { ...import_dom_query.getByTypeahead.defaultOptions }
+    };
+  },
+  // Always-on: keep the active trigger valid as triggers mount/change, and listen for the
+  // menu coordination events dispatched on the root element.
+  effects: ["trackTriggers", "trackMenuEvents"],
+  on: {
+    "TRIGGER.FOCUS": {
+      actions: ["setActiveId"]
+    },
+    TYPEAHEAD: {
+      actions: ["focusMatchingTrigger"]
+    }
+  },
+  states: {
+    idle: {
+      on: {
+        "TRIGGER.FOCUS_IN": {
+          target: "focused",
+          actions: ["setActiveId"]
+        },
+        "MENU.OPEN": {
+          target: "open",
+          actions: ["setHasOpenMenu"]
+        }
+      }
+    },
+    focused: {
+      on: {
+        "ROOT.BLUR": {
+          target: "idle"
+        },
+        "TRIGGER.FOCUS_NEXT": {
+          actions: ["focusNextTrigger"]
+        },
+        "TRIGGER.FOCUS_PREV": {
+          actions: ["focusPrevTrigger"]
+        },
+        "TRIGGER.FOCUS_FIRST": {
+          actions: ["focusFirstTrigger"]
+        },
+        "TRIGGER.FOCUS_LAST": {
+          actions: ["focusLastTrigger"]
+        },
+        "MENU.OPEN": {
+          target: "open",
+          actions: ["setHasOpenMenu"]
+        }
+      }
+    },
+    open: {
+      on: {
+        // Arrow-switch to the sibling menu (move + request open).
+        "TRIGGER.FOCUS_NEXT": {
+          actions: ["switchToNextMenu"]
+        },
+        "TRIGGER.FOCUS_PREV": {
+          actions: ["switchToPrevMenu"]
+        },
+        // Another menu opened (sibling switch) — stay open.
+        "MENU.OPEN": {
+          actions: ["setHasOpenMenu"]
+        },
+        "MENU.CLOSE": [
+          {
+            // Transient close: another menu is about to open. Keep `hasOpenMenu` active
+            // so it doesn't flicker while switching siblings.
+            guard: "isTransientClose"
+          },
+          {
+            target: "focused",
+            actions: ["clearHasOpenMenu"]
+          }
+        ]
+        // No ROOT.BLUR: focus lives in the open menu's portalled content. The menu drives
+        // close transitions via `menu:close`.
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isTransientClose: ({ event }) => event.reason === "sibling-open" || event.reason === "list-navigation"
+    },
+    effects: {
+      // Reconcile activeId as triggers mount/unmount. Triggers render `role=menuitem`
+      // synchronously (the menu is told it's in a menubar via props), so childList is enough.
+      trackTriggers({ scope, context }) {
+        const rootEl = dom.getRootEl(scope);
+        if (!rootEl) return;
+        const reconcile = () => reconcileActiveId(context, scope);
+        (0, import_dom_query.raf)(reconcile);
+        return (0, import_dom_query.observeChildren)(rootEl, { callback: reconcile });
+      },
+      trackMenuEvents({ scope, send }) {
+        const rootEl = dom.getRootEl(scope);
+        if (!rootEl) return;
+        const onFocusIn = (event) => {
+          const target = event.target;
+          if (!dom.isTriggerEl(target)) return;
+          send({ type: "TRIGGER.FOCUS_IN", id: target.id });
+          send({ type: "TRIGGER.FOCUS", id: target.id });
+        };
+        const onFocusOut = (event) => {
+          const related = event.relatedTarget;
+          if (related && rootEl.contains(related)) return;
+          send({ type: "ROOT.BLUR" });
+        };
+        const cleanups = [
+          (0, import_dom_query.addDomEvent)(rootEl, "menu:open", (event) => {
+            send({ type: "MENU.OPEN", id: event.detail?.menuId, triggerId: event.detail?.triggerId });
+          }),
+          (0, import_dom_query.addDomEvent)(rootEl, "menu:close", (event) => {
+            send({ type: "MENU.CLOSE", id: event.detail?.menuId, reason: event.detail?.reason });
+          }),
+          (0, import_dom_query.addDomEvent)(rootEl, "menu:focus-next", () => send({ type: "TRIGGER.FOCUS_NEXT" })),
+          (0, import_dom_query.addDomEvent)(rootEl, "menu:focus-prev", () => send({ type: "TRIGGER.FOCUS_PREV" })),
+          (0, import_dom_query.addDomEvent)(rootEl, "focusin", onFocusIn),
+          (0, import_dom_query.addDomEvent)(rootEl, "focusout", onFocusOut)
+        ];
+        return () => {
+          cleanups.forEach((fn) => fn());
+        };
+      }
+    },
+    actions: {
+      setActiveId({ context, event }) {
+        if (event.id == null) return;
+        context.set("activeId", event.id);
+      },
+      setHasOpenMenu({ context, event }) {
+        context.set("hasOpenMenu", true);
+        if (event.triggerId) {
+          context.set("activeId", event.triggerId);
+        }
+      },
+      clearHasOpenMenu({ context }) {
+        context.set("hasOpenMenu", false);
+      },
+      focusNextTrigger({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const nextEl = activeId ? dom.getNextTriggerEl(scope, activeId, prop("loopFocus")) : dom.getFirstTriggerEl(scope);
+        focusTrigger(context, scope, nextEl);
+      },
+      focusPrevTrigger({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const prevEl = activeId ? dom.getPrevTriggerEl(scope, activeId, prop("loopFocus")) : dom.getLastTriggerEl(scope);
+        focusTrigger(context, scope, prevEl);
+      },
+      focusMatchingTrigger({ context, scope, event, refs }) {
+        const matched = (0, import_dom_query.getByTypeahead)(dom.getTriggerEls(scope), {
+          state: refs.get("typeaheadState"),
+          key: event.key,
+          activeId: context.get("activeId")
+        });
+        focusTrigger(context, scope, matched);
+      },
+      focusFirstTrigger({ context, scope }) {
+        focusTrigger(context, scope, dom.getFirstTriggerEl(scope));
+      },
+      focusLastTrigger({ context, scope }) {
+        focusTrigger(context, scope, dom.getLastTriggerEl(scope));
+      },
+      switchToNextMenu({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const nextEl = activeId ? dom.getNextTriggerEl(scope, activeId, prop("loopFocus")) : dom.getFirstTriggerEl(scope);
+        if (!nextEl) return;
+        setActiveTrigger(context, nextEl.id);
+        dom.requestOpenMenu(scope, nextEl.id);
+      },
+      switchToPrevMenu({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const prevEl = activeId ? dom.getPrevTriggerEl(scope, activeId, prop("loopFocus")) : dom.getLastTriggerEl(scope);
+        if (!prevEl) return;
+        setActiveTrigger(context, prevEl.id);
+        dom.requestOpenMenu(scope, prevEl.id);
+      }
+    }
+  }
+});
+function reconcileActiveId(context, scope) {
+  const activeId = context.get("activeId");
+  const nextActiveId = dom.getValidActiveId(scope, activeId);
+  if (nextActiveId !== activeId) context.set("activeId", nextActiveId);
+}
+function setActiveTrigger(context, id) {
+  context.set("activeId", id);
+}
+function focusTrigger(context, scope, el) {
+  if (!el) return;
+  setActiveTrigger(context, el.id);
+  (0, import_dom_query.raf)(() => el.focus());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  machine
+});

package/dist/menubar.machine.mjs

@@ -0,0 +1,218 @@
+// src/menubar.machine.ts
+import { createMachine } from "@zag-js/core";
+import { addDomEvent, getByTypeahead, observeChildren, raf } from "@zag-js/dom-query";
+import * as dom from "./menubar.dom.mjs";
+var machine = createMachine({
+  props({ props }) {
+    return {
+      orientation: "horizontal",
+      loopFocus: true,
+      ...props
+    };
+  },
+  initialState() {
+    return "idle";
+  },
+  context({ bindable }) {
+    return {
+      activeId: bindable(() => ({ defaultValue: null })),
+      hasOpenMenu: bindable(() => ({ defaultValue: false }))
+    };
+  },
+  refs() {
+    return {
+      typeaheadState: { ...getByTypeahead.defaultOptions }
+    };
+  },
+  // Always-on: keep the active trigger valid as triggers mount/change, and listen for the
+  // menu coordination events dispatched on the root element.
+  effects: ["trackTriggers", "trackMenuEvents"],
+  on: {
+    "TRIGGER.FOCUS": {
+      actions: ["setActiveId"]
+    },
+    TYPEAHEAD: {
+      actions: ["focusMatchingTrigger"]
+    }
+  },
+  states: {
+    idle: {
+      on: {
+        "TRIGGER.FOCUS_IN": {
+          target: "focused",
+          actions: ["setActiveId"]
+        },
+        "MENU.OPEN": {
+          target: "open",
+          actions: ["setHasOpenMenu"]
+        }
+      }
+    },
+    focused: {
+      on: {
+        "ROOT.BLUR": {
+          target: "idle"
+        },
+        "TRIGGER.FOCUS_NEXT": {
+          actions: ["focusNextTrigger"]
+        },
+        "TRIGGER.FOCUS_PREV": {
+          actions: ["focusPrevTrigger"]
+        },
+        "TRIGGER.FOCUS_FIRST": {
+          actions: ["focusFirstTrigger"]
+        },
+        "TRIGGER.FOCUS_LAST": {
+          actions: ["focusLastTrigger"]
+        },
+        "MENU.OPEN": {
+          target: "open",
+          actions: ["setHasOpenMenu"]
+        }
+      }
+    },
+    open: {
+      on: {
+        // Arrow-switch to the sibling menu (move + request open).
+        "TRIGGER.FOCUS_NEXT": {
+          actions: ["switchToNextMenu"]
+        },
+        "TRIGGER.FOCUS_PREV": {
+          actions: ["switchToPrevMenu"]
+        },
+        // Another menu opened (sibling switch) — stay open.
+        "MENU.OPEN": {
+          actions: ["setHasOpenMenu"]
+        },
+        "MENU.CLOSE": [
+          {
+            // Transient close: another menu is about to open. Keep `hasOpenMenu` active
+            // so it doesn't flicker while switching siblings.
+            guard: "isTransientClose"
+          },
+          {
+            target: "focused",
+            actions: ["clearHasOpenMenu"]
+          }
+        ]
+        // No ROOT.BLUR: focus lives in the open menu's portalled content. The menu drives
+        // close transitions via `menu:close`.
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      isTransientClose: ({ event }) => event.reason === "sibling-open" || event.reason === "list-navigation"
+    },
+    effects: {
+      // Reconcile activeId as triggers mount/unmount. Triggers render `role=menuitem`
+      // synchronously (the menu is told it's in a menubar via props), so childList is enough.
+      trackTriggers({ scope, context }) {
+        const rootEl = dom.getRootEl(scope);
+        if (!rootEl) return;
+        const reconcile = () => reconcileActiveId(context, scope);
+        raf(reconcile);
+        return observeChildren(rootEl, { callback: reconcile });
+      },
+      trackMenuEvents({ scope, send }) {
+        const rootEl = dom.getRootEl(scope);
+        if (!rootEl) return;
+        const onFocusIn = (event) => {
+          const target = event.target;
+          if (!dom.isTriggerEl(target)) return;
+          send({ type: "TRIGGER.FOCUS_IN", id: target.id });
+          send({ type: "TRIGGER.FOCUS", id: target.id });
+        };
+        const onFocusOut = (event) => {
+          const related = event.relatedTarget;
+          if (related && rootEl.contains(related)) return;
+          send({ type: "ROOT.BLUR" });
+        };
+        const cleanups = [
+          addDomEvent(rootEl, "menu:open", (event) => {
+            send({ type: "MENU.OPEN", id: event.detail?.menuId, triggerId: event.detail?.triggerId });
+          }),
+          addDomEvent(rootEl, "menu:close", (event) => {
+            send({ type: "MENU.CLOSE", id: event.detail?.menuId, reason: event.detail?.reason });
+          }),
+          addDomEvent(rootEl, "menu:focus-next", () => send({ type: "TRIGGER.FOCUS_NEXT" })),
+          addDomEvent(rootEl, "menu:focus-prev", () => send({ type: "TRIGGER.FOCUS_PREV" })),
+          addDomEvent(rootEl, "focusin", onFocusIn),
+          addDomEvent(rootEl, "focusout", onFocusOut)
+        ];
+        return () => {
+          cleanups.forEach((fn) => fn());
+        };
+      }
+    },
+    actions: {
+      setActiveId({ context, event }) {
+        if (event.id == null) return;
+        context.set("activeId", event.id);
+      },
+      setHasOpenMenu({ context, event }) {
+        context.set("hasOpenMenu", true);
+        if (event.triggerId) {
+          context.set("activeId", event.triggerId);
+        }
+      },
+      clearHasOpenMenu({ context }) {
+        context.set("hasOpenMenu", false);
+      },
+      focusNextTrigger({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const nextEl = activeId ? dom.getNextTriggerEl(scope, activeId, prop("loopFocus")) : dom.getFirstTriggerEl(scope);
+        focusTrigger(context, scope, nextEl);
+      },
+      focusPrevTrigger({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const prevEl = activeId ? dom.getPrevTriggerEl(scope, activeId, prop("loopFocus")) : dom.getLastTriggerEl(scope);
+        focusTrigger(context, scope, prevEl);
+      },
+      focusMatchingTrigger({ context, scope, event, refs }) {
+        const matched = getByTypeahead(dom.getTriggerEls(scope), {
+          state: refs.get("typeaheadState"),
+          key: event.key,
+          activeId: context.get("activeId")
+        });
+        focusTrigger(context, scope, matched);
+      },
+      focusFirstTrigger({ context, scope }) {
+        focusTrigger(context, scope, dom.getFirstTriggerEl(scope));
+      },
+      focusLastTrigger({ context, scope }) {
+        focusTrigger(context, scope, dom.getLastTriggerEl(scope));
+      },
+      switchToNextMenu({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const nextEl = activeId ? dom.getNextTriggerEl(scope, activeId, prop("loopFocus")) : dom.getFirstTriggerEl(scope);
+        if (!nextEl) return;
+        setActiveTrigger(context, nextEl.id);
+        dom.requestOpenMenu(scope, nextEl.id);
+      },
+      switchToPrevMenu({ context, scope, prop }) {
+        const activeId = context.get("activeId");
+        const prevEl = activeId ? dom.getPrevTriggerEl(scope, activeId, prop("loopFocus")) : dom.getLastTriggerEl(scope);
+        if (!prevEl) return;
+        setActiveTrigger(context, prevEl.id);
+        dom.requestOpenMenu(scope, prevEl.id);
+      }
+    }
+  }
+});
+function reconcileActiveId(context, scope) {
+  const activeId = context.get("activeId");
+  const nextActiveId = dom.getValidActiveId(scope, activeId);
+  if (nextActiveId !== activeId) context.set("activeId", nextActiveId);
+}
+function setActiveTrigger(context, id) {
+  context.set("activeId", id);
+}
+function focusTrigger(context, scope, el) {
+  if (!el) return;
+  setActiveTrigger(context, el.id);
+  raf(() => el.focus());
+}
+export {
+  machine
+};

package/dist/menubar.props.d.mts

@@ -0,0 +1,9 @@
+import { MenubarProps } from './menubar.types.mjs';
+import '@zag-js/core';
+import '@zag-js/dom-query';
+import '@zag-js/types';
+
+declare const props: (keyof MenubarProps)[];
+declare const splitProps: <Props extends Partial<MenubarProps>>(props: Props) => [Partial<MenubarProps>, Omit<Props, keyof MenubarProps>];
+
+export { props, splitProps };

package/dist/menubar.props.d.ts

@@ -0,0 +1,9 @@
+import { MenubarProps } from './menubar.types.js';
+import '@zag-js/core';
+import '@zag-js/dom-query';
+import '@zag-js/types';
+
+declare const props: (keyof MenubarProps)[];
+declare const splitProps: <Props extends Partial<MenubarProps>>(props: Props) => [Partial<MenubarProps>, Omit<Props, keyof MenubarProps>];
+
+export { props, splitProps };

package/dist/menubar.props.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/menubar.props.ts
+var menubar_props_exports = {};
+__export(menubar_props_exports, {
+  props: () => props,
+  splitProps: () => splitProps
+});
+module.exports = __toCommonJS(menubar_props_exports);
+var import_types = require("@zag-js/types");
+var import_utils = require("@zag-js/utils");
+var props = (0, import_types.createProps)()([
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "loopFocus",
+  "orientation"
+]);
+var splitProps = (0, import_utils.createSplitProps)(props);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  props,
+  splitProps
+});

package/dist/menubar.props.mjs

@@ -0,0 +1,17 @@
+// src/menubar.props.ts
+import { createProps } from "@zag-js/types";
+import { createSplitProps } from "@zag-js/utils";
+var props = createProps()([
+  "dir",
+  "disabled",
+  "getRootNode",
+  "id",
+  "ids",
+  "loopFocus",
+  "orientation"
+]);
+var splitProps = createSplitProps(props);
+export {
+  props,
+  splitProps
+};

package/dist/menubar.types.d.mts

@@ -0,0 +1,106 @@
+import { Machine, EventObject, Service } from '@zag-js/core';
+import { TypeaheadState } from '@zag-js/dom-query';
+import { PropTypes, Orientation, RequiredBy, DirectionProperty, CommonProperties } from '@zag-js/types';
+export { Orientation } from '@zag-js/types';
+
+/**
+ * The reason a menu within the menubar closed. Used to decide whether the menubar
+ * should keep `hasOpenMenu` active (another menu is about to open) or reset it.
+ */
+type MenuCloseReason = "escape" | "click-outside" | "sibling-open" | "item-select" | "list-navigation";
+/**
+ * The custom DOM events menus dispatch on the menubar element to coordinate.
+ * Coordination is intentionally DOM-based — no imports between the menu and menubar packages.
+ */
+interface MenubarEventMap {
+    "menu:open": CustomEvent<{
+        menuId: string;
+    }>;
+    "menu:close": CustomEvent<{
+        menuId: string;
+        reason: MenuCloseReason;
+    }>;
+    "menu:focus-next": CustomEvent<void>;
+    "menu:focus-prev": CustomEvent<void>;
+}
+type ElementIds = Partial<{
+    root: string;
+}>;
+interface MenubarProps extends DirectionProperty, CommonProperties {
+    /**
+     * The ids of the elements in the menubar. Useful for composition.
+     */
+    ids?: ElementIds | undefined;
+    /**
+     * The orientation of the menubar.
+     * @default "horizontal"
+     */
+    orientation?: Orientation | undefined;
+    /**
+     * Whether to loop the keyboard navigation across the triggers.
+     * @default true
+     */
+    loopFocus?: boolean | undefined;
+    /**
+     * Whether the menubar (and all its menu triggers) is disabled.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+}
+type PropsWithDefault = "orientation" | "loopFocus";
+interface MenubarContext {
+    /**
+     * The id of the currently focused/tabbable trigger (roving tabindex).
+     */
+    activeId: string | null;
+    /**
+     * Whether any menu within the menubar is currently open.
+     */
+    hasOpenMenu: boolean;
+}
+interface MenubarSchema {
+    props: RequiredBy<MenubarProps, PropsWithDefault>;
+    context: MenubarContext;
+    refs: {
+        typeaheadState: TypeaheadState;
+    };
+    state: "idle" | "focused" | "open";
+    event: EventObject;
+    action: string;
+    effect: string;
+    guard: string;
+}
+type MenubarService = Service<MenubarSchema>;
+type MenubarMachine = Machine<MenubarSchema>;
+/**
+ * Config to pass to a child menu's `menubar` prop so it behaves as a menubar menu.
+ * Structurally matches the `MenubarContext` type from `@zag-js/menu`.
+ */
+interface MenubarMenuContext {
+    rootId: string;
+    disabled: boolean;
+    orientation: Orientation;
+    activeId: string | null;
+}
+interface MenubarApi<T extends PropTypes = PropTypes> {
+    /**
+     * Whether any menu within the menubar is open.
+     */
+    hasOpenMenu: boolean;
+    /**
+     * The orientation of the menubar.
+     */
+    orientation: Orientation;
+    /**
+     * Whether the menubar is disabled.
+     */
+    disabled: boolean;
+    getRootProps: () => T["element"];
+    /**
+     * Returns the config to pass to each top-level menu's `menubar` prop. Adapters
+     * usually expose this via a context so nested `<Menu>`s can read it.
+     */
+    getMenuContext: () => MenubarMenuContext;
+}
+
+export type { ElementIds, MenuCloseReason, MenubarApi, MenubarEventMap, MenubarMachine, MenubarMenuContext, MenubarProps, MenubarSchema, MenubarService };