@limonify/zest-ui 0.1.0

package/lib/menu/radio-item/MenuRadioItem.js

@@ -0,0 +1,108 @@
+"use strict";
+'use client';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuRadioItem = MenuRadioItem;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const MenuRootContext_1 = require("../root/MenuRootContext");
+const MenuRadioGroupContext_1 = require("../radio-group/MenuRadioGroupContext");
+const MenuSubmenuRootContext_1 = require("../submenu-root/MenuSubmenuRootContext");
+const useRenderElement_1 = require("../../use-render/useRenderElement");
+const useButton_1 = require("../../internals/use-button/useButton");
+const useCompositeListItem_1 = require("../../internals/composite/list/useCompositeListItem");
+const createChangeEventDetails_1 = require("../../utils/createChangeEventDetails");
+const reasons_1 = require("../../utils/reasons");
+const MenuRadioItemContext_1 = require("./MenuRadioItemContext");
+/**
+ * A menu item that works like a radio button in a given group.
+ * Renders a `<Pressable>`.
+ *
+ * Requires a `Menu.RadioGroup` and throws without one — the same rule as
+ * `Radio.Root`: with no group there is no source of truth and the item would be
+ * silently inert.
+ *
+ * Unlike `Menu.Item`, `closeOnPress` defaults to `false`.
+ */
+function MenuRadioItem(componentProps) {
+    var _a;
+    const { className, closeOnClick: closeOnClickProp, closeOnPress: closeOnPressProp, disabled: disabledProp = false, onPress: onPressProp, render, style, value, ref, ...elementProps } = componentProps;
+    // `closeOnPress` is the React Native name; `closeOnPress` is a deprecated
+    // alias kept for Base UI parity.
+    const closeOnPress = (_a = closeOnPressProp !== null && closeOnPressProp !== void 0 ? closeOnPressProp : closeOnClickProp) !== null && _a !== void 0 ? _a : false;
+    const store = (0, MenuRootContext_1.useMenuRootContext)();
+    const submenuRootContext = (0, MenuSubmenuRootContext_1.useMenuSubmenuRootContext)();
+    const group = (0, MenuRadioGroupContext_1.useMenuRadioGroupContext)();
+    const { index, onLayout } = (0, useCompositeListItem_1.useCompositeListItem)();
+    const [pressed, setPressed] = React.useState(false);
+    const checked = group.value === value;
+    const disabled = disabledProp || group.disabled;
+    const { getButtonProps } = (0, useButton_1.useButton)({ disabled });
+    const state = { checked, disabled, pressed, index };
+    const element = (0, useRenderElement_1.useRenderElement)(react_native_1.Pressable, componentProps, {
+        state,
+        ref,
+        props: [
+            {
+                onLayout,
+                accessibilityRole: 'menuitem',
+                accessibilityState: { checked, disabled: disabled || undefined },
+                'aria-checked': checked,
+                onPress(event) {
+                    if (disabled) {
+                        return;
+                    }
+                    group.setValue(value, event);
+                    onPressProp === null || onPressProp === void 0 ? void 0 : onPressProp(event);
+                    if (closeOnPress) {
+                        store.setOpen(false, (0, createChangeEventDetails_1.createChangeEventDetails)(reasons_1.REASONS.itemPress, event));
+                        submenuRootContext === null || submenuRootContext === void 0 ? void 0 : submenuRootContext.closeAncestors(reasons_1.REASONS.itemPress, event);
+                    }
+                },
+                onPressIn() {
+                    setPressed(true);
+                },
+                onPressOut() {
+                    setPressed(false);
+                },
+            },
+            elementProps,
+            getButtonProps,
+        ],
+    });
+    return (0, jsx_runtime_1.jsx)(MenuRadioItemContext_1.MenuRadioItemContext.Provider, { value: state, children: element });
+}
+//# sourceMappingURL=MenuRadioItem.js.map

package/lib/menu/radio-item/MenuRadioItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRadioItem.js","sourceRoot":"","sources":["../../../src/menu/radio-item/MenuRadioItem.tsx"],"names":[],"mappings":";AAAA,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBb,sCAoEC;;AA3FD,6CAA+B;AAC/B,+CAAqE;AACrE,6DAA6D;AAC7D,gFAAgF;AAChF,mFAAmF;AACnF,wEAAqE;AACrE,oEAAiE;AACjE,8FAA2F;AAE3F,mFAAgF;AAChF,iDAA8C;AAC9C,iEAA8D;AAE9D;;;;;;;;;GASG;AACH,SAAgB,aAAa,CAAc,cAA0C;;IACnF,MAAM,EACJ,SAAS,EACT,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,gBAAgB,EAC9B,QAAQ,EAAE,YAAY,GAAG,KAAK,EAC9B,OAAO,EAAE,WAAW,EACpB,MAAM,EACN,KAAK,EACL,KAAK,EACL,GAAG,EACH,GAAG,YAAY,EAChB,GAAG,cAAc,CAAC;IAEnB,0EAA0E;IAC1E,iCAAiC;IACjC,MAAM,YAAY,GAAG,MAAA,gBAAgB,aAAhB,gBAAgB,cAAhB,gBAAgB,GAAI,gBAAgB,mCAAI,KAAK,CAAC;IAEnE,MAAM,KAAK,GAAG,IAAA,oCAAkB,GAAE,CAAC;IACnC,MAAM,kBAAkB,GAAG,IAAA,kDAAyB,GAAE,CAAC;IACvD,MAAM,KAAK,GAAG,IAAA,gDAAwB,GAAS,CAAC;IAEhD,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAA,2CAAoB,GAAE,CAAC;IAEnD,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAEpD,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC;IACtC,MAAM,QAAQ,GAAG,YAAY,IAAI,KAAK,CAAC,QAAQ,CAAC;IAEhD,MAAM,EAAE,cAAc,EAAE,GAAG,IAAA,qBAAS,EAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAEnD,MAAM,KAAK,GAAuB,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAExE,MAAM,OAAO,GAAG,IAAA,mCAAgB,EAAC,wBAAS,EAAE,cAAc,EAAE;QAC1D,KAAK;QACL,GAAG;QACH,KAAK,EAAE;YACL;gBACE,QAAQ;gBACR,iBAAiB,EAAE,UAAmB;gBACtC,kBAAkB,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,IAAI,SAAS,EAAE;gBAChE,cAAc,EAAE,OAAO;gBACvB,OAAO,CAAC,KAA4B;oBAClC,IAAI,QAAQ,EAAE,CAAC;wBACb,OAAO;oBACT,CAAC;oBAED,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBAC7B,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAG,KAAK,CAAC,CAAC;oBAErB,IAAI,YAAY,EAAE,CAAC;wBACjB,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,IAAA,mDAAwB,EAAC,iBAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;wBACzE,kBAAkB,aAAlB,kBAAkB,uBAAlB,kBAAkB,CAAE,cAAc,CAAC,iBAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;oBAC/D,CAAC;gBACH,CAAC;gBACD,SAAS;oBACP,UAAU,CAAC,IAAI,CAAC,CAAC;gBACnB,CAAC;gBACD,UAAU;oBACR,UAAU,CAAC,KAAK,CAAC,CAAC;gBACpB,CAAC;aACF;YACD,YAAY;YACZ,cAAc;SACf;KACF,CAAC,CAAC;IAEH,OAAO,uBAAC,2CAAoB,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YAAG,OAAO,GAAiC,CAAC;AAChG,CAAC"}

package/lib/menu/radio-item/MenuRadioItemContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { MenuRadioItemState } from './MenuRadioItem';
+export declare const MenuRadioItemContext: React.Context<MenuRadioItemState | undefined>;
+export declare function useMenuRadioItemContext(): MenuRadioItemState;
+//# sourceMappingURL=MenuRadioItemContext.d.ts.map

package/lib/menu/radio-item/MenuRadioItemContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRadioItemContext.d.ts","sourceRoot":"","sources":["../../../src/menu/radio-item/MenuRadioItemContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,eAAO,MAAM,oBAAoB,+CAAiE,CAAC;AAEnG,wBAAgB,uBAAuB,uBAStC"}

package/lib/menu/radio-item/MenuRadioItemContext.js

@@ -0,0 +1,48 @@
+"use strict";
+'use client';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuRadioItemContext = void 0;
+exports.useMenuRadioItemContext = useMenuRadioItemContext;
+const React = __importStar(require("react"));
+exports.MenuRadioItemContext = React.createContext(undefined);
+function useMenuRadioItemContext() {
+    const context = React.useContext(exports.MenuRadioItemContext);
+    if (context === undefined) {
+        throw new Error('Zest: MenuRadioItemContext is missing. Menu.RadioItemIndicator must be placed within <Menu.RadioItem>.');
+    }
+    return context;
+}
+//# sourceMappingURL=MenuRadioItemContext.js.map

package/lib/menu/radio-item/MenuRadioItemContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRadioItemContext.js","sourceRoot":"","sources":["../../../src/menu/radio-item/MenuRadioItemContext.ts"],"names":[],"mappings":";AAAA,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMb,0DASC;AAdD,6CAA+B;AAGlB,QAAA,oBAAoB,GAAG,KAAK,CAAC,aAAa,CAAiC,SAAS,CAAC,CAAC;AAEnG,SAAgB,uBAAuB;IACrC,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,4BAAoB,CAAC,CAAC;IACvD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,wGAAwG,CACzG,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/lib/menu/radio-item-indicator/MenuRadioItemIndicator.d.ts

@@ -0,0 +1,22 @@
+import { View } from 'react-native';
+import type { MenuRadioItemState } from '../radio-item/MenuRadioItem';
+import type { ZestUIComponentProps } from '../../types';
+/**
+ * Indicates whether the radio item is selected.
+ * Renders a `<View>`.
+ */
+export declare function MenuRadioItemIndicator(componentProps: MenuRadioItemIndicator.Props): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | null;
+export interface MenuRadioItemIndicatorState extends MenuRadioItemState {
+}
+export interface MenuRadioItemIndicatorProps extends ZestUIComponentProps<typeof View, MenuRadioItemIndicatorState> {
+    /**
+     * Whether to keep the element mounted when the radio item is not selected.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+export declare namespace MenuRadioItemIndicator {
+    type State = MenuRadioItemIndicatorState;
+    type Props = MenuRadioItemIndicatorProps;
+}
+//# sourceMappingURL=MenuRadioItemIndicator.d.ts.map

package/lib/menu/radio-item-indicator/MenuRadioItemIndicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRadioItemIndicator.d.ts","sourceRoot":"","sources":["../../../src/menu/radio-item-indicator/MenuRadioItemIndicator.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,sBAAsB,CAAC,KAAK,qGAWlF;AAED,MAAM,WAAW,2BAA4B,SAAQ,kBAAkB;CAAG;AAE1E,MAAM,WAAW,2BACf,SAAQ,oBAAoB,CAAC,OAAO,IAAI,EAAE,2BAA2B,CAAC;IACtE;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACnC;AAED,yBAAiB,sBAAsB,CAAC;IACtC,KAAY,KAAK,GAAG,2BAA2B,CAAC;IAChD,KAAY,KAAK,GAAG,2BAA2B,CAAC;CACjD"}

package/lib/menu/radio-item-indicator/MenuRadioItemIndicator.js

@@ -0,0 +1,22 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuRadioItemIndicator = MenuRadioItemIndicator;
+const react_native_1 = require("react-native");
+const MenuRadioItemContext_1 = require("../radio-item/MenuRadioItemContext");
+const useRenderElement_1 = require("../../use-render/useRenderElement");
+/**
+ * Indicates whether the radio item is selected.
+ * Renders a `<View>`.
+ */
+function MenuRadioItemIndicator(componentProps) {
+    const { render, className, style, keepMounted = false, ref, ...elementProps } = componentProps;
+    const state = (0, MenuRadioItemContext_1.useMenuRadioItemContext)();
+    return (0, useRenderElement_1.useRenderElement)(react_native_1.View, componentProps, {
+        state,
+        ref,
+        props: elementProps,
+        enabled: keepMounted || state.checked,
+    });
+}
+//# sourceMappingURL=MenuRadioItemIndicator.js.map

package/lib/menu/radio-item-indicator/MenuRadioItemIndicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRadioItemIndicator.js","sourceRoot":"","sources":["../../../src/menu/radio-item-indicator/MenuRadioItemIndicator.tsx"],"names":[],"mappings":";AAAA,YAAY,CAAC;;AAWb,wDAWC;AArBD,+CAAoC;AACpC,6EAA6E;AAC7E,wEAAqE;AAIrE;;;GAGG;AACH,SAAgB,sBAAsB,CAAC,cAA4C;IACjF,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,YAAY,EAAE,GAAG,cAAc,CAAC;IAE/F,MAAM,KAAK,GAAG,IAAA,8CAAuB,GAAE,CAAC;IAExC,OAAO,IAAA,mCAAgB,EAAC,mBAAI,EAAE,cAAc,EAAE;QAC5C,KAAK;QACL,GAAG;QACH,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,WAAW,IAAI,KAAK,CAAC,OAAO;KACtC,CAAC,CAAC;AACL,CAAC"}

package/lib/menu/root/MenuRoot.d.ts

@@ -0,0 +1,83 @@
+import type * as React from 'react';
+import type { ZestChangeEventDetails } from '../../utils/createChangeEventDetails';
+import type { REASONS } from '../../utils/reasons';
+import type { MenuHandle } from '../store/MenuHandle';
+/**
+ * Groups all parts of the menu.
+ * Doesn't render its own element.
+ *
+ * **Not ported from upstream.** `Menu.Viewport`, which exists only to animate a
+ * content swap when one popup is opened by several triggers: it works by
+ * capturing the previous content's DOM node and keeping it on screen while a CSS
+ * transition runs, and a rendered React Native node cannot be retained that way
+ * once its element is gone.
+ */
+export declare function MenuRoot<Payload = unknown>(props: MenuRoot.Props<Payload>): React.JSX.Element;
+export interface MenuRootState {
+}
+export interface MenuRootActions {
+    /**
+     * Unmounts the menu without firing `onOpenChange`. Call it after an externally
+     * controlled closing animation finishes.
+     */
+    unmount: () => void;
+    /**
+     * Closes the menu, reporting the `imperative-action` reason.
+     */
+    close: () => void;
+}
+export interface MenuRootProps<Payload = unknown> {
+    /**
+     * Whether the menu is currently open.
+     */
+    open?: boolean | undefined;
+    /**
+     * Whether the menu is initially open.
+     *
+     * To render a controlled menu, use the `open` prop instead.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Event handler called when the menu is opened or closed.
+     */
+    onOpenChange?: ((open: boolean, eventDetails: MenuRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Whether to prevent the menu from closing on presses outside the popup.
+     * @default false
+     */
+    disablePointerDismissal?: boolean | undefined;
+    /**
+     * A ref to imperative actions.
+     */
+    actionsRef?: React.RefObject<MenuRoot.Actions | null> | undefined;
+    /**
+     * A handle associating this menu with triggers rendered outside it, and letting
+     * it be opened and closed imperatively. Create one with `Menu.createHandle()`.
+     */
+    handle?: MenuHandle<Payload> | undefined;
+    /**
+     * The id of the trigger the menu is anchored to and associated with.
+     */
+    triggerId?: string | null | undefined;
+    /**
+     * The id of the trigger the menu is initially associated with.
+     */
+    defaultTriggerId?: string | null | undefined;
+    /**
+     * The content of the menu.
+     *
+     * Pass a function to receive the payload the menu was opened with.
+     */
+    children?: React.ReactNode | ((payload: Payload) => React.ReactNode);
+}
+export type MenuRootChangeEventReason = typeof REASONS.triggerPress | typeof REASONS.outsidePress | typeof REASONS.escapeKey | typeof REASONS.itemPress | typeof REASONS.linkPress | typeof REASONS.closePress | typeof REASONS.imperativeAction | typeof REASONS.none;
+export type MenuRootChangeEventDetails = ZestChangeEventDetails<MenuRootChangeEventReason>;
+export declare namespace MenuRoot {
+    type State = MenuRootState;
+    type Props<Payload = unknown> = MenuRootProps<Payload>;
+    type Actions = MenuRootActions;
+    type ChangeEventReason = MenuRootChangeEventReason;
+    type ChangeEventDetails = MenuRootChangeEventDetails;
+}
+//# sourceMappingURL=MenuRoot.d.ts.map

package/lib/menu/root/MenuRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRoot.d.ts","sourceRoot":"","sources":["../../../src/menu/root/MenuRoot.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAGtD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAG,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,qBAsCzE;AAED,MAAM,WAAW,aAAa;CAAG;AAEjC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,aAAa,CAAC,OAAO,GAAG,OAAO;IAC9C;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,kBAAkB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAChG;;;OAGG;IACH,uBAAuB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9C;;OAEG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IAClE;;;OAGG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;IACzC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;CACtE;AAED,MAAM,MAAM,yBAAyB,GACjC,OAAO,OAAO,CAAC,YAAY,GAC3B,OAAO,OAAO,CAAC,YAAY,GAC3B,OAAO,OAAO,CAAC,SAAS,GACxB,OAAO,OAAO,CAAC,SAAS,GACxB,OAAO,OAAO,CAAC,SAAS,GACxB,OAAO,OAAO,CAAC,UAAU,GACzB,OAAO,OAAO,CAAC,gBAAgB,GAC/B,OAAO,OAAO,CAAC,IAAI,CAAC;AAExB,MAAM,MAAM,0BAA0B,GAAG,sBAAsB,CAAC,yBAAyB,CAAC,CAAC;AAE3F,yBAAiB,QAAQ,CAAC;IACxB,KAAY,KAAK,GAAG,aAAa,CAAC;IAClC,KAAY,KAAK,CAAC,OAAO,GAAG,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;IAC9D,KAAY,OAAO,GAAG,eAAe,CAAC;IACtC,KAAY,iBAAiB,GAAG,yBAAyB,CAAC;IAC1D,KAAY,kBAAkB,GAAG,0BAA0B,CAAC;CAC7D"}

package/lib/menu/root/MenuRoot.js

@@ -0,0 +1,37 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuRoot = MenuRoot;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const useRefWithInit_1 = require("../../hooks/useRefWithInit");
+const usePopupRootHandle_1 = require("../../utils/popups/usePopupRootHandle");
+const MenuStore_1 = require("../store/MenuStore");
+const MenuRootContext_1 = require("./MenuRootContext");
+/**
+ * Groups all parts of the menu.
+ * Doesn't render its own element.
+ *
+ * **Not ported from upstream.** `Menu.Viewport`, which exists only to animate a
+ * content swap when one popup is opened by several triggers: it works by
+ * capturing the previous content's DOM node and keeping it on screen while a CSS
+ * transition runs, and a rendered React Native node cannot be retained that way
+ * once its element is gone.
+ */
+function MenuRoot(props) {
+    const { actionsRef, children, defaultOpen = false, defaultTriggerId = null, disablePointerDismissal = false, handle, onOpenChange, open, triggerId, } = props;
+    const store = (0, useRefWithInit_1.useRefWithInit)(() => new MenuStore_1.MenuStore({
+        open: defaultOpen,
+        openProp: open,
+        triggerId: defaultTriggerId,
+        triggerIdProp: triggerId,
+        disablePointerDismissal,
+    })).current;
+    store.useControlledProp('openProp', open);
+    store.useControlledProp('triggerIdProp', triggerId);
+    store.useContextCallback('onOpenChange', onOpenChange);
+    store.useSyncedValues({ disablePointerDismissal });
+    (0, usePopupRootHandle_1.usePopupRootHandle)({ store, handle, actionsRef });
+    const payload = store.useState('payload');
+    return ((0, jsx_runtime_1.jsx)(MenuRootContext_1.MenuRootContext.Provider, { value: store, children: typeof children === 'function' ? children(payload) : children }));
+}
+//# sourceMappingURL=MenuRoot.js.map

package/lib/menu/root/MenuRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRoot.js","sourceRoot":"","sources":["../../../src/menu/root/MenuRoot.tsx"],"names":[],"mappings":";AAAA,YAAY,CAAC;;AAoBb,4BAsCC;;AAxDD,+DAA4D;AAC5D,8EAA2E;AAG3E,kDAA+C;AAE/C,uDAAoD;AAEpD;;;;;;;;;GASG;AACH,SAAgB,QAAQ,CAAoB,KAA8B;IACxE,MAAM,EACJ,UAAU,EACV,QAAQ,EACR,WAAW,GAAG,KAAK,EACnB,gBAAgB,GAAG,IAAI,EACvB,uBAAuB,GAAG,KAAK,EAC/B,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,SAAS,GACV,GAAG,KAAK,CAAC;IAEV,MAAM,KAAK,GAAG,IAAA,+BAAc,EAC1B,GAAG,EAAE,CACH,IAAI,qBAAS,CAAC;QACZ,IAAI,EAAE,WAAW;QACjB,QAAQ,EAAE,IAAI;QACd,SAAS,EAAE,gBAAgB;QAC3B,aAAa,EAAE,SAAS;QACxB,uBAAuB;KACxB,CAAC,CACL,CAAC,OAAO,CAAC;IAEV,KAAK,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAC1C,KAAK,CAAC,iBAAiB,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;IACpD,KAAK,CAAC,kBAAkB,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;IACvD,KAAK,CAAC,eAAe,CAAC,EAAE,uBAAuB,EAAE,CAAC,CAAC;IAEnD,IAAA,uCAAkB,EAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;IAElD,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAY,CAAC;IAErD,OAAO,CACL,uBAAC,iCAAe,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YACnC,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,GACrC,CAC5B,CAAC;AACJ,CAAC"}

package/lib/menu/root/MenuRootContext.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+import type { MenuStore } from '../store/MenuStore';
+export declare const MenuRootContext: React.Context<MenuStore | undefined>;
+export declare function useMenuRootContext(): MenuStore;
+//# sourceMappingURL=MenuRootContext.d.ts.map

package/lib/menu/root/MenuRootContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRootContext.d.ts","sourceRoot":"","sources":["../../../src/menu/root/MenuRootContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,eAAO,MAAM,eAAe,sCAAwD,CAAC;AAErF,wBAAgB,kBAAkB,cASjC"}

package/lib/menu/root/MenuRootContext.js

@@ -0,0 +1,48 @@
+"use strict";
+'use client';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuRootContext = void 0;
+exports.useMenuRootContext = useMenuRootContext;
+const React = __importStar(require("react"));
+exports.MenuRootContext = React.createContext(undefined);
+function useMenuRootContext() {
+    const context = React.useContext(exports.MenuRootContext);
+    if (context === undefined) {
+        throw new Error('Zest: MenuRootContext is missing. Menu parts must be placed within <Menu.Root>.');
+    }
+    return context;
+}
+//# sourceMappingURL=MenuRootContext.js.map

package/lib/menu/root/MenuRootContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuRootContext.js","sourceRoot":"","sources":["../../../src/menu/root/MenuRootContext.ts"],"names":[],"mappings":";AAAA,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMb,gDASC;AAdD,6CAA+B;AAGlB,QAAA,eAAe,GAAG,KAAK,CAAC,aAAa,CAAwB,SAAS,CAAC,CAAC;AAErF,SAAgB,kBAAkB;IAChC,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,uBAAe,CAAC,CAAC;IAClD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,iFAAiF,CAClF,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/lib/menu/store/MenuHandle.d.ts

@@ -0,0 +1,42 @@
+import { MenuStore } from './MenuStore';
+import { BasePopupHandle } from '../../utils/popups/BasePopupHandle';
+/**
+ * Controls a menu imperatively, and associates `Menu.Trigger`s rendered outside
+ * the root with it. Create one with `Menu.createHandle()` and pass it to the
+ * root's and the triggers' `handle` prop.
+ *
+ * The imperative methods only take effect while a root using this handle is
+ * mounted; calls made before one attaches (or after it unmounts) are ignored.
+ */
+export declare class MenuHandle<Payload = unknown> extends BasePopupHandle<MenuStore, MenuStore> {
+    constructor();
+    /**
+     * Points the positioner at the trigger the menu was opened by. Without this an
+     * imperative open would anchor to whatever was last pressed.
+     */
+    protected associateTrigger(store: MenuStore, triggerNode: unknown): void;
+    /**
+     * Opens the menu, anchored to the trigger with the given id.
+     *
+     * Call this from an event handler or an effect, never during rendering.
+     *
+     * @param triggerId The `nativeID` of a mounted `Menu.Trigger` carrying this handle.
+     */
+    open(triggerId: string): void;
+    /**
+     * Closes the menu.
+     *
+     * Call this from an event handler or an effect, never during rendering.
+     */
+    close(): void;
+    /**
+     * Whether the menu is open. `false` while no root is attached.
+     */
+    get isOpen(): boolean;
+}
+/**
+ * Creates a handle that connects a `Menu.Root` to `Menu.Trigger`s rendered
+ * outside it, and controls it imperatively.
+ */
+export declare function createMenuHandle<Payload = unknown>(): MenuHandle<Payload>;
+//# sourceMappingURL=MenuHandle.d.ts.map

package/lib/menu/store/MenuHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuHandle.d.ts","sourceRoot":"","sources":["../../../src/menu/store/MenuHandle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;;;;;GAOG;AAKH,qBAAa,UAAU,CAAC,OAAO,GAAG,OAAO,CAAE,SAAQ,eAAe,CAAC,SAAS,EAAE,SAAS,CAAC;;IAOtF;;;OAGG;cACgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO;IAM1E;;;;;;OAMG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM;IAItB;;;;OAIG;IACH,KAAK;IAIL;;OAEG;IACH,IAAI,MAAM,YAET;CACF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAG,OAAO,KAAK,UAAU,CAAC,OAAO,CAAC,CAEzE"}

package/lib/menu/store/MenuHandle.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuHandle = void 0;
+exports.createMenuHandle = createMenuHandle;
+const MenuStore_1 = require("./MenuStore");
+const BasePopupHandle_1 = require("../../utils/popups/BasePopupHandle");
+/**
+ * Controls a menu imperatively, and associates `Menu.Trigger`s rendered outside
+ * the root with it. Create one with `Menu.createHandle()` and pass it to the
+ * root's and the triggers' `handle` prop.
+ *
+ * The imperative methods only take effect while a root using this handle is
+ * mounted; calls made before one attaches (or after it unmounts) are ignored.
+ */
+// `Payload` is unused in the class body but load-bearing in the public API: a
+// `Menu.Root`'s `handle?: MenuHandle<Payload>` prop is what infers the payload
+// type its `children(payload)` receives.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class MenuHandle extends BasePopupHandle_1.BasePopupHandle {
+    constructor() {
+        // `true`: a menu is anchored, so opening it by an unknown trigger id is an
+        // error rather than a warning — there would be nothing to anchor to.
+        super(new MenuStore_1.MenuStore(), 'Menu', true);
+    }
+    /**
+     * Points the positioner at the trigger the menu was opened by. Without this an
+     * imperative open would anchor to whatever was last pressed.
+     */
+    associateTrigger(store, triggerNode) {
+        if (triggerNode !== undefined) {
+            store.set('triggerNode', triggerNode);
+        }
+    }
+    /**
+     * Opens the menu, anchored to the trigger with the given id.
+     *
+     * Call this from an event handler or an effect, never during rendering.
+     *
+     * @param triggerId The `nativeID` of a mounted `Menu.Trigger` carrying this handle.
+     */
+    open(triggerId) {
+        this.openByTrigger(triggerId);
+    }
+    /**
+     * Closes the menu.
+     *
+     * Call this from an event handler or an effect, never during rendering.
+     */
+    close() {
+        this.closePopup();
+    }
+    /**
+     * Whether the menu is open. `false` while no root is attached.
+     */
+    get isOpen() {
+        var _a, _b;
+        return (_b = (_a = this.attachedStore) === null || _a === void 0 ? void 0 : _a.select('open')) !== null && _b !== void 0 ? _b : false;
+    }
+}
+exports.MenuHandle = MenuHandle;
+/**
+ * Creates a handle that connects a `Menu.Root` to `Menu.Trigger`s rendered
+ * outside it, and controls it imperatively.
+ */
+function createMenuHandle() {
+    return new MenuHandle();
+}
+//# sourceMappingURL=MenuHandle.js.map

package/lib/menu/store/MenuHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuHandle.js","sourceRoot":"","sources":["../../../src/menu/store/MenuHandle.ts"],"names":[],"mappings":";;;AAgEA,4CAEC;AAlED,2CAAwC;AACxC,wEAAqE;AAErE;;;;;;;GAOG;AACH,8EAA8E;AAC9E,+EAA+E;AAC/E,yCAAyC;AACzC,6DAA6D;AAC7D,MAAa,UAA8B,SAAQ,iCAAqC;IACtF;QACE,2EAA2E;QAC3E,qEAAqE;QACrE,KAAK,CAAC,IAAI,qBAAS,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACgB,gBAAgB,CAAC,KAAgB,EAAE,WAAoB;QACxE,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,KAAK,CAAC,GAAG,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,SAAiB;QACpB,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;;QACR,OAAO,MAAA,MAAA,IAAI,CAAC,aAAa,0CAAE,MAAM,CAAC,MAAM,CAAC,mCAAI,KAAK,CAAC;IACrD,CAAC;CACF;AA3CD,gCA2CC;AAED;;;GAGG;AACH,SAAgB,gBAAgB;IAC9B,OAAO,IAAI,UAAU,EAAW,CAAC;AACnC,CAAC"}

package/lib/menu/store/MenuStore.d.ts

@@ -0,0 +1,48 @@
+import { ReactStore } from '../../store/ReactStore';
+import { PopupTriggerMap } from '../../utils/popups/PopupTriggerMap';
+import type { MenuRoot } from '../root/MenuRoot';
+export type State = {
+    open: boolean;
+    openProp: boolean | undefined;
+    disablePointerDismissal: boolean;
+    /**
+     * The anchor's native node, carried across the portal boundary.
+     */
+    triggerNode: unknown;
+    update: (() => void) | undefined;
+    /**
+     * The payload of the trigger the popup was opened by, handed to the root's
+     * children when they are a function.
+     */
+    payload: unknown;
+    /**
+     * The id of the trigger the popup is associated with, or `null` for none.
+     */
+    triggerId: string | null;
+    /**
+     * The controlled `triggerId` prop, when provided.
+     */
+    triggerIdProp: string | null | undefined;
+};
+type Context = {
+    onOpenChange: ((open: boolean, eventDetails: MenuRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Every trigger bound to this popup, by id. A handle resolves `open(id)`
+     * through this, which is what lets a trigger rendered outside the root open it.
+     */
+    triggerNodes: PopupTriggerMap;
+};
+declare const selectors: {
+    open: (state: State) => boolean;
+    disablePointerDismissal: (state: State) => boolean;
+    triggerNode: (state: State) => unknown;
+    update: (state: State) => (() => void) | undefined;
+    payload: (state: State) => unknown;
+    triggerId: (state: State) => string | null;
+};
+export declare class MenuStore extends ReactStore<Readonly<State>, Context, typeof selectors> {
+    constructor(initialState?: Partial<State>);
+    setOpen: (nextOpen: boolean, eventDetails: MenuRoot.ChangeEventDetails) => void;
+}
+export {};
+//# sourceMappingURL=MenuStore.d.ts.map

package/lib/menu/store/MenuStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MenuStore.d.ts","sourceRoot":"","sources":["../../../src/menu/store/MenuStore.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,uBAAuB,EAAE,OAAO,CAAC;IACjC;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IACjC;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;OAEG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC1C,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,kBAAkB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC/F;;;OAGG;IACH,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAEF,QAAA,MAAM,SAAS;;;;qCAzBE,IAAI;;;CAgCpB,CAAC;AAEF,qBAAa,SAAU,SAAQ,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,SAAS,CAAC;gBACvE,YAAY,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC;IAkBlC,OAAO,GAAI,UAAU,OAAO,EAAE,cAAc,QAAQ,CAAC,kBAAkB,UAY5E;CACH"}

package/lib/menu/store/MenuStore.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuStore = void 0;
+const createSelector_1 = require("../../store/createSelector");
+const ReactStore_1 = require("../../store/ReactStore");
+const PopupTriggerMap_1 = require("../../utils/popups/PopupTriggerMap");
+const selectors = {
+    open: (0, createSelector_1.createSelector)((state) => { var _a; return (_a = state.openProp) !== null && _a !== void 0 ? _a : state.open; }),
+    disablePointerDismissal: (0, createSelector_1.createSelector)((state) => state.disablePointerDismissal),
+    triggerNode: (0, createSelector_1.createSelector)((state) => state.triggerNode),
+    update: (0, createSelector_1.createSelector)((state) => state.update),
+    payload: (0, createSelector_1.createSelector)((state) => state.payload),
+    triggerId: (0, createSelector_1.createSelector)((state) => { var _a; return (_a = state.triggerIdProp) !== null && _a !== void 0 ? _a : state.triggerId; }),
+};
+class MenuStore extends ReactStore_1.ReactStore {
+    constructor(initialState) {
+        super({
+            open: false,
+            openProp: undefined,
+            disablePointerDismissal: false,
+            triggerNode: null,
+            update: undefined,
+            payload: undefined,
+            triggerId: null,
+            triggerIdProp: undefined,
+            ...initialState,
+        }, { onOpenChange: undefined, triggerNodes: new PopupTriggerMap_1.PopupTriggerMap() }, selectors);
+        this.setOpen = (nextOpen, eventDetails) => {
+            var _a, _b;
+            if (nextOpen === this.select('open')) {
+                return;
+            }
+            (_b = (_a = this.context).onOpenChange) === null || _b === void 0 ? void 0 : _b.call(_a, nextOpen, eventDetails);
+            if (eventDetails.isCanceled) {
+                return;
+            }
+            this.set('open', nextOpen);
+        };
+    }
+}
+exports.MenuStore = MenuStore;
+//# sourceMappingURL=MenuStore.js.map