botframework-webchat-api 4.18.1-main.20260511.8fcd02a → 4.18.1

package/src/middleware/private/templateMiddleware.tsx

@@ -1,106 +0,0 @@
-import { warnOnce } from '@msinternal/botframework-webchat-base/utils';
-import React, { memo, type ReactNode } from 'react';
-import { createChainOfResponsibility, type ComponentMiddleware } from 'react-chain-of-responsibility';
-import { array, function_, is, type InferOutput } from 'valibot';
-
-type MiddlewareWithInit<M extends ComponentMiddleware<any, any, any>, I> = (init: I) => ReturnType<M> | false;
-
-const arrayOfFunctionSchema = array(function_());
-
-/** @deprecated New middleware should use `templatePolymiddleware`. */
-const middlewareFactoryMarker = Symbol();
-
-const isArrayOfFunction = (middleware: unknown): middleware is InferOutput<typeof arrayOfFunctionSchema> =>
-  is(arrayOfFunctionSchema, middleware);
-
-const EMPTY_ARRAY = Object.freeze([]);
-
-/** @deprecated New middleware should use `templatePolymiddleware`. */
-// Following @types/react to use {} for props.
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-function templateMiddleware<Request, Props extends {}>(name: string) {
-  type Middleware = ComponentMiddleware<Request, Props, string>;
-
-  const createMiddleware = (enhancer: ReturnType<Middleware>): Middleware => {
-    const factory: Middleware = init => init === name && enhancer;
-
-    // This is for checking if the middleware is created via factory function or not.
-    // We recommend middleware to be created using factory function.
-    factory[middlewareFactoryMarker satisfies symbol] = middlewareFactoryMarker;
-
-    return factory;
-  };
-
-  const warnInvalidExtraction = warnOnce(`Middleware passed for extraction of "${name}" must be an array of function`);
-
-  const extractMiddleware = (
-    middleware: readonly MiddlewareWithInit<ComponentMiddleware<unknown, unknown>, string>[] | undefined
-  ): readonly Middleware[] => {
-    if (middleware) {
-      if (isArrayOfFunction(middleware)) {
-        return Object.freeze(
-          middleware
-            .map(middleware => {
-              const result = middleware(name);
-
-              if (typeof result !== 'function' && result !== false) {
-                console.warn(`botframework-webchat: ${name}.middleware must return enhancer function or false`);
-
-                return false;
-              }
-
-              return result;
-            })
-            .filter((enhancer): enhancer is ReturnType<Middleware> => !!enhancer)
-            .map(enhancer => () => enhancer)
-        );
-      }
-
-      warnInvalidExtraction();
-    }
-
-    return EMPTY_ARRAY;
-  };
-
-  const { Provider, Proxy } = createChainOfResponsibility<Request, Props, string>();
-
-  type TemplatedProviderProps = {
-    readonly children?: ReactNode | undefined;
-    readonly middleware: readonly Middleware[];
-  };
-
-  // eslint-disable-next-line prefer-arrow-callback
-  const TemplatedProvider = memo(function TemplatedProvider({ children, middleware }: TemplatedProviderProps) {
-    return (
-      <Provider init={name} middleware={middleware}>
-        {children}
-      </Provider>
-    );
-  });
-
-  TemplatedProvider.displayName = `${name}Provider`;
-
-  Proxy.displayName = `${name}Proxy`;
-
-  return {
-    createMiddleware,
-    extractMiddleware,
-    Provider: TemplatedProvider,
-    Proxy,
-    '~types': undefined as {
-      middleware: Middleware;
-      props: Props;
-      request: Request;
-    }
-  };
-}
-
-/** @deprecated New middleware should use `templatePolymiddleware`. */
-type InferMiddleware<T extends { '~types': { middleware } }> = T['~types']['middleware'];
-/** @deprecated New middleware should use `templatePolymiddleware`. */
-type InferProps<T extends { '~types': { props } }> = T['~types']['props'];
-/** @deprecated New middleware should use `templatePolymiddleware`. */
-type InferRequest<T extends { '~types': { request } }> = T['~types']['request'];
-
-export default templateMiddleware;
-export { middlewareFactoryMarker, type InferMiddleware, type InferProps, type InferRequest };

package/src/middleware/useBuildRenderAvatarCallback.ts

@@ -1,37 +0,0 @@
-// We need to patch `useBuildRenderAvatarCallback()` from `api-middleware`.
-//
-// - Request of `useBuildRenderAvatarCallback()` should not need `styleOptions`
-//   - We should call `useStyleOptions()` to get style options
-// - However, `api-middleware` is before `api`, so it do not have access to `useStyleOptions`
-//
-// Until we have `api-style-options`, we have to patch `useBuildRenderAvatarCallback()` inside `api`.
-
-import {
-  __INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol,
-  useBuildRenderAvatarCallback as useBuildRenderAvatarCallbackRaw
-} from '@msinternal/botframework-webchat-api-middleware';
-import type { WebChatActivity } from 'botframework-webchat-core';
-import { useCallback } from 'react';
-import type { ComponentRenderer } from 'react-chain-of-responsibility/preview';
-import { useRefFrom } from 'use-ref-from';
-import { useStyleOptions } from '../hooks';
-
-export default function useBuildRenderAvatarCallback(): (request: {
-  readonly activity: WebChatActivity;
-}) => ComponentRenderer<{ children?: never }> {
-  const [styleOptions] = useStyleOptions();
-
-  const renderAvatar = useBuildRenderAvatarCallbackRaw();
-  const styleOptionsRef = useRefFrom(styleOptions);
-
-  return useCallback<(request: { readonly activity: WebChatActivity }) => ReturnType<typeof renderAvatar>>(
-    request =>
-      renderAvatar(
-        Object.freeze({
-          activity: request.activity,
-          [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: styleOptionsRef.current
-        })
-      ),
-    [renderAvatar, styleOptionsRef]
-  );
-}

package/src/providers/ActivityTyping/private/useReduceActivities.spec.tsx

@@ -1,236 +0,0 @@
-/** @jest-environment @happy-dom/jest-environment */
-/// <reference types="jest" />
-/// <reference types="node" />
-
-import { render, type RenderResult } from '@testing-library/react';
-import type { WebChatActivity } from 'botframework-webchat-core';
-import type { LocalId } from 'botframework-webchat-core/activity.js';
-import React, { type ComponentType } from 'react';
-import { type useActivities as UseActivitiesType } from '../../../hooks';
-import type UseReduceActivitiesType from './useReduceActivities';
-
-type UseReduceActivitiesFn = Parameters<typeof UseReduceActivitiesType>[0];
-
-const ACTIVITY_TEMPLATE = {
-  channelData: {
-    'webchat:internal:local-id': '_:a-00001' as LocalId,
-    'webchat:internal:position': 0,
-    'webchat:sequence-id': 0,
-    'webchat:send-status': undefined
-  },
-  from: { id: 'bot', role: 'bot' },
-  id: 'a-00001',
-  text: '',
-  timestamp: '2025-03-10T12:34:56.789Z',
-  type: 'message'
-} satisfies WebChatActivity & { type: 'message' };
-
-describe('setup', () => {
-  let HookApp: ComponentType<{ fn: UseReduceActivitiesFn }>;
-  let useActivities: jest.Mock<ReturnType<typeof UseActivitiesType>, Parameters<typeof UseActivitiesType>>;
-  let useReduceActivities: jest.Mock<
-    ReturnType<typeof UseReduceActivitiesType>,
-    Parameters<typeof UseReduceActivitiesType>
-  >;
-  let fn: jest.Mock<ReturnType<UseReduceActivitiesFn>, Parameters<UseReduceActivitiesFn>>;
-  let renderResult: RenderResult;
-
-  beforeEach(() => {
-    jest.mock('../../../hooks', () => ({ __esModule: true, useActivities: jest.fn(() => [[]]) }));
-
-    ({ useActivities } = require('../../../hooks'));
-
-    useReduceActivities = jest.fn(require('./useReduceActivities').default);
-
-    fn = jest.fn().mockImplementation((prevResult, activity) => ({
-      maxText: prevResult?.maxText > activity['text'] ? prevResult?.maxText : activity['text']
-    }));
-
-    HookApp = ({ fn }) => {
-      useReduceActivities(fn);
-
-      return null;
-    };
-  });
-
-  test('reduce nothing', () => {
-    render(<HookApp fn={fn} />);
-
-    expect(fn).toHaveBeenCalledTimes(0);
-  });
-
-  describe('when the first activity is received', () => {
-    let firstActivity: WebChatActivity;
-
-    beforeEach(() => {
-      firstActivity = { ...ACTIVITY_TEMPLATE, id: 'a-00001', text: 'Aloha!' };
-
-      useActivities.mockImplementationOnce(() => [[firstActivity]]);
-
-      renderResult = render(<HookApp fn={fn} />);
-    });
-
-    describe('fn() should have been called', () => {
-      test('once', () => expect(fn).toHaveBeenCalledTimes(1));
-      test('with the activity', () =>
-        expect(fn).toHaveBeenLastCalledWith(undefined, firstActivity, 0, expect.arrayContaining([])));
-    });
-
-    test('return value should be derived from the first activity', () =>
-      expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Aloha!' }));
-
-    describe('when the second activity is received', () => {
-      let secondActivity: WebChatActivity;
-
-      beforeEach(() => {
-        secondActivity = { ...ACTIVITY_TEMPLATE, id: 'a-00002', text: 'Hello, World!' };
-
-        useActivities.mockImplementationOnce(() => [[firstActivity, secondActivity]]);
-
-        renderResult.rerender(<HookApp fn={fn} />);
-      });
-
-      describe('fn() should have been called', () => {
-        test('twice in total', () => expect(fn).toHaveBeenCalledTimes(2));
-        test('with the second activity', () =>
-          expect(fn).toHaveBeenLastCalledWith({ maxText: 'Aloha!' }, secondActivity, 1, expect.arrayContaining([])));
-
-        test('return value should be derived from the second activity', () =>
-          expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Hello, World!' }));
-      });
-
-      describe('when the third activity is inserted between the first and second activity', () => {
-        let thirdActivity: WebChatActivity;
-
-        beforeEach(() => {
-          thirdActivity = { ...ACTIVITY_TEMPLATE, id: 'a-00003', text: 'Morning!' };
-
-          useActivities.mockImplementationOnce(() => [[firstActivity, thirdActivity, secondActivity]]);
-
-          renderResult.rerender(<HookApp fn={fn} />);
-        });
-
-        describe('fn() should have been called', () => {
-          // It should call 2 more times because the first one should be from cache.
-          test('4 times in total', () => expect(fn).toHaveBeenCalledTimes(4));
-
-          test('with the third activity on 3rd call', () =>
-            expect(fn).toHaveBeenNthCalledWith(3, { maxText: 'Aloha!' }, thirdActivity, 1, expect.arrayContaining([])));
-          test('with the second activity on 4th call', () =>
-            expect(fn).toHaveBeenNthCalledWith(
-              4,
-              { maxText: 'Morning!' },
-              secondActivity,
-              2,
-              expect.arrayContaining([])
-            ));
-        });
-
-        test('return value should be derived from the third activity', () =>
-          expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Morning!' }));
-
-        describe('when all activities are removed', () => {
-          beforeEach(() => {
-            useActivities.mockImplementationOnce(() => [[]]);
-
-            renderResult.rerender(<HookApp fn={fn} />);
-          });
-
-          test('should not call fn()', () => expect(fn).toHaveBeenCalledTimes(4));
-          test('return value should be undefined', () => expect(useReduceActivities).toHaveLastReturnedWith(undefined));
-        });
-
-        describe('when the third activity is being replaced', () => {
-          let fourthActivity: WebChatActivity;
-
-          beforeEach(() => {
-            fourthActivity = { ...ACTIVITY_TEMPLATE, id: 'a-00004', text: 'Good morning!' };
-
-            useActivities.mockImplementationOnce(() => [[firstActivity, fourthActivity, secondActivity]]);
-
-            renderResult.rerender(<HookApp fn={fn} />);
-          });
-
-          describe('fn() should have been called', () => {
-            // It should call 2 more times because the first one should be from cache.
-            test('6 times in total', () => expect(fn).toHaveBeenCalledTimes(6));
-
-            test('with the fourth activity on 5rd call', () =>
-              expect(fn).toHaveBeenNthCalledWith(
-                5,
-                { maxText: 'Aloha!' },
-                fourthActivity,
-                1,
-                expect.arrayContaining([])
-              ));
-
-            test('with the second activity on 6th call', () =>
-              expect(fn).toHaveBeenNthCalledWith(
-                6,
-                { maxText: 'Good morning!' },
-                secondActivity,
-                2,
-                expect.arrayContaining([])
-              ));
-
-            test('return value should be derived from the second activity', () =>
-              expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Hello, World!' }));
-          });
-        });
-      });
-
-      describe('when the first activity is removed', () => {
-        beforeEach(() => {
-          useActivities.mockImplementationOnce(() => [[secondActivity]]);
-
-          renderResult.rerender(<HookApp fn={fn} />);
-        });
-
-        describe('should call fn', () => {
-          test('3 times in total', () => expect(fn).toHaveBeenCalledTimes(3));
-          test('with the second activity only', () =>
-            expect(fn).toHaveBeenLastCalledWith(undefined, secondActivity, 0, expect.arrayContaining([])));
-        });
-
-        test('return value should be derived from the second activity', () =>
-          expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Hello, World!' }));
-      });
-
-      describe('when the second activity is removed', () => {
-        beforeEach(() => {
-          useActivities.mockImplementationOnce(() => [[firstActivity]]);
-
-          renderResult.rerender(<HookApp fn={fn} />);
-        });
-
-        describe('should not call fn()', () => test('once', () => expect(fn).toHaveBeenCalledTimes(2)));
-
-        test('return value should be derived from the first activity', () =>
-          expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Aloha!' }));
-      });
-    });
-
-    describe('when all activities are removed', () => {
-      beforeEach(() => {
-        useActivities.mockImplementationOnce(() => [[]]);
-
-        renderResult.rerender(<HookApp fn={fn} />);
-      });
-
-      test('should not call fn()', () => expect(fn).toHaveBeenCalledTimes(1));
-      test('return value should be undefined', () => expect(useReduceActivities).toHaveLastReturnedWith(undefined));
-    });
-
-    describe('when activities are unchanged', () => {
-      beforeEach(() => {
-        useActivities.mockImplementationOnce(() => [[firstActivity]]);
-
-        renderResult.rerender(<HookApp fn={fn} />);
-      });
-
-      test('should not call fn()', () => expect(fn).toHaveBeenCalledTimes(1));
-      test('return value should be derived from the first activity', () =>
-        expect(useReduceActivities).toHaveLastReturnedWith({ maxText: 'Aloha!' }));
-    });
-  });
-});

package/src/providers/ActivityTyping/private/useReduceActivities.ts

@@ -1,49 +0,0 @@
-import { useMemoWithPrevious } from '@msinternal/botframework-webchat-react-hooks';
-import { type WebChatActivity } from 'botframework-webchat-core';
-
-import { useActivities } from '../../../hooks';
-
-type Entry<T> = Readonly<{
-  activity: WebChatActivity;
-  value: T | undefined;
-}>;
-
-export default function useReduceActivities<T>(
-  fn: (prevValue: T, activity: WebChatActivity, index: number, activities: Readonly<WebChatActivity[]>) => T
-): T {
-  const [activities] = useActivities();
-
-  const state = useMemoWithPrevious<readonly Entry<T>[]>(
-    (state = Object.freeze([])) => {
-      let changed = activities.length !== state.length;
-      let prevValue: T | undefined;
-      let shouldRecompute = false;
-
-      const nextState = activities.map<Entry<T>>((activity, index) => {
-        const entry = state[+index];
-
-        if (!shouldRecompute && Object.is(entry?.activity, activity)) {
-          prevValue = entry?.value;
-
-          // Skips the activity if it has been reduced in the past render loop.
-          return entry;
-        }
-
-        changed = true;
-        shouldRecompute = true;
-
-        return Object.freeze({
-          activity,
-          value: (prevValue = fn(prevValue, activity, index, activities))
-        });
-      });
-
-      // Returns the original array if nothing changed.
-      return changed ? nextState : state;
-    },
-    [activities, fn]
-  );
-
-  // eslint-disable-next-line no-magic-numbers
-  return state.at(-1)?.value;
-}

package/src/providers/Capabilities/CapabilitiesComposer.tsx

@@ -1,53 +0,0 @@
-import React, { memo, useCallback, useEffect, useMemo, useState, type ReactNode } from 'react';
-
-import useWebChatAPIContext from '../../hooks/internal/useWebChatAPIContext';
-import CapabilitiesContext from './private/Context';
-import fetchCapabilitiesFromAdapter from './private/fetchCapabilitiesFromAdapter';
-import type { Capabilities } from './types/Capabilities';
-
-type Props = Readonly<{ children?: ReactNode | undefined }>;
-
-const EMPTY_CAPABILITIES: Capabilities = Object.freeze({});
-
-/**
- * Composer that provides capabilities from the adapter via EventTarget pattern.
- *
- * Design principles:
- * 1. Initial fetch: Pulls capabilities from adapter on mount
- * 2. Event-driven updates: Re-fetches when adapter dispatches 'capabilitieschanged' event
- * 3. Stable references: Individual capability objects maintain reference equality if unchanged
- *    - This ensures consumers using selectors only re-render when their capability changes
- */
-const CapabilitiesComposer = memo(({ children }: Props) => {
-  const { directLine } = useWebChatAPIContext();
-
-  const getAllCapabilities = useCallback(
-    () => fetchCapabilitiesFromAdapter(directLine, EMPTY_CAPABILITIES).capabilities,
-    [directLine]
-  );
-
-  const [capabilities, setCapabilities] = useState<Capabilities>(() => getAllCapabilities());
-
-  useEffect(() => {
-    const handleCapabilitiesChange = () => {
-      setCapabilities(prevCapabilities => {
-        const { capabilities, hasChanged } = fetchCapabilitiesFromAdapter(directLine, prevCapabilities);
-        return hasChanged ? capabilities : prevCapabilities;
-      });
-    };
-
-    if (typeof directLine?.addEventListener === 'function') {
-      directLine.addEventListener('capabilitieschanged', handleCapabilitiesChange);
-
-      return () => directLine.removeEventListener('capabilitieschanged', handleCapabilitiesChange);
-    }
-  }, [directLine]);
-
-  const contextValue = useMemo(() => Object.freeze({ capabilities }), [capabilities]);
-
-  return <CapabilitiesContext.Provider value={contextValue}>{children}</CapabilitiesContext.Provider>;
-});
-
-CapabilitiesComposer.displayName = 'CapabilitiesComposer';
-
-export default CapabilitiesComposer;

package/src/providers/Capabilities/private/Context.ts

@@ -1,13 +0,0 @@
-import { createContext } from 'react';
-import type { Capabilities } from '../types/Capabilities';
-
-type CapabilitiesContextType = Readonly<{
-  capabilities: Capabilities;
-}>;
-
-const CapabilitiesContext = createContext<CapabilitiesContextType | undefined>(undefined);
-
-CapabilitiesContext.displayName = 'CapabilitiesContext';
-
-export default CapabilitiesContext;
-export type { CapabilitiesContextType };

package/src/providers/Capabilities/private/capabilityRegistry.ts

@@ -1,45 +0,0 @@
-import type { Capabilities } from '../types/Capabilities';
-
-/**
- * Descriptor for a capability that can be fetched from the adapter.
- */
-export type CapabilityDescriptor<K extends keyof Capabilities> = {
-  /** The key in the Capabilities object */
-  readonly key: K;
-  /** The getter function name on the adapter (e.g., 'getVoiceConfiguration') */
-  readonly getterName: string;
-  /**
-   * Custom equality comparator for this capability.
-   * If not provided, uses shallow object comparison.
-   * Return true if values are equal (should reuse previous reference).
-   */
-  readonly isEqual?: (a: Capabilities[K], b: Capabilities[K]) => boolean;
-};
-
-/**
- * Registry of all capabilities.
- *
- * To add a new capability:
- * 1. Add type to Capabilities interface in types/Capabilities.ts
- * 2. Add entry here with key, getterName, and optional custom isEqual
- *
- * @example
- * // Simple capability (uses default shallowEqual)
- * { key: 'voiceConfiguration', getterName: 'getVoiceConfiguration' }
- *
- * @example
- * // Capability with custom equality check
- * {
- *   key: 'complexConfig',
- *   getterName: 'getComplexConfig',
- *   isEqual: (a, b) => a?.nested?.value === b?.nested?.value
- * }
- */
-const CAPABILITY_REGISTRY: readonly CapabilityDescriptor<keyof Capabilities>[] = Object.freeze([
-  {
-    key: 'voiceConfiguration',
-    getterName: 'getVoiceConfiguration'
-  }
-]);
-
-export default CAPABILITY_REGISTRY;

package/src/providers/Capabilities/private/fetchCapabilitiesFromAdapter.ts

@@ -1,59 +0,0 @@
-import { DirectLineJSBotConnection, isForbiddenPropertyName } from 'botframework-webchat-core';
-import type { Capabilities } from '../types/Capabilities';
-import CAPABILITY_REGISTRY from './capabilityRegistry';
-import shallowEqual from './shallowEqual';
-
-type FetchResult = {
-  capabilities: Capabilities;
-  hasChanged: boolean;
-};
-
-/**
- * Fetches all capabilities from the adapter based on the registry.
- * Returns a new capabilities object with values fetched from the adapter.
- */
-export default function fetchCapabilitiesFromAdapter(
-  directLine: DirectLineJSBotConnection,
-  prevCapabilities: Capabilities
-): FetchResult {
-  let hasChanged = false;
-
-  const entries: [string, unknown][] = [];
-
-  for (const descriptor of CAPABILITY_REGISTRY) {
-    const { key, getterName, isEqual = shallowEqual } = descriptor;
-
-    if (isForbiddenPropertyName(key) || isForbiddenPropertyName(getterName)) {
-      continue;
-    }
-
-    // eslint-disable-next-line security/detect-object-injection
-    const getter = directLine?.[getterName];
-
-    if (typeof getter === 'function') {
-      try {
-        const fetchedValue = getter.call(directLine);
-        // eslint-disable-next-line security/detect-object-injection
-        const prevValue = prevCapabilities[key];
-
-        if (fetchedValue) {
-          if (typeof prevValue !== 'undefined' && isEqual(prevValue, fetchedValue)) {
-            entries.push([key, prevValue]);
-          } else {
-            entries.push([key, Object.freeze({ ...fetchedValue })]);
-            hasChanged = true;
-          }
-        } else if (typeof prevValue !== 'undefined') {
-          hasChanged = true;
-        }
-      } catch (error) {
-        console.warn(`botframework-webchat: Error calling capability ${getterName}:`, error);
-      }
-    }
-  }
-
-  return {
-    capabilities: Object.freeze(Object.fromEntries(entries)) as Capabilities,
-    hasChanged
-  };
-}

package/src/providers/Capabilities/private/shallowEqual.ts

@@ -1,18 +0,0 @@
-import { isForbiddenPropertyName } from 'botframework-webchat-core';
-
-// TODO: [P2] Move this file to `base` package.
-export default function shallowEqual(x, y) {
-  if (x === y) {
-    return true;
-  }
-
-  const xKeys = Object.keys(x);
-  const yKeys = Object.keys(y);
-
-  return (
-    xKeys.length === yKeys.length &&
-    // Mitigated through denylisting.
-    // eslint-disable-next-line security/detect-object-injection
-    xKeys.every(key => !isForbiddenPropertyName(key) && yKeys.includes(key) && x[key] === y[key])
-  );
-}

package/src/providers/Capabilities/private/useContext.ts

@@ -1,12 +0,0 @@
-import { useContext } from 'react';
-import CapabilitiesContext, { type CapabilitiesContextType } from './Context';
-
-export default function useCapabilitiesContext(): CapabilitiesContextType {
-  const context = useContext(CapabilitiesContext);
-
-  if (!context) {
-    throw new Error('botframework-webchat internal: This hook can only be used under <CapabilitiesComposer>.');
-  }
-
-  return context;
-}

package/src/providers/Capabilities/types/Capabilities.ts

@@ -1,16 +0,0 @@
-/**
- * All capabilities are optional as they depend on adapter/server support.
- */
-type Capabilities = Readonly<{
-  voiceConfiguration?: VoiceConfiguration | undefined;
-}>;
-
-/**
- * Optional for adapter/server to provide these configs for speech-to-speech.
- */
-type VoiceConfiguration = Readonly<{
-  chunkIntervalMs: number;
-  sampleRate: number;
-}>;
-
-export type { Capabilities, VoiceConfiguration };

package/src/providers/Capabilities/useCapabilities.ts

@@ -1,25 +0,0 @@
-import { useMemo, useRef } from 'react';
-import useCapabilitiesContext from './private/useContext';
-import type { Capabilities } from './types/Capabilities';
-
-/**
- * Hook to access adapter capabilities with a selector function.
- * Only triggers re-render when the selected value changes (shallow comparison).
- *
- * @example
- * // Get voice configuration only
- * const voiceConfig = useCapabilities(caps => caps.voiceConfiguration);
- */
-export default function useCapabilities<T>(selector: (capabilities: Capabilities) => T): T {
-  const { capabilities } = useCapabilitiesContext();
-  const selectedValue = selector(capabilities);
-  const prevSelectedValueRef = useRef<T>(selectedValue);
-
-  return useMemo(() => {
-    if (Object.is(prevSelectedValueRef.current, selectedValue)) {
-      return prevSelectedValueRef.current;
-    }
-    prevSelectedValueRef.current = selectedValue;
-    return selectedValue;
-  }, [selectedValue]);
-}