refactor(AsyncSelect): simplify search-restore tracking and tighten tests

Replace wasSearchingRef with usePrevious(inputValue), restructure the
fetchPage().then() branching so allValuesLoaded lives in the non-search
branch (removes the dead resultData variable), and harden the new tests
with disjoint datasets and negative assertions so they would fail against
the original merge-on-search bug.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

superset-frontend/packages/superset-ui-core/src/components/Select/AsyncSelect.test.tsx

@@ -897,6 +897,128 @@ test('fires onChange when pasting a selection', async () => {
   await waitFor(() => expect(onChange).toHaveBeenCalledTimes(1));
 });
 
+test('replaces cached options with search results instead of merging', async () => {
+  const page0Data = Array.from({ length: 10 }, (_, i) => ({
+    label: `Option ${i}`,
+    value: i,
+  }));
+  const searchData = [{ label: 'Search Match', value: 100 }];
+  const loadOptions = jest.fn(async (search: string) => {
+    if (search === '') {
+      return { data: page0Data, totalCount: 100 };
+    }
+    return { data: searchData, totalCount: 1 };
+  });
+
+  render(<AsyncSelect {...defaultProps} options={loadOptions} />);
+  await open();
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(1));
+
+  let options = await findAllSelectOptions();
+  expect(options).toHaveLength(10);
+
+  await type('search');
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(2));
+
+  options = await findAllSelectOptions();
+  expect(options).toHaveLength(1);
+  expect(options[0]).toHaveTextContent('Search Match');
+});
+
+test('shows all options when filterOption is false', async () => {
+  const page0Data = Array.from({ length: 10 }, (_, i) => ({
+    label: `Base ${i}`,
+    value: i,
+  }));
+  const searchData = Array.from({ length: 5 }, (_, i) => ({
+    label: `Server ${i}`,
+    value: 100 + i,
+  }));
+  const loadOptions = jest.fn(async (search: string) =>
+    search === ''
+      ? { data: page0Data, totalCount: 100 }
+      : { data: searchData, totalCount: 5 },
+  );
+
+  render(
+    <AsyncSelect
+      {...defaultProps}
+      options={loadOptions}
+      filterOption={false}
+    />,
+  );
+  await open();
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(1));
+
+  await type('zzz_no_match');
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(2));
+
+  const options = await findAllSelectOptions();
+  expect(options).toHaveLength(5);
+  expect(options[0]).toHaveTextContent('Server 0');
+});
+
+test('preserves new option entry across search fetch when allowNewOptions is on', async () => {
+  const page0Data = Array.from({ length: 10 }, (_, i) => ({
+    label: `Option ${i}`,
+    value: i,
+  }));
+  const loadOptions = jest.fn(async (search: string) => {
+    if (search === '') {
+      return { data: page0Data, totalCount: 100 };
+    }
+    return { data: [], totalCount: 0 };
+  });
+
+  render(
+    <AsyncSelect {...defaultProps} options={loadOptions} allowNewOptions />,
+  );
+  await open();
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(1));
+
+  await type('newval');
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(2));
+
+  const options = await findAllSelectOptions();
+  expect(options).toHaveLength(1);
+  expect(options[0]).toHaveTextContent('newval');
+  // Stale page-0 options must not bleed through.
+  expect(screen.queryByText('Option 0')).not.toBeInTheDocument();
+});
+
+test('restores base options when search is cleared', async () => {
+  const page0Data = Array.from({ length: 10 }, (_, i) => ({
+    label: `Option ${i}`,
+    value: i,
+  }));
+  const searchData = [{ label: 'Search Match', value: 100 }];
+  const loadOptions = jest.fn(async (search: string) => {
+    if (search === '') {
+      return { data: page0Data, totalCount: 100 };
+    }
+    return { data: searchData, totalCount: 1 };
+  });
+
+  render(<AsyncSelect {...defaultProps} options={loadOptions} />);
+  await open();
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(1));
+
+  await type('search');
+  await waitFor(() => expect(loadOptions).toHaveBeenCalledTimes(2));
+  let options = await findAllSelectOptions();
+  expect(options).toHaveLength(1);
+  expect(options[0]).toHaveTextContent('Search Match');
+
+  // type() clears the input before typing, so passing '' clears the search.
+  await type('');
+  await waitFor(async () => {
+    options = await findAllSelectOptions();
+    expect(options).toHaveLength(10);
+  });
+  expect(options[0]).toHaveTextContent('Option 0');
+  expect(screen.queryByText('Search Match')).not.toBeInTheDocument();
+});
+
 test('does not duplicate options when using numeric values', async () => {
   render(
     <AsyncSelect

superset-frontend/packages/superset-ui-core/src/components/Select/AsyncSelect.tsx

@@ -160,6 +160,7 @@ const AsyncSelect = forwardRef(
     const [allValuesLoaded, setAllValuesLoaded] = useState(false);
     const selectValueRef = useRef(selectValue);
     const fetchedQueries = useRef(new Map<string, number>());
+    const initialOptionsRef = useRef<SelectOptionsType>(EMPTY_OPTIONS);
     const mappedMode = isSingleMode ? undefined : 'multiple';
     const allowFetch = !fetchOnlyOnSearch || inputValue;
     const [maxTagCount, setMaxTagCount] = useState(
@@ -335,16 +336,31 @@ const AsyncSelect = forwardRef(
         const fetchOptions = options as SelectOptionsPagePromise;
         fetchOptions(search, page, pageSize)
           .then(({ data, totalCount }: SelectOptionsTypePage) => {
-            const mergedData = mergeData(data);
+            if (search && page === 0) {
+              // Replace cached options with server results; preserve
+              // optimistic isNewOption entries inserted by handleOnSearch
+              // so allowNewOptions users can still click the value they
+              // typed when the server returns no match.
+              setSelectOptions(prevOptions => {
+                const dataValues = new Set(data.map(opt => opt.value));
+                const preservedNew = prevOptions.filter(
+                  opt => opt.isNewOption && !dataValues.has(opt.value),
+                );
+                return preservedNew
+                  .concat(data)
+                  .sort(sortComparatorForNoSearch);
+              });
+            } else {
+              const mergedData = mergeData(data);
+              if (!search) {
+                initialOptionsRef.current = mergedData;
+                if (!fetchOnlyOnSearch && mergedData.length >= totalCount) {
+                  setAllValuesLoaded(true);
+                }
+              }
+            }
             fetchedQueries.current.set(key, totalCount);
             setTotalCount(totalCount);
-            if (
-              !fetchOnlyOnSearch &&
-              search === '' &&
-              mergedData.length >= totalCount
-            ) {
-              setAllValuesLoaded(true);
-            }
           })
           .catch(internalOnError)
           .finally(() => {
@@ -358,6 +374,7 @@ const AsyncSelect = forwardRef(
         internalOnError,
         options,
         pageSize,
+        sortComparatorForNoSearch,
       ],
     );
 
@@ -500,6 +517,7 @@ const AsyncSelect = forwardRef(
       fetchedQueries.current.clear();
       setAllValuesLoaded(false);
       setSelectOptions(EMPTY_OPTIONS);
+      initialOptionsRef.current = EMPTY_OPTIONS;
     }, [options]);
 
     useEffect(() => {
@@ -514,16 +532,33 @@ const AsyncSelect = forwardRef(
       [debouncedFetchPage],
     );
 
+    const previousInputValue = usePrevious(inputValue, '');
     useEffect(() => {
       if (loadingEnabled && allowFetch) {
         // trigger fetch every time inputValue changes
         if (inputValue) {
           debouncedFetchPage(inputValue, 0);
         } else {
+          // On returning to empty input after a search, restore the cached
+          // base options so the dropdown shows the original page-0 list
+          // instead of the stale search results.
+          if (previousInputValue && initialOptionsRef.current.length > 0) {
+            setSelectOptions(
+              [...initialOptionsRef.current].sort(sortComparatorForNoSearch),
+            );
+          }
           fetchPage('', 0);
         }
       }
-    }, [loadingEnabled, fetchPage, allowFetch, inputValue, debouncedFetchPage]);
+    }, [
+      loadingEnabled,
+      fetchPage,
+      allowFetch,
+      inputValue,
+      previousInputValue,
+      debouncedFetchPage,
+      sortComparatorForNoSearch,
+    ]);
 
     useEffect(() => {
       if (loading !== undefined && loading !== isLoading) {

superset-frontend/packages/superset-ui-core/src/components/Select/utils.tsx

@@ -211,6 +211,10 @@ export const handleFilterOptionHelper = (
     return filterOption(search, option);
   }
 
+  if (filterOption === false) {
+    return true;
+  }
+
   if (filterOption) {
     const searchValue = search.trim().toLowerCase();
     if (optionFilterProps?.length) {