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

package/src/decorator/ActivityBorder/ActivityBorderDecorator.tsx

@@ -1,57 +0,0 @@
-import {
-  getActivityLivestreamingMetadata,
-  getVoiceActivityRole,
-  isVoiceActivity,
-  type WebChatActivity
-} from 'botframework-webchat-core';
-import React, { memo, useMemo, type ReactNode } from 'react';
-
-import {
-  ActivityBorderDecoratorMiddlewareProxy,
-  createActivityBorderMiddleware,
-  type ActivityBorderDecoratorMiddlewareRequest
-} from './private/ActivityBorderDecoratorMiddleware';
-import ActivityBorderDecoratorRequestContext from './private/ActivityBorderDecoratorRequestContext';
-
-const supportedActivityRoles: ActivityBorderDecoratorMiddlewareRequest['from'][] = [
-  'bot',
-  'channel',
-  'user',
-  undefined
-];
-
-type ActivityBorderDecoratorProps = Readonly<{
-  activity?: WebChatActivity | undefined;
-  children?: ReactNode | undefined;
-}>;
-
-function ActivityBorderDecorator({ activity, children }: ActivityBorderDecoratorProps) {
-  const request = useMemo<ActivityBorderDecoratorMiddlewareRequest>(() => {
-    const { type } = getActivityLivestreamingMetadata(activity) || {};
-
-    return {
-      from: isVoiceActivity(activity)
-        ? getVoiceActivityRole(activity)
-        : supportedActivityRoles.includes(activity?.from?.role)
-          ? activity?.from?.role
-          : undefined,
-      modality: new Set(isVoiceActivity(activity) ? ['audio', 'text'] : ['text']),
-      livestreamingState:
-        type === 'final activity'
-          ? 'completing'
-          : type === 'informative message'
-            ? 'preparing'
-            : type === 'interim activity'
-              ? 'ongoing'
-              : type === 'contentless'
-                ? undefined // No bubble is shown for "contentless" livestream, should not decorate.
-                : undefined
-    };
-  }, [activity]);
-
-  return <ActivityBorderDecoratorMiddlewareProxy request={request}>{children}</ActivityBorderDecoratorMiddlewareProxy>;
-}
-
-export default memo(ActivityBorderDecorator);
-export { createActivityBorderMiddleware, type ActivityBorderDecoratorProps };
-export { ActivityBorderDecoratorRequestContext as ActivityBorderDecoratorRequest };

package/src/decorator/ActivityBorder/private/ActivityBorderDecoratorMiddleware.ts

@@ -1,34 +0,0 @@
-import { type ReactNode } from 'react';
-import templateDecorator, {
-  InferRequest,
-  type InferMiddleware,
-  type InferProps
-} from '../../private/templateDecorator';
-import ActivityBorderDecoratorRequestContext, {
-  type ActivityBorderDecoratorRequest
-} from './ActivityBorderDecoratorRequestContext';
-
-type Props = Readonly<{
-  children?: ReactNode | undefined;
-  showFlair?: boolean | undefined;
-  showLoader?: boolean | undefined;
-}>;
-
-const template = templateDecorator<Props, ActivityBorderDecoratorRequest>(
-  'activity border',
-  ActivityBorderDecoratorRequestContext
-);
-
-const { createMiddleware: createActivityBorderMiddleware, Proxy: ActivityBorderDecoratorMiddlewareProxy } = template;
-
-type ActivityBorderDecoratorMiddleware = InferMiddleware<typeof template>;
-type ActivityBorderDecoratorMiddlewareProps = InferProps<typeof template>;
-type ActivityBorderDecoratorMiddlewareRequest = InferRequest<typeof template>;
-
-export {
-  ActivityBorderDecoratorMiddlewareProxy,
-  createActivityBorderMiddleware,
-  type ActivityBorderDecoratorMiddleware,
-  type ActivityBorderDecoratorMiddlewareProps,
-  type ActivityBorderDecoratorMiddlewareRequest
-};

package/src/decorator/ActivityBorder/private/ActivityBorderDecoratorRequestContext.ts

@@ -1,48 +0,0 @@
-import { createContext } from 'react';
-
-type ActivityBorderDecoratorRequest = Readonly<{
-  /**
-   * Decorate the activity as it participate in a livestreaming session.
-   *
-   * - `"completing"` - decorate as the livestreaming is completing
-   * - `"ongoing"` - decorate as the livestreaming is ongoing
-   * - `"preparing"` - decorate as the livestreaming is being prepared
-   * - `undefined` - not participated in a livestreaming session
-   */
-  livestreamingState: 'completing' | 'ongoing' | 'preparing' | undefined;
-
-  /**
-   * Gets the role of the sender for the activity.
-   *
-   * - `"bot"` - the sender is a bot or other users
-   * - `"channel"` - the sender is the channel service
-   * - `"user"` - the sender is the current user
-   * - `undefined` - the sender is unknown
-   */
-  from: 'bot' | 'channel' | `user` | undefined;
-
-  /**
-   * Gets the modalities of the activity.
-   *
-   * - `'audio'` - the activity originated from audio/voice input
-   * - `'text'` - the activity originated from text input
-   */
-  modality: Set<'audio' | 'text'>;
-}>;
-
-type ActivityBorderDecoratorRequestContextType = Readonly<{
-  request: ActivityBorderDecoratorRequest;
-}>;
-
-const ActivityBorderDecoratorRequestContext = createContext<ActivityBorderDecoratorRequestContextType>(
-  Object.freeze({
-    request: Object.freeze({
-      from: undefined,
-      modality: new Set<'audio' | 'text'>(),
-      livestreamingState: undefined
-    })
-  })
-);
-
-export default ActivityBorderDecoratorRequestContext;
-export { type ActivityBorderDecoratorRequestContextType, type ActivityBorderDecoratorRequest };

package/src/decorator/ActivityGrouping/ActivityGroupingDecorator.tsx

@@ -1,43 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-import React, { memo, useContext, useMemo, type ReactNode } from 'react';
-
-import DecoratorComposerContext from '../private/DecoratorComposerContext';
-import PassthroughFallback from '../private/PassthroughFallback';
-import {
-  ActivityGroupingDecoratorMiddlewareProvider,
-  ActivityGroupingDecoratorMiddlewareProxy,
-  createActivityGroupingMiddleware,
-  extractActivityGroupingDecoratorMiddleware,
-  type ActivityGroupingDecoratorMiddlewareRequest
-} from './private/ActivityGroupingDecoratorMiddleware';
-
-type ActivityGroupingDecoratorProps = Readonly<{
-  activities: readonly WebChatActivity[];
-  children?: ReactNode | undefined;
-  groupingName: string;
-}>;
-
-function ActivityGroupingDecorator({ activities, children, groupingName }: ActivityGroupingDecoratorProps) {
-  const request = useMemo<ActivityGroupingDecoratorMiddlewareRequest>(() => ({ groupingName }), [groupingName]);
-  const { middleware } = useContext(DecoratorComposerContext);
-
-  const activityGroupingMiddleware = useMemo(
-    () => extractActivityGroupingDecoratorMiddleware(middleware),
-    [middleware]
-  );
-
-  return (
-    <ActivityGroupingDecoratorMiddlewareProvider middleware={activityGroupingMiddleware}>
-      <ActivityGroupingDecoratorMiddlewareProxy
-        activities={activities}
-        fallbackComponent={PassthroughFallback}
-        request={request}
-      >
-        {children}
-      </ActivityGroupingDecoratorMiddlewareProxy>
-    </ActivityGroupingDecoratorMiddlewareProvider>
-  );
-}
-
-export default memo(ActivityGroupingDecorator);
-export { createActivityGroupingMiddleware, type ActivityGroupingDecoratorProps };

package/src/decorator/ActivityGrouping/private/ActivityGroupingDecoratorMiddleware.ts

@@ -1,40 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-import templateMiddleware, {
-  type InferMiddleware,
-  type InferProps,
-  type InferRequest
-} from '../../../middleware/private/templateMiddleware';
-
-type Request = Readonly<{
-  /**
-   * Name of the grouping from the result of `groupActivitesMiddleware()`.
-   */
-  groupingName: string;
-}>;
-
-type Props = Readonly<{
-  activities: readonly WebChatActivity[];
-}>;
-
-const template = templateMiddleware<Request, Props>('activity grouping');
-
-const {
-  createMiddleware: createActivityGroupingMiddleware,
-  extractMiddleware: extractActivityGroupingDecoratorMiddleware,
-  Provider: ActivityGroupingDecoratorMiddlewareProvider,
-  Proxy: ActivityGroupingDecoratorMiddlewareProxy
-} = template;
-
-type ActivityGroupingDecoratorMiddleware = InferMiddleware<typeof template>;
-type ActivityGroupingDecoratorMiddlewareProps = InferProps<typeof template>;
-type ActivityGroupingDecoratorMiddlewareRequest = InferRequest<typeof template>;
-
-export {
-  ActivityGroupingDecoratorMiddlewareProvider,
-  ActivityGroupingDecoratorMiddlewareProxy,
-  createActivityGroupingMiddleware,
-  extractActivityGroupingDecoratorMiddleware,
-  type ActivityGroupingDecoratorMiddleware,
-  type ActivityGroupingDecoratorMiddlewareProps,
-  type ActivityGroupingDecoratorMiddlewareRequest
-};

package/src/decorator/DecoratorComposer.tsx

@@ -1,51 +0,0 @@
-import { reactNode, validateProps } from '@msinternal/botframework-webchat-react-valibot';
-import React, { Fragment, memo, useMemo } from 'react';
-import { array, custom, is, object, optional, pipe, readonly, type InferInput } from 'valibot';
-
-import { middlewareFactoryMarker } from '../middleware/private/templateMiddleware';
-import InternalDecoratorComposer from './internal/InternalDecoratorComposer';
-import { type DecoratorMiddleware } from './types';
-
-const decoratorComposerPropsSchema = pipe(
-  object({
-    children: optional(reactNode()),
-    middleware: optional(pipe(array(custom<DecoratorMiddleware>(value => typeof value === 'function')), readonly()))
-  }),
-  readonly()
-);
-
-const warnInvalidMiddlewarePropsSchema = optional(
-  array(custom(value => value[middlewareFactoryMarker satisfies symbol] === middlewareFactoryMarker))
-);
-
-type DecoratorComposerProps = Omit<InferInput<typeof decoratorComposerPropsSchema>, 'middleware'> & {
-  // Mark "middleware" as read-only.
-  // Otherwise, passing a read-only middleware would fail because we prefer writable.
-  // eslint-disable-next-line react/require-default-props, react/no-unused-prop-types
-  readonly middleware?: readonly DecoratorMiddleware[] | undefined;
-};
-
-function DecoratorComposer(props: DecoratorComposerProps) {
-  const { children, middleware } = validateProps(decoratorComposerPropsSchema, props);
-
-  useMemo(() => {
-    if (!is(warnInvalidMiddlewarePropsSchema, middleware)) {
-      console.warn(
-        'botframework-webchat: "middleware" props passed to <DecoratorComposer> should be created using createXXXMiddleware() functions.',
-        { middleware }
-      );
-    }
-  }, [middleware]);
-
-  return middleware ? (
-    <InternalDecoratorComposer middleware={middleware} priority="normal">
-      {children}
-    </InternalDecoratorComposer>
-  ) : (
-    // We can't return `children` unless we are not using memo().
-    <Fragment>{children}</Fragment>
-  );
-}
-
-export default memo(DecoratorComposer);
-export { decoratorComposerPropsSchema, type DecoratorComposerProps };

package/src/decorator/internal/InternalDecoratorComposer.tsx

@@ -1,33 +0,0 @@
-import React, { memo, useContext, useMemo, type ReactNode } from 'react';
-import DecoratorComposerContext from '../private/DecoratorComposerContext';
-import { type DecoratorMiddleware } from '../types';
-
-type InternalDecoratorComposerProps = Readonly<{
-  children?: ReactNode | undefined;
-  middleware: readonly DecoratorMiddleware[];
-  priority: 'low' | 'normal';
-}>;
-
-const EMPTY_ARRAY = Object.freeze([]);
-
-function InternalDecoratorComposer({
-  children,
-  middleware: middlewareFromProps = EMPTY_ARRAY,
-  priority
-}: InternalDecoratorComposerProps) {
-  const existingContext = useContext(DecoratorComposerContext);
-  const middleware = useMemo(
-    () =>
-      priority === 'low'
-        ? Object.freeze([...existingContext.middleware, ...middlewareFromProps])
-        : Object.freeze([...middlewareFromProps, ...existingContext.middleware]),
-    [existingContext, middlewareFromProps, priority]
-  );
-
-  const context = useMemo(() => ({ middleware }), [middleware]);
-
-  return <DecoratorComposerContext.Provider value={context}>{children}</DecoratorComposerContext.Provider>;
-}
-
-export default memo(InternalDecoratorComposer);
-export { type InternalDecoratorComposerProps };

package/src/decorator/internal/LowPriorityDecoratorComposer.tsx

@@ -1,19 +0,0 @@
-import React, { memo, type ReactNode } from 'react';
-import { type DecoratorMiddleware } from '../types';
-import InternalDecoratorComposer from './InternalDecoratorComposer';
-
-type LowPriorityDecoratorComposerProps = Readonly<{
-  children?: ReactNode | undefined;
-  middleware: readonly DecoratorMiddleware[];
-}>;
-
-function LowPriorityDecoratorDecomposer({ children, middleware }: LowPriorityDecoratorComposerProps) {
-  return (
-    <InternalDecoratorComposer middleware={middleware} priority="low">
-      {children}
-    </InternalDecoratorComposer>
-  );
-}
-
-export default memo(LowPriorityDecoratorDecomposer);
-export { type LowPriorityDecoratorComposerProps };

package/src/decorator/private/DecoratorComposerContext.ts

@@ -1,16 +0,0 @@
-import { createContext } from 'react';
-
-import { type DecoratorMiddleware } from '../types';
-
-type DecoratorComposerContextType = Readonly<{
-  middleware: readonly DecoratorMiddleware[];
-}>;
-
-const DecoratorComposerContext = createContext<DecoratorComposerContextType>(
-  Object.freeze({
-    middleware: Object.freeze([])
-  })
-);
-
-export default DecoratorComposerContext;
-export { type DecoratorComposerContextType };

package/src/decorator/private/PassthroughFallback.tsx

@@ -1,12 +0,0 @@
-import React, { Fragment, memo, type ReactNode } from 'react';
-
-type PassthroughFallbackProps = Readonly<{
-  children?: ReactNode | undefined;
-}>;
-
-function PassthroughFallback({ children }: PassthroughFallbackProps) {
-  return <Fragment>{children}</Fragment>;
-}
-
-export default memo(PassthroughFallback);
-export { type PassthroughFallbackProps };

package/src/decorator/private/templateDecorator.tsx

@@ -1,113 +0,0 @@
-import PassthroughFallback from './PassthroughFallback';
-import DecoratorComposerContext from './DecoratorComposerContext';
-import React, { memo, useContext, useMemo, type Context, type ComponentType, type ReactNode } from 'react';
-import { ComponentMiddleware, createChainOfResponsibility } from 'react-chain-of-responsibility';
-import { middlewareFactoryMarker } from '../../middleware/private/templateMiddleware';
-
-const decoratorChain = createChainOfResponsibility<undefined, any, any>();
-
-export default function templateDecorator<
-  const P extends { children?: ReactNode | undefined },
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  const R extends {},
-  const Name extends string = string
->(
-  name: Name,
-  DecoratorRequestContext: Context<{ request: R }>,
-  FinalComponent: ComponentType<P> = PassthroughFallback
-) {
-  type FullProps = P & {
-    Next: ComponentType<P>;
-    request: R;
-  };
-  type Middleware = (name: Name) => ReturnType<ComponentMiddleware<undefined, FullProps, typeof name>> | false;
-
-  function buildComponent<T extends P>(
-    Component: ComponentType<FullProps>,
-    Next: ComponentType<P>
-  ): React.ComponentType<T> {
-    function ChainNext(props: T) {
-      const request = useContext(DecoratorRequestContext)?.request;
-      return <Component {...props} Next={Next} request={request} />;
-    }
-
-    ChainNext.displayName = `ChainNext(Next ${name})`;
-    return memo<T>(ChainNext);
-  }
-
-  function createMiddleware(Component: ComponentType<FullProps>): Middleware {
-    const factory: Middleware = (init: string): ReturnType<Middleware> | false => {
-      if (init !== name) {
-        return false;
-      }
-
-      return next => () => {
-        const Next = next(undefined);
-        return Next && buildComponent(Component, Next);
-      };
-    };
-
-    // 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;
-  }
-
-  // Reuse global chain, but cast it to the correct type.
-  const { Provider: DecoratorChainProvider, useBuildComponentCallback } = decoratorChain as ReturnType<
-    typeof createChainOfResponsibility<undefined, P, unknown>
-  >;
-
-  function Chain(props: P) {
-    const buildMiddleware = useBuildComponentCallback();
-    const Proxy = useMemo(() => buildMiddleware(undefined, { fallbackComponent: FinalComponent }), [buildMiddleware]);
-
-    return Proxy && <Proxy {...props} />;
-  }
-
-  Chain.displayName = `DecoratorChain(Chain ${name})`;
-
-  const MemoChain = memo<P>(Chain);
-
-  function DecoratorProxy(props: P & Readonly<{ request: R }>) {
-    const { request } = props;
-    const { middleware } = useContext(DecoratorComposerContext);
-    const decoratorMiddleware = useMemo(
-      () =>
-        middleware
-          .map(middleware => middleware(name))
-          .filter(enhancer => enhancer)
-          // Conversion from internal props to actual middleware stack props.
-          .map(enhancer => () => enhancer) as ComponentMiddleware<undefined, P, unknown>[],
-      [middleware]
-    );
-
-    const value = useMemo(() => ({ request }), [request]);
-
-    return (
-      <DecoratorRequestContext.Provider value={value}>
-        <DecoratorChainProvider init={name} middleware={decoratorMiddleware}>
-          <MemoChain {...props} />
-        </DecoratorChainProvider>
-      </DecoratorRequestContext.Provider>
-    );
-  }
-
-  DecoratorProxy.displayName = `DecoratorProxy(Decorator ${name})`;
-
-  return {
-    createMiddleware,
-    Proxy: memo<P & Readonly<{ request: R }>>(DecoratorProxy),
-    // This is for type inference, so we can use it in other files.
-    '~types': undefined as unknown as {
-      middleware: Middleware;
-      request: R;
-      props: P;
-    }
-  };
-}
-
-export type InferMiddleware<T extends ReturnType<typeof templateDecorator>> = T['~types']['middleware'];
-export type InferProps<T extends ReturnType<typeof templateDecorator>> = T['~types']['props'];
-export type InferRequest<T extends ReturnType<typeof templateDecorator>> = T['~types']['request'];

package/src/decorator/types.ts

@@ -1,4 +0,0 @@
-import { ActivityBorderDecoratorMiddleware } from './ActivityBorder/private/ActivityBorderDecoratorMiddleware';
-import { ActivityGroupingDecoratorMiddleware } from './ActivityGrouping/private/ActivityGroupingDecoratorMiddleware';
-
-export type DecoratorMiddleware = ActivityBorderDecoratorMiddleware | ActivityGroupingDecoratorMiddleware;

package/src/decorator/useDecoratorRequest.ts

@@ -1,15 +0,0 @@
-import { useContext } from 'react';
-import { ActivityBorderDecoratorRequest } from './ActivityBorder/ActivityBorderDecorator';
-
-export default function useDecoratorRequest(type: typeof ActivityBorderDecoratorRequest) {
-  const request = useContext(type)?.request;
-
-  if (!request) {
-    throw new Error(`useDecoratorRequest must be used within a ${type}Provider`);
-  }
-
-  return request;
-}
-
-export type InferDecoratorRequest<T extends typeof ActivityBorderDecoratorRequest> =
-  T extends React.Context<infer U> ? (U extends { request: infer R } ? R : never) : never;

package/src/env.d.ts

@@ -1,9 +0,0 @@
-// For adding things to `globalThis`, TypeScript need `var`, not `const` or `let`.
-/* eslint-disable no-var */
-declare global {
-  var WEB_CHAT_BUILD_INFO_BUILD_TOOL: string | undefined;
-  var WEB_CHAT_BUILD_INFO_MODULE_FORMAT: string | undefined;
-  var WEB_CHAT_BUILD_INFO_VERSION: string | undefined;
-}
-
-export {};

package/src/errorBox/errorBoxTelemetryPolymiddleware.ts

@@ -1,53 +0,0 @@
-import {
-  createErrorBoxPolymiddleware,
-  errorBoxComponent,
-  ErrorBoxPolymiddlewareHandlerResult
-} from '@msinternal/botframework-webchat-api-middleware';
-import { validateProps } from '@msinternal/botframework-webchat-react-valibot';
-import { memo, useEffect } from 'react';
-import { custom, never, object, optional, pipe, readonly, unknown, type InferInput } from 'valibot';
-
-import { useTrackException } from '../hooks';
-
-const errorBoxTelemetryHeadlessPropsSchema = pipe(
-  object({
-    children: optional(never()),
-    error: unknown(),
-    render: optional(custom<ErrorBoxPolymiddlewareHandlerResult['render']>(value => typeof value === 'function'))
-  }),
-  readonly()
-);
-
-type ErrorBoxTelemetryHeadlessProps = InferInput<typeof errorBoxTelemetryHeadlessPropsSchema>;
-
-// Use traditional function for component name.
-// eslint-disable-next-line prefer-arrow-callback
-const ErrorBoxTelemetryHeadless = memo(function ErrorBoxTelemetryHeadless(props: ErrorBoxTelemetryHeadlessProps) {
-  const { error, render } = validateProps(errorBoxTelemetryHeadlessPropsSchema, props);
-  const trackException = useTrackException();
-
-  useEffect(() => {
-    if (error instanceof Error) {
-      trackException(error, false);
-    } else {
-      const telemetryError = new Error('Unknown error');
-
-      telemetryError.cause = error;
-      telemetryError.name = 'WebChatError';
-
-      trackException(telemetryError, false);
-    }
-  }, [error, trackException]);
-
-  return render?.();
-});
-
-const errorBoxTelemetryPolymiddleware = createErrorBoxPolymiddleware(
-  next => request =>
-    errorBoxComponent(ErrorBoxTelemetryHeadless, {
-      error: request.error,
-      render: next(request)?.render
-    })
-);
-
-export default errorBoxTelemetryPolymiddleware;

package/src/hooks/internal/usePostVoiceActivity.ts

@@ -1,18 +0,0 @@
-import { postVoiceActivity, type WebChatActivity } from 'botframework-webchat-core';
-import { useCallback } from 'react';
-import { useDispatch } from './WebChatReduxContext';
-
-/**
- * Hook to post voice activities (fire-and-forget, no echo back).
- * Use this for DTMF and other voice-related event activities.
- */
-export default function usePostVoiceActivity(): (activity: WebChatActivity) => void {
-  const dispatch = useDispatch();
-
-  return useCallback(
-    (activity: WebChatActivity) => {
-      dispatch(postVoiceActivity(activity));
-    },
-    [dispatch]
-  );
-}

package/src/hooks/internal/useRegisterVoiceHandler.ts

@@ -1,23 +0,0 @@
-import { registerVoiceHandler, unregisterVoiceHandler, type VoiceHandler } from 'botframework-webchat-core';
-import { useCallback } from 'react';
-import randomId from '../../utils/randomId';
-import { useDispatch } from './WebChatReduxContext';
-
-/**
- * Internal hook to register a voice handler for audio playback.
- * @returns A function that registers a voice handler and returns an unregister function.
- */
-export default function useRegisterVoiceHandler(): (voiceHandler: VoiceHandler) => () => void {
-  const dispatch = useDispatch();
-
-  return useCallback(
-    (voiceHandler: VoiceHandler) => {
-      const id = randomId();
-      dispatch(registerVoiceHandler(id, voiceHandler));
-      return () => {
-        dispatch(unregisterVoiceHandler(id));
-      };
-    },
-    [dispatch]
-  );
-}

package/src/hooks/internal/useShouldShowMicrophoneButton.ts

@@ -1,22 +0,0 @@
-import useStyleOptions from '../useStyleOptions';
-import useCapabilities from '../../providers/Capabilities/useCapabilities';
-
-/**
- * Internal hook to determine if the microphone button should be shown based on:
- * - `showMicrophoneButton` style option ('auto' | 'hide')
- * - Adapter voice capability (voiceConfiguration)
- *
- * - 'auto': Show if adapter has voiceConfiguration capability, hide otherwise
- * - 'hide': Never show
- */
-export default function useShouldShowMicrophoneButton(): boolean {
-  const [{ showMicrophoneButton }] = useStyleOptions();
-  // If adapter has voice capability, voiceConfiguration will be defined,
-  const voiceConfiguration = useCapabilities(caps => caps.voiceConfiguration);
-
-  if (showMicrophoneButton === 'hide') {
-    return false;
-  }
-
-  return !!voiceConfiguration;
-}

package/src/hooks/internal/useVoiceHandlers.ts

@@ -1,11 +0,0 @@
-import type { VoiceHandler } from 'botframework-webchat-core';
-import { useSelector } from './WebChatReduxContext';
-
-/**
- * Internal hook to get all registered voice handlers from Redux state.
- */
-export default function useVoiceHandlers(): readonly [ReadonlyMap<string, VoiceHandler>] {
-  return Object.freeze([
-    useSelector((state: { voice: { voiceHandlers: Map<string, VoiceHandler> } }) => state.voice.voiceHandlers)
-  ]);
-}

package/src/hooks/internal/useVoiceStateWritable.ts

@@ -1,18 +0,0 @@
-import { setVoiceState, type VoiceState } from 'botframework-webchat-core';
-import { useCallback } from 'react';
-import { useDispatch, useSelector } from './WebChatReduxContext';
-
-/**
- * Internal hook to set the voice state.
- */
-export default function useVoiceStateWritable(): readonly [VoiceState, (state: VoiceState) => void] {
-  const dispatch = useDispatch();
-  const setter = useCallback(
-    (state: VoiceState) => {
-      dispatch(setVoiceState(state));
-    },
-    [dispatch]
-  );
-  const value = useSelector(({ voice }) => voice.voiceState);
-  return Object.freeze([value, setter]);
-}