diff --git a/README.md b/README.md
index 94aa29e..420bf64 100644
--- a/README.md
+++ b/README.md
@@ -134,6 +134,7 @@ Any use of third-party trademarks or logos are subject to those third-party's po
 | [no-empty-buttons](docs/rules/no-empty-buttons.md)                                                                     | Accessibility: Button, ToggleButton, SplitButton, MenuButton, CompoundButton must either text content or icon or child component                       | ✅  |    |    |
 | [no-empty-components](docs/rules/no-empty-components.md)                                                               | FluentUI components should not be empty                                                                                                                | ✅  |    |    |
 | [prefer-aria-over-title-attribute](docs/rules/prefer-aria-over-title-attribute.md)                                     | The title attribute is not consistently read by screen readers, and its behavior can vary depending on the screen reader and the user's settings.      |    | ✅  | 🔧 |
+| [prefer-disabledfocusable-over-disabled](docs/rules/prefer-disabledfocusable-over-disabled.md)                         | Prefer 'disabledFocusable' over 'disabled' when component has loading state to maintain keyboard navigation accessibility                              |    | ✅  | 🔧 |
 | [progressbar-needs-labelling](docs/rules/progressbar-needs-labelling.md)                                               | Accessibility: Progressbar must have aria-valuemin, aria-valuemax, aria-valuenow, aria-describedby and either aria-label or aria-labelledby attributes | ✅  |    |    |
 | [radio-button-missing-label](docs/rules/radio-button-missing-label.md)                                                 | Accessibility: Radio button without label must have an accessible and visual label: aria-labelledby                                                    | ✅  |    |    |
 | [radiogroup-missing-label](docs/rules/radiogroup-missing-label.md)                                                     | Accessibility: RadioGroup without label must have an accessible and visual label: aria-labelledby                                                      | ✅  |    |    |
diff --git a/docs/rules/prefer-disabledfocusable-over-disabled.md b/docs/rules/prefer-disabledfocusable-over-disabled.md
new file mode 100644
index 0000000..2b0cb3f
--- /dev/null
+++ b/docs/rules/prefer-disabledfocusable-over-disabled.md
@@ -0,0 +1,139 @@
+# Prefer 'disabledFocusable' over 'disabled' when component has loading state to maintain keyboard navigation accessibility (`@microsoft/fluentui-jsx-a11y/prefer-disabledfocusable-over-disabled`)
+
+⚠️ This rule _warns_ in the ✅ `recommended` config.
+
+🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+When components are in a loading state, prefer using `disabledFocusable` over `disabled` to maintain proper keyboard navigation flow and accessibility.
+
+## Rule Details
+
+This rule encourages the use of `disabledFocusable` instead of `disabled` when components have loading state indicators. This ensures:
+
+1. **Keyboard Navigation**: The component remains in the keyboard tab order, allowing users to discover and navigate to it
+2. **Screen Reader Compatibility**: Screen reader users can still navigate to and understand the component's state  
+3. **Loading State Awareness**: Users understand that the component is temporarily unavailable due to loading, not permanently disabled
+4. **Consistent UX**: Provides a more predictable and accessible user experience
+
+### Accessibility Impact
+
+- `disabled` removes elements completely from the tab order (tabindex="-1")
+- `disabledFocusable` keeps elements in the tab order while conveying disabled state via `aria-disabled="true"`
+- Loading states are temporary conditions where users benefit from knowing the component exists and will become available
+
+### Applicable Components
+
+This rule applies to FluentUI components that support both `disabled` and `disabledFocusable` props:
+
+**Button Components:** `Button`, `ToggleButton`, `CompoundButton`, `MenuButton`, `SplitButton`
+**Form Controls:** `Checkbox`, `Radio`, `Switch`  
+**Input Components:** `Input`, `Textarea`, `Combobox`, `Dropdown`, `SpinButton`, `Slider`, `DatePicker`, `TimePicker`
+**Other Interactive:** `Link`, `Tab`
+
+### Loading State Indicators
+
+The rule detects these loading-related props:
+- `loading`
+- `isLoading`
+- `pending` 
+- `isPending`
+- `busy`
+- `isBusy`
+
+## Examples
+
+### ❌ Incorrect
+
+```jsx
+<Button disabled loading>Submit</Button>
+<ToggleButton disabled isLoading />
+<Checkbox disabled pending />
+<Input disabled={true} busy={isBusy} />
+<SpinButton disabled={isDisabled} loading={isSubmitting} />
+<Combobox disabled pending />
+```
+
+### ✅ Correct
+
+```jsx
+<Button disabledFocusable loading>Submit</Button>
+<ToggleButton disabledFocusable isLoading />
+<Checkbox disabledFocusable pending />
+<Input disabledFocusable={true} busy={isBusy} />
+<SpinButton disabledFocusable={isDisabled} loading={isSubmitting} />
+<Combobox disabledFocusable pending />
+
+<!-- These are acceptable since no loading state is present -->
+<Button disabled>Cancel</Button>
+<Checkbox disabled />
+<Input disabled={permanentlyDisabled} />
+
+<!-- These are acceptable since component is not disabled -->
+<Button loading>Submit</Button>
+<SpinButton isLoading />
+<Input busy />
+```
+
+## Edge Cases & Considerations
+
+### Both Props Present
+If both `disabled` and `disabledFocusable` are present, this rule will not trigger as it represents a different configuration issue.
+
+```jsx
+<!-- Rule will not trigger - different concern -->
+<Button disabled disabledFocusable loading>Submit</Button>
+```
+
+### Non-Loading Disabled States
+The rule only applies when both disabled AND loading states are present:
+
+```jsx
+<!-- ✅ Acceptable - no loading state -->
+<Button disabled>Permanently Disabled Action</Button>
+```
+
+### Complex Expressions
+The rule works with boolean expressions and variables:
+
+```jsx
+<!-- ❌ Will trigger -->
+<Button disabled={!isEnabled} loading={isSubmitting}>Submit</Button>
+
+<!-- ✅ Correct -->
+<Button disabledFocusable={!isEnabled} loading={isSubmitting}>Submit</Button>
+```
+
+## When Not To Use It
+
+You may want to disable this rule if:
+
+1. **Intentional UX Decision**: You specifically want loading components removed from tab order
+2. **Legacy Codebase**: Existing implementations rely on specific disabled behavior during loading
+3. **Custom Loading Patterns**: Your application uses non-standard loading state management
+
+However, disabling this rule is generally **not recommended** as it reduces accessibility.
+
+## Automatic Fixes
+
+The rule provides automatic fixes that replace `disabled` with `disabledFocusable` while preserving the original prop value:
+
+```jsx
+// Before fix
+<Button disabled={isSubmitting} loading>Submit</Button>
+
+// After fix  
+<Button disabledFocusable={isSubmitting} loading>Submit</Button>
+```
+
+## Related Rules
+
+- [`no-empty-buttons`](./no-empty-buttons.md) - Ensures buttons have content or accessible labeling
+- [`prefer-aria-over-title-attribute`](./prefer-aria-over-title-attribute.md) - Improves screen reader compatibility
+
+## Further Reading
+
+- [WAI-ARIA: Keyboard Interface](https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/)
+- [FluentUI Accessibility Guidelines](https://react.fluentui.dev/?path=/docs/concepts-developer-accessibility--page)
+- [Understanding ARIA: disabled vs aria-disabled](https://css-tricks.com/making-disabled-buttons-more-inclusive/)
diff --git a/lib/applicableComponents/disabledFocusableComponents.ts b/lib/applicableComponents/disabledFocusableComponents.ts
new file mode 100644
index 0000000..f4b6ae3
--- /dev/null
+++ b/lib/applicableComponents/disabledFocusableComponents.ts
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/**
+ * FluentUI components that support both 'disabled' and 'disabledFocusable' props
+ * These are components where the rule should apply
+ */
+const disabledFocusableComponents = [
+    // Button components
+    "Button",
+    "ToggleButton",
+    "CompoundButton",
+    "MenuButton",
+    "SplitButton",
+
+    // Form controls
+    "Checkbox",
+    "Radio",
+    "Switch",
+
+    // Input components
+    "Input",
+    "Textarea",
+    "Combobox",
+    "Dropdown",
+    "SpinButton",
+    "Slider",
+    "DatePicker",
+    "TimePicker",
+
+    // Other interactive components
+    "Link",
+    "Tab"
+] as const;
+
+export { disabledFocusableComponents };
diff --git a/lib/index.ts b/lib/index.ts
index 8fd98c1..1c063e5 100644
--- a/lib/index.ts
+++ b/lib/index.ts
@@ -41,6 +41,7 @@ module.exports = {
                 "@microsoft/fluentui-jsx-a11y/no-empty-buttons": "error",
                 "@microsoft/fluentui-jsx-a11y/no-empty-components": "error",
                 "@microsoft/fluentui-jsx-a11y/prefer-aria-over-title-attribute": "warn",
+                "@microsoft/fluentui-jsx-a11y/prefer-disabledfocusable-over-disabled": "warn",
                 "@microsoft/fluentui-jsx-a11y/progressbar-needs-labelling": "error",
                 "@microsoft/fluentui-jsx-a11y/radio-button-missing-label": "error",
                 "@microsoft/fluentui-jsx-a11y/radiogroup-missing-label": "error",
@@ -83,6 +84,7 @@ module.exports = {
         "no-empty-buttons": rules.noEmptyButtons,
         "no-empty-components": rules.noEmptyComponents,
         "prefer-aria-over-title-attribute": rules.preferAriaOverTitleAttribute,
+        "prefer-disabledfocusable-over-disabled": rules.preferDisabledFocusableOverDisabled,
         "progressbar-needs-labelling": rules.progressbarNeedsLabelling,
         "radio-button-missing-label": rules.radioButtonMissingLabel,
         "radiogroup-missing-label": rules.radiogroupMissingLabel,
diff --git a/lib/rules/index.ts b/lib/rules/index.ts
index d0db540..c31ac56 100644
--- a/lib/rules/index.ts
+++ b/lib/rules/index.ts
@@ -39,3 +39,4 @@ export { default as tablistAndTabsNeedLabelling } from "./tablist-and-tabs-need-
 export { default as toolbarMissingAria } from "./toolbar-missing-aria";
 export { default as tooltipNotRecommended } from "./tooltip-not-recommended";
 export { default as visualLabelBetterThanAriaSuggestion } from "./visual-label-better-than-aria-suggestion";
+export { default as preferDisabledFocusableOverDisabled } from "./prefer-disabledfocusable-over-disabled";
diff --git a/lib/rules/prefer-disabledfocusable-over-disabled.ts b/lib/rules/prefer-disabledfocusable-over-disabled.ts
new file mode 100644
index 0000000..88c9232
--- /dev/null
+++ b/lib/rules/prefer-disabledfocusable-over-disabled.ts
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import { elementType } from "jsx-ast-utils";
+import { hasNonEmptyProp } from "../util/hasNonEmptyProp";
+import { hasLoadingState, getLoadingStateProp } from "../util/hasLoadingState";
+import { disabledFocusableComponents } from "../applicableComponents/disabledFocusableComponents";
+import { JSXOpeningElement } from "estree-jsx";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const rule = ESLintUtils.RuleCreator.withoutDocs({
+    defaultOptions: [],
+    meta: {
+        messages: {
+            preferDisabledFocusable:
+                "Accessibility: Prefer 'disabledFocusable={{{{loadingProp}}}}}' over 'disabled={{{{loadingProp}}}}}' when component has loading state '{{loadingProp}}' to maintain keyboard navigation accessibility",
+            preferDisabledFocusableGeneric:
+                "Accessibility: Prefer 'disabledFocusable' over 'disabled' when component has loading state to maintain keyboard navigation accessibility"
+        },
+        type: "suggestion", // This is a suggestion for better accessibility
+        docs: {
+            description:
+                "Prefer 'disabledFocusable' over 'disabled' when component has loading state to maintain keyboard navigation accessibility",
+            recommended: "warn",
+            url: "https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/"
+        },
+        fixable: "code", // Allow auto-fixing
+        schema: []
+    },
+
+    create(context) {
+        return {
+            JSXOpeningElement(node: TSESTree.JSXOpeningElement) {
+                const componentName = elementType(node as JSXOpeningElement);
+
+                // Check if this is an applicable component
+                if (!disabledFocusableComponents.includes(componentName as any)) {
+                    return;
+                }
+
+                // Check if component has 'disabled' prop
+                const hasDisabled = hasNonEmptyProp(node.attributes, "disabled");
+                if (!hasDisabled) {
+                    return;
+                }
+
+                // Check if component has loading state
+                const hasLoading = hasLoadingState(node.attributes);
+                if (!hasLoading) {
+                    return;
+                }
+
+                // Check if component already has disabledFocusable (avoid conflicts)
+                const hasDisabledFocusable = hasNonEmptyProp(node.attributes, "disabledFocusable");
+                if (hasDisabledFocusable) {
+                    return; // Don't report if both are present - that's a different issue
+                }
+
+                const loadingProp = getLoadingStateProp(node.attributes);
+
+                context.report({
+                    node,
+                    messageId: loadingProp ? "preferDisabledFocusable" : "preferDisabledFocusableGeneric",
+                    data: {
+                        loadingProp: loadingProp || "loading"
+                    },
+                    fix(fixer) {
+                        // Find the disabled attribute and replace it with disabledFocusable
+                        const disabledAttr = node.attributes.find(
+                            attr => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "disabled"
+                        );
+
+                        if (disabledAttr && disabledAttr.type === "JSXAttribute" && disabledAttr.name) {
+                            return fixer.replaceText(disabledAttr.name, "disabledFocusable");
+                        }
+                        return null;
+                    }
+                });
+            }
+        };
+    }
+});
+
+export default rule;
diff --git a/lib/util/hasLoadingState.ts b/lib/util/hasLoadingState.ts
new file mode 100644
index 0000000..8824177
--- /dev/null
+++ b/lib/util/hasLoadingState.ts
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { TSESTree } from "@typescript-eslint/utils";
+import { hasNonEmptyProp } from "./hasNonEmptyProp";
+
+/**
+ * Common prop names that indicate a loading state in FluentUI components
+ */
+const LOADING_STATE_PROPS = ["loading", "isLoading", "pending", "isPending", "busy", "isBusy"] as const;
+
+/**
+ * Determines if the component has any loading state indicator prop
+ * @param attributes - JSX attributes array
+ * @returns boolean indicating if component has loading state
+ */
+export const hasLoadingState = (attributes: TSESTree.JSXOpeningElement["attributes"]): boolean => {
+    return LOADING_STATE_PROPS.some(prop => hasNonEmptyProp(attributes, prop));
+};
+
+/**
+ * Gets the specific loading prop that is present (for better error messages)
+ * @param attributes - JSX attributes array
+ * @returns string name of the loading prop found, or null if none
+ */
+export const getLoadingStateProp = (attributes: TSESTree.JSXOpeningElement["attributes"]): string | null => {
+    return LOADING_STATE_PROPS.find(prop => hasNonEmptyProp(attributes, prop)) ?? null;
+};
diff --git a/tests/lib/rules/prefer-disabledfocusable-over-disabled.test.ts b/tests/lib/rules/prefer-disabledfocusable-over-disabled.test.ts
new file mode 100644
index 0000000..ca217ea
--- /dev/null
+++ b/tests/lib/rules/prefer-disabledfocusable-over-disabled.test.ts
@@ -0,0 +1,441 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { Rule } from "eslint";
+import ruleTester from "./helper/ruleTester";
+import rule from "../../../lib/rules/prefer-disabledfocusable-over-disabled";
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+ruleTester.run("prefer-disabledfocusable-over-disabled", rule as unknown as Rule.RuleModule, {
+    valid: [
+        // ✅ Correct usage: disabledFocusable with loading state
+        "<Button disabledFocusable loading>Submit</Button>",
+        "<Button disabledFocusable isLoading>Submit</Button>",
+        "<ToggleButton disabledFocusable pending />",
+        "<Checkbox disabledFocusable={true} loading={isLoading} />",
+        "<Input disabledFocusable={disabled} busy={isBusy} />",
+
+        // ✅ Acceptable: disabled without loading state
+        "<Button disabled>Submit</Button>",
+        "<Checkbox disabled />",
+        "<Input disabled={true} />",
+        "<SpinButton disabled={isDisabled} />",
+        "<CompoundButton disabled={false} />",
+        "<ToggleButton disabled={isFormDisabled} />",
+
+        // ✅ Acceptable: loading state without disabled
+        "<Button loading>Submit</Button>",
+        "<SpinButton isLoading />",
+        "<Combobox pending={isPending} />",
+        "<Input busy />",
+        "<Textarea isPending />",
+        "<Dropdown isBusy />",
+        "<Slider loading={true} />",
+        "<DatePicker isLoading={fetching} />",
+        "<TimePicker pending={processing} />",
+
+        // ✅ Acceptable: neither disabled nor loading
+        "<Button>Submit</Button>",
+        "<Checkbox />",
+        "<Input />",
+        "<CompoundButton />",
+        "<MenuButton />",
+        "<SplitButton />",
+        "<Switch />",
+        "<Radio />",
+        "<Link />",
+        "<Tab />",
+
+        // ✅ Non-applicable components (don't support disabledFocusable)
+        "<div disabled loading>Content</div>",
+        "<Label disabled loading>Label</Label>",
+        "<Text disabled loading>Text</Text>",
+        "<span disabled isLoading>Span</span>",
+        "<Accordion disabled loading />",
+        "<Avatar disabled pending />",
+        "<Badge disabled busy />",
+        "<Breadcrumb disabled isLoading />",
+        "<Card disabled pending />",
+        "<Dialog disabled loading />",
+        "<Divider disabled isLoading />",
+        "<Field disabled pending />",
+        "<Image disabled busy />",
+        "<List disabled loading />",
+        "<MessageBar disabled isLoading />",
+        "<Nav disabled pending />",
+        "<Popover disabled busy />",
+        "<Portal disabled loading />",
+        "<ProgressBar disabled isLoading />",
+        "<Skeleton disabled pending />",
+        "<Spinner disabled busy />",
+        "<Toolbar disabled loading />",
+        "<Tooltip disabled isLoading />",
+
+        // ✅ Edge case: both disabledFocusable and disabled present (different rule concern)
+        "<Button disabled disabledFocusable loading>Submit</Button>",
+        "<Input disabled disabledFocusable isLoading />",
+        "<Checkbox disabled={true} disabledFocusable={false} pending />",
+        "<ToggleButton disabled={isDisabled} disabledFocusable={shouldFocus} busy />",
+
+        // ✅ Complex expressions with disabledFocusable
+        "<Button disabledFocusable={shouldDisable} loading={isSubmitting}>Submit</Button>",
+        "<Input disabledFocusable={disabled && !error} isLoading={fetching} />",
+        "<SpinButton disabledFocusable={!enabled || hasError} pending={processing} />",
+
+        // ✅ All supported loading props with disabledFocusable
+        "<Button disabledFocusable isPending>Submit</Button>",
+        "<Button disabledFocusable isBusy>Submit</Button>",
+        "<Button disabledFocusable busy>Submit</Button>",
+
+        // ✅ Empty prop values that should be considered "empty" by hasNonEmptyProp
+        '<Button disabled="" loading>Submit</Button>', // Empty string should not trigger
+        "<Input disabled={null} isLoading />", // Null should not trigger
+        "<Checkbox disabled={undefined} pending />", // Undefined should not trigger
+
+        // ✅ Test all applicable components without issues
+        "<Button>Normal Button</Button>",
+        "<ToggleButton>Normal Toggle</ToggleButton>",
+        "<CompoundButton>Normal Compound</CompoundButton>",
+        "<MenuButton>Normal Menu</MenuButton>",
+        "<SplitButton>Normal Split</SplitButton>",
+        "<Checkbox>Normal Checkbox</Checkbox>",
+        "<Radio>Normal Radio</Radio>",
+        "<Switch>Normal Switch</Switch>",
+        "<Input>Normal Input</Input>",
+        "<Textarea>Normal Textarea</Textarea>",
+        "<Combobox>Normal Combobox</Combobox>",
+        "<Dropdown>Normal Dropdown</Dropdown>",
+        "<SpinButton>Normal SpinButton</SpinButton>",
+        "<Slider>Normal Slider</Slider>",
+        "<DatePicker>Normal DatePicker</DatePicker>",
+        "<TimePicker>Normal TimePicker</TimePicker>",
+        "<Link>Normal Link</Link>",
+        "<Tab>Normal Tab</Tab>",
+
+        // ✅ Test components with different casing variations
+        "<button disabled loading>Submit</button>", // lowercase (should not trigger - not a FluentUI component)
+        "<BUTTON disabled loading>Submit</BUTTON>", // uppercase (should not trigger - not a FluentUI component)
+
+        // ✅ Cases where loading props are truly empty (null, undefined, empty string)
+        '<Input disabled={true} isLoading="">Submit</Input>', // loading is empty string
+        "<Checkbox disabled={true} pending={null} />", // loading is null
+        "<SpinButton disabled={true} busy={undefined} />", // loading is undefined
+
+        // ✅ Cases where only one prop exists (no combination to trigger rule)
+        "<Button disabled={(() => false)()}>Submit</Button>", // only disabled, no loading
+        "<Input isLoading={status === 'loading'} />", // only loading, no disabled
+        "<Checkbox loading={(() => true)()} />", // only loading, no disabled
+        "<ToggleButton disabled={isDisabled ? false : true} />", // only disabled, no loading
+
+        // ✅ JSXSpreadAttribute cases without both props
+        "<Button {...props} disabled={false}>Submit</Button>", // only disabled, no loading
+        "<Input {...buttonProps} isLoading={1} />", // only loading, no disabled
+
+        // ✅ Cases where disabled has truly empty values
+        '<Button disabled="" loading={false}>Submit</Button>', // disabled is empty string (should not trigger because disabled is empty)
+        "<Input disabled={null} loading={true} />", // disabled is null (should not trigger because disabled is empty)
+        "<Checkbox disabled={undefined} pending={true} />" // disabled is undefined (should not trigger because disabled is empty)
+    ],
+
+    invalid: [
+        // ❌ Basic cases - test messageId: "preferDisabledFocusable"
+        {
+            code: "<Button disabled loading>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable loading>Submit</Button>"
+        },
+        {
+            code: "<ToggleButton disabled isLoading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<ToggleButton disabledFocusable isLoading />"
+        },
+        {
+            code: "<Checkbox disabled pending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Checkbox disabledFocusable pending />"
+        },
+
+        // ❌ Boolean prop values (ALL boolean values are considered "non-empty" by hasNonEmptyProp)
+        {
+            code: "<Button disabled={true} loading={true}>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={true} loading={true}>Submit</Button>"
+        },
+        {
+            code: "<Button disabled={true} loading={false}>Submit</Button>", // MOVED FROM VALID - false is still non-empty!
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={true} loading={false}>Submit</Button>"
+        },
+        {
+            code: "<Input disabled={false} isLoading={processing} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable={false} isLoading={processing} />"
+        },
+
+        // ❌ Cases that were incorrectly in valid section (hasNonEmptyProp treats these as non-empty)
+        {
+            code: "<Button disabled={(() => false)()} loading={(() => true)()}>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={(() => false)()} loading={(() => true)()}>Submit</Button>"
+        },
+        {
+            code: "<Input disabled={isDisabled ? false : true} isLoading={status === 'loading'} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable={isDisabled ? false : true} isLoading={status === 'loading'} />"
+        },
+        {
+            code: "<Button {...props} disabled={false} loading>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button {...props} disabledFocusable={false} loading>Submit</Button>"
+        },
+        {
+            code: "<Input {...buttonProps} disabled loading={false} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input {...buttonProps} disabledFocusable loading={false} />"
+        },
+        {
+            code: "<Button disabled={0} loading>Submit</Button>", // 0 is considered non-empty
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={0} loading>Submit</Button>"
+        },
+        {
+            code: "<Input disabled={false} isLoading={1} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable={false} isLoading={1} />"
+        },
+
+        // ❌ Expression prop values
+        {
+            code: "<SpinButton disabled={isDisabled} loading={isSubmitting} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<SpinButton disabledFocusable={isDisabled} loading={isSubmitting} />"
+        },
+        {
+            code: "<Combobox disabled={!isEnabled} pending={isPending} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Combobox disabledFocusable={!isEnabled} pending={isPending} />"
+        },
+
+        // ❌ Test all loading prop variations
+        {
+            code: "<Button disabled loading>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable loading>Submit</Button>"
+        },
+        {
+            code: "<Button disabled isLoading>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable isLoading>Submit</Button>"
+        },
+        {
+            code: "<Button disabled pending>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable pending>Submit</Button>"
+        },
+        {
+            code: "<Button disabled isPending>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable isPending>Submit</Button>"
+        },
+        {
+            code: "<Button disabled busy>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable busy>Submit</Button>"
+        },
+        {
+            code: "<Button disabled isBusy>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable isBusy>Submit</Button>"
+        },
+
+        // ❌ Multiple loading props (should still trigger)
+        {
+            code: "<Button disabled loading pending>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable loading pending>Submit</Button>"
+        },
+        {
+            code: "<Input disabled isLoading busy pending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable isLoading busy pending />"
+        },
+
+        // ❌ Test all applicable component types
+        {
+            code: "<Button disabled loading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable loading />"
+        },
+        {
+            code: "<ToggleButton disabled isLoading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<ToggleButton disabledFocusable isLoading />"
+        },
+        {
+            code: "<CompoundButton disabled pending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<CompoundButton disabledFocusable pending />"
+        },
+        {
+            code: "<MenuButton disabled isPending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<MenuButton disabledFocusable isPending />"
+        },
+        {
+            code: "<SplitButton disabled busy />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<SplitButton disabledFocusable busy />"
+        },
+        {
+            code: "<Checkbox disabled isBusy />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Checkbox disabledFocusable isBusy />"
+        },
+        {
+            code: "<Radio disabled loading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Radio disabledFocusable loading />"
+        },
+        {
+            code: "<Switch disabled isLoading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Switch disabledFocusable isLoading />"
+        },
+        {
+            code: "<Input disabled pending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable pending />"
+        },
+        {
+            code: "<Textarea disabled isPending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Textarea disabledFocusable isPending />"
+        },
+        {
+            code: "<Combobox disabled busy />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Combobox disabledFocusable busy />"
+        },
+        {
+            code: "<Dropdown disabled isBusy />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Dropdown disabledFocusable isBusy />"
+        },
+        {
+            code: "<SpinButton disabled loading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<SpinButton disabledFocusable loading />"
+        },
+        {
+            code: "<Slider disabled isLoading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Slider disabledFocusable isLoading />"
+        },
+        {
+            code: "<DatePicker disabled pending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<DatePicker disabledFocusable pending />"
+        },
+        {
+            code: "<TimePicker disabled isPending />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<TimePicker disabledFocusable isPending />"
+        },
+        {
+            code: "<Link disabled busy />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Link disabledFocusable busy />"
+        },
+        {
+            code: "<Tab disabled isBusy />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Tab disabledFocusable isBusy />"
+        },
+
+        // ❌ Complex expressions with all components
+        {
+            code: "<Button disabled={isSubmitting} loading={fetchingData}>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={isSubmitting} loading={fetchingData}>Submit</Button>"
+        },
+        {
+            code: "<Input disabled={!isEnabled && hasValidation} pending={validating} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable={!isEnabled && hasValidation} pending={validating} />"
+        },
+        {
+            code: "<Checkbox disabled={shouldDisable || isReadonly} busy={processing} />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Checkbox disabledFocusable={shouldDisable || isReadonly} busy={processing} />"
+        },
+
+        // ❌ Test more complex expression scenarios
+        {
+            code: "<Button disabled={isSubmitting || hasError} loading={status === 'pending'}>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={isSubmitting || hasError} loading={status === 'pending'}>Submit</Button>"
+        },
+
+        // ❌ Additional test cases to ensure full coverage
+        {
+            code: "<Button disabled={true} loading>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={true} loading>Submit</Button>"
+        },
+
+        // ❌ Test edge cases for fix function coverage
+        {
+            code: "<Button disabled={1} loading={true}>Submit</Button>", // truthy number
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={1} loading={true}>Submit</Button>"
+        },
+        {
+            code: "<Input disabled={'true'} isLoading={'false'} />", // string values
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable={'true'} isLoading={'false'} />"
+        },
+
+        // ❌ Test JSXSpreadAttribute with invalid cases
+        {
+            code: "<Button {...props} disabled loading>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button {...props} disabledFocusable loading>Submit</Button>"
+        },
+        {
+            code: "<Input disabled {...inputProps} isLoading />",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Input disabledFocusable {...inputProps} isLoading />"
+        },
+
+        // ❌ Test cases where fix function edge cases might be triggered
+        {
+            code: "<Button disabled={variable} pending={anotherVariable}>Submit</Button>",
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={variable} pending={anotherVariable}>Submit</Button>"
+        },
+
+        // ❌ Test more combinations to increase coverage
+        {
+            code: "<Combobox disabled={true} loading={true} pending={false} />", // Multiple loading props
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Combobox disabledFocusable={true} loading={true} pending={false} />"
+        },
+
+        // ❌ Edge case: Test with numeric and other literal values
+        {
+            code: "<Button disabled={42} loading={-1}>Submit</Button>", // Numeric values
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: "<Button disabledFocusable={42} loading={-1}>Submit</Button>"
+        },
+
+        // ❌ Test string prop values that are non-empty
+        {
+            code: '<Button disabled="true" loading="false">Submit</Button>',
+            errors: [{ messageId: "preferDisabledFocusable" }],
+            output: '<Button disabledFocusable="true" loading="false">Submit</Button>'
+        }
+    ]
+});
diff --git a/tests/lib/util/hasLoadingState.test.ts b/tests/lib/util/hasLoadingState.test.ts
new file mode 100644
index 0000000..e38908f
--- /dev/null
+++ b/tests/lib/util/hasLoadingState.test.ts
@@ -0,0 +1,197 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { hasLoadingState, getLoadingStateProp } from "../../../lib/util/hasLoadingState";
+import { TSESTree } from "@typescript-eslint/utils";
+
+// Mock attributes helper
+const createMockAttributes = (props: Record<string, any>): TSESTree.JSXOpeningElement["attributes"] => {
+    return Object.entries(props).map(([name, value]) => ({
+        type: "JSXAttribute" as const,
+        name: {
+            type: "JSXIdentifier" as const,
+            name,
+            loc: {
+                start: { line: 1, column: 0 },
+                end: { line: 1, column: name.length }
+            },
+            range: [0, name.length]
+        },
+        value:
+            value === true
+                ? null
+                : {
+                      type: "Literal" as const,
+                      value,
+                      raw: String(value),
+                      loc: {
+                          start: { line: 1, column: 0 },
+                          end: { line: 1, column: String(value).length }
+                      },
+                      range: [0, String(value).length]
+                  },
+        loc: {
+            start: { line: 1, column: 0 },
+            end: { line: 1, column: name.length + String(value).length }
+        },
+        range: [0, name.length + String(value).length]
+    })) as TSESTree.JSXOpeningElement["attributes"];
+};
+
+describe("hasLoadingState", () => {
+    test("returns true for loading prop", () => {
+        const attributes = createMockAttributes({ loading: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns true for isLoading prop", () => {
+        const attributes = createMockAttributes({ isLoading: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns true for pending prop", () => {
+        const attributes = createMockAttributes({ pending: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns true for isPending prop", () => {
+        const attributes = createMockAttributes({ isPending: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns true for busy prop", () => {
+        const attributes = createMockAttributes({ busy: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns true for isBusy prop", () => {
+        const attributes = createMockAttributes({ isBusy: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns false for no loading props", () => {
+        const attributes = createMockAttributes({ disabled: true });
+        expect(hasLoadingState(attributes)).toBe(false);
+    });
+
+    test("returns false for empty attributes", () => {
+        const attributes: TSESTree.JSXOpeningElement["attributes"] = [];
+        expect(hasLoadingState(attributes)).toBe(false);
+    });
+
+    test("returns true for multiple loading props", () => {
+        const attributes = createMockAttributes({ loading: true, pending: true });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns false for empty string values", () => {
+        const attributes = createMockAttributes({ loading: "" });
+        expect(hasLoadingState(attributes)).toBe(false);
+    });
+
+    test("returns false for null values", () => {
+        const attributes = createMockAttributes({ loading: null });
+        expect(hasLoadingState(attributes)).toBe(false);
+    });
+
+    test("returns false for undefined values", () => {
+        const attributes = createMockAttributes({ loading: undefined });
+        expect(hasLoadingState(attributes)).toBe(false);
+    });
+
+    // Note: false and 0 are considered "non-empty" by hasNonEmptyProp for boolean/number types
+    test("returns true for false boolean values", () => {
+        const attributes = createMockAttributes({ loading: false });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+
+    test("returns true for zero number values", () => {
+        const attributes = createMockAttributes({ loading: 0 });
+        expect(hasLoadingState(attributes)).toBe(true);
+    });
+});
+
+describe("getLoadingStateProp", () => {
+    test("returns 'loading' for loading prop", () => {
+        const attributes = createMockAttributes({ loading: true });
+        expect(getLoadingStateProp(attributes)).toBe("loading");
+    });
+
+    test("returns 'isLoading' for isLoading prop", () => {
+        const attributes = createMockAttributes({ isLoading: true });
+        expect(getLoadingStateProp(attributes)).toBe("isLoading");
+    });
+
+    test("returns 'pending' for pending prop", () => {
+        const attributes = createMockAttributes({ pending: true });
+        expect(getLoadingStateProp(attributes)).toBe("pending");
+    });
+
+    test("returns 'isPending' for isPending prop", () => {
+        const attributes = createMockAttributes({ isPending: true });
+        expect(getLoadingStateProp(attributes)).toBe("isPending");
+    });
+
+    test("returns 'busy' for busy prop", () => {
+        const attributes = createMockAttributes({ busy: true });
+        expect(getLoadingStateProp(attributes)).toBe("busy");
+    });
+
+    test("returns 'isBusy' for isBusy prop", () => {
+        const attributes = createMockAttributes({ isBusy: true });
+        expect(getLoadingStateProp(attributes)).toBe("isBusy");
+    });
+
+    test("returns null for no loading props", () => {
+        const attributes = createMockAttributes({ disabled: true });
+        expect(getLoadingStateProp(attributes)).toBe(null);
+    });
+
+    test("returns null for empty attributes", () => {
+        const attributes: TSESTree.JSXOpeningElement["attributes"] = [];
+        expect(getLoadingStateProp(attributes)).toBe(null);
+    });
+
+    test("returns first found loading prop when multiple present", () => {
+        const attributes = createMockAttributes({ pending: true, loading: true });
+        // Should return 'loading' as it comes first in LOADING_STATE_PROPS array
+        expect(getLoadingStateProp(attributes)).toBe("loading");
+    });
+
+    test("returns first found loading prop in priority order", () => {
+        const attributes = createMockAttributes({ isBusy: true, pending: true, loading: true });
+        // Should return 'loading' as it has highest priority in LOADING_STATE_PROPS array
+        expect(getLoadingStateProp(attributes)).toBe("loading");
+    });
+
+    test("returns null for empty string values", () => {
+        const attributes = createMockAttributes({ loading: "" });
+        expect(getLoadingStateProp(attributes)).toBe(null);
+    });
+
+    test("returns null for null values", () => {
+        const attributes = createMockAttributes({ loading: null });
+        expect(getLoadingStateProp(attributes)).toBe(null);
+    });
+
+    test("returns null for undefined values", () => {
+        const attributes = createMockAttributes({ loading: undefined });
+        expect(getLoadingStateProp(attributes)).toBe(null);
+    });
+
+    // Note: hasNonEmptyProp considers false and 0 as "non-empty" for boolean/number types
+    test("returns prop name for false boolean values", () => {
+        const attributes = createMockAttributes({ loading: false });
+        expect(getLoadingStateProp(attributes)).toBe("loading");
+    });
+
+    test("returns prop name for truthy number values", () => {
+        const attributes = createMockAttributes({ loading: 1 });
+        expect(getLoadingStateProp(attributes)).toBe("loading");
+    });
+
+    test("returns prop name for zero number values", () => {
+        const attributes = createMockAttributes({ loading: 0 });
+        expect(getLoadingStateProp(attributes)).toBe("loading");
+    });
+});