@moneyforward/mfui-components 4.1.2 → 4.3.0

package/dist/src/Toast/api/toast.d.ts

@@ -12,9 +12,42 @@ declare const showToast: (props: ToastApiProps | string, type?: ToastSlotRecipeV
  * Destroy a toast message.
  * If the key is not provided, all toasts will be destroyed.
  *
+ * This only hides the toasts; the internal React root stays mounted. To also
+ * unmount that root and remove its container, use {@link toast.reset}.
+ *
  * @param key - The key of the toast message to destroy.
  */
 declare const destroyToast: (key?: string) => void;
+/**
+ * Tear down the toast renderer completely.
+ *
+ * Unmounts the internal React root, removes the container element it created,
+ * and resets every module-scoped reference, so the next toast starts from the
+ * same state as the very first one. Calling it before any toast has been shown,
+ * or twice in a row, is a safe no-op.
+ *
+ * This is intended for test teardown and application shutdown. To only hide the
+ * currently displayed toasts, use {@link toast.destroy} instead.
+ *
+ * The unmount flushes synchronously, which has two consequences: do not call it
+ * from a render or an effect cleanup, and wrap it in `act()` in tests. Calling
+ * it bare in a test logs "An update to Root inside a test was not wrapped in
+ * act(...)".
+ *
+ * @example
+ * ```ts
+ * import { act } from '@testing-library/react';
+ * import { afterEach } from 'vitest';
+ * import { toast } from '@moneyforward/mfui-components/Toast';
+ *
+ * afterEach(() => {
+ *   act(() => {
+ *     toast.reset();
+ *   });
+ * });
+ * ```
+ */
+declare const resetToast: () => void;
 export declare const toast: {
     show: typeof showToast;
     success: (props: ToastApiProps | string) => void;
@@ -23,5 +56,6 @@ export declare const toast: {
     progress: (props: ToastApiProps | string) => void;
     caution: (props: ToastApiProps | string) => void;
     destroy: typeof destroyToast;
+    reset: typeof resetToast;
 };
 export {};

package/dist/src/Toast/api/toast.js

@@ -95,11 +95,51 @@ const showToast = (props, type = 'custom') => {
  * Destroy a toast message.
  * If the key is not provided, all toasts will be destroyed.
  *
+ * This only hides the toasts; the internal React root stays mounted. To also
+ * unmount that root and remove its container, use {@link toast.reset}.
+ *
  * @param key - The key of the toast message to destroy.
  */
 const destroyToast = (key) => {
     removeToast(key);
 };
+/**
+ * Tear down the toast renderer completely.
+ *
+ * Unmounts the internal React root, removes the container element it created,
+ * and resets every module-scoped reference, so the next toast starts from the
+ * same state as the very first one. Calling it before any toast has been shown,
+ * or twice in a row, is a safe no-op.
+ *
+ * This is intended for test teardown and application shutdown. To only hide the
+ * currently displayed toasts, use {@link toast.destroy} instead.
+ *
+ * The unmount flushes synchronously, which has two consequences: do not call it
+ * from a render or an effect cleanup, and wrap it in `act()` in tests. Calling
+ * it bare in a test logs "An update to Root inside a test was not wrapped in
+ * act(...)".
+ *
+ * @example
+ * ```ts
+ * import { act } from '@testing-library/react';
+ * import { afterEach } from 'vitest';
+ * import { toast } from '@moneyforward/mfui-components/Toast';
+ *
+ * afterEach(() => {
+ *   act(() => {
+ *     toast.reset();
+ *   });
+ * });
+ * ```
+ */
+const resetToast = () => {
+    root?.unmount();
+    rootElement?.remove();
+    root = null;
+    rootElement = null;
+    rootWrapper = undefined;
+    toastList = [];
+};
 export const toast = {
     show: showToast,
     success: (props) => {
@@ -118,4 +158,5 @@ export const toast = {
         showToast(props, 'caution');
     },
     destroy: destroyToast,
+    reset: resetToast,
 };

package/dist/src/shared/Menu/MenuCloseContext.d.ts

@@ -0,0 +1,10 @@
+type MenuCloseContextValue = {
+    /**
+     * The function to close the menu popover.
+     * This function is provided by the menu component (e.g. `DropdownMenu`, `ApplicationMenu`).
+     */
+    closeMenuPopover?: () => void;
+};
+export declare const useMenuCloseContext: () => MenuCloseContextValue;
+export declare const MenuCloseProvider: import("react").Provider<MenuCloseContextValue>;
+export {};

package/dist/src/shared/Menu/MenuCloseContext.js

@@ -0,0 +1,7 @@
+'use client';
+import { createContext, useContext } from 'react';
+const MenuCloseContext = createContext({
+    closeMenuPopover: undefined,
+});
+export const useMenuCloseContext = () => useContext(MenuCloseContext);
+export const MenuCloseProvider = MenuCloseContext.Provider;

package/dist/src/shared/Menu/MenuContainer.d.ts

@@ -0,0 +1,10 @@
+import { type MenuContainerProps } from './MenuContainer.types';
+/**
+ * The shared root component for menu-button components (e.g. `DropdownMenu`, `ApplicationMenu`).
+ * Put focusable menu item components (marked with `data-mfui-menu-item` /
+ * `data-mfui-focusable="true"`) inside this component.
+ *
+ * Owns the roving focus of the menu items: Escape / Tab close the menu, ArrowDown / ArrowUp
+ * move the focus between the items.
+ */
+export declare const MenuContainer: import("react").ForwardRefExoticComponent<MenuContainerProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/src/{DropdownMenu/DropdownMenuContainer/DropdownMenuContainer.js → shared/Menu/MenuContainer.js}

@@ -1,15 +1,16 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef, useCallback, useEffect, useRef } from 'react';
-import { cx } from '../../../styled-system/css';
 import { mergeRefs } from '../../utilities/dom/mergeRefs';
-import { dropdownMenuContainerSlotRecipe } from '../../../styled-system/recipes';
 /**
- * The root component for the dropdown menu.
- * Put the `DropdownMenuItem` or `DropdownMenuDivider` components inside this component.
+ * The shared root component for menu-button components (e.g. `DropdownMenu`, `ApplicationMenu`).
+ * Put focusable menu item components (marked with `data-mfui-menu-item` /
+ * `data-mfui-focusable="true"`) inside this component.
+ *
+ * Owns the roving focus of the menu items: Escape / Tab close the menu, ArrowDown / ArrowUp
+ * move the focus between the items.
  */
-export const DropdownMenuContainer = forwardRef(({ children, className, defaultFocusItem: defaultFocus = 'first', style, onClose }, ref) => {
-    const classes = dropdownMenuContainerSlotRecipe();
+export const MenuContainer = forwardRef(({ children, className, defaultFocusItem: defaultFocus = 'first', style, onClose }, ref) => {
     const menuContainerRef = useRef(null);
     const getFocusableItems = useCallback(() => menuContainerRef.current?.querySelectorAll('[data-mfui-menu-item]:is([data-mfui-focusable=true])'), []);
     useEffect(() => {
@@ -54,5 +55,5 @@ export const DropdownMenuContainer = forwardRef(({ children, className, defaultF
             }
         }
     }, [onClose, getFocusableItems]);
-    return (_jsx("div", { ref: mergeRefs(ref, menuContainerRef), "data-mfui-menu-container": true, role: "menu", className: cx(classes.root, 'mfui-DropdownMenuContainer__root', className), tabIndex: -1, style: style, onKeyDown: handleKeyDown, children: children }));
+    return (_jsx("div", { ref: mergeRefs(ref, menuContainerRef), "data-mfui-menu-container": true, role: "menu", className: className, tabIndex: -1, style: style, onKeyDown: handleKeyDown, children: children }));
 });

package/dist/src/{DropdownMenu/DropdownMenuContainer/DropdownMenuContainer.types.d.ts → shared/Menu/MenuContainer.types.d.ts}

@@ -1,12 +1,9 @@
-/**
- * The default focus position of the menu.
- */
-export type DropdownMenuDefaultFocusItem = 'first' | 'last' | 'none';
-export type DropdownMenuContainerProps = {
+import { type MenuDefaultFocusItem } from './useMenuTriggerActivation';
+export type MenuContainerProps = {
     /**
      * The content of the component.
      *
-     * It should be a collection of `DropdownMenuItem`, `DropdownMenuDivider` components.
+     * It should be a collection of menu item / divider / heading components.
      */
     children: React.ReactNode;
     /**
@@ -14,7 +11,7 @@ export type DropdownMenuContainerProps = {
      */
     className?: string;
     /**
-     * The default focus position of the dropdown menu.
+     * The default focus position of the menu.
      *
      * It should be either 'first', 'last' or 'none'.
      *
@@ -26,7 +23,7 @@ export type DropdownMenuContainerProps = {
      *
      * @default 'first'
      */
-    defaultFocusItem?: DropdownMenuDefaultFocusItem;
+    defaultFocusItem?: MenuDefaultFocusItem;
     /**
      * The style to apply to the component.
      * This prop is used to add custom styles to the component.
@@ -36,7 +33,7 @@ export type DropdownMenuContainerProps = {
      */
     style?: React.CSSProperties;
     /**
-     * The function to close the DropdownMenu.
+     * The function to close the menu.
      */
     onClose: () => void;
 };

package/dist/src/shared/Menu/MenuContainer.types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/shared/Menu/index.d.ts

@@ -0,0 +1,5 @@
+export { MenuContainer } from './MenuContainer';
+export type { MenuContainerProps } from './MenuContainer.types';
+export { useMenuTriggerActivation } from './useMenuTriggerActivation';
+export type { MenuDefaultFocusItem } from './useMenuTriggerActivation';
+export { useMenuCloseContext, MenuCloseProvider } from './MenuCloseContext';

package/dist/src/shared/Menu/index.js

@@ -0,0 +1,3 @@
+export { MenuContainer } from './MenuContainer';
+export { useMenuTriggerActivation } from './useMenuTriggerActivation';
+export { useMenuCloseContext, MenuCloseProvider } from './MenuCloseContext';

package/dist/src/shared/Menu/useMenuTriggerActivation.d.ts

@@ -0,0 +1,35 @@
+import { type FocusEvent, type KeyboardEvent, type MouseEvent } from 'react';
+/**
+ * The default focus position of the menu.
+ */
+export type MenuDefaultFocusItem = 'first' | 'last' | 'none';
+/**
+ * Shared trigger-activation machinery for menu-button components (e.g. `DropdownMenu`,
+ * `ApplicationMenu`). Tracks whether the trigger was activated by keyboard so the menu focuses
+ * its first item on Enter / Space, and moves the default focus position on ArrowUp / ArrowDown.
+ *
+ * The returned handlers wrap the corresponding handler already provided by `Popover`'s
+ * `renderTrigger`, so callers compose them at the trigger call site:
+ *
+ * @example
+ * ```tsx
+ * const { menuDefaultFocusPosition, handleTriggerKeyDown, handleTriggerBlur, handleTriggerClick } =
+ *   useMenuTriggerActivation();
+ *
+ * <Popover
+ *   renderTrigger={({ togglePopover, handleTriggerKeyDown: popoverKeyDown, handleTriggerBlur: popoverBlur }) => (
+ *     <Button
+ *       onKeyDown={(event) => handleTriggerKeyDown(event, popoverKeyDown)}
+ *       onBlur={(event) => handleTriggerBlur(event, popoverBlur)}
+ *       onClick={(event) => handleTriggerClick(event, togglePopover)}
+ *     />
+ *   )}
+ * />
+ * ```
+ */
+export declare function useMenuTriggerActivation(): {
+    menuDefaultFocusPosition: MenuDefaultFocusItem;
+    handleTriggerKeyDown: (event: KeyboardEvent<HTMLElement>, next: (event: KeyboardEvent<HTMLElement>) => void) => void;
+    handleTriggerBlur: (event: FocusEvent<HTMLElement>, next: (event: FocusEvent<HTMLElement>) => void) => void;
+    handleTriggerClick: (event: MouseEvent<HTMLElement>, next: (event: MouseEvent<HTMLElement>) => void) => void;
+};

package/dist/src/shared/Menu/useMenuTriggerActivation.js

@@ -0,0 +1,69 @@
+'use client';
+import { useCallback, useRef, useState } from 'react';
+/**
+ * Shared trigger-activation machinery for menu-button components (e.g. `DropdownMenu`,
+ * `ApplicationMenu`). Tracks whether the trigger was activated by keyboard so the menu focuses
+ * its first item on Enter / Space, and moves the default focus position on ArrowUp / ArrowDown.
+ *
+ * The returned handlers wrap the corresponding handler already provided by `Popover`'s
+ * `renderTrigger`, so callers compose them at the trigger call site:
+ *
+ * @example
+ * ```tsx
+ * const { menuDefaultFocusPosition, handleTriggerKeyDown, handleTriggerBlur, handleTriggerClick } =
+ *   useMenuTriggerActivation();
+ *
+ * <Popover
+ *   renderTrigger={({ togglePopover, handleTriggerKeyDown: popoverKeyDown, handleTriggerBlur: popoverBlur }) => (
+ *     <Button
+ *       onKeyDown={(event) => handleTriggerKeyDown(event, popoverKeyDown)}
+ *       onBlur={(event) => handleTriggerBlur(event, popoverBlur)}
+ *       onClick={(event) => handleTriggerClick(event, togglePopover)}
+ *     />
+ *   )}
+ * />
+ * ```
+ */
+export function useMenuTriggerActivation() {
+    const [menuDefaultFocusPosition, setMenuDefaultFocusPosition] = useState('first');
+    // Tracks keyboard activation (Enter / Space) of the trigger. The resulting click event usually
+    // has `detail === 0`, but Safari reports keyboard-triggered clicks with `detail === 1`, so the
+    // keydown itself is recorded as the reliable signal.
+    const isTriggerActivatedByKeyboardRef = useRef(false);
+    const handleTriggerKeyDown = useCallback((event, next) => {
+        // The flag only survives from an Enter / Space keydown to its follow-up click; any other key
+        // invalidates the pending keyboard activation so the flag cannot linger when the click never
+        // fires.
+        isTriggerActivatedByKeyboardRef.current = event.key === 'Enter' || event.key === ' ';
+        switch (event.key) {
+            case 'ArrowDown':
+                event.stopPropagation();
+                event.preventDefault();
+                setMenuDefaultFocusPosition('first');
+                break;
+            case 'ArrowUp':
+                event.stopPropagation();
+                event.preventDefault();
+                setMenuDefaultFocusPosition('last');
+                break;
+        }
+        next(event);
+    }, []);
+    const handleTriggerBlur = useCallback((event, next) => {
+        // Focus leaving the trigger invalidates any pending keyboard activation (e.g. a Space
+        // keydown whose follow-up click never fired), so a later mouse click cannot be
+        // misclassified as keyboard activation.
+        isTriggerActivatedByKeyboardRef.current = false;
+        next(event);
+    }, []);
+    const handleTriggerClick = useCallback((event, next) => {
+        // Opening with the keyboard (Enter / Space) focuses the first item, following the
+        // WAI-ARIA menu button pattern. Opening with the mouse focuses no item; the menu
+        // container receives focus instead so that arrow keys still work.
+        const isKeyboardActivation = isTriggerActivatedByKeyboardRef.current || event.detail === 0;
+        isTriggerActivatedByKeyboardRef.current = false;
+        setMenuDefaultFocusPosition(isKeyboardActivation ? 'first' : 'none');
+        next(event);
+    }, []);
+    return { menuDefaultFocusPosition, handleTriggerKeyDown, handleTriggerBlur, handleTriggerClick };
+}

package/dist/styled-system/recipes/application-menu-divider-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ApplicationMenuDividerSlotRecipeVariant {
+  
+}
+
+type ApplicationMenuDividerSlotRecipeVariantMap = {
+  [key in keyof ApplicationMenuDividerSlotRecipeVariant]: Array<ApplicationMenuDividerSlotRecipeVariant[key]>
+}
+
+type ApplicationMenuDividerSlotRecipeSlot = "root" | "line"
+
+export type ApplicationMenuDividerSlotRecipeVariantProps = {
+  [key in keyof ApplicationMenuDividerSlotRecipeVariant]?: ConditionalValue<ApplicationMenuDividerSlotRecipeVariant[key]> | undefined
+}
+
+export interface ApplicationMenuDividerSlotRecipeRecipe {
+  __slot: ApplicationMenuDividerSlotRecipeSlot
+  __type: ApplicationMenuDividerSlotRecipeVariantProps
+  (props?: ApplicationMenuDividerSlotRecipeVariantProps): Pretty<Record<ApplicationMenuDividerSlotRecipeSlot, string>>
+  raw: (props?: ApplicationMenuDividerSlotRecipeVariantProps) => ApplicationMenuDividerSlotRecipeVariantProps
+  variantMap: ApplicationMenuDividerSlotRecipeVariantMap
+  variantKeys: Array<keyof ApplicationMenuDividerSlotRecipeVariant>
+  splitVariantProps<Props extends ApplicationMenuDividerSlotRecipeVariantProps>(props: Props): [ApplicationMenuDividerSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ApplicationMenuDividerSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ApplicationMenuDividerSlotRecipeVariantProps) => ApplicationMenuDividerSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI ApplicationMenuDivider component.
+ */
+export declare const applicationMenuDividerSlotRecipe: ApplicationMenuDividerSlotRecipeRecipe

package/dist/styled-system/recipes/application-menu-divider-slot-recipe.js

@@ -0,0 +1,32 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const applicationMenuDividerSlotRecipeDefaultVariants = {};
+const applicationMenuDividerSlotRecipeCompoundVariants = [];
+const applicationMenuDividerSlotRecipeSlotNames = [
+    [
+        "root",
+        "ApplicationMenuDivider__root"
+    ],
+    [
+        "line",
+        "ApplicationMenuDivider__line"
+    ]
+];
+const applicationMenuDividerSlotRecipeSlotFns = /* @__PURE__ */ applicationMenuDividerSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, applicationMenuDividerSlotRecipeDefaultVariants, getSlotCompoundVariant(applicationMenuDividerSlotRecipeCompoundVariants, slotName))]);
+const applicationMenuDividerSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(applicationMenuDividerSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const applicationMenuDividerSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...applicationMenuDividerSlotRecipeDefaultVariants, ...compact(variants) });
+export const applicationMenuDividerSlotRecipe = /* @__PURE__ */ Object.assign(applicationMenuDividerSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'applicationMenuDividerSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: applicationMenuDividerSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, applicationMenuDividerSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/styled-system/recipes/application-menu-group-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ApplicationMenuGroupSlotRecipeVariant {
+  
+}
+
+type ApplicationMenuGroupSlotRecipeVariantMap = {
+  [key in keyof ApplicationMenuGroupSlotRecipeVariant]: Array<ApplicationMenuGroupSlotRecipeVariant[key]>
+}
+
+type ApplicationMenuGroupSlotRecipeSlot = "root"
+
+export type ApplicationMenuGroupSlotRecipeVariantProps = {
+  [key in keyof ApplicationMenuGroupSlotRecipeVariant]?: ConditionalValue<ApplicationMenuGroupSlotRecipeVariant[key]> | undefined
+}
+
+export interface ApplicationMenuGroupSlotRecipeRecipe {
+  __slot: ApplicationMenuGroupSlotRecipeSlot
+  __type: ApplicationMenuGroupSlotRecipeVariantProps
+  (props?: ApplicationMenuGroupSlotRecipeVariantProps): Pretty<Record<ApplicationMenuGroupSlotRecipeSlot, string>>
+  raw: (props?: ApplicationMenuGroupSlotRecipeVariantProps) => ApplicationMenuGroupSlotRecipeVariantProps
+  variantMap: ApplicationMenuGroupSlotRecipeVariantMap
+  variantKeys: Array<keyof ApplicationMenuGroupSlotRecipeVariant>
+  splitVariantProps<Props extends ApplicationMenuGroupSlotRecipeVariantProps>(props: Props): [ApplicationMenuGroupSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ApplicationMenuGroupSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ApplicationMenuGroupSlotRecipeVariantProps) => ApplicationMenuGroupSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI ApplicationMenuGroup component.
+ */
+export declare const applicationMenuGroupSlotRecipe: ApplicationMenuGroupSlotRecipeRecipe

package/dist/styled-system/recipes/application-menu-group-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const applicationMenuGroupSlotRecipeDefaultVariants = {};
+const applicationMenuGroupSlotRecipeCompoundVariants = [];
+const applicationMenuGroupSlotRecipeSlotNames = [
+    [
+        "root",
+        "ApplicationMenuGroup__root"
+    ]
+];
+const applicationMenuGroupSlotRecipeSlotFns = /* @__PURE__ */ applicationMenuGroupSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, applicationMenuGroupSlotRecipeDefaultVariants, getSlotCompoundVariant(applicationMenuGroupSlotRecipeCompoundVariants, slotName))]);
+const applicationMenuGroupSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(applicationMenuGroupSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const applicationMenuGroupSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...applicationMenuGroupSlotRecipeDefaultVariants, ...compact(variants) });
+export const applicationMenuGroupSlotRecipe = /* @__PURE__ */ Object.assign(applicationMenuGroupSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'applicationMenuGroupSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: applicationMenuGroupSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, applicationMenuGroupSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/styled-system/recipes/application-menu-item-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ApplicationMenuItemSlotRecipeVariant {
+  
+}
+
+type ApplicationMenuItemSlotRecipeVariantMap = {
+  [key in keyof ApplicationMenuItemSlotRecipeVariant]: Array<ApplicationMenuItemSlotRecipeVariant[key]>
+}
+
+type ApplicationMenuItemSlotRecipeSlot = "root"
+
+export type ApplicationMenuItemSlotRecipeVariantProps = {
+  [key in keyof ApplicationMenuItemSlotRecipeVariant]?: ConditionalValue<ApplicationMenuItemSlotRecipeVariant[key]> | undefined
+}
+
+export interface ApplicationMenuItemSlotRecipeRecipe {
+  __slot: ApplicationMenuItemSlotRecipeSlot
+  __type: ApplicationMenuItemSlotRecipeVariantProps
+  (props?: ApplicationMenuItemSlotRecipeVariantProps): Pretty<Record<ApplicationMenuItemSlotRecipeSlot, string>>
+  raw: (props?: ApplicationMenuItemSlotRecipeVariantProps) => ApplicationMenuItemSlotRecipeVariantProps
+  variantMap: ApplicationMenuItemSlotRecipeVariantMap
+  variantKeys: Array<keyof ApplicationMenuItemSlotRecipeVariant>
+  splitVariantProps<Props extends ApplicationMenuItemSlotRecipeVariantProps>(props: Props): [ApplicationMenuItemSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ApplicationMenuItemSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ApplicationMenuItemSlotRecipeVariantProps) => ApplicationMenuItemSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI ApplicationMenuItem component.
+ */
+export declare const applicationMenuItemSlotRecipe: ApplicationMenuItemSlotRecipeRecipe

package/dist/styled-system/recipes/application-menu-item-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const applicationMenuItemSlotRecipeDefaultVariants = {};
+const applicationMenuItemSlotRecipeCompoundVariants = [];
+const applicationMenuItemSlotRecipeSlotNames = [
+    [
+        "root",
+        "ApplicationMenuItem__root"
+    ]
+];
+const applicationMenuItemSlotRecipeSlotFns = /* @__PURE__ */ applicationMenuItemSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, applicationMenuItemSlotRecipeDefaultVariants, getSlotCompoundVariant(applicationMenuItemSlotRecipeCompoundVariants, slotName))]);
+const applicationMenuItemSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(applicationMenuItemSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const applicationMenuItemSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...applicationMenuItemSlotRecipeDefaultVariants, ...compact(variants) });
+export const applicationMenuItemSlotRecipe = /* @__PURE__ */ Object.assign(applicationMenuItemSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'applicationMenuItemSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: applicationMenuItemSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, applicationMenuItemSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/styled-system/recipes/application-menu-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ApplicationMenuSlotRecipeVariant {
+  
+}
+
+type ApplicationMenuSlotRecipeVariantMap = {
+  [key in keyof ApplicationMenuSlotRecipeVariant]: Array<ApplicationMenuSlotRecipeVariant[key]>
+}
+
+type ApplicationMenuSlotRecipeSlot = "popover" | "menuContainer"
+
+export type ApplicationMenuSlotRecipeVariantProps = {
+  [key in keyof ApplicationMenuSlotRecipeVariant]?: ConditionalValue<ApplicationMenuSlotRecipeVariant[key]> | undefined
+}
+
+export interface ApplicationMenuSlotRecipeRecipe {
+  __slot: ApplicationMenuSlotRecipeSlot
+  __type: ApplicationMenuSlotRecipeVariantProps
+  (props?: ApplicationMenuSlotRecipeVariantProps): Pretty<Record<ApplicationMenuSlotRecipeSlot, string>>
+  raw: (props?: ApplicationMenuSlotRecipeVariantProps) => ApplicationMenuSlotRecipeVariantProps
+  variantMap: ApplicationMenuSlotRecipeVariantMap
+  variantKeys: Array<keyof ApplicationMenuSlotRecipeVariant>
+  splitVariantProps<Props extends ApplicationMenuSlotRecipeVariantProps>(props: Props): [ApplicationMenuSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof ApplicationMenuSlotRecipeVariantProps>>]
+  getVariantProps: (props?: ApplicationMenuSlotRecipeVariantProps) => ApplicationMenuSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI ApplicationMenu component.
+ */
+export declare const applicationMenuSlotRecipe: ApplicationMenuSlotRecipeRecipe

package/dist/styled-system/recipes/application-menu-slot-recipe.js

@@ -0,0 +1,32 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const applicationMenuSlotRecipeDefaultVariants = {};
+const applicationMenuSlotRecipeCompoundVariants = [];
+const applicationMenuSlotRecipeSlotNames = [
+    [
+        "popover",
+        "ApplicationMenu__popover"
+    ],
+    [
+        "menuContainer",
+        "ApplicationMenu__menuContainer"
+    ]
+];
+const applicationMenuSlotRecipeSlotFns = /* @__PURE__ */ applicationMenuSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, applicationMenuSlotRecipeDefaultVariants, getSlotCompoundVariant(applicationMenuSlotRecipeCompoundVariants, slotName))]);
+const applicationMenuSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(applicationMenuSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const applicationMenuSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...applicationMenuSlotRecipeDefaultVariants, ...compact(variants) });
+export const applicationMenuSlotRecipe = /* @__PURE__ */ Object.assign(applicationMenuSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'applicationMenuSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: applicationMenuSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, applicationMenuSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/styled-system/recipes/index.d.ts

@@ -1,4 +1,8 @@
 /* eslint-disable */
+export * from './application-menu-slot-recipe';
+export * from './application-menu-divider-slot-recipe';
+export * from './application-menu-item-slot-recipe';
+export * from './application-menu-group-slot-recipe';
 export * from './breadcrumbs-slot-recipe';
 export * from './icon-button-slot-recipe';
 export * from './focus-indicator-slot-recipe';

package/dist/styled-system/recipes/index.js

@@ -1,3 +1,7 @@
+export * from './application-menu-slot-recipe.js';
+export * from './application-menu-divider-slot-recipe.js';
+export * from './application-menu-item-slot-recipe.js';
+export * from './application-menu-group-slot-recipe.js';
 export * from './breadcrumbs-slot-recipe.js';
 export * from './icon-button-slot-recipe.js';
 export * from './focus-indicator-slot-recipe.js';