botframework-webchat-api 4.18.1-main.20260518.2a3d1d3 → 4.18.2

package/src/providers/GroupActivities/GroupActivitiesComposer.tsx

@@ -1,116 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-import React, { memo, useCallback, useMemo, type ReactNode } from 'react';
-import { useRefFrom } from 'use-ref-from';
-
-import applyMiddleware from '../../hooks/middleware/applyMiddleware';
-import useStyleOptions from '../../hooks/useStyleOptions';
-import type GroupActivitiesMiddleware from '../../types/GroupActivitiesMiddleware';
-import { type GroupActivities } from '../../types/GroupActivitiesMiddleware';
-import usePonyfill from '../Ponyfill/usePonyfill';
-import createDefaultGroupActivitiesMiddleware from './private/createDefaultGroupActivitiesMiddleware';
-import GroupActivitiesContext, { type GroupActivitiesContextType } from './private/GroupActivitiesContext';
-import isGroupingValid from './private/isGroupingValid';
-
-type GroupActivitiesComposerProps = Readonly<{
-  children?: ReactNode | undefined;
-  groupActivitiesMiddleware: readonly GroupActivitiesMiddleware[] | undefined;
-}>;
-
-function GroupActivitiesComposer({ children, groupActivitiesMiddleware }: GroupActivitiesComposerProps) {
-  const [ponyfill] = usePonyfill();
-  const [{ groupActivitiesBy, groupTimestamp }] = useStyleOptions();
-
-  const runMiddleware = useMemo<(type?: string | undefined) => GroupActivities>(
-    () =>
-      applyMiddleware(
-        'group activities',
-        ...(groupActivitiesMiddleware ?? []),
-        ...createDefaultGroupActivitiesMiddleware({ groupTimestamp, ponyfill }),
-        () => () => () => ({})
-      ),
-    [groupActivitiesMiddleware, groupTimestamp, ponyfill]
-  );
-
-  const runAllMiddleware = useMemo(() => runMiddleware(), [runMiddleware]);
-
-  const groupActivities: GroupActivities = useCallback(
-    ({ activities }: { activities: readonly WebChatActivity[] }) => {
-      const results: Readonly<{
-        [key: string]: readonly (readonly WebChatActivity[])[];
-      }> = runAllMiddleware({ activities }) || Object.freeze({});
-      const validatedResults = new Map<string, readonly (readonly WebChatActivity[])[]>();
-
-      for (const [name, result] of Object.entries(results)) {
-        if (isGroupingValid(activities, result)) {
-          validatedResults.set(name, result);
-        } else {
-          validatedResults.set(
-            name,
-            activities.map(activity => Object.freeze([activity]))
-          );
-        }
-      }
-
-      return Object.fromEntries(validatedResults);
-    },
-    [runAllMiddleware]
-  );
-
-  const groupActivitiesByGroup: Map<string, GroupActivities> = useMemo(
-    () =>
-      new Map<string, GroupActivities>(
-        groupActivitiesBy.map(groupingName => [groupingName, runMiddleware(groupingName)])
-      ),
-    [groupActivitiesBy, runMiddleware]
-  );
-
-  const groupActivitiesByRef = useRefFrom(groupActivitiesBy);
-
-  // When `groupActivitiesMiddleware` or `styleOptions.groupActivities` changed, the callback should be invalidated.
-  // The invalidation will help hook callers to re-render.
-  const groupActivitiesByName = useCallback<
-    (activities: readonly WebChatActivity[], groupingName: string) => readonly (readonly WebChatActivity[])[]
-  >(
-    (activities, groupingName) => {
-      const group = groupActivitiesByGroup.get(groupingName);
-
-      if (group) {
-        const result: ReadonlyMap<string, readonly (readonly WebChatActivity[])[]> = new Map(
-          Object.entries(group({ activities }) || {})
-        );
-
-        if (result.has(groupingName)) {
-          const groupingResult = result.get(groupingName);
-
-          if (isGroupingValid(activities, groupingResult)) {
-            return groupingResult;
-          }
-        } else {
-          console.warn(
-            `botframework-webchat: groupActivitiesMiddleware('${groupingName}') does not return any results`
-          );
-        }
-      } else {
-        console.warn(
-          `botframework-webchat: useGroupActivitiesBy can only be called with one of ${groupActivitiesByRef.current}, however "${groupingName}" was passed instead`
-        );
-      }
-
-      return Object.freeze(activities.map(activity => Object.freeze([activity])));
-    },
-    [groupActivitiesByGroup, groupActivitiesByRef]
-  );
-
-  const context = useMemo<GroupActivitiesContextType>(
-    () => ({
-      groupActivities,
-      groupActivitiesByName
-    }),
-    [groupActivities, groupActivitiesByName]
-  );
-
-  return <GroupActivitiesContext.Provider value={context}>{children}</GroupActivitiesContext.Provider>;
-}
-
-export default memo(GroupActivitiesComposer);
-export { type GroupActivitiesComposerProps };

package/src/providers/GroupActivities/private/GroupActivitiesContext.ts

@@ -1,23 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-import { createContext } from 'react';
-
-type GroupActivitiesContextType = {
-  groupActivities: (options: { activities: readonly WebChatActivity[] }) => Readonly<{
-    [key: string]: readonly (readonly WebChatActivity[])[];
-  }>;
-  groupActivitiesByName: (
-    activities: readonly WebChatActivity[],
-    groupingName: string
-  ) => readonly (readonly WebChatActivity[])[];
-};
-
-const GroupActivitiesContext = createContext<GroupActivitiesContextType>(
-  new Proxy({} as GroupActivitiesContextType, {
-    get() {
-      throw new Error('botframework-webchat: This hook can only be used under <GroupActivitiesContext>');
-    }
-  })
-);
-
-export default GroupActivitiesContext;
-export { type GroupActivitiesContextType };

package/src/providers/GroupActivities/private/createDefaultGroupActivitiesMiddleware.ts

@@ -1,113 +0,0 @@
-import { getOrgSchemaMessage, type GlobalScopePonyfill, type WebChatActivity } from 'botframework-webchat-core';
-import { IdentifierSchema } from 'botframework-webchat-core/graph.js';
-import { safeParse } from 'valibot';
-
-import { querySendStatusFromOutgoingActivity } from 'botframework-webchat-core/activity.js';
-import type GroupActivitiesMiddleware from '../../../types/GroupActivitiesMiddleware';
-import { type SendStatus } from '../../../types/SendStatus';
-
-function bin<T>(items: readonly T[], grouping: (last: T, current: T) => boolean): readonly (readonly T[])[] {
-  let lastBin: T[];
-  const bins: T[][] = [];
-  let lastItem: T;
-
-  for (const item of items) {
-    if (lastItem && grouping(lastItem, item)) {
-      lastBin.push(item);
-    } else {
-      lastBin = [item];
-      bins.push(lastBin);
-    }
-
-    lastItem = item;
-  }
-
-  for (const bin in bins) {
-    Object.freeze(bin);
-  }
-
-  return Object.freeze(bins);
-}
-
-function isSending(activity: WebChatActivity): SendStatus | undefined {
-  if (activity.from.role === 'user') {
-    return querySendStatusFromOutgoingActivity(activity);
-  }
-}
-
-function createShouldGroupTimestamp(groupTimestamp: boolean | number, { Date }: GlobalScopePonyfill) {
-  return (activityX: WebChatActivity, activityY: WebChatActivity): boolean => {
-    if (groupTimestamp === false) {
-      // Hide timestamp for all activities.
-      return true;
-    } else if (activityX && activityY) {
-      if (isSending(activityX) !== isSending(activityY)) {
-        return false;
-      }
-
-      groupTimestamp = typeof groupTimestamp === 'number' ? groupTimestamp : Infinity;
-
-      const timeX = new Date(activityX.timestamp).getTime();
-      const timeY = new Date(activityY.timestamp).getTime();
-
-      return Math.abs(timeX - timeY) <= groupTimestamp;
-    }
-
-    return false;
-  };
-}
-
-function shouldGroupSender(x: WebChatActivity, y: WebChatActivity): boolean {
-  const {
-    from: { role: roleX, id: idX }
-  } = x;
-  const {
-    from: { role: roleY, id: idY }
-  } = y;
-  return roleX === roleY && idX === idY;
-}
-
-export default function createDefaultGroupActivitiesMiddleware({
-  groupTimestamp,
-  ponyfill
-}: Readonly<{
-  groupTimestamp: boolean | number;
-  ponyfill: GlobalScopePonyfill;
-}>): readonly GroupActivitiesMiddleware[] {
-  return Object.freeze([
-    type =>
-      type === 'sender' || typeof type === 'undefined'
-        ? next =>
-            ({ activities }) => ({ ...next({ activities }), sender: bin(activities, shouldGroupSender) })
-        : undefined,
-    type =>
-      type === 'status' || typeof type === 'undefined'
-        ? next =>
-            ({ activities }) => ({
-              ...next({ activities }),
-              status: bin(activities, createShouldGroupTimestamp(groupTimestamp, ponyfill))
-            })
-        : undefined,
-    type =>
-      type === 'part'
-        ? next =>
-            ({ activities }) => {
-              const messages = activities.map(activity => [getOrgSchemaMessage(activity.entities), activity] as const);
-
-              return {
-                ...next({ activities }),
-                part: bin(messages, ([last], [current]) => {
-                  const lastPartIdResult = safeParse(IdentifierSchema, last?.isPartOf[0]?.['@id']);
-                  const currentPartIdResult = safeParse(IdentifierSchema, current?.isPartOf[0]?.['@id']);
-
-                  return (
-                    lastPartIdResult.success &&
-                    currentPartIdResult.success &&
-                    lastPartIdResult.output === currentPartIdResult.output
-                  );
-                }).map(bin => bin.map(([, activity]) => activity))
-              };
-            }
-        : undefined
-  ]);
-}

package/src/providers/GroupActivities/private/isGroupingValid.ts

@@ -1,41 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-
-export default function isGroupingValid(
-  source: readonly WebChatActivity[],
-  bins: readonly (readonly WebChatActivity[])[]
-): boolean {
-  const set = new Set(source);
-
-  if (source.length !== set.size) {
-    console.warn('botframework-webchat: Cannot validate activity grouping because some activities are duplicated');
-
-    return false;
-  }
-
-  for (const bin of bins) {
-    for (const activityInBin of bin) {
-      if (!set.has(activityInBin)) {
-        console.warn(
-          'botframework-webchat: All binned items must be originate from the source list, check groupingActivityMiddleware to make sure it bin from the source list',
-          {
-            activityInBin
-          }
-        );
-
-        return false;
-      }
-
-      set.delete(activityInBin);
-    }
-  }
-
-  if (set.size) {
-    console.warn(
-      'botframework-webchat: Not every activity is binned, check groupingActivityMiddleware to make sure it is binning every activity passed'
-    );
-
-    return false;
-  }
-
-  return true;
-}

package/src/providers/GroupActivities/private/useGroupActivitiesContext.ts

@@ -1,6 +0,0 @@
-import { useContext } from 'react';
-import GroupActivitiesContext, { type GroupActivitiesContextType } from './GroupActivitiesContext';
-
-export default function useGroupActivitiesContext(): GroupActivitiesContextType {
-  return useContext(GroupActivitiesContext);
-}

package/src/providers/GroupActivities/useGroupActivities.ts

@@ -1,20 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-
-import useGroupActivitiesContext from './private/useGroupActivitiesContext';
-
-type GroupedActivities = readonly (readonly WebChatActivity[])[];
-
-/**
- * This hook will return a callback function. When called with `activities`, the callback function will run the `groupActivitiesMiddleware` and will return all groupings.
- *
- * @deprecated This function is deprecated and will be removed on or after 2027-05-04. Developers should migrate to [`useGroupActivitiesByName`](#usegroupactivitiesbyname) for performance reason.
- */
-export default function useGroupActivities(): ({
-  activities
-}: Readonly<{
-  activities: readonly WebChatActivity[];
-}>) => Readonly<{
-  [key: string]: GroupedActivities;
-}> {
-  return useGroupActivitiesContext().groupActivities;
-}

package/src/providers/GroupActivities/useGroupActivitiesByName.ts

@@ -1,17 +0,0 @@
-import { type WebChatActivity } from 'botframework-webchat-core';
-
-import useGroupActivitiesContext from './private/useGroupActivitiesContext';
-
-/**
- * This hook will return a callback function. When called with `activities`, the callback function will run the `groupActivitiesMiddleware` for the specified grouping name.
- *
- * Unlike the [`useGroupActivities`](#usegroupactivities) hook which provide result for all groupings, this hook only provide result for the specified grouping name and the grouping name must be one of the name specified in `styleOptions.groupActivitiesBy`.
- *
- * @returns Result of `groupActivitiesMiddleware` for the specified grouping name
- */
-export default function useGroupActivitiesBy(): (
-  activities: readonly WebChatActivity[],
-  name: string
-) => readonly (readonly WebChatActivity[])[] {
-  return useGroupActivitiesContext().groupActivitiesByName;
-}

package/src/providers/SpeechToSpeech/SpeechToSpeechComposer.tsx

@@ -1,20 +0,0 @@
-import React, { type ReactNode } from 'react';
-import { VoiceHandlerBridge } from './private/VoiceHandlerBridge';
-import { VoiceRecorderBridge } from './private/VoiceRecorderBridge';
-
-/**
- * SpeechToSpeechComposer sets up the speech-to-speech infrastructure.
- *
- * This component renders invisible bridge components that:
- * 1. VoiceHandlerBridge - registers audio player functions with Redux
- * 2. VoiceRecorderBridge - reacts to recording state and manages microphone
- *
- * Use the `useVoiceState`, `useStartVoice`, and `useStopVoice` hooks to access state and controls.
- */
-export const SpeechToSpeechComposer: React.FC<{ readonly children: ReactNode }> = ({ children }) => (
-  <React.Fragment>
-    <VoiceHandlerBridge />
-    <VoiceRecorderBridge />
-    {children}
-  </React.Fragment>
-);

package/src/providers/SpeechToSpeech/private/VoiceHandlerBridge.tsx

@@ -1,23 +0,0 @@
-import { useEffect } from 'react';
-import { useAudioPlayer } from './useAudioPlayer';
-import useRegisterVoiceHandler from '../../../hooks/internal/useRegisterVoiceHandler';
-import useShouldShowMicrophoneButton from '../../../hooks/internal/useShouldShowMicrophoneButton';
-
-/**
- * VoiceHandlerBridge is an invisible component that registers the audio player
- * functions (queueAudio, stopAllAudio) with Redux
- */
-export const VoiceHandlerBridge = () => {
-  const { queueAudio, stopAllAudio } = useAudioPlayer();
-  const registerVoiceHandler = useRegisterVoiceHandler();
-  const shouldShowMicrophoneButton = useShouldShowMicrophoneButton();
-
-  useEffect(() => {
-    if (!shouldShowMicrophoneButton) {
-      return;
-    }
-    return registerVoiceHandler({ queueAudio, stopAllAudio });
-  }, [queueAudio, registerVoiceHandler, shouldShowMicrophoneButton, stopAllAudio]);
-
-  return null;
-};

package/src/providers/SpeechToSpeech/private/VoiceRecorderBridge.tsx

@@ -1,49 +0,0 @@
-import { useEffect, useCallback } from 'react';
-import { useRecorder } from './useRecorder';
-import usePostVoiceActivity from '../../../hooks/internal/usePostVoiceActivity';
-import useVoiceRecordingMuted from '../../../hooks/useVoiceRecordingMuted';
-import useVoiceState from '../../../hooks/useVoiceState';
-
-/**
- * VoiceRecorderBridge is an invisible component that bridges the Redux recording state
- * with the actual microphone recording functionality.
- */
-export function VoiceRecorderBridge(): null {
-  const [muted] = useVoiceRecordingMuted();
-  const [voiceState] = useVoiceState();
-  const postVoiceActivity = usePostVoiceActivity();
-
-  // Derive recording state from voiceState - recording is active when not idle
-  const recording = voiceState !== 'idle';
-
-  const handleAudioChunk = useCallback(
-    (base64: string, timestamp: string) => {
-      postVoiceActivity({
-        name: 'media.chunk',
-        type: 'event',
-        value: {
-          contentType: 'audio/webm',
-          content: base64,
-          timestamp
-        }
-      } as any);
-    },
-    [postVoiceActivity]
-  );
-
-  const { mute, record } = useRecorder(handleAudioChunk);
-
-  useEffect(() => {
-    if (recording) {
-      return record();
-    }
-  }, [record, recording]);
-
-  useEffect(() => {
-    if (muted) {
-      return mute();
-    }
-  }, [muted, mute]);
-
-  return null;
-}