Skip to content

An open source design system that's fully customizable and agent ready

TypeScript

fix(ComplexSelector): block commits from disabled open popups (#8399)

zakelstorm64b473d24af0
diff --git a/.changeset/ast-085-complexselector.md b/.changeset/ast-085-complexselector.md
new file mode 100644
index 0000000000..5239ed008b
--- /dev/null
+++ b/.changeset/ast-085-complexselector.md
@@ -0,0 +1,6 @@
+---
+'@astryxdesign/core': patch
+---
+
+[fix] ComplexSelector ignores value commits from an already-open popup while disabled, without changing focus or caller-owned content.
+@korkt-kim
diff --git a/packages/core/src/ComplexSelector/ComplexSelector.test.tsx b/packages/core/src/ComplexSelector/ComplexSelector.test.tsx
index 828e793009..c0210e53b4 100644
--- a/packages/core/src/ComplexSelector/ComplexSelector.test.tsx
+++ b/packages/core/src/ComplexSelector/ComplexSelector.test.tsx
@@ -9,7 +9,7 @@
* SYNC: When ComplexSelector.tsx API changes, update these tests.
*/
-import React from 'react';
+import React, {useLayoutEffect} from 'react';
import {beforeEach, describe, expect, it, vi} from 'vitest';
import {act, fireEvent, render, screen, waitFor} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
@@ -213,6 +213,121 @@ describe('ComplexSelector', () => {
});
});
+ it('blocks a commit helper kept from an enabled render once disabled', async () => {
+ const user = userEvent.setup();
+ const onChange = vi.fn();
+ const kept: {current: ((value: string) => void) | null} = {current: null};
+ const renderSelector = (isDisabled: boolean) => (
+ <ComplexSelector
+ label="Fruit"
+ value="Apple"
+ isDisabled={isDisabled}
+ onChange={onChange}>
+ {(_value, commit) => {
+ kept.current ??= commit;
+ return <span>Choices</span>;
+ }}
+ </ComplexSelector>
+ );
+ const {rerender} = render(renderSelector(false));
+ await user.click(screen.getByRole('combobox', {name: 'Fruit'}));
+ expect(kept.current).not.toBeNull();
+ rerender(renderSelector(true));
+ act(() => kept.current?.('Banana'));
+ expect(onChange).not.toHaveBeenCalled();
+ });
+
+ it('blocks a commit from content in the render that disables it', async () => {
+ const user = userEvent.setup();
+ const onChange = vi.fn();
+ function CommitOnDisable({
+ isDisabled,
+ commit,
+ }: {
+ isDisabled: boolean;
+ commit: (value: string) => void;
+ }) {
+ useLayoutEffect(() => {
+ if (isDisabled) {
+ commit('Banana');
+ }
+ }, [isDisabled, commit]);
+ return <span>Choices</span>;
+ }
+ const renderSelector = (isDisabled: boolean) => (
+ <ComplexSelector
+ label="Fruit"
+ value="Apple"
+ isDisabled={isDisabled}
+ onChange={onChange}>
+ {(_value, commit) => (
+ <CommitOnDisable isDisabled={isDisabled} commit={commit} />
+ )}
+ </ComplexSelector>
+ );
+ const {rerender} = render(renderSelector(false));
+ await user.click(screen.getByRole('combobox', {name: 'Fruit'}));
+ rerender(renderSelector(true));
+ expect(onChange).not.toHaveBeenCalled();
+ });
+
+ it('commits through a helper kept from a disabled render once enabled', async () => {
+ const user = userEvent.setup();
+ const onChange = vi.fn();
+ const kept: {current: ((value: string) => void) | null} = {current: null};
+ const renderSelector = (isDisabled: boolean) => (
+ <ComplexSelector
+ label="Fruit"
+ value="Apple"
+ isDisabled={isDisabled}
+ onChange={onChange}>
+ {(_value, commit) => {
+ kept.current ??= commit;
+ return <span>Choices</span>;
+ }}
+ </ComplexSelector>
+ );
+ const {rerender} = render(renderSelector(true));
+ expect(kept.current).not.toBeNull();
+ rerender(renderSelector(false));
+ await user.click(screen.getByRole('combobox', {name: 'Fruit'}));
+ act(() => kept.current?.('Banana'));
+ expect(onChange).toHaveBeenCalledExactlyOnceWith('Banana');
+ });
+
+ it('blocks commits when disabled while open and allows them after re-enabling', async () => {
+ const user = userEvent.setup();
+ const onChange = vi.fn();
+ const changeAction = vi.fn();
+ const renderSelector = (isDisabled: boolean) => (
+ <ComplexSelector
+ label="Fruit"
+ value="Apple"
+ isDisabled={isDisabled}
+ onChange={onChange}
+ changeAction={changeAction}>
+ {(_value, commit) => (
+ <button type="button" onClick={() => commit('Banana')}>
+ Select Banana
+ </button>
+ )}
+ </ComplexSelector>
+ );
+ const {rerender} = render(renderSelector(false));
+ await user.click(screen.getByRole('combobox', {name: 'Fruit'}));
+ const choice = screen.getByRole('button', {name: 'Select Banana', ...h});
+
+ rerender(renderSelector(true));
+ await user.click(choice);
+ expect(onChange).not.toHaveBeenCalled();
+ expect(changeAction).not.toHaveBeenCalled();
+
+ rerender(renderSelector(false));
+ await user.click(choice);
+ expect(onChange).toHaveBeenCalledExactlyOnceWith('Banana');
+ expect(changeAction).toHaveBeenCalledExactlyOnceWith('Banana');
+ });
+
it('passes a close helper to composed content', async () => {
const user = userEvent.setup();
diff --git a/packages/core/src/ComplexSelector/ComplexSelector.tsx b/packages/core/src/ComplexSelector/ComplexSelector.tsx
index 3882f3bd5f..85701f9454 100644
--- a/packages/core/src/ComplexSelector/ComplexSelector.tsx
+++ b/packages/core/src/ComplexSelector/ComplexSelector.tsx
@@ -20,6 +20,7 @@ import React, {
useCallback,
useId,
useImperativeHandle,
+ useInsertionEffect,
useOptimistic,
useRef,
useTransition,
@@ -378,7 +379,7 @@ export interface ComplexSelectorProps<Value> extends Omit<
isOptional?: boolean;
/** Marks the field required. */
isRequired?: boolean;
- /** Disables the selector. */
+ /** Blocks opening and value commits, including from an already-open popup. */
isDisabled?: boolean;
/** Shows loading state on the trigger. */
isLoading?: boolean;
@@ -687,8 +688,24 @@ export function ComplexSelector<Value>({
[isDisabled, popover],
);
+ // The helper reads the selector's availability when it runs, not the
+ // render it came from: content may keep a helper from an earlier render
+ // (after an await, say) across a change either way. The insertion effect
+ // runs before any layout effect of the content, so a commit from the
+ // content's own layout effect in the render that changes it sees the new
+ // availability too.
+ const isDisabledRef = useRef(isDisabled);
+ useInsertionEffect(() => {
+ isDisabledRef.current = isDisabled;
+ }, [isDisabled]);
+
const commitValue = useCallback(
(nextValue: Value) => {
+ // Caller-owned popup controls may remain mounted after disablement.
+ // Guard the supplied commit boundary, not just the trigger.
+ if (isDisabledRef.current) {
+ return;
+ }
onChange?.(nextValue);
if (changeAction) {
startTransition(async () => {