[FSSDK-12296] decideForKeysAsync, decideAllAsync impl.

Author: junaed-optimizely

src/hooks/index.ts

@@ -24,3 +24,6 @@ export type { UseDecideMultiResult } from './useDecideForKeys';
 export { useDecideAll } from './useDecideAll';
 export { useDecideAsync } from './useDecideAsync';
 export type { UseDecideAsyncResult } from './useDecideAsync';
+export { useDecideForKeysAsync } from './useDecideForKeysAsync';
+export type { UseDecideMultiAsyncResult } from './useDecideForKeysAsync';
+export { useDecideAllAsync } from './useDecideAllAsync';

src/hooks/useDecideAllAsync.ts

@@ -0,0 +1,103 @@
+/**
+ * Copyright 2026, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { useEffect, useState } from 'react';
+import type { OptimizelyDecision } from '@optimizely/optimizely-sdk';
+
+import { useOptimizelyContext } from './useOptimizelyContext';
+import { useProviderState } from './useProviderState';
+import { useStableArray } from './useStableArray';
+import type { UseDecideConfig } from './useDecide';
+import type { UseDecideMultiAsyncResult } from './useDecideForKeysAsync';
+
+/**
+ * Returns feature flag decisions for all flags using the async
+ * `decideAllAsync` API. Required for CMAB (Contextual Multi-Armed Bandit) support.
+ *
+ * Client-side only — `decideAllAsync` returns a Promise which cannot resolve
+ * during server render.
+ *
+ * @param config - Optional configuration (decideOptions)
+ */
+export function useDecideAllAsync(config?: UseDecideConfig): UseDecideMultiAsyncResult {
+  const { store, client } = useOptimizelyContext();
+  const decideOptions = useStableArray(config?.decideOptions);
+  const state = useProviderState(store);
+
+  // --- Forced decision subscription — any flag key ---
+  const [fdVersion, setFdVersion] = useState(0);
+  useEffect(() => {
+    return store.subscribeAllForcedDecisions(() => setFdVersion((v) => v + 1));
+  }, [store]);
+
+  // --- Async decision state ---
+  const [asyncState, setAsyncState] = useState<{
+    decisions: Record<string, OptimizelyDecision> | Record<string, never>;
+    error: Error | null;
+    isLoading: boolean;
+  }>({ decisions: {} as Record<string, never>, error: null, isLoading: true });
+
+  // --- Async decision effect ---
+  useEffect(() => {
+    const { userContext, error } = state;
+    const hasConfig = client.getOptimizelyConfig() !== null;
+
+    // Store-level error — no async call needed
+    if (error) {
+      setAsyncState({ decisions: {} as Record<string, never>, error, isLoading: false });
+      return;
+    }
+
+    // Store not ready — stay in loading
+    if (!hasConfig || userContext === null) {
+      setAsyncState({ decisions: {} as Record<string, never>, error: null, isLoading: true });
+      return;
+    }
+
+    // Store is ready — fire async decision
+    let cancelled = false;
+    // Reset to loading before firing the async call.
+    // If already in the initial loading state, returns `prev` as-is to
+    // skip a redundant re-render on first mount.
+    setAsyncState((prev) => {
+      if (prev.isLoading && prev.error === null && Object.keys(prev.decisions).length === 0) return prev;
+      return { decisions: {} as Record<string, never>, error: null, isLoading: true };
+    });
+
+    userContext.decideAllAsync(decideOptions).then(
+      (decisions) => {
+        if (!cancelled) {
+          setAsyncState({ decisions, error: null, isLoading: false });
+        }
+      },
+      (err) => {
+        if (!cancelled) {
+          setAsyncState({
+            decisions: {} as Record<string, never>,
+            error: err instanceof Error ? err : new Error(String(err)),
+            isLoading: false,
+          });
+        }
+      }
+    );
+
+    return () => {
+      cancelled = true;
+    };
+  }, [state, fdVersion, client, decideOptions]);
+
+  return asyncState as UseDecideMultiAsyncResult;
+}

src/hooks/useDecideAsync.spec.tsx

@@ -99,37 +99,40 @@ describe('useDecideAsync', () => {
     expect(result.current.error).toBeNull();
   });
 
-  it('should return decision when async call resolves', async () => {
+  it('should not trigger a redundant re-render when mounting with store already ready', () => {
     mockClient = createMockClient(true);
     const mockUserContext = createMockUserContext();
+    (mockUserContext.decideAsync as ReturnType<typeof vi.fn>).mockReturnValue(new Promise(() => {}));
     store.setUserContext(mockUserContext);
 
+    let renderCount = 0;
     const wrapper = createWrapper(store, mockClient);
-    const { result } = renderHook(() => useDecideAsync('flag_1'), { wrapper });
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.decision).toBe(MOCK_DECISION);
-    expect(result.current.error).toBeNull();
+    renderHook(
+      () => {
+        renderCount++;
+        return useDecideAsync('flag_1');
+      },
+      { wrapper }
+    );
+
+    // Should render once (initial), not twice (initial + redundant setState)
+    expect(renderCount).toBe(1);
   });
 
-  it('should pass decideOptions to decideAsync()', async () => {
+  it('should return decision when async call resolves', async () => {
     mockClient = createMockClient(true);
     const mockUserContext = createMockUserContext();
     store.setUserContext(mockUserContext);
 
-    const decideOptions = ['DISABLE_DECISION_EVENT'] as unknown as OptimizelyDecideOption[];
-
     const wrapper = createWrapper(store, mockClient);
-    const { result } = renderHook(() => useDecideAsync('flag_1', { decideOptions }), { wrapper });
+    const { result } = renderHook(() => useDecideAsync('flag_1'), { wrapper });
 
     await waitFor(() => {
       expect(result.current.isLoading).toBe(false);
     });
 
-    expect(mockUserContext.decideAsync).toHaveBeenCalledWith('flag_1', decideOptions);
+    expect(result.current.decision).toBe(MOCK_DECISION);
+    expect(result.current.error).toBeNull();
   });
 
   it('should return error when decideAsync() rejects', async () => {
@@ -280,34 +283,6 @@ describe('useDecideAsync', () => {
     expect(mockUserContext.decideAsync).toHaveBeenCalledWith('flag_1', newOptions);
   });
 
-  it('should re-fire async call when user context changes (store state)', async () => {
-    mockClient = createMockClient(true);
-    const mockUserContext1 = createMockUserContext();
-    store.setUserContext(mockUserContext1);
-
-    const wrapper = createWrapper(store, mockClient);
-    const { result } = renderHook(() => useDecideAsync('flag_1'), { wrapper });
-
-    await waitFor(() => {
-      expect(result.current.isLoading).toBe(false);
-    });
-
-    expect(result.current.decision).toBe(MOCK_DECISION);
-    expect(mockUserContext1.decideAsync).toHaveBeenCalledTimes(1);
-
-    // Now change to a different user context
-    const updatedDecision: OptimizelyDecision = { ...MOCK_DECISION, variationKey: 'variation_2' };
-    const mockUserContext2 = createMockUserContext();
-    (mockUserContext2.decideAsync as ReturnType<typeof vi.fn>).mockResolvedValue(updatedDecision);
-
-    await act(async () => {
-      store.setUserContext(mockUserContext2);
-    });
-
-    expect(result.current.decision).toBe(updatedDecision);
-    expect(mockUserContext2.decideAsync).toHaveBeenCalledTimes(1);
-  });
-
   it('should re-fire async call on config update', async () => {
     const mockUserContext = createMockUserContext();
     const { wrapper, fireConfigUpdate } = createProviderWrapper(mockUserContext);
@@ -435,15 +410,4 @@ describe('useDecideAsync', () => {
       expect(unsubscribeFdSpy).toHaveBeenCalledTimes(1);
     });
   });
-
-  it('should not call decideAsync() while loading', () => {
-    const mockUserContext = createMockUserContext();
-    // Config not available, user context set
-    store.setUserContext(mockUserContext);
-
-    const wrapper = createWrapper(store, mockClient);
-    renderHook(() => useDecideAsync('flag_1'), { wrapper });
-
-    expect(mockUserContext.decideAsync).not.toHaveBeenCalled();
-  });
 });

src/hooks/useDecideAsync.ts

@@ -76,6 +76,9 @@ export function useDecideAsync(flagKey: string, config?: UseDecideConfig): UseDe
 
     // Store is ready — fire async decision
     let cancelled = false;
+    // Reset to loading before firing the async call.
+    // If already in the initial loading state, returns `prev` as-is to
+    // skip a redundant re-render on first mount.
     setAsyncState((prev) => {
       if (prev.isLoading && prev.error === null && prev.decision === null) return prev;
       return { decision: null, error: null, isLoading: true };