botframework-webchat-component 4.18.0 → 4.18.1-hotfix.20260127.b53acdf

package/src/TranscriptActivity.tsx

@@ -1,64 +0,0 @@
-import React, { memo, useCallback, useMemo } from 'react';
-import { hooks, type ActivityComponentFactory } from 'botframework-webchat-api';
-import type { ActivityElementMap } from './Transcript/types';
-import type { MutableRefObject, ReactNode } from 'react';
-import type { WebChatActivity } from 'botframework-webchat-core';
-import ActivityRow from './Transcript/ActivityRow';
-
-const { useCreateActivityStatusRenderer } = hooks;
-
-function TranscriptActivity({
-  activityElementMapRef,
-  activityKey,
-  activity,
-  hideTimestamp,
-  renderActivity,
-  renderAvatar,
-  showCallout
-}: Readonly<{
-  activityElementMapRef: MutableRefObject<ActivityElementMap>;
-  activityKey: string;
-  activity: WebChatActivity;
-  hideTimestamp: boolean;
-  renderActivity: Exclude<ReturnType<ActivityComponentFactory>, false>;
-  renderAvatar: false | (() => Exclude<ReactNode, boolean | null | undefined>);
-  showCallout: boolean;
-}>) {
-  const createActivityStatusRenderer = useCreateActivityStatusRenderer();
-  const activityCallbackRef = useCallback(
-    (activityElement: HTMLElement) => {
-      activityElement
-        ? activityElementMapRef.current.set(activityKey, activityElement)
-        : activityElementMapRef.current.delete(activityKey);
-    },
-    [activityElementMapRef, activityKey]
-  );
-
-  const renderActivityStatus = useMemo(
-    () =>
-      createActivityStatusRenderer({
-        activity,
-        nextVisibleActivity: undefined
-      }),
-    [activity, createActivityStatusRenderer]
-  );
-
-  const children = useMemo(
-    () =>
-      renderActivity({
-        hideTimestamp,
-        renderActivityStatus,
-        renderAvatar,
-        showCallout
-      }),
-    [hideTimestamp, renderActivity, renderActivityStatus, renderAvatar, showCallout]
-  );
-
-  return (
-    <ActivityRow activity={activity} ref={activityCallbackRef}>
-      {children}
-    </ActivityRow>
-  );
-}
-
-export default memo(TranscriptActivity);

package/src/Utils/CroppedImage.js

@@ -1,45 +0,0 @@
-import classNames from 'classnames';
-import PropTypes from 'prop-types';
-import React, { useMemo } from 'react';
-
-import useStyleToEmotionObject from '../hooks/internal/useStyleToEmotionObject';
-
-const ROOT_STYLE = {
-  overflow: 'hidden',
-  position: 'relative',
-
-  '& > img': {
-    height: 'auto',
-    left: '50%',
-    position: 'absolute',
-    top: '50%',
-    transform: 'translate(-50%, -50%)',
-    width: '100%'
-  }
-};
-
-const CroppedImage = ({ alt, className, height, src, width }) => {
-  const rootClassName = useStyleToEmotionObject()(ROOT_STYLE) + '';
-  const sizeStyle = useMemo(() => ({ height, width }), [height, width]);
-
-  return (
-    <div className={classNames(rootClassName, (className || '') + '')} style={sizeStyle}>
-      <img alt={alt} src={src} />
-    </div>
-  );
-};
-
-CroppedImage.defaultProps = {
-  alt: '',
-  className: ''
-};
-
-CroppedImage.propTypes = {
-  alt: PropTypes.string,
-  className: PropTypes.string,
-  height: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired,
-  src: PropTypes.string.isRequired,
-  width: PropTypes.oneOfType([PropTypes.number, PropTypes.string]).isRequired
-};
-
-export default CroppedImage;

package/src/Utils/parseDocumentFromString.ts

@@ -1,5 +0,0 @@
-export default function parseDocumentFromString(html: string): Document {
-  const parser = new DOMParser();
-
-  return parser.parseFromString(html, 'text/html');
-}

package/src/Utils/serializeDocumentIntoString.ts

@@ -1,10 +0,0 @@
-export default function serializeDocumentIntoString(document: Document): string {
-  const serializer = new XMLSerializer();
-  const elementHTML: string[] = [];
-
-  for (const element of document.body.children) {
-    elementHTML.push(serializer.serializeToString(element));
-  }
-
-  return `${elementHTML.join('\n')}\n`;
-}

package/src/hooks/internal/useStyleToEmotionObject.js

@@ -1,5 +0,0 @@
-import useWebChatUIContext from './useWebChatUIContext';
-
-export default function useStyleToEmotionObject() {
-  return useWebChatUIContext().styleToEmotionObject;
-}

package/src/providers/ActivityTree/ActivityTreeComposer.tsx

@@ -1,90 +0,0 @@
-import { hooks, type ActivityComponentFactory } from 'botframework-webchat-api';
-import type { WebChatActivity } from 'botframework-webchat-core';
-import React, { useMemo, type ReactNode } from 'react';
-
-import useMemoWithPrevious from '../../hooks/internal/useMemoWithPrevious';
-import ActivityTreeContext from './private/Context';
-import { ActivityWithRenderer, ReadonlyActivityTree } from './private/types';
-import useActivitiesWithRenderer from './private/useActivitiesWithRenderer';
-import useActivityTreeWithRenderer from './private/useActivityTreeWithRenderer';
-import useActivityTreeContext from './private/useContext';
-
-import type { ActivityTreeContextType } from './private/Context';
-
-type ActivityTreeComposerProps = Readonly<{ children?: ReactNode | undefined }>;
-
-const { useActivities, useCreateActivityRenderer, useGetActivitiesByKey, useGetKeyByActivity } = hooks;
-
-const ActivityTreeComposer = ({ children }: ActivityTreeComposerProps) => {
-  const existingContext = useActivityTreeContext(false);
-
-  if (existingContext) {
-    throw new Error('botframework-webchat internal: <ActivityTreeComposer> should not be nested.');
-  }
-
-  const [rawActivities] = useActivities();
-  const getActivitiesByKey = useGetActivitiesByKey();
-  const getKeyByActivity = useGetKeyByActivity();
-
-  const activities = useMemo<readonly WebChatActivity[]>(() => {
-    const activities: WebChatActivity[] = [];
-
-    for (const activity of rawActivities) {
-      // If an activity has multiple revisions, display the latest revision only at the position of the first revision.
-
-      // "Activities with same key" means "multiple revisions of same activity."
-      const activitiesWithSameKey = getActivitiesByKey(getKeyByActivity(activity));
-
-      // TODO: We may want to send all revisions of activity to the middleware so they can render UI to see previous revisions.
-      activitiesWithSameKey[0] === activity && activities.push(activitiesWithSameKey[activitiesWithSameKey.length - 1]);
-    }
-
-    return Object.freeze(activities);
-  }, [getActivitiesByKey, getKeyByActivity, rawActivities]);
-
-  const createActivityRenderer: ActivityComponentFactory = useCreateActivityRenderer();
-
-  const activitiesWithRenderer = useActivitiesWithRenderer(activities, createActivityRenderer);
-
-  const activityTreeWithRenderer = useActivityTreeWithRenderer(activitiesWithRenderer);
-
-  const flattenedActivityTreeWithRenderer = useMemoWithPrevious<Readonly<ActivityWithRenderer[]>>(
-    prevFlattenedActivityTree => {
-      const nextFlattenedActivityTree = Object.freeze(
-        activityTreeWithRenderer.reduce<ActivityWithRenderer[]>(
-          (intermediate, entriesWithSameSender) =>
-            entriesWithSameSender.reduce<ActivityWithRenderer[]>(
-              (intermediate, entriesWithSameSenderAndStatus) =>
-                entriesWithSameSenderAndStatus.reduce<ActivityWithRenderer[]>((intermediate, entry) => {
-                  intermediate.push(entry);
-
-                  return intermediate;
-                }, intermediate),
-              intermediate
-            ),
-          []
-        )
-      );
-
-      return nextFlattenedActivityTree.length === prevFlattenedActivityTree?.length &&
-        nextFlattenedActivityTree.every((item, index) => item === prevFlattenedActivityTree[+index])
-        ? prevFlattenedActivityTree
-        : nextFlattenedActivityTree;
-    },
-    [activityTreeWithRenderer]
-  );
-
-  const contextValue: ActivityTreeContextType = useMemo(
-    () => ({
-      activityTreeWithRendererState: Object.freeze([activityTreeWithRenderer]) as readonly [ReadonlyActivityTree],
-      flattenedActivityTreeWithRendererState: Object.freeze([flattenedActivityTreeWithRenderer]) as readonly [
-        readonly ActivityWithRenderer[]
-      ]
-    }),
-    [activityTreeWithRenderer, flattenedActivityTreeWithRenderer]
-  );
-
-  return <ActivityTreeContext.Provider value={contextValue}>{children}</ActivityTreeContext.Provider>;
-};
-
-export default ActivityTreeComposer;

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

@@ -1,12 +0,0 @@
-import { createContext } from 'react';
-
-import type { ActivityWithRenderer, ReadonlyActivityTree } from './types';
-
-type ActivityTreeContextType = {
-  activityTreeWithRendererState: readonly [ReadonlyActivityTree];
-  flattenedActivityTreeWithRendererState: readonly [readonly ActivityWithRenderer[]];
-};
-
-export default createContext<ActivityTreeContextType>(undefined);
-
-export type { ActivityTreeContextType };

package/src/providers/ActivityTree/private/types.ts

@@ -1,12 +0,0 @@
-import type { ActivityComponentFactory } from 'botframework-webchat-api';
-import type { WebChatActivity } from 'botframework-webchat-core';
-
-type ActivityWithRenderer = {
-  activity: WebChatActivity;
-  renderActivity: Exclude<ReturnType<ActivityComponentFactory>, false>;
-};
-
-type ActivityTree = ActivityWithRenderer[][][];
-type ReadonlyActivityTree = readonly (readonly (readonly ActivityWithRenderer[])[])[];
-
-export type { ActivityTree, ActivityWithRenderer, ReadonlyActivityTree };

package/src/providers/ActivityTree/private/useActivitiesWithRenderer.ts

@@ -1,40 +0,0 @@
-import { useMemo } from 'react';
-import type { WebChatActivity } from 'botframework-webchat-core';
-
-import type { ActivityWithRenderer } from './types';
-import useMemoized from '../../../hooks/internal/useMemoized';
-
-export default function useActivitiesWithRenderer(
-  activities: readonly WebChatActivity[],
-  createActivityRenderer
-): readonly ActivityWithRenderer[] {
-  // Create a memoized context of the createActivityRenderer function.
-  const createActivityRendererMemoized = useMemoized(
-    (activity: WebChatActivity, nextVisibleActivity: WebChatActivity) =>
-      createActivityRenderer({ activity, nextVisibleActivity }),
-    [createActivityRenderer]
-  );
-
-  const entries = useMemo(() => {
-    const activitiesWithRenderer: ActivityWithRenderer[] = [];
-    let nextVisibleActivity: WebChatActivity;
-
-    for (let index = activities.length - 1; index >= 0; index--) {
-      const activity = activities[+index];
-      const renderActivity = createActivityRendererMemoized(activity, nextVisibleActivity);
-
-      if (renderActivity) {
-        activitiesWithRenderer.splice(0, 0, {
-          activity,
-          renderActivity
-        });
-
-        nextVisibleActivity = activity;
-      }
-    }
-
-    return Object.freeze(activitiesWithRenderer);
-  }, [activities, createActivityRendererMemoized]);
-
-  return entries;
-}

package/src/providers/ActivityTree/private/useActivityTreeWithRenderer.ts

@@ -1,140 +0,0 @@
-import { hooks } from 'botframework-webchat-api';
-import { useMemo } from 'react';
-
-import type { WebChatActivity } from 'botframework-webchat-core';
-import intersectionOf from '../../../Utils/intersectionOf';
-import removeInline from '../../../Utils/removeInline';
-import type { ActivityWithRenderer, ReadonlyActivityTree } from './types';
-
-const { useGroupActivities } = hooks;
-
-function validateAllEntriesTagged<T>(entries: readonly T[], bins: readonly (readonly T[])[]): boolean {
-  return entries.every(entry => bins.some(bin => bin.includes(entry)));
-}
-
-// Activity tree is a multidimensional array, while activities is a 1D array.
-// - The first dimension of the array contains activities with same sender;
-// - The second dimension of the array contains activities with same status.
-
-// [
-//   [
-//     // Both messages are from bot and is sent as a batch, we will group them as an array.
-//     'Bot: Hello!'
-//     'Bot: What can I help today?'
-//   ],
-//   [
-//     'User: What is the weather?'
-//   ],
-//   [
-//     'Bot: Let me look it up... hold on.'
-//   ],
-//   [
-//     // This message is in a different group because it is more than a few seconds apart from the previous message.
-//     'Bot: Here is the weather forecast.'
-//   ]
-// ]
-
-function useActivityTreeWithRenderer(entries: readonly ActivityWithRenderer[]): ReadonlyActivityTree {
-  const groupActivities = useGroupActivities();
-  const entryMap: Map<WebChatActivity, ActivityWithRenderer> = useMemo(
-    () => new Map(entries.map(entry => [entry.activity, entry])),
-    [entries]
-  );
-
-  // We bin activities in 2 different ways:
-  // - `activitiesBySender` is a 2D array containing activities with same sender
-  // - `activitiesByStatus` is a 2D array containing activities with same status
-  // Both arrays should contains all activities.
-
-  const { entriesBySender, entriesByStatus } = useMemo<{
-    entriesBySender: readonly (readonly ActivityWithRenderer[])[];
-    entriesByStatus: readonly (readonly ActivityWithRenderer[])[];
-  }>(() => {
-    const visibleActivities = [...entryMap.keys()];
-
-    const groupActivitiesResult = groupActivities({ activities: visibleActivities });
-
-    const activitiesBySender = groupActivitiesResult?.sender || [];
-    const activitiesByStatus = groupActivitiesResult?.status || [];
-
-    const [entriesBySender, entriesByStatus] = [activitiesBySender, activitiesByStatus].map(bins =>
-      bins.map(bin => bin.map(activity => entryMap.get(activity)))
-    );
-
-    if (!validateAllEntriesTagged(visibleActivities, activitiesBySender)) {
-      console.warn(
-        'botframework-webchat: Not every activities are grouped in the "sender" property. Please fix "groupActivitiesMiddleware" and group every activities.'
-      );
-    }
-
-    if (!validateAllEntriesTagged(visibleActivities, activitiesByStatus)) {
-      console.warn(
-        'botframework-webchat: Not every activities are grouped in the "status" property. Please fix "groupActivitiesMiddleware" and group every activities.'
-      );
-    }
-
-    return {
-      entriesBySender,
-      entriesByStatus
-    };
-  }, [entryMap, groupActivities]);
-
-  // Create a tree of activities with 2 dimensions: sender, followed by status.
-
-  const activityTree: ReadonlyActivityTree = useMemo(() => {
-    const entriesPendingGrouping = [...entries];
-    const activityTree: (readonly (readonly ActivityWithRenderer[])[])[] = [];
-
-    while (entriesPendingGrouping.length) {
-      let found: boolean;
-      const entriesWithSameSender = entriesBySender.find(bin => bin.includes(entriesPendingGrouping[0]));
-      const senderTree: (readonly ActivityWithRenderer[])[] = [];
-
-      entriesWithSameSender?.forEach(entry => {
-        const entriesWithSameStatus = entriesByStatus.find(bin => bin.includes(entry));
-
-        const entriesWithSameSenderAndStatus = intersectionOf<ActivityWithRenderer>(
-          entriesPendingGrouping,
-          entriesWithSameSender,
-          entriesWithSameStatus
-        );
-
-        if (entriesWithSameSenderAndStatus.length) {
-          senderTree.push(Object.freeze(entriesWithSameSenderAndStatus));
-          removeInline(entriesPendingGrouping, ...entriesWithSameSenderAndStatus);
-
-          found = true;
-        }
-      });
-
-      // If the entry is not grouped by the middleware, just put the entry in its own bin.
-      found || senderTree.push(Object.freeze([entriesPendingGrouping.shift()]));
-
-      activityTree.push(Object.freeze(senderTree));
-    }
-
-    // Assertion: All entries must be assigned to the activityTree.
-    if (
-      !entries.every(activity =>
-        activityTree.some(activitiesWithSameSender =>
-          activitiesWithSameSender.some(activitiesWithSameSenderAndStatus =>
-            activitiesWithSameSenderAndStatus.includes(activity)
-          )
-        )
-      )
-    ) {
-      console.warn('botframework-webchat internal: Not all visible activities are grouped in the activityTree.', {
-        entries,
-        activityTree
-      });
-    }
-
-    return Object.freeze(activityTree);
-  }, [entriesBySender, entriesByStatus, entries]);
-
-  return activityTree;
-}
-
-export type { ActivityWithRenderer };
-
-export default useActivityTreeWithRenderer;

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

@@ -1,15 +0,0 @@
-import { useContext } from 'react';
-
-import ActivityTreeContext from './Context';
-
-import type { ActivityTreeContextType } from './Context';
-
-export default function useActivityTreeContext(thrownOnUndefined = true): ActivityTreeContextType {
-  const contextValue = useContext(ActivityTreeContext);
-
-  if (thrownOnUndefined && !contextValue) {
-    throw new Error('botframework-webchat internal: This hook can only be used under <ActivityTreeComposer>.');
-  }
-
-  return contextValue;
-}

package/src/providers/ActivityTree/useActivityTreeWithRenderer.ts

@@ -1,16 +0,0 @@
-import useActivityTreeContext from './private/useContext';
-
-import type { ActivityWithRenderer, ReadonlyActivityTree } from './private/types';
-
-export default function useActivityTreeWithRenderer(options?: { flat?: false }): readonly [ReadonlyActivityTree];
-export default function useActivityTreeWithRenderer(options: {
-  flat: true;
-}): readonly [readonly ActivityWithRenderer[]];
-
-export default function useActivityTreeWithRenderer(options: { flat?: boolean } = {}) {
-  const context = useActivityTreeContext();
-
-  return options?.flat === true
-    ? context.flattenedActivityTreeWithRendererState
-    : context.activityTreeWithRendererState;
-}

package/src/providers/LiveRegionTwin/LiveRegionTwinComposer.tsx

@@ -1,172 +0,0 @@
-import { hooks } from 'botframework-webchat-api';
-import PropTypes from 'prop-types';
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-
-import type { FC, PropsWithChildren } from 'react';
-
-import LiveRegionTwinContainer from './private/LiveRegionTwinContainer';
-import LiveRegionTwinContext from './private/Context';
-import useValueRef from '../../hooks/internal/useValueRef';
-
-import type { StaticElement, StaticElementEntry } from './private/types';
-
-const { usePonyfill } = hooks;
-
-const DEFAULT_ARIA_LIVE = 'polite';
-const DEFAULT_FADE_AFTER = 1000;
-
-type LiveRegionTwinComposerProps = PropsWithChildren<{
-  /** Optional "aria-label" attribute for the live region twin container. */
-  'aria-label'?: string;
-
-  /** "aria-live" attribute for the live region twin container, defaults to `'polite'`. */
-  'aria-live'?: 'assertive' | 'polite';
-
-  /** Optional "aria-roledescription" attribute for the live region twin container. */
-  'aria-roledescription'?: string;
-
-  /** Optional "className" attribute for the live region twin container. */
-  className?: string;
-
-  /**
-   * Static elements will fade out after this timeout value specified in milliseconds, defaults to `1000`.
-   *
-   * When lowering this value, make sure screen reader can continue to pick up new static elements before fading out.
-   *
-   * If this prop is updated, it will be reflected in next queueing elements.
-   */
-  fadeAfter?: number;
-
-  /** Optional "role" attribute for the live region twin container. */
-  role?: string;
-
-  /** Optional "className" attribute for static text element. */
-  textElementClassName?: string;
-}>;
-
-/**
- * Live region twin is an UI component for queueing texts or elements to the screen reader using
- * a container element with `aria-live` attribute set.
- *
- * After the text is rendered and queued, it will be removed to reduce burden on the DOM tree.
- * Currently, we assume the assistive technologies should pick up the text within 1 second of rendering.
- * This value is configurable.
- *
- * By default, the live region is visible. If is is not desirable, the caller can use `className` prop to
- * hide its visuals.
- */
-const LiveRegionTwinComposer: FC<LiveRegionTwinComposerProps> = ({
-  'aria-label': ariaLabel,
-  'aria-live': ariaLive = DEFAULT_ARIA_LIVE,
-  'aria-roledescription': ariaRoleDescription,
-  children,
-  className,
-  fadeAfter = DEFAULT_FADE_AFTER,
-  role,
-  textElementClassName
-}) => {
-  const [{ clearTimeout, setTimeout }] = usePonyfill();
-  const [staticElementEntries, setStaticElementEntries] = useState<StaticElementEntry[]>([]);
-  const fadeAfterRef = useValueRef(fadeAfter);
-  const markAllAsRenderedTimeoutIdRef = useRef<any>();
-  const nextKeyRef = useRef<number>(1);
-
-  const staticElementEntriesRef = useValueRef(staticElementEntries);
-
-  // This function is called by an effect hook `useMarkAllAsRenderedEffect`, it must be designed with converging in mind.
-  // To prevent infinite render loop, after multiple calls to this function, it should eventually no-op.
-  const markAllAsRendered = useCallback<() => void>(() => {
-    if (!staticElementEntriesRef.current.length) {
-      // Nothing to remove.
-      return;
-    }
-
-    // When removing each element one-by-one based on an individual timeout, Narrator would narrate them twice occasionally.
-    // Possibly it think some elements that is not removed during the current cycle, are new elements and queued them twice.
-    // Thus, we are removing all at once to prevent bugs in Narrator.
-    markAllAsRenderedTimeoutIdRef.current && clearTimeout(markAllAsRenderedTimeoutIdRef.current);
-
-    markAllAsRenderedTimeoutIdRef.current = setTimeout(() => {
-      // We are playing safe by using value ref to check its length here.
-      // If we are certain that `setStaticElements(emptyArray => emptyArray)` is a no-op,
-      // we could replace it with just the setter function.
-      staticElementEntriesRef.current.length && setStaticElementEntries([]);
-    }, fadeAfterRef.current);
-  }, [
-    clearTimeout,
-    fadeAfterRef,
-    markAllAsRenderedTimeoutIdRef,
-    setStaticElementEntries,
-    setTimeout,
-    staticElementEntriesRef
-  ]);
-
-  // When this component is unmounting, make sure all future `setTimeout` are cleared and should not be fired.
-  useEffect(
-    () => () => markAllAsRenderedTimeoutIdRef.current && clearTimeout(markAllAsRenderedTimeoutIdRef.current),
-    [clearTimeout, markAllAsRenderedTimeoutIdRef]
-  );
-
-  const queueStaticElement = useCallback<(staticElement: StaticElement) => void>(
-    (element: StaticElement): void => {
-      const key = nextKeyRef.current;
-
-      nextKeyRef.current = nextKeyRef.current + 1;
-
-      setStaticElementEntries(entries => [...entries, { element, key }]);
-    },
-    [nextKeyRef, setStaticElementEntries]
-  );
-
-  const staticElementEntriesState = useMemo<readonly [readonly StaticElementEntry[]]>(
-    () => Object.freeze([Object.freeze(staticElementEntries)]) as readonly [readonly StaticElementEntry[]],
-    [staticElementEntries]
-  );
-
-  const context = useMemo(
-    () => ({
-      markAllAsRendered,
-      queueStaticElement,
-      staticElementEntriesState
-    }),
-    [markAllAsRendered, queueStaticElement, staticElementEntriesState]
-  );
-
-  return (
-    <LiveRegionTwinContext.Provider value={context}>
-      <LiveRegionTwinContainer
-        aria-label={ariaLabel}
-        aria-live={ariaLive}
-        aria-roledescription={ariaRoleDescription}
-        className={className}
-        role={role}
-        textElementClassName={textElementClassName}
-      />
-      {children}
-    </LiveRegionTwinContext.Provider>
-  );
-};
-
-LiveRegionTwinComposer.defaultProps = {
-  'aria-label': undefined,
-  'aria-live': DEFAULT_ARIA_LIVE,
-  'aria-roledescription': undefined,
-  children: undefined,
-  className: undefined,
-  fadeAfter: DEFAULT_FADE_AFTER,
-  role: undefined,
-  textElementClassName: undefined
-};
-
-LiveRegionTwinComposer.propTypes = {
-  'aria-label': PropTypes.string,
-  'aria-live': PropTypes.oneOf(['assertive', 'polite']),
-  'aria-roledescription': PropTypes.string,
-  children: PropTypes.any,
-  className: PropTypes.string,
-  fadeAfter: PropTypes.number,
-  role: PropTypes.string,
-  textElementClassName: PropTypes.string
-};
-
-export default LiveRegionTwinComposer;

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

@@ -1,15 +0,0 @@
-import { createContext } from 'react';
-
-import type { StaticElement, StaticElementEntry } from './types';
-
-type LiveRegionTwinContextType = {
-  markAllAsRendered: () => void;
-  queueStaticElement: (element: StaticElement) => void;
-  staticElementEntriesState: readonly [readonly StaticElementEntry[]];
-};
-
-const LiveRegionTwinContext = createContext<LiveRegionTwinContextType>(undefined);
-
-export default LiveRegionTwinContext;
-
-export type { LiveRegionTwinContextType };