@fluentui/react-aria 9.3.20 → 9.3.22

package/CHANGELOG.json

@@ -2,7 +2,52 @@
   "name": "@fluentui/react-aria",
   "entries": [
     {
-      "date": "Thu, 18 May 2023 00:35:32 GMT",
+      "date": "Wed, 31 May 2023 06:43:06 GMT",
+      "tag": "@fluentui/react-aria_v9.3.22",
+      "version": "9.3.22",
+      "comments": {
+        "patch": [
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-aria",
+            "comment": "Bump @fluentui/react-utilities to v9.9.2",
+            "commit": "17ca96c6b7f684f36a5c63e40e78b4986a86c713"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 25 May 2023 10:00:48 GMT",
+      "tag": "@fluentui/react-aria_v9.3.21",
+      "version": "9.3.21",
+      "comments": {
+        "patch": [
+          {
+            "author": "beachball",
+            "package": "@fluentui/react-aria",
+            "comment": "Bump @fluentui/react-utilities to v9.9.1",
+            "commit": "8f7c1b7591b3e665ae39e1b22ab0f0b28fb795c4"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 24 May 2023 20:45:23 GMT",
+      "tag": "@fluentui/react-aria_v9.3.20",
+      "version": "9.3.20",
+      "comments": {
+        "none": [
+          {
+            "author": "olfedias@microsoft.com",
+            "package": "@fluentui/react-aria",
+            "commit": "69e0617a93cb44ef42f3bd19284b7dc5fe27fed3",
+            "comment": "chore: update test-ssr script"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 18 May 2023 00:39:02 GMT",
       "tag": "@fluentui/react-aria_v9.3.20",
       "version": "9.3.20",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,30 @@
 # Change Log - @fluentui/react-aria
 
-This log was last generated on Thu, 18 May 2023 00:35:32 GMT and should not be manually modified.
+This log was last generated on Wed, 31 May 2023 06:43:06 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.3.22](https://github.com/microsoft/fluentui/tree/@fluentui/react-aria_v9.3.22)
+
+Wed, 31 May 2023 06:43:06 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-aria_v9.3.21..@fluentui/react-aria_v9.3.22)
+
+### Patches
+
+- Bump @fluentui/react-utilities to v9.9.2 ([PR #28054](https://github.com/microsoft/fluentui/pull/28054) by beachball)
+
+## [9.3.21](https://github.com/microsoft/fluentui/tree/@fluentui/react-aria_v9.3.21)
+
+Thu, 25 May 2023 10:00:48 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-aria_v9.3.20..@fluentui/react-aria_v9.3.21)
+
+### Patches
+
+- Bump @fluentui/react-utilities to v9.9.1 ([PR #27988](https://github.com/microsoft/fluentui/pull/27988) by beachball)
+
 ## [9.3.20](https://github.com/microsoft/fluentui/tree/@fluentui/react-aria_v9.3.20)
 
-Thu, 18 May 2023 00:35:32 GMT 
+Thu, 18 May 2023 00:39:02 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-aria_v9.3.19..@fluentui/react-aria_v9.3.20)
 
 ### Patches

package/lib/button/index.js

@@ -1,4 +1,3 @@
 export * from './useARIAButtonProps';
 export * from './useARIAButtonShorthand';
 export * from './types';
-//# sourceMappingURL=index.js.map

package/lib/button/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["../../src/button/index.ts"],"sourcesContent":["export * from './useARIAButtonProps';\nexport * from './useARIAButtonShorthand';\nexport * from './types';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './useARIAButtonProps';\nexport * from './useARIAButtonShorthand';\nexport * from './types';\n"],"names":[],"mappings":"AAAA,cAAc,uBAAuB;AACrC,cAAc,2BAA2B;AACzC,cAAc,UAAU"}

package/lib/button/types.js

@@ -1,2 +1 @@
 import * as React from 'react';
-//# sourceMappingURL=types.js.map

package/lib/button/types.js.map

@@ -1 +1 @@
-{"version":3,"names":["React"],"sources":["../../src/button/types.ts"],"sourcesContent":["import type { ExtractSlotProps, Slot } from '@fluentui/react-utilities';\nimport * as React from 'react';\n\ntype UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;\n\nexport type ARIAButtonType = 'button' | 'a' | 'div';\n\nexport type ARIAButtonElement<AlternateAs extends 'a' | 'div' = 'a' | 'div'> =\n  | HTMLButtonElement\n  | (AlternateAs extends 'a' ? HTMLAnchorElement : never)\n  | (AlternateAs extends 'div' ? HTMLDivElement : never);\n\n/**\n * @internal\n */\nexport type ARIAButtonElementIntersection<AlternateAs extends 'a' | 'div' = 'a' | 'div'> = UnionToIntersection<\n  ARIAButtonElement<AlternateAs>\n>;\n\n/**\n * Props expected by `useARIAButtonProps` hooks\n */\nexport type ARIAButtonProps<Type extends ARIAButtonType = ARIAButtonType> = React.PropsWithRef<\n  JSX.IntrinsicElements[Type]\n> & {\n  disabled?: boolean;\n  /**\n   * When set, allows the button to be focusable even when it has been disabled.\n   * This is used in scenarios where it is important to keep a consistent tab order\n   * for screen reader and keyboard users. The primary example of this\n   * pattern is when the disabled button is in a menu or a commandbar and is seldom used for standalone buttons.\n   *\n   * @default false\n   */\n  disabledFocusable?: boolean;\n};\n\nexport type ARIAButtonSlotProps<AlternateAs extends 'a' | 'div' = 'a' | 'div'> = ExtractSlotProps<\n  Slot<'button', AlternateAs>\n> &\n  Pick<ARIAButtonProps<ARIAButtonType>, 'disabled' | 'disabledFocusable'>;\n\n/**\n * Props that will be modified internally by `useARIAButtonProps` by each case.\n * This typing is to ensure a well specified return value for `useARIAbButtonProps`\n */\nexport type ARIAButtonAlteredProps<Type extends ARIAButtonType> =\n  | (Type extends 'button'\n      ? Pick<\n          JSX.IntrinsicElements['button'],\n          'onClick' | 'onKeyDown' | 'onKeyUp' | 'disabled' | 'aria-disabled' | 'tabIndex'\n        >\n      : never)\n  | (Type extends 'a'\n      ? Pick<\n          JSX.IntrinsicElements['a'],\n          'onClick' | 'onKeyDown' | 'onKeyUp' | 'aria-disabled' | 'tabIndex' | 'role' | 'href'\n        >\n      : never)\n  | (Type extends 'div'\n      ? Pick<JSX.IntrinsicElements['div'], 'onClick' | 'onKeyDown' | 'onKeyUp' | 'aria-disabled' | 'tabIndex' | 'role'>\n      : never);\n\n/**\n * Merge of props provided by the user and props provided internally.\n */\nexport type ARIAButtonResultProps<Type extends ARIAButtonType, Props> = Props &\n  UnionToIntersection<ARIAButtonAlteredProps<Type>>;\n"],"mappings":"AACA,YAAYA,KAAA,MAAW"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import type { ExtractSlotProps, Slot } from '@fluentui/react-utilities';\nimport * as React from 'react';\n\ntype UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;\n\nexport type ARIAButtonType = 'button' | 'a' | 'div';\n\nexport type ARIAButtonElement<AlternateAs extends 'a' | 'div' = 'a' | 'div'> =\n  | HTMLButtonElement\n  | (AlternateAs extends 'a' ? HTMLAnchorElement : never)\n  | (AlternateAs extends 'div' ? HTMLDivElement : never);\n\n/**\n * @internal\n */\nexport type ARIAButtonElementIntersection<AlternateAs extends 'a' | 'div' = 'a' | 'div'> = UnionToIntersection<\n  ARIAButtonElement<AlternateAs>\n>;\n\n/**\n * Props expected by `useARIAButtonProps` hooks\n */\nexport type ARIAButtonProps<Type extends ARIAButtonType = ARIAButtonType> = React.PropsWithRef<\n  JSX.IntrinsicElements[Type]\n> & {\n  disabled?: boolean;\n  /**\n   * When set, allows the button to be focusable even when it has been disabled.\n   * This is used in scenarios where it is important to keep a consistent tab order\n   * for screen reader and keyboard users. The primary example of this\n   * pattern is when the disabled button is in a menu or a commandbar and is seldom used for standalone buttons.\n   *\n   * @default false\n   */\n  disabledFocusable?: boolean;\n};\n\nexport type ARIAButtonSlotProps<AlternateAs extends 'a' | 'div' = 'a' | 'div'> = ExtractSlotProps<\n  Slot<'button', AlternateAs>\n> &\n  Pick<ARIAButtonProps<ARIAButtonType>, 'disabled' | 'disabledFocusable'>;\n\n/**\n * Props that will be modified internally by `useARIAButtonProps` by each case.\n * This typing is to ensure a well specified return value for `useARIAbButtonProps`\n */\nexport type ARIAButtonAlteredProps<Type extends ARIAButtonType> =\n  | (Type extends 'button'\n      ? Pick<\n          JSX.IntrinsicElements['button'],\n          'onClick' | 'onKeyDown' | 'onKeyUp' | 'disabled' | 'aria-disabled' | 'tabIndex'\n        >\n      : never)\n  | (Type extends 'a'\n      ? Pick<\n          JSX.IntrinsicElements['a'],\n          'onClick' | 'onKeyDown' | 'onKeyUp' | 'aria-disabled' | 'tabIndex' | 'role' | 'href'\n        >\n      : never)\n  | (Type extends 'div'\n      ? Pick<JSX.IntrinsicElements['div'], 'onClick' | 'onKeyDown' | 'onKeyUp' | 'aria-disabled' | 'tabIndex' | 'role'>\n      : never);\n\n/**\n * Merge of props provided by the user and props provided internally.\n */\nexport type ARIAButtonResultProps<Type extends ARIAButtonType, Props> = Props &\n  UnionToIntersection<ARIAButtonAlteredProps<Type>>;\n"],"names":["React"],"mappings":"AACA,YAAYA,WAAW,QAAQ"}

package/lib/button/useARIAButtonProps.js

@@ -27,91 +27,81 @@ import * as React from 'react';
  *  <a {...buttonProps}>This anchor will behave as a proper button</a>
  * )
  * ```
- */
-export function useARIAButtonProps(type, props) {
-  const {
-    disabled,
-    disabledFocusable = false,
-    ['aria-disabled']: ariaDisabled,
-    onClick,
-    onKeyDown,
-    onKeyUp,
-    ...rest
-  } = props !== null && props !== void 0 ? props : {};
-  const normalizedARIADisabled = typeof ariaDisabled === 'string' ? ariaDisabled === 'true' : ariaDisabled;
-  const isDisabled = disabled || disabledFocusable || normalizedARIADisabled;
-  const handleClick = useEventCallback(ev => {
-    if (isDisabled) {
-      ev.preventDefault();
-      ev.stopPropagation();
+ */ export function useARIAButtonProps(type, props) {
+    const { disabled , disabledFocusable =false , ['aria-disabled']: ariaDisabled , onClick , onKeyDown , onKeyUp , ...rest } = props !== null && props !== void 0 ? props : {};
+    const normalizedARIADisabled = typeof ariaDisabled === 'string' ? ariaDisabled === 'true' : ariaDisabled;
+    const isDisabled = disabled || disabledFocusable || normalizedARIADisabled;
+    const handleClick = useEventCallback((ev)=>{
+        if (isDisabled) {
+            ev.preventDefault();
+            ev.stopPropagation();
+        } else {
+            onClick === null || onClick === void 0 ? void 0 : onClick(ev);
+        }
+    });
+    const handleKeyDown = useEventCallback((ev)=>{
+        onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(ev);
+        if (ev.isDefaultPrevented()) {
+            return;
+        }
+        const key = ev.key;
+        if (isDisabled && (key === Enter || key === Space)) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            return;
+        }
+        if (key === Space) {
+            ev.preventDefault();
+            return;
+        } else if (key === Enter) {
+            ev.preventDefault();
+            ev.currentTarget.click();
+        }
+    });
+    const handleKeyUp = useEventCallback((ev)=>{
+        onKeyUp === null || onKeyUp === void 0 ? void 0 : onKeyUp(ev);
+        if (ev.isDefaultPrevented()) {
+            return;
+        }
+        const key = ev.key;
+        if (isDisabled && (key === Enter || key === Space)) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            return;
+        }
+        if (key === Space) {
+            ev.preventDefault();
+            ev.currentTarget.click();
+        }
+    });
+    // If a <button> tag is to be rendered we just need to set disabled and aria-disabled correctly
+    if (type === 'button' || type === undefined) {
+        return {
+            ...rest,
+            disabled: disabled && !disabledFocusable,
+            'aria-disabled': disabledFocusable ? true : normalizedARIADisabled,
+            // onclick should still use internal handler to ensure prevention if disabled
+            // if disabledFocusable then there's no requirement for handlers as those events should not be propagated
+            onClick: disabledFocusable ? undefined : handleClick,
+            onKeyUp: disabledFocusable ? undefined : onKeyUp,
+            onKeyDown: disabledFocusable ? undefined : onKeyDown
+        };
     } else {
-      onClick === null || onClick === void 0 ? void 0 : onClick(ev);
+        const resultProps = {
+            role: 'button',
+            tabIndex: disabled && !disabledFocusable ? undefined : 0,
+            ...rest,
+            // If it's not a <button> than listeners are required even with disabledFocusable
+            // Since you cannot assure the default behavior of the element
+            // E.g: <a> will redirect on click
+            onClick: handleClick,
+            onKeyUp: handleKeyUp,
+            onKeyDown: handleKeyDown,
+            'aria-disabled': disabled || disabledFocusable || normalizedARIADisabled
+        };
+        if (type === 'a' && isDisabled) {
+            resultProps.href = undefined;
+        }
+        return resultProps;
     }
-  });
-  const handleKeyDown = useEventCallback(ev => {
-    onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(ev);
-    if (ev.isDefaultPrevented()) {
-      return;
-    }
-    const key = ev.key;
-    if (isDisabled && (key === Enter || key === Space)) {
-      ev.preventDefault();
-      ev.stopPropagation();
-      return;
-    }
-    if (key === Space) {
-      ev.preventDefault();
-      return;
-    } else if (key === Enter) {
-      ev.preventDefault();
-      ev.currentTarget.click();
-    }
-  });
-  const handleKeyUp = useEventCallback(ev => {
-    onKeyUp === null || onKeyUp === void 0 ? void 0 : onKeyUp(ev);
-    if (ev.isDefaultPrevented()) {
-      return;
-    }
-    const key = ev.key;
-    if (isDisabled && (key === Enter || key === Space)) {
-      ev.preventDefault();
-      ev.stopPropagation();
-      return;
-    }
-    if (key === Space) {
-      ev.preventDefault();
-      ev.currentTarget.click();
-    }
-  });
-  // If a <button> tag is to be rendered we just need to set disabled and aria-disabled correctly
-  if (type === 'button' || type === undefined) {
-    return {
-      ...rest,
-      disabled: disabled && !disabledFocusable,
-      'aria-disabled': disabledFocusable ? true : normalizedARIADisabled,
-      // onclick should still use internal handler to ensure prevention if disabled
-      // if disabledFocusable then there's no requirement for handlers as those events should not be propagated
-      onClick: disabledFocusable ? undefined : handleClick,
-      onKeyUp: disabledFocusable ? undefined : onKeyUp,
-      onKeyDown: disabledFocusable ? undefined : onKeyDown
-    };
-  } else {
-    const resultProps = {
-      role: 'button',
-      tabIndex: disabled && !disabledFocusable ? undefined : 0,
-      ...rest,
-      // If it's not a <button> than listeners are required even with disabledFocusable
-      // Since you cannot assure the default behavior of the element
-      // E.g: <a> will redirect on click
-      onClick: handleClick,
-      onKeyUp: handleKeyUp,
-      onKeyDown: handleKeyDown,
-      'aria-disabled': disabled || disabledFocusable || normalizedARIADisabled
-    };
-    if (type === 'a' && isDisabled) {
-      resultProps.href = undefined;
-    }
-    return resultProps;
-  }
 }
-//# sourceMappingURL=useARIAButtonProps.js.map

package/lib/button/useARIAButtonProps.js.map

@@ -1 +1 @@
-{"version":3,"names":["Enter","Space","useEventCallback","React","useARIAButtonProps","type","props","disabled","disabledFocusable","ariaDisabled","onClick","onKeyDown","onKeyUp","rest","normalizedARIADisabled","isDisabled","handleClick","ev","preventDefault","stopPropagation","handleKeyDown","isDefaultPrevented","key","currentTarget","click","handleKeyUp","undefined","resultProps","role","tabIndex","href"],"sources":["../../src/button/useARIAButtonProps.ts"],"sourcesContent":["import { Enter, Space } from '@fluentui/keyboard-keys';\nimport { useEventCallback } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport type { ARIAButtonElementIntersection, ARIAButtonProps, ARIAButtonResultProps, ARIAButtonType } from './types';\n\n/**\n * @internal\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of non native button elements. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n *\n * @param type - the proper scenario to be interpreted by the hook.\n *  1. `button` - Minimal interference from the hook, as semantic button already supports most of the states\n *  2. `a` or `div` - Proper keyboard/mouse handling plus other support to ensure ARIA behavior\n * @param props - the props to be passed down the line to the desired element.\n * This hook will encapsulate proper properties, such as `onClick`, `onKeyDown`, `onKeyUp`, etc,.\n *\n * @example\n * ```tsx\n * const buttonProps = useARIAButtonProps('a', {\n *   href: './some-route'\n *   onClick: () => console.log('this should run both on click and Space and Enter')\n * })\n *\n * // ...\n *\n * return (\n *  <a {...buttonProps}>This anchor will behave as a proper button</a>\n * )\n * ```\n */\nexport function useARIAButtonProps<Type extends ARIAButtonType, Props extends ARIAButtonProps<Type>>(\n  type?: Type,\n  props?: Props,\n): ARIAButtonResultProps<Type, Props> {\n  const {\n    disabled,\n    disabledFocusable = false,\n    ['aria-disabled']: ariaDisabled,\n    onClick,\n    onKeyDown,\n    onKeyUp,\n    ...rest\n  } = props ?? {};\n\n  const normalizedARIADisabled = typeof ariaDisabled === 'string' ? ariaDisabled === 'true' : ariaDisabled;\n\n  const isDisabled = disabled || disabledFocusable || normalizedARIADisabled;\n\n  const handleClick = useEventCallback((ev: React.MouseEvent<ARIAButtonElementIntersection>) => {\n    if (isDisabled) {\n      ev.preventDefault();\n      ev.stopPropagation();\n    } else {\n      onClick?.(ev);\n    }\n  });\n\n  const handleKeyDown = useEventCallback((ev: React.KeyboardEvent<ARIAButtonElementIntersection>) => {\n    onKeyDown?.(ev);\n\n    if (ev.isDefaultPrevented()) {\n      return;\n    }\n\n    const key = ev.key;\n\n    if (isDisabled && (key === Enter || key === Space)) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      return;\n    }\n\n    if (key === Space) {\n      ev.preventDefault();\n      return;\n    }\n\n    // If enter is pressed, activate the button\n    else if (key === Enter) {\n      ev.preventDefault();\n      ev.currentTarget.click();\n    }\n  });\n\n  const handleKeyUp = useEventCallback((ev: React.KeyboardEvent<ARIAButtonElementIntersection>) => {\n    onKeyUp?.(ev);\n\n    if (ev.isDefaultPrevented()) {\n      return;\n    }\n\n    const key = ev.key;\n\n    if (isDisabled && (key === Enter || key === Space)) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      return;\n    }\n\n    if (key === Space) {\n      ev.preventDefault();\n      ev.currentTarget.click();\n    }\n  });\n\n  // If a <button> tag is to be rendered we just need to set disabled and aria-disabled correctly\n  if (type === 'button' || type === undefined) {\n    return {\n      ...rest,\n      disabled: disabled && !disabledFocusable,\n      'aria-disabled': disabledFocusable ? true : normalizedARIADisabled,\n      // onclick should still use internal handler to ensure prevention if disabled\n      // if disabledFocusable then there's no requirement for handlers as those events should not be propagated\n      onClick: disabledFocusable ? undefined : handleClick,\n      onKeyUp: disabledFocusable ? undefined : onKeyUp,\n      onKeyDown: disabledFocusable ? undefined : onKeyDown,\n    } as ARIAButtonResultProps<Type, Props>;\n  }\n\n  // If an <a> or <div> tag is to be rendered we have to remove disabled and type,\n  // and set aria-disabled, role and tabIndex.\n  else {\n    const resultProps = {\n      role: 'button',\n      tabIndex: disabled && !disabledFocusable ? undefined : 0,\n      ...rest,\n      // If it's not a <button> than listeners are required even with disabledFocusable\n      // Since you cannot assure the default behavior of the element\n      // E.g: <a> will redirect on click\n      onClick: handleClick,\n      onKeyUp: handleKeyUp,\n      onKeyDown: handleKeyDown,\n      'aria-disabled': disabled || disabledFocusable || normalizedARIADisabled,\n    } as ARIAButtonResultProps<Type, Props>;\n\n    if (type === 'a' && isDisabled) {\n      (resultProps as ARIAButtonResultProps<'a', Props>).href = undefined;\n    }\n\n    return resultProps;\n  }\n}\n"],"mappings":"AAAA,SAASA,KAAK,EAAEC,KAAK,QAAQ;AAC7B,SAASC,gBAAgB,QAAQ;AACjC,YAAYC,KAAA,MAAW;AAGvB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,SAASC,mBACdC,IAAW,EACXC,KAAa,EACuB;EACpC,MAAM;IACJC,QAAA;IACAC,iBAAA,GAAoB,KAAK;IACzB,CAAC,kBAAkBC,YAAA;IACnBC,OAAA;IACAC,SAAA;IACAC,OAAA;IACA,GAAGC;EAAA,CACJ,GAAGP,KAAA,aAAAA,KAAA,cAAAA,KAAA,GAAS,CAAC,CAAC;EAEf,MAAMQ,sBAAA,GAAyB,OAAOL,YAAA,KAAiB,WAAWA,YAAA,KAAiB,SAASA,YAAY;EAExG,MAAMM,UAAA,GAAaR,QAAA,IAAYC,iBAAA,IAAqBM,sBAAA;EAEpD,MAAME,WAAA,GAAcd,gBAAA,CAAkBe,EAAA,IAAwD;IAC5F,IAAIF,UAAA,EAAY;MACdE,EAAA,CAAGC,cAAc;MACjBD,EAAA,CAAGE,eAAe;IACpB,OAAO;MACLT,OAAA,aAAAA,OAAA,uBAAAA,OAAA,CAAUO,EAAA;IACZ;EACF;EAEA,MAAMG,aAAA,GAAgBlB,gBAAA,CAAkBe,EAAA,IAA2D;IACjGN,SAAA,aAAAA,SAAA,uBAAAA,SAAA,CAAYM,EAAA;IAEZ,IAAIA,EAAA,CAAGI,kBAAkB,IAAI;MAC3B;IACF;IAEA,MAAMC,GAAA,GAAML,EAAA,CAAGK,GAAG;IAElB,IAAIP,UAAA,KAAeO,GAAA,KAAQtB,KAAA,IAASsB,GAAA,KAAQrB,KAAI,GAAI;MAClDgB,EAAA,CAAGC,cAAc;MACjBD,EAAA,CAAGE,eAAe;MAClB;IACF;IAEA,IAAIG,GAAA,KAAQrB,KAAA,EAAO;MACjBgB,EAAA,CAAGC,cAAc;MACjB;IACF,OAGK,IAAII,GAAA,KAAQtB,KAAA,EAAO;MACtBiB,EAAA,CAAGC,cAAc;MACjBD,EAAA,CAAGM,aAAa,CAACC,KAAK;IACxB;EACF;EAEA,MAAMC,WAAA,GAAcvB,gBAAA,CAAkBe,EAAA,IAA2D;IAC/FL,OAAA,aAAAA,OAAA,uBAAAA,OAAA,CAAUK,EAAA;IAEV,IAAIA,EAAA,CAAGI,kBAAkB,IAAI;MAC3B;IACF;IAEA,MAAMC,GAAA,GAAML,EAAA,CAAGK,GAAG;IAElB,IAAIP,UAAA,KAAeO,GAAA,KAAQtB,KAAA,IAASsB,GAAA,KAAQrB,KAAI,GAAI;MAClDgB,EAAA,CAAGC,cAAc;MACjBD,EAAA,CAAGE,eAAe;MAClB;IACF;IAEA,IAAIG,GAAA,KAAQrB,KAAA,EAAO;MACjBgB,EAAA,CAAGC,cAAc;MACjBD,EAAA,CAAGM,aAAa,CAACC,KAAK;IACxB;EACF;EAEA;EACA,IAAInB,IAAA,KAAS,YAAYA,IAAA,KAASqB,SAAA,EAAW;IAC3C,OAAO;MACL,GAAGb,IAAI;MACPN,QAAA,EAAUA,QAAA,IAAY,CAACC,iBAAA;MACvB,iBAAiBA,iBAAA,GAAoB,IAAI,GAAGM,sBAAsB;MAClE;MACA;MACAJ,OAAA,EAASF,iBAAA,GAAoBkB,SAAA,GAAYV,WAAW;MACpDJ,OAAA,EAASJ,iBAAA,GAAoBkB,SAAA,GAAYd,OAAO;MAChDD,SAAA,EAAWH,iBAAA,GAAoBkB,SAAA,GAAYf;IAC7C;EACF,OAIK;IACH,MAAMgB,WAAA,GAAc;MAClBC,IAAA,EAAM;MACNC,QAAA,EAAUtB,QAAA,IAAY,CAACC,iBAAA,GAAoBkB,SAAA,GAAY,CAAC;MACxD,GAAGb,IAAI;MACP;MACA;MACA;MACAH,OAAA,EAASM,WAAA;MACTJ,OAAA,EAASa,WAAA;MACTd,SAAA,EAAWS,aAAA;MACX,iBAAiBb,QAAA,IAAYC,iBAAA,IAAqBM;IACpD;IAEA,IAAIT,IAAA,KAAS,OAAOU,UAAA,EAAY;MAC7BY,WAAA,CAAkDG,IAAI,GAAGJ,SAAA;IAC5D;IAEA,OAAOC,WAAA;EACT;AACF"}
+{"version":3,"sources":["useARIAButtonProps.ts"],"sourcesContent":["import { Enter, Space } from '@fluentui/keyboard-keys';\nimport { useEventCallback } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport type { ARIAButtonElementIntersection, ARIAButtonProps, ARIAButtonResultProps, ARIAButtonType } from './types';\n\n/**\n * @internal\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of non native button elements. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n *\n * @param type - the proper scenario to be interpreted by the hook.\n *  1. `button` - Minimal interference from the hook, as semantic button already supports most of the states\n *  2. `a` or `div` - Proper keyboard/mouse handling plus other support to ensure ARIA behavior\n * @param props - the props to be passed down the line to the desired element.\n * This hook will encapsulate proper properties, such as `onClick`, `onKeyDown`, `onKeyUp`, etc,.\n *\n * @example\n * ```tsx\n * const buttonProps = useARIAButtonProps('a', {\n *   href: './some-route'\n *   onClick: () => console.log('this should run both on click and Space and Enter')\n * })\n *\n * // ...\n *\n * return (\n *  <a {...buttonProps}>This anchor will behave as a proper button</a>\n * )\n * ```\n */\nexport function useARIAButtonProps<Type extends ARIAButtonType, Props extends ARIAButtonProps<Type>>(\n  type?: Type,\n  props?: Props,\n): ARIAButtonResultProps<Type, Props> {\n  const {\n    disabled,\n    disabledFocusable = false,\n    ['aria-disabled']: ariaDisabled,\n    onClick,\n    onKeyDown,\n    onKeyUp,\n    ...rest\n  } = props ?? {};\n\n  const normalizedARIADisabled = typeof ariaDisabled === 'string' ? ariaDisabled === 'true' : ariaDisabled;\n\n  const isDisabled = disabled || disabledFocusable || normalizedARIADisabled;\n\n  const handleClick = useEventCallback((ev: React.MouseEvent<ARIAButtonElementIntersection>) => {\n    if (isDisabled) {\n      ev.preventDefault();\n      ev.stopPropagation();\n    } else {\n      onClick?.(ev);\n    }\n  });\n\n  const handleKeyDown = useEventCallback((ev: React.KeyboardEvent<ARIAButtonElementIntersection>) => {\n    onKeyDown?.(ev);\n\n    if (ev.isDefaultPrevented()) {\n      return;\n    }\n\n    const key = ev.key;\n\n    if (isDisabled && (key === Enter || key === Space)) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      return;\n    }\n\n    if (key === Space) {\n      ev.preventDefault();\n      return;\n    }\n\n    // If enter is pressed, activate the button\n    else if (key === Enter) {\n      ev.preventDefault();\n      ev.currentTarget.click();\n    }\n  });\n\n  const handleKeyUp = useEventCallback((ev: React.KeyboardEvent<ARIAButtonElementIntersection>) => {\n    onKeyUp?.(ev);\n\n    if (ev.isDefaultPrevented()) {\n      return;\n    }\n\n    const key = ev.key;\n\n    if (isDisabled && (key === Enter || key === Space)) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      return;\n    }\n\n    if (key === Space) {\n      ev.preventDefault();\n      ev.currentTarget.click();\n    }\n  });\n\n  // If a <button> tag is to be rendered we just need to set disabled and aria-disabled correctly\n  if (type === 'button' || type === undefined) {\n    return {\n      ...rest,\n      disabled: disabled && !disabledFocusable,\n      'aria-disabled': disabledFocusable ? true : normalizedARIADisabled,\n      // onclick should still use internal handler to ensure prevention if disabled\n      // if disabledFocusable then there's no requirement for handlers as those events should not be propagated\n      onClick: disabledFocusable ? undefined : handleClick,\n      onKeyUp: disabledFocusable ? undefined : onKeyUp,\n      onKeyDown: disabledFocusable ? undefined : onKeyDown,\n    } as ARIAButtonResultProps<Type, Props>;\n  }\n\n  // If an <a> or <div> tag is to be rendered we have to remove disabled and type,\n  // and set aria-disabled, role and tabIndex.\n  else {\n    const resultProps = {\n      role: 'button',\n      tabIndex: disabled && !disabledFocusable ? undefined : 0,\n      ...rest,\n      // If it's not a <button> than listeners are required even with disabledFocusable\n      // Since you cannot assure the default behavior of the element\n      // E.g: <a> will redirect on click\n      onClick: handleClick,\n      onKeyUp: handleKeyUp,\n      onKeyDown: handleKeyDown,\n      'aria-disabled': disabled || disabledFocusable || normalizedARIADisabled,\n    } as ARIAButtonResultProps<Type, Props>;\n\n    if (type === 'a' && isDisabled) {\n      (resultProps as ARIAButtonResultProps<'a', Props>).href = undefined;\n    }\n\n    return resultProps;\n  }\n}\n"],"names":["Enter","Space","useEventCallback","React","useARIAButtonProps","type","props","disabled","disabledFocusable","ariaDisabled","onClick","onKeyDown","onKeyUp","rest","normalizedARIADisabled","isDisabled","handleClick","ev","preventDefault","stopPropagation","handleKeyDown","isDefaultPrevented","key","currentTarget","click","handleKeyUp","undefined","resultProps","role","tabIndex","href"],"mappings":"AAAA,SAASA,KAAK,EAAEC,KAAK,QAAQ,0BAA0B;AACvD,SAASC,gBAAgB,QAAQ,4BAA4B;AAC7D,YAAYC,WAAW,QAAQ;AAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GACD,OAAO,SAASC,mBACdC,IAAW,EACXC,KAAa,EACuB;IACpC,MAAM,EACJC,SAAQ,EACRC,mBAAoB,KAAK,CAAA,EACzB,CAAC,gBAAgB,EAAEC,aAAY,EAC/BC,QAAO,EACPC,UAAS,EACTC,QAAO,EACP,GAAGC,MACJ,GAAGP,kBAAAA,mBAAAA,QAAS,CAAC,CAAC;IAEf,MAAMQ,yBAAyB,OAAOL,iBAAiB,WAAWA,iBAAiB,SAASA,YAAY;IAExG,MAAMM,aAAaR,YAAYC,qBAAqBM;IAEpD,MAAME,cAAcd,iBAAiB,CAACe,KAAwD;QAC5F,IAAIF,YAAY;YACdE,GAAGC,cAAc;YACjBD,GAAGE,eAAe;QACpB,OAAO;YACLT,oBAAAA,qBAAAA,KAAAA,IAAAA,QAAUO;QACZ,CAAC;IACH;IAEA,MAAMG,gBAAgBlB,iBAAiB,CAACe,KAA2D;QACjGN,sBAAAA,uBAAAA,KAAAA,IAAAA,UAAYM;QAEZ,IAAIA,GAAGI,kBAAkB,IAAI;YAC3B;QACF,CAAC;QAED,MAAMC,MAAML,GAAGK,GAAG;QAElB,IAAIP,cAAeO,CAAAA,QAAQtB,SAASsB,QAAQrB,KAAI,GAAI;YAClDgB,GAAGC,cAAc;YACjBD,GAAGE,eAAe;YAClB;QACF,CAAC;QAED,IAAIG,QAAQrB,OAAO;YACjBgB,GAAGC,cAAc;YACjB;QACF,OAGK,IAAII,QAAQtB,OAAO;YACtBiB,GAAGC,cAAc;YACjBD,GAAGM,aAAa,CAACC,KAAK;QACxB,CAAC;IACH;IAEA,MAAMC,cAAcvB,iBAAiB,CAACe,KAA2D;QAC/FL,oBAAAA,qBAAAA,KAAAA,IAAAA,QAAUK;QAEV,IAAIA,GAAGI,kBAAkB,IAAI;YAC3B;QACF,CAAC;QAED,MAAMC,MAAML,GAAGK,GAAG;QAElB,IAAIP,cAAeO,CAAAA,QAAQtB,SAASsB,QAAQrB,KAAI,GAAI;YAClDgB,GAAGC,cAAc;YACjBD,GAAGE,eAAe;YAClB;QACF,CAAC;QAED,IAAIG,QAAQrB,OAAO;YACjBgB,GAAGC,cAAc;YACjBD,GAAGM,aAAa,CAACC,KAAK;QACxB,CAAC;IACH;IAEA,+FAA+F;IAC/F,IAAInB,SAAS,YAAYA,SAASqB,WAAW;QAC3C,OAAO;YACL,GAAGb,IAAI;YACPN,UAAUA,YAAY,CAACC;YACvB,iBAAiBA,oBAAoB,IAAI,GAAGM,sBAAsB;YAClE,6EAA6E;YAC7E,yGAAyG;YACzGJ,SAASF,oBAAoBkB,YAAYV,WAAW;YACpDJ,SAASJ,oBAAoBkB,YAAYd,OAAO;YAChDD,WAAWH,oBAAoBkB,YAAYf,SAAS;QACtD;IACF,OAIK;QACH,MAAMgB,cAAc;YAClBC,MAAM;YACNC,UAAUtB,YAAY,CAACC,oBAAoBkB,YAAY,CAAC;YACxD,GAAGb,IAAI;YACP,iFAAiF;YACjF,8DAA8D;YAC9D,kCAAkC;YAClCH,SAASM;YACTJ,SAASa;YACTd,WAAWS;YACX,iBAAiBb,YAAYC,qBAAqBM;QACpD;QAEA,IAAIT,SAAS,OAAOU,YAAY;YAC7BY,YAAkDG,IAAI,GAAGJ;QAC5D,CAAC;QAED,OAAOC;IACT,CAAC;AACH,CAAC"}

package/lib/button/useARIAButtonShorthand.js

@@ -8,11 +8,9 @@ import { useARIAButtonProps } from './useARIAButtonProps';
  * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec
  * for multiple scenarios of shorthand properties. Ensuring 1st rule of ARIA for cases
  * where no attribute addition is required.
- */
-export const useARIAButtonShorthand = (slot, options) => {
-  const shorthand = resolveShorthand(slot, options);
-  var _shorthand_as;
-  const shorthandARIAButton = useARIAButtonProps((_shorthand_as = shorthand === null || shorthand === void 0 ? void 0 : shorthand.as) !== null && _shorthand_as !== void 0 ? _shorthand_as : 'button', shorthand);
-  return shorthand && shorthandARIAButton;
+ */ export const useARIAButtonShorthand = (slot, options)=>{
+    const shorthand = resolveShorthand(slot, options);
+    var _shorthand_as;
+    const shorthandARIAButton = useARIAButtonProps((_shorthand_as = shorthand === null || shorthand === void 0 ? void 0 : shorthand.as) !== null && _shorthand_as !== void 0 ? _shorthand_as : 'button', shorthand);
+    return shorthand && shorthandARIAButton;
 };
-//# sourceMappingURL=useARIAButtonShorthand.js.map

package/lib/button/useARIAButtonShorthand.js.map

@@ -1 +1 @@
-{"version":3,"names":["resolveShorthand","useARIAButtonProps","useARIAButtonShorthand","slot","options","shorthand","_shorthand_as","shorthandARIAButton","as"],"sources":["../../src/button/useARIAButtonShorthand.ts"],"sourcesContent":["import { resolveShorthand } from '@fluentui/react-utilities';\nimport { useARIAButtonProps } from './useARIAButtonProps';\nimport type { ResolveShorthandFunction } from '@fluentui/react-utilities';\nimport type { ARIAButtonProps, ARIAButtonSlotProps, ARIAButtonType } from './types';\n\n/**\n * @internal\n *\n * This function expects to receive a slot, if `as` property is not desired use `useARIAButtonProps` instead\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of shorthand properties. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n */\nexport const useARIAButtonShorthand: ResolveShorthandFunction<ARIAButtonSlotProps> = (slot, options) => {\n  const shorthand = resolveShorthand(slot, options);\n  const shorthandARIAButton = useARIAButtonProps<ARIAButtonType, ARIAButtonProps>(shorthand?.as ?? 'button', shorthand);\n  return shorthand && shorthandARIAButton;\n};\n"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ;AACjC,SAASC,kBAAkB,QAAQ;AAInC;;;;;;;;;AASA,OAAO,MAAMC,sBAAA,GAAwEA,CAACC,IAAA,EAAMC,OAAA,KAAY;EACtG,MAAMC,SAAA,GAAYL,gBAAA,CAAiBG,IAAA,EAAMC,OAAA;MACuCE,aAAA;EAAhF,MAAMC,mBAAA,GAAsBN,kBAAA,CAAoD,CAAAK,aAAA,GAAAD,SAAA,aAAAA,SAAA,uBAAAA,SAAA,CAAWG,EAAE,cAAbF,aAAA,cAAAA,aAAA,GAAiB,QAAQ,EAAED,SAAA;EAC3G,OAAOA,SAAA,IAAaE,mBAAA;AACtB"}
+{"version":3,"sources":["useARIAButtonShorthand.ts"],"sourcesContent":["import { resolveShorthand } from '@fluentui/react-utilities';\nimport { useARIAButtonProps } from './useARIAButtonProps';\nimport type { ResolveShorthandFunction } from '@fluentui/react-utilities';\nimport type { ARIAButtonProps, ARIAButtonSlotProps, ARIAButtonType } from './types';\n\n/**\n * @internal\n *\n * This function expects to receive a slot, if `as` property is not desired use `useARIAButtonProps` instead\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of shorthand properties. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n */\nexport const useARIAButtonShorthand: ResolveShorthandFunction<ARIAButtonSlotProps> = (slot, options) => {\n  const shorthand = resolveShorthand(slot, options);\n  const shorthandARIAButton = useARIAButtonProps<ARIAButtonType, ARIAButtonProps>(shorthand?.as ?? 'button', shorthand);\n  return shorthand && shorthandARIAButton;\n};\n"],"names":["resolveShorthand","useARIAButtonProps","useARIAButtonShorthand","slot","options","shorthand","shorthandARIAButton","as"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,4BAA4B;AAC7D,SAASC,kBAAkB,QAAQ,uBAAuB;AAI1D;;;;;;;;CAQC,GACD,OAAO,MAAMC,yBAAwE,CAACC,MAAMC,UAAY;IACtG,MAAMC,YAAYL,iBAAiBG,MAAMC;QACuCC;IAAhF,MAAMC,sBAAsBL,mBAAoDI,CAAAA,gBAAAA,sBAAAA,uBAAAA,KAAAA,IAAAA,UAAWE,EAAE,cAAbF,2BAAAA,gBAAiB,QAAQ,EAAEA;IAC3G,OAAOA,aAAaC;AACtB,EAAE"}

package/lib/index.js

@@ -1,2 +1 @@
 export { useARIAButtonShorthand, useARIAButtonProps } from './button/index';
-//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["useARIAButtonShorthand","useARIAButtonProps"],"sources":["../src/index.ts"],"sourcesContent":["export { useARIAButtonShorthand, useARIAButtonProps } from './button/index';\nexport type {\n  ARIAButtonSlotProps,\n  ARIAButtonProps,\n  ARIAButtonResultProps,\n  ARIAButtonType,\n  ARIAButtonElement,\n  ARIAButtonElementIntersection,\n  ARIAButtonAlteredProps,\n} from './button/index';\n"],"mappings":"AAAA,SAASA,sBAAsB,EAAEC,kBAAkB,QAAQ"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export { useARIAButtonShorthand, useARIAButtonProps } from './button/index';\nexport type {\n  ARIAButtonSlotProps,\n  ARIAButtonProps,\n  ARIAButtonResultProps,\n  ARIAButtonType,\n  ARIAButtonElement,\n  ARIAButtonElementIntersection,\n  ARIAButtonAlteredProps,\n} from './button/index';\n"],"names":["useARIAButtonShorthand","useARIAButtonProps"],"mappings":"AAAA,SAASA,sBAAsB,EAAEC,kBAAkB,QAAQ,iBAAiB"}

package/lib-commonjs/button/index.js

@@ -6,6 +6,3 @@ const _exportStar = require("@swc/helpers/lib/_export_star.js").default;
 _exportStar(require("./useARIAButtonProps"), exports);
 _exportStar(require("./useARIAButtonShorthand"), exports);
 _exportStar(require("./types"), exports);
- //# sourceMappingURL=index.js.map
-
-//# sourceMappingURL=index.js.map

package/lib-commonjs/button/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/button/index.js"],"sourcesContent":["export * from './useARIAButtonProps';\nexport * from './useARIAButtonShorthand';\nexport * from './types';\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":";;;;;oBAAc;oBACA;oBACA;CACd,iCAAiC"}
+{"version":3,"sources":["index.js"],"sourcesContent":["export * from './useARIAButtonProps';\nexport * from './useARIAButtonShorthand';\nexport * from './types';\n"],"names":[],"mappings":";;;;;oBAAc;oBACA;oBACA"}

package/lib-commonjs/button/types.js

@@ -4,6 +4,3 @@ Object.defineProperty(exports, "__esModule", {
 });
 const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
 const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
- //# sourceMappingURL=types.js.map
-
-//# sourceMappingURL=types.js.map

package/lib-commonjs/button/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/button/types.js"],"sourcesContent":["import * as React from 'react';\n//# sourceMappingURL=types.js.map"],"names":[],"mappings":";;;;;6DAAuB;CACvB,iCAAiC"}
+{"version":3,"sources":["types.js"],"sourcesContent":["import * as React from 'react';\n"],"names":[],"mappings":";;;;;6DAAuB"}

package/lib-commonjs/button/useARIAButtonProps.js

@@ -87,6 +87,4 @@ function useARIAButtonProps(type, props) {
         }
         return resultProps;
     }
-} //# sourceMappingURL=useARIAButtonProps.js.map
-
-//# sourceMappingURL=useARIAButtonProps.js.map
+}

package/lib-commonjs/button/useARIAButtonProps.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/button/useARIAButtonProps.js"],"sourcesContent":["import { Enter, Space } from '@fluentui/keyboard-keys';\nimport { useEventCallback } from '@fluentui/react-utilities';\nimport * as React from 'react';\n/**\n * @internal\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of non native button elements. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n *\n * @param type - the proper scenario to be interpreted by the hook.\n *  1. `button` - Minimal interference from the hook, as semantic button already supports most of the states\n *  2. `a` or `div` - Proper keyboard/mouse handling plus other support to ensure ARIA behavior\n * @param props - the props to be passed down the line to the desired element.\n * This hook will encapsulate proper properties, such as `onClick`, `onKeyDown`, `onKeyUp`, etc,.\n *\n * @example\n * ```tsx\n * const buttonProps = useARIAButtonProps('a', {\n *   href: './some-route'\n *   onClick: () => console.log('this should run both on click and Space and Enter')\n * })\n *\n * // ...\n *\n * return (\n *  <a {...buttonProps}>This anchor will behave as a proper button</a>\n * )\n * ```\n */\nexport function useARIAButtonProps(type, props) {\n  const {\n    disabled,\n    disabledFocusable = false,\n    ['aria-disabled']: ariaDisabled,\n    onClick,\n    onKeyDown,\n    onKeyUp,\n    ...rest\n  } = props !== null && props !== void 0 ? props : {};\n  const normalizedARIADisabled = typeof ariaDisabled === 'string' ? ariaDisabled === 'true' : ariaDisabled;\n  const isDisabled = disabled || disabledFocusable || normalizedARIADisabled;\n  const handleClick = useEventCallback(ev => {\n    if (isDisabled) {\n      ev.preventDefault();\n      ev.stopPropagation();\n    } else {\n      onClick === null || onClick === void 0 ? void 0 : onClick(ev);\n    }\n  });\n  const handleKeyDown = useEventCallback(ev => {\n    onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(ev);\n    if (ev.isDefaultPrevented()) {\n      return;\n    }\n    const key = ev.key;\n    if (isDisabled && (key === Enter || key === Space)) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      return;\n    }\n    if (key === Space) {\n      ev.preventDefault();\n      return;\n    } else if (key === Enter) {\n      ev.preventDefault();\n      ev.currentTarget.click();\n    }\n  });\n  const handleKeyUp = useEventCallback(ev => {\n    onKeyUp === null || onKeyUp === void 0 ? void 0 : onKeyUp(ev);\n    if (ev.isDefaultPrevented()) {\n      return;\n    }\n    const key = ev.key;\n    if (isDisabled && (key === Enter || key === Space)) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      return;\n    }\n    if (key === Space) {\n      ev.preventDefault();\n      ev.currentTarget.click();\n    }\n  });\n  // If a <button> tag is to be rendered we just need to set disabled and aria-disabled correctly\n  if (type === 'button' || type === undefined) {\n    return {\n      ...rest,\n      disabled: disabled && !disabledFocusable,\n      'aria-disabled': disabledFocusable ? true : normalizedARIADisabled,\n      // onclick should still use internal handler to ensure prevention if disabled\n      // if disabledFocusable then there's no requirement for handlers as those events should not be propagated\n      onClick: disabledFocusable ? undefined : handleClick,\n      onKeyUp: disabledFocusable ? undefined : onKeyUp,\n      onKeyDown: disabledFocusable ? undefined : onKeyDown\n    };\n  } else {\n    const resultProps = {\n      role: 'button',\n      tabIndex: disabled && !disabledFocusable ? undefined : 0,\n      ...rest,\n      // If it's not a <button> than listeners are required even with disabledFocusable\n      // Since you cannot assure the default behavior of the element\n      // E.g: <a> will redirect on click\n      onClick: handleClick,\n      onKeyUp: handleKeyUp,\n      onKeyDown: handleKeyDown,\n      'aria-disabled': disabled || disabledFocusable || normalizedARIADisabled\n    };\n    if (type === 'a' && isDisabled) {\n      resultProps.href = undefined;\n    }\n    return resultProps;\n  }\n}\n//# sourceMappingURL=useARIAButtonProps.js.map"],"names":["useARIAButtonProps","type","props","disabled","disabledFocusable","ariaDisabled","onClick","onKeyDown","onKeyUp","rest","normalizedARIADisabled","isDisabled","handleClick","useEventCallback","ev","preventDefault","stopPropagation","handleKeyDown","isDefaultPrevented","key","Enter","Space","currentTarget","click","handleKeyUp","undefined","resultProps","role","tabIndex","href"],"mappings":";;;;+BA8BgBA;;aAAAA;;;8BA9Ba;gCACI;6DACV;AA4BhB,SAASA,mBAAmBC,IAAI,EAAEC,KAAK,EAAE;IAC9C,MAAM,EACJC,SAAQ,EACRC,mBAAoB,KAAK,CAAA,EACzB,CAAC,gBAAgB,EAAEC,aAAY,EAC/BC,QAAO,EACPC,UAAS,EACTC,QAAO,EACP,GAAGC,MACJ,GAAGP,UAAU,IAAI,IAAIA,UAAU,KAAK,IAAIA,QAAQ,CAAC,CAAC;IACnD,MAAMQ,yBAAyB,OAAOL,iBAAiB,WAAWA,iBAAiB,SAASA,YAAY;IACxG,MAAMM,aAAaR,YAAYC,qBAAqBM;IACpD,MAAME,cAAcC,IAAAA,gCAAgB,EAACC,CAAAA,KAAM;QACzC,IAAIH,YAAY;YACdG,GAAGC,cAAc;YACjBD,GAAGE,eAAe;QACpB,OAAO;YACLV,YAAY,IAAI,IAAIA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQQ,GAAG;QAC/D,CAAC;IACH;IACA,MAAMG,gBAAgBJ,IAAAA,gCAAgB,EAACC,CAAAA,KAAM;QAC3CP,cAAc,IAAI,IAAIA,cAAc,KAAK,IAAI,KAAK,IAAIA,UAAUO,GAAG;QACnE,IAAIA,GAAGI,kBAAkB,IAAI;YAC3B;QACF,CAAC;QACD,MAAMC,MAAML,GAAGK,GAAG;QAClB,IAAIR,cAAeQ,CAAAA,QAAQC,mBAAK,IAAID,QAAQE,mBAAK,AAAD,GAAI;YAClDP,GAAGC,cAAc;YACjBD,GAAGE,eAAe;YAClB;QACF,CAAC;QACD,IAAIG,QAAQE,mBAAK,EAAE;YACjBP,GAAGC,cAAc;YACjB;QACF,OAAO,IAAII,QAAQC,mBAAK,EAAE;YACxBN,GAAGC,cAAc;YACjBD,GAAGQ,aAAa,CAACC,KAAK;QACxB,CAAC;IACH;IACA,MAAMC,cAAcX,IAAAA,gCAAgB,EAACC,CAAAA,KAAM;QACzCN,YAAY,IAAI,IAAIA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQM,GAAG;QAC7D,IAAIA,GAAGI,kBAAkB,IAAI;YAC3B;QACF,CAAC;QACD,MAAMC,MAAML,GAAGK,GAAG;QAClB,IAAIR,cAAeQ,CAAAA,QAAQC,mBAAK,IAAID,QAAQE,mBAAK,AAAD,GAAI;YAClDP,GAAGC,cAAc;YACjBD,GAAGE,eAAe;YAClB;QACF,CAAC;QACD,IAAIG,QAAQE,mBAAK,EAAE;YACjBP,GAAGC,cAAc;YACjBD,GAAGQ,aAAa,CAACC,KAAK;QACxB,CAAC;IACH;IACA,+FAA+F;IAC/F,IAAItB,SAAS,YAAYA,SAASwB,WAAW;QAC3C,OAAO;YACL,GAAGhB,IAAI;YACPN,UAAUA,YAAY,CAACC;YACvB,iBAAiBA,oBAAoB,IAAI,GAAGM,sBAAsB;YAClE,6EAA6E;YAC7E,yGAAyG;YACzGJ,SAASF,oBAAoBqB,YAAYb,WAAW;YACpDJ,SAASJ,oBAAoBqB,YAAYjB,OAAO;YAChDD,WAAWH,oBAAoBqB,YAAYlB,SAAS;QACtD;IACF,OAAO;QACL,MAAMmB,cAAc;YAClBC,MAAM;YACNC,UAAUzB,YAAY,CAACC,oBAAoBqB,YAAY,CAAC;YACxD,GAAGhB,IAAI;YACP,iFAAiF;YACjF,8DAA8D;YAC9D,kCAAkC;YAClCH,SAASM;YACTJ,SAASgB;YACTjB,WAAWU;YACX,iBAAiBd,YAAYC,qBAAqBM;QACpD;QACA,IAAIT,SAAS,OAAOU,YAAY;YAC9Be,YAAYG,IAAI,GAAGJ;QACrB,CAAC;QACD,OAAOC;IACT,CAAC;AACH,EACA,8CAA8C"}
+{"version":3,"sources":["useARIAButtonProps.js"],"sourcesContent":["import { Enter, Space } from '@fluentui/keyboard-keys';\nimport { useEventCallback } from '@fluentui/react-utilities';\nimport * as React from 'react';\n/**\n * @internal\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of non native button elements. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n *\n * @param type - the proper scenario to be interpreted by the hook.\n *  1. `button` - Minimal interference from the hook, as semantic button already supports most of the states\n *  2. `a` or `div` - Proper keyboard/mouse handling plus other support to ensure ARIA behavior\n * @param props - the props to be passed down the line to the desired element.\n * This hook will encapsulate proper properties, such as `onClick`, `onKeyDown`, `onKeyUp`, etc,.\n *\n * @example\n * ```tsx\n * const buttonProps = useARIAButtonProps('a', {\n *   href: './some-route'\n *   onClick: () => console.log('this should run both on click and Space and Enter')\n * })\n *\n * // ...\n *\n * return (\n *  <a {...buttonProps}>This anchor will behave as a proper button</a>\n * )\n * ```\n */ export function useARIAButtonProps(type, props) {\n    const { disabled , disabledFocusable =false , ['aria-disabled']: ariaDisabled , onClick , onKeyDown , onKeyUp , ...rest } = props !== null && props !== void 0 ? props : {};\n    const normalizedARIADisabled = typeof ariaDisabled === 'string' ? ariaDisabled === 'true' : ariaDisabled;\n    const isDisabled = disabled || disabledFocusable || normalizedARIADisabled;\n    const handleClick = useEventCallback((ev)=>{\n        if (isDisabled) {\n            ev.preventDefault();\n            ev.stopPropagation();\n        } else {\n            onClick === null || onClick === void 0 ? void 0 : onClick(ev);\n        }\n    });\n    const handleKeyDown = useEventCallback((ev)=>{\n        onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(ev);\n        if (ev.isDefaultPrevented()) {\n            return;\n        }\n        const key = ev.key;\n        if (isDisabled && (key === Enter || key === Space)) {\n            ev.preventDefault();\n            ev.stopPropagation();\n            return;\n        }\n        if (key === Space) {\n            ev.preventDefault();\n            return;\n        } else if (key === Enter) {\n            ev.preventDefault();\n            ev.currentTarget.click();\n        }\n    });\n    const handleKeyUp = useEventCallback((ev)=>{\n        onKeyUp === null || onKeyUp === void 0 ? void 0 : onKeyUp(ev);\n        if (ev.isDefaultPrevented()) {\n            return;\n        }\n        const key = ev.key;\n        if (isDisabled && (key === Enter || key === Space)) {\n            ev.preventDefault();\n            ev.stopPropagation();\n            return;\n        }\n        if (key === Space) {\n            ev.preventDefault();\n            ev.currentTarget.click();\n        }\n    });\n    // If a <button> tag is to be rendered we just need to set disabled and aria-disabled correctly\n    if (type === 'button' || type === undefined) {\n        return {\n            ...rest,\n            disabled: disabled && !disabledFocusable,\n            'aria-disabled': disabledFocusable ? true : normalizedARIADisabled,\n            // onclick should still use internal handler to ensure prevention if disabled\n            // if disabledFocusable then there's no requirement for handlers as those events should not be propagated\n            onClick: disabledFocusable ? undefined : handleClick,\n            onKeyUp: disabledFocusable ? undefined : onKeyUp,\n            onKeyDown: disabledFocusable ? undefined : onKeyDown\n        };\n    } else {\n        const resultProps = {\n            role: 'button',\n            tabIndex: disabled && !disabledFocusable ? undefined : 0,\n            ...rest,\n            // If it's not a <button> than listeners are required even with disabledFocusable\n            // Since you cannot assure the default behavior of the element\n            // E.g: <a> will redirect on click\n            onClick: handleClick,\n            onKeyUp: handleKeyUp,\n            onKeyDown: handleKeyDown,\n            'aria-disabled': disabled || disabledFocusable || normalizedARIADisabled\n        };\n        if (type === 'a' && isDisabled) {\n            resultProps.href = undefined;\n        }\n        return resultProps;\n    }\n}\n"],"names":["useARIAButtonProps","type","props","disabled","disabledFocusable","ariaDisabled","onClick","onKeyDown","onKeyUp","rest","normalizedARIADisabled","isDisabled","handleClick","useEventCallback","ev","preventDefault","stopPropagation","handleKeyDown","isDefaultPrevented","key","Enter","Space","currentTarget","click","handleKeyUp","undefined","resultProps","role","tabIndex","href"],"mappings":";;;;+BA6BoBA;;aAAAA;;;8BA7BS;gCACI;6DACV;AA2BZ,SAASA,mBAAmBC,IAAI,EAAEC,KAAK,EAAE;IAChD,MAAM,EAAEC,SAAQ,EAAGC,mBAAmB,KAAK,CAAA,EAAG,CAAC,gBAAgB,EAAEC,aAAY,EAAGC,QAAO,EAAGC,UAAS,EAAGC,QAAO,EAAG,GAAGC,MAAM,GAAGP,UAAU,IAAI,IAAIA,UAAU,KAAK,IAAIA,QAAQ,CAAC,CAAC;IAC3K,MAAMQ,yBAAyB,OAAOL,iBAAiB,WAAWA,iBAAiB,SAASA,YAAY;IACxG,MAAMM,aAAaR,YAAYC,qBAAqBM;IACpD,MAAME,cAAcC,IAAAA,gCAAgB,EAAC,CAACC,KAAK;QACvC,IAAIH,YAAY;YACZG,GAAGC,cAAc;YACjBD,GAAGE,eAAe;QACtB,OAAO;YACHV,YAAY,IAAI,IAAIA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQQ,GAAG;QACjE,CAAC;IACL;IACA,MAAMG,gBAAgBJ,IAAAA,gCAAgB,EAAC,CAACC,KAAK;QACzCP,cAAc,IAAI,IAAIA,cAAc,KAAK,IAAI,KAAK,IAAIA,UAAUO,GAAG;QACnE,IAAIA,GAAGI,kBAAkB,IAAI;YACzB;QACJ,CAAC;QACD,MAAMC,MAAML,GAAGK,GAAG;QAClB,IAAIR,cAAeQ,CAAAA,QAAQC,mBAAK,IAAID,QAAQE,mBAAK,AAAD,GAAI;YAChDP,GAAGC,cAAc;YACjBD,GAAGE,eAAe;YAClB;QACJ,CAAC;QACD,IAAIG,QAAQE,mBAAK,EAAE;YACfP,GAAGC,cAAc;YACjB;QACJ,OAAO,IAAII,QAAQC,mBAAK,EAAE;YACtBN,GAAGC,cAAc;YACjBD,GAAGQ,aAAa,CAACC,KAAK;QAC1B,CAAC;IACL;IACA,MAAMC,cAAcX,IAAAA,gCAAgB,EAAC,CAACC,KAAK;QACvCN,YAAY,IAAI,IAAIA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQM,GAAG;QAC7D,IAAIA,GAAGI,kBAAkB,IAAI;YACzB;QACJ,CAAC;QACD,MAAMC,MAAML,GAAGK,GAAG;QAClB,IAAIR,cAAeQ,CAAAA,QAAQC,mBAAK,IAAID,QAAQE,mBAAK,AAAD,GAAI;YAChDP,GAAGC,cAAc;YACjBD,GAAGE,eAAe;YAClB;QACJ,CAAC;QACD,IAAIG,QAAQE,mBAAK,EAAE;YACfP,GAAGC,cAAc;YACjBD,GAAGQ,aAAa,CAACC,KAAK;QAC1B,CAAC;IACL;IACA,+FAA+F;IAC/F,IAAItB,SAAS,YAAYA,SAASwB,WAAW;QACzC,OAAO;YACH,GAAGhB,IAAI;YACPN,UAAUA,YAAY,CAACC;YACvB,iBAAiBA,oBAAoB,IAAI,GAAGM,sBAAsB;YAClE,6EAA6E;YAC7E,yGAAyG;YACzGJ,SAASF,oBAAoBqB,YAAYb,WAAW;YACpDJ,SAASJ,oBAAoBqB,YAAYjB,OAAO;YAChDD,WAAWH,oBAAoBqB,YAAYlB,SAAS;QACxD;IACJ,OAAO;QACH,MAAMmB,cAAc;YAChBC,MAAM;YACNC,UAAUzB,YAAY,CAACC,oBAAoBqB,YAAY,CAAC;YACxD,GAAGhB,IAAI;YACP,iFAAiF;YACjF,8DAA8D;YAC9D,kCAAkC;YAClCH,SAASM;YACTJ,SAASgB;YACTjB,WAAWU;YACX,iBAAiBd,YAAYC,qBAAqBM;QACtD;QACA,IAAIT,SAAS,OAAOU,YAAY;YAC5Be,YAAYG,IAAI,GAAGJ;QACvB,CAAC;QACD,OAAOC;IACX,CAAC;AACL"}

package/lib-commonjs/button/useARIAButtonShorthand.js

@@ -13,6 +13,4 @@ const useARIAButtonShorthand = (slot, options)=>{
     var _shorthand_as;
     const shorthandARIAButton = (0, _useARIAButtonProps.useARIAButtonProps)((_shorthand_as = shorthand === null || shorthand === void 0 ? void 0 : shorthand.as) !== null && _shorthand_as !== void 0 ? _shorthand_as : 'button', shorthand);
     return shorthand && shorthandARIAButton;
-}; //# sourceMappingURL=useARIAButtonShorthand.js.map
-
-//# sourceMappingURL=useARIAButtonShorthand.js.map
+};

package/lib-commonjs/button/useARIAButtonShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../lib/button/useARIAButtonShorthand.js"],"sourcesContent":["import { resolveShorthand } from '@fluentui/react-utilities';\nimport { useARIAButtonProps } from './useARIAButtonProps';\n/**\n * @internal\n *\n * This function expects to receive a slot, if `as` property is not desired use `useARIAButtonProps` instead\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of shorthand properties. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n */\nexport const useARIAButtonShorthand = (slot, options) => {\n  const shorthand = resolveShorthand(slot, options);\n  var _shorthand_as;\n  const shorthandARIAButton = useARIAButtonProps((_shorthand_as = shorthand === null || shorthand === void 0 ? void 0 : shorthand.as) !== null && _shorthand_as !== void 0 ? _shorthand_as : 'button', shorthand);\n  return shorthand && shorthandARIAButton;\n};\n//# sourceMappingURL=useARIAButtonShorthand.js.map"],"names":["useARIAButtonShorthand","slot","options","shorthand","resolveShorthand","_shorthand_as","shorthandARIAButton","useARIAButtonProps","as"],"mappings":";;;;+BAWaA;;aAAAA;;gCAXoB;oCACE;AAU5B,MAAMA,yBAAyB,CAACC,MAAMC,UAAY;IACvD,MAAMC,YAAYC,IAAAA,gCAAgB,EAACH,MAAMC;IACzC,IAAIG;IACJ,MAAMC,sBAAsBC,IAAAA,sCAAkB,EAAC,AAACF,CAAAA,gBAAgBF,cAAc,IAAI,IAAIA,cAAc,KAAK,IAAI,KAAK,IAAIA,UAAUK,EAAE,AAAD,MAAO,IAAI,IAAIH,kBAAkB,KAAK,IAAIA,gBAAgB,QAAQ,EAAEF;IACrM,OAAOA,aAAaG;AACtB,GACA,kDAAkD"}
+{"version":3,"sources":["useARIAButtonShorthand.js"],"sourcesContent":["import { resolveShorthand } from '@fluentui/react-utilities';\nimport { useARIAButtonProps } from './useARIAButtonProps';\n/**\n * @internal\n *\n * This function expects to receive a slot, if `as` property is not desired use `useARIAButtonProps` instead\n *\n * Button keyboard handling, role, disabled and tabIndex implementation that ensures ARIA spec\n * for multiple scenarios of shorthand properties. Ensuring 1st rule of ARIA for cases\n * where no attribute addition is required.\n */ export const useARIAButtonShorthand = (slot, options)=>{\n    const shorthand = resolveShorthand(slot, options);\n    var _shorthand_as;\n    const shorthandARIAButton = useARIAButtonProps((_shorthand_as = shorthand === null || shorthand === void 0 ? void 0 : shorthand.as) !== null && _shorthand_as !== void 0 ? _shorthand_as : 'button', shorthand);\n    return shorthand && shorthandARIAButton;\n};\n"],"names":["useARIAButtonShorthand","slot","options","shorthand","resolveShorthand","_shorthand_as","shorthandARIAButton","useARIAButtonProps","as"],"mappings":";;;;+BAUiBA;;aAAAA;;gCAVgB;oCACE;AASxB,MAAMA,yBAAyB,CAACC,MAAMC,UAAU;IACvD,MAAMC,YAAYC,IAAAA,gCAAgB,EAACH,MAAMC;IACzC,IAAIG;IACJ,MAAMC,sBAAsBC,IAAAA,sCAAkB,EAAC,AAACF,CAAAA,gBAAgBF,cAAc,IAAI,IAAIA,cAAc,KAAK,IAAI,KAAK,IAAIA,UAAUK,EAAE,AAAD,MAAO,IAAI,IAAIH,kBAAkB,KAAK,IAAIA,gBAAgB,QAAQ,EAAEF;IACrM,OAAOA,aAAaG;AACxB"}

package/lib-commonjs/index.js

@@ -13,6 +13,3 @@ _export(exports, {
     useARIAButtonProps: ()=>_index.useARIAButtonProps
 });
 const _index = require("./button/index");
- //# sourceMappingURL=index.js.map
-
-//# sourceMappingURL=index.js.map

package/lib-commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../lib/index.js"],"sourcesContent":["export { useARIAButtonShorthand, useARIAButtonProps } from './button/index';\n//# sourceMappingURL=index.js.map"],"names":["useARIAButtonShorthand","useARIAButtonProps"],"mappings":";;;;;;;;;;;IAASA,sBAAsB,MAAtBA,6BAAsB;IAAEC,kBAAkB,MAAlBA,yBAAkB;;uBAAQ;CAC3D,iCAAiC"}
+{"version":3,"sources":["index.js"],"sourcesContent":["export { useARIAButtonShorthand, useARIAButtonProps } from './button/index';\n"],"names":["useARIAButtonShorthand","useARIAButtonProps"],"mappings":";;;;;;;;;;;IAASA,sBAAsB,MAAtBA,6BAAsB;IAAEC,kBAAkB,MAAlBA,yBAAkB;;uBAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-aria",
-  "version": "9.3.20",
+  "version": "9.3.22",
   "description": "React helper to ensure ARIA",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -22,7 +22,7 @@
     "storybook": "start-storybook",
     "type-check": "tsc -b tsconfig.json",
     "generate-api": "just-scripts generate-api",
-    "test-ssr": "test-ssr ./stories/**/*.stories.tsx"
+    "test-ssr": "test-ssr \"./stories/**/*.stories.tsx\""
   },
   "devDependencies": {
     "@fluentui/eslint-plugin": "*",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@fluentui/keyboard-keys": "^9.0.3",
-    "@fluentui/react-utilities": "^9.9.0",
+    "@fluentui/react-utilities": "^9.9.2",
     "@swc/helpers": "^0.4.14"
   },
   "peerDependencies": {