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

package/src/providers/GroupedRenderingActivities/private/group.ts

@@ -0,0 +1,19 @@
+import pick from './pick';
+
+export default function group<T>(
+  ungrouped: Iterable<T>,
+  getItemsOfSameGroup: (item: T) => Iterable<T> | undefined
+): readonly (readonly T[])[] {
+  let processing: readonly T[] = Array.from(ungrouped);
+  const result: (readonly T[])[] = [];
+
+  while (processing.length) {
+    const [value] = processing;
+    const [left, right] = pick<T>(processing, [value, ...(getItemsOfSameGroup(value) || [])]);
+
+    processing = left;
+    result.push(right);
+  }
+
+  return Object.freeze(result);
+}

package/src/providers/GroupedRenderingActivities/private/pick.spec.ts

@@ -0,0 +1,33 @@
+import pick from './pick';
+
+test('when no item should return empty', () => {
+  expect(pick([], [])).toEqual([[], []]);
+});
+
+test('when picking non-existing item should return empty', () => {
+  expect(pick([], [1])).toEqual([[], []]);
+});
+
+test('when picking an item should remove item', () => {
+  expect(pick([1], [1])).toEqual([[], [1]]);
+});
+
+test('when item do not exist should not remove item', () => {
+  expect(pick([1], [2])).toEqual([[1], []]);
+});
+
+test('when item exist should remove item', () => {
+  expect(pick([1, 2, 3], [2])).toEqual([[1, 3], [2]]);
+});
+
+test('when not picking anything should return all items', () => {
+  expect(pick([1, 2, 3], [])).toEqual([[1, 2, 3], []]);
+});
+
+test('when picking two items should pick properly', () => {
+  expect(pick([1, 2, 3], [2, 3])).toEqual([[1], [2, 3]]);
+});
+
+test('when picking undefined', () => {
+  expect(pick([1], undefined)).toEqual([[1], []]);
+});

package/src/providers/GroupedRenderingActivities/private/pick.ts

@@ -0,0 +1,22 @@
+export default function pick<T>(array: Iterable<T>, pick: Iterable<T>): readonly [readonly T[], readonly T[]] {
+  if (!pick) {
+    return Object.freeze([Object.freeze(Array.from(array)), Object.freeze([])]);
+  }
+
+  const pickArray = Array.from(pick);
+
+  const [left, right] = Array.from(array).reduce(
+    ([left, right], item) => {
+      if (pickArray.includes(item)) {
+        right.push(item);
+      } else {
+        left.push(item);
+      }
+
+      return [left, right];
+    },
+    [[], []]
+  );
+
+  return Object.freeze([Object.freeze(left), Object.freeze(right)]);
+}

package/src/providers/GroupedRenderingActivities/useGroupedRenderingActivities.ts

@@ -0,0 +1,6 @@
+import { type GroupedRenderingActivities } from './GroupedRenderingActivities';
+import { useGroupedRenderingActivitiesContext } from './private/GroupedRenderingActivitiesContext';
+
+export default function useGroupedRenderingActivities(): readonly [readonly GroupedRenderingActivities[]] {
+  return useGroupedRenderingActivitiesContext().groupedRenderingActivitiesState;
+}

package/src/providers/GroupedRenderingActivities/useNumRenderingActivities.ts

@@ -0,0 +1,5 @@
+import { useGroupedRenderingActivitiesContext } from './private/GroupedRenderingActivitiesContext';
+
+export default function useNumRenderingActivities(): readonly [number] {
+  return useGroupedRenderingActivitiesContext().numRenderingActivitiesState;
+}

package/src/providers/HTMLContentTransformCOR/HTMLContentTransformComposer.tsx

@@ -0,0 +1,41 @@
+import React, { memo, useMemo, type ReactNode } from 'react';
+
+import HTMLContentTransformContext, {
+  type HTMLContentTransformContextType,
+  type HTMLContentTransformFunction,
+  type HTMLContentTransformMiddleware
+} from './private/HTMLContentTransformContext';
+
+type HTMLContentTransformComposerProps = Readonly<{
+  children?: ReactNode | undefined;
+  middleware?: readonly HTMLContentTransformMiddleware[] | undefined;
+}>;
+
+const HTMLContentTransformComposer = memo(({ children, middleware }: HTMLContentTransformComposerProps) => {
+  const transform = useMemo<HTMLContentTransformFunction>(() => {
+    const enhancers = (middleware || []).map(enhancer => enhancer()).reverse();
+
+    return enhancers.reduce(
+      (chain: HTMLContentTransformFunction, fn) => fn(chain),
+      fragment => {
+        // With bundle or sanitizer installed, it should not fall into this code.
+
+        const result = document.createDocumentFragment();
+        const paragraph = document.createElement('p');
+
+        paragraph.textContent = fragment.documentFragment.firstElementChild.outerHTML;
+        result.append(paragraph);
+
+        return result;
+      }
+    );
+  }, [middleware]);
+
+  const context = useMemo<HTMLContentTransformContextType>(() => Object.freeze({ transform }), [transform]);
+
+  return <HTMLContentTransformContext.Provider value={context}>{children}</HTMLContentTransformContext.Provider>;
+});
+
+HTMLContentTransformComposer.displayName = 'HTMLContentTransformComposer';
+
+export default HTMLContentTransformComposer;

package/src/providers/HTMLContentTransformCOR/index.ts

@@ -0,0 +1,8 @@
+export {
+  type HTMLContentTransformEnhancer,
+  type HTMLContentTransformFunction,
+  type HTMLContentTransformMiddleware,
+  type HTMLContentTransformRequest
+} from './private/HTMLContentTransformContext';
+
+export { default as useTransformHTMLContent } from './useTransformHTMLContent';

package/src/providers/HTMLContentTransformCOR/private/HTMLContentTransformContext.ts

@@ -0,0 +1,34 @@
+import { createContext } from 'react';
+
+export type HTMLContentTransformRequest = Readonly<{
+  allowedTags: ReadonlyMap<
+    string,
+    Readonly<{
+      // TODO: Ultimately, we could allowlist a cherry-picked instance of element, but not all elements sharing the same tag name.
+      attributes: ReadonlySet<string>;
+    }>
+  >;
+  codeBlockTagName: string;
+  documentFragment: DocumentFragment;
+  externalLinkAlt: string;
+}>;
+
+export type HTMLContentTransformFunction = (request: HTMLContentTransformRequest) => DocumentFragment;
+
+export type HTMLContentTransformEnhancer = (next: HTMLContentTransformFunction) => HTMLContentTransformFunction;
+
+export type HTMLContentTransformMiddleware = () => HTMLContentTransformEnhancer;
+
+export type HTMLContentTransformContextType = Readonly<{
+  transform: HTMLContentTransformFunction;
+}>;
+
+const HTMLContentTransformContext = createContext<HTMLContentTransformContextType>(
+  new Proxy({} as HTMLContentTransformContextType, {
+    get() {
+      throw new Error('botframework-webchat: This hook can only be used under <HTMLContentTransformComposer>.');
+    }
+  })
+);
+
+export default HTMLContentTransformContext;

package/src/providers/HTMLContentTransformCOR/private/useHTMLContentTransformContext.ts

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

package/src/providers/HTMLContentTransformCOR/useTransformHTMLContent.ts

@@ -0,0 +1,187 @@
+import { hooks } from 'botframework-webchat-api';
+import { useCallback } from 'react';
+
+import useCodeBlockTag from '../CustomElements/useCodeBlockTagName';
+import useHTMLContentTransformContext from './private/useHTMLContentTransformContext';
+
+const { useLocalizer } = hooks;
+
+const DEFAULT_ALLOWED_TAGS: ReadonlyMap<string, Readonly<{ attributes: ReadonlySet<string> }>> = Object.freeze(
+  new Map(
+    (
+      [
+        ['a', ['aria-label', 'class', 'href', 'name', 'rel', 'target']],
+        ['b', []],
+        ['blockquote', []],
+        ['br', []],
+        ['button', ['aria-label', 'class', 'type', 'value']],
+        ['caption', []],
+        ['code', ['data-math-type']],
+        ['del', []],
+        ['div', []],
+        ['em', []],
+        ['figure', ['data-math-type', 'tabindex']],
+        ['h1', []],
+        ['h2', []],
+        ['h3', []],
+        ['h4', []],
+        ['h5', []],
+        ['h6', []],
+        ['hr', []],
+        ['i', []],
+        ['img', ['alt', 'aria-label', 'class', 'src', 'title']],
+        ['ins', []],
+        ['li', []],
+        ['nl', []],
+        ['ol', []],
+        ['p', []],
+        ['pre', ['class', 'data-math-type']],
+        ['s', []],
+        ['span', ['aria-label', 'data-math-type']],
+        ['strike', []],
+        ['strong', []],
+        ['table', []],
+        ['tbody', []],
+        ['td', []],
+        ['tfoot', []],
+        ['th', []],
+        ['thead', []],
+        ['tr', []],
+        ['ul', []],
+
+        // Followings are for MathML elements, from https://developer.mozilla.org/en-US/docs/Web/MathML.
+        ['annotation-xml', ['encoding', 'src', 'name', 'definitionURL']],
+        ['annotation', ['encoding', 'src', 'name', 'definitionURL']],
+        ['math', ['display', 'xmlns', 'mode', 'overflow', 'alttext', 'mathbackground', 'mathcolor']],
+        ['merror', ['mathbackground', 'mathcolor']],
+        ['mfenced', ['close', 'open', 'separators']],
+        ['mfrac', ['linethickness', 'numalign', 'denomalign', 'bevelled']],
+        ['mi', ['mathvariant', 'mathsize', 'mathbackground', 'mathcolor']],
+        ['mmultiscripts', ['subscriptshift', 'superscriptshift']],
+        ['mn', ['mathvariant', 'mathsize', 'mathbackground', 'mathcolor']],
+        [
+          'mo',
+          [
+            'form',
+            'fence',
+            'separator',
+            'lspace',
+            'rspace',
+            'stretchy',
+            'symmetric',
+            'maxsize',
+            'minsize',
+            'largeop',
+            'movablelimits',
+            'accent',
+            'linebreak',
+            'mathvariant',
+            'mathsize',
+            'mathbackground',
+            'mathcolor'
+          ]
+        ],
+        ['mover', ['accent', 'align']],
+        ['mpadded', ['height', 'width', 'depth', 'lspace', 'voffset']],
+        ['mphantom', ['mathbackground']],
+        ['mprescripts', []],
+        ['mroot', ['mathbackground', 'mathcolor']],
+        ['mrow', ['dir', 'mathbackground', 'mathcolor']],
+        ['ms', ['lquote', 'rquote', 'mathvariant', 'mathsize', 'mathbackground', 'mathcolor']],
+        [
+          'mspace',
+          [
+            'linebreak',
+            'width',
+            'height',
+            'depth',
+            'mediummathspace',
+            'negativemediummathspace',
+            'negativethickmathspace',
+            'negativethinmathspace',
+            'negativeverythickmathspace',
+            'negativeverythinmathspace',
+            'thickmathspace',
+            'thinmathspace',
+            'verythickmathspace',
+            'verythinmathspace'
+          ]
+        ],
+        ['msqrt', ['mathbackground', 'mathcolor']],
+        [
+          'mstyle',
+          [
+            'scriptlevel',
+            'displaystyle',
+            'scriptsizemultiplier',
+            'scriptminsize',
+            'infixlinebreakstyle',
+            'decimalpoint',
+            'mathvariant',
+            'mathsize',
+            'mathbackground',
+            'mathcolor',
+            'dir'
+          ]
+        ],
+        ['msub', ['subscriptshift']],
+        ['msubsup', ['subscriptshift', 'superscriptshift']],
+        ['msup', ['superscriptshift']],
+        [
+          'mtable',
+          [
+            'align',
+            'rowalign',
+            'columnalign',
+            'groupalign',
+            'alignmentscope',
+            'columnwidth',
+            'width',
+            'rowspacing',
+            'columnspacing',
+            'rowlines',
+            'columnlines',
+            'frame',
+            'framespacing',
+            'equalrows',
+            'equalcolumns',
+            'displaystyle',
+            'side',
+            'minlabelspacing'
+          ]
+        ],
+        ['mtd', ['rowspan', 'columnspan', 'rowalign', 'columnalign', 'groupalign']],
+        ['mtext', ['mathvariant', 'mathsize', 'mathbackground', 'mathcolor']],
+        ['mtr', ['rowalign', 'columnalign', 'groupalign']],
+        ['munder', ['accentunder', 'align']],
+        ['munderover', ['accent', 'accentunder', 'align']],
+        ['semantics', ['definitionURL', 'encoding']]
+      ] satisfies [string, string[]][]
+    ).map(
+      ([tag, attributes]) =>
+        [tag, Object.freeze({ attributes: Object.freeze(new Set(attributes)) })] satisfies [
+          string,
+          Readonly<{ attributes: ReadonlySet<string> }>
+        ]
+    )
+  )
+);
+
+export default function useTransformHTMLContent(): (documentFragment: DocumentFragment) => DocumentFragment {
+  const [codeBlockTagName] = useCodeBlockTag();
+  const { transform } = useHTMLContentTransformContext();
+
+  const localize = useLocalizer();
+  const externalLinkAlt = localize('MARKDOWN_EXTERNAL_LINK_ALT');
+
+  return useCallback(
+    documentFragment =>
+      transform({
+        allowedTags: DEFAULT_ALLOWED_TAGS,
+        codeBlockTagName,
+        documentFragment,
+        externalLinkAlt
+      }),
+    [codeBlockTagName, externalLinkAlt, transform]
+  );
+}

package/src/providers/LiveRegionTwin/index.ts

@@ -0,0 +1,3 @@
+export { default as LiveRegionTwinComposer } from './private/LiveRegionTwinComposer';
+export { default as useLiveRegion } from './useLiveRegion';
+export { default as useQueueStaticElement } from './useQueueStaticElement';

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

@@ -0,0 +1,27 @@
+import { createContext } from 'react';
+import createLiveRegionTwinComposer from './createLiveRegionTwinComposer';
+
+import type { StaticElement, StaticElementEntry } from './types';
+
+export type LiveRegionTwinContextType = {
+  markAllAsRendered: () => void;
+  queueStaticElement: (element: StaticElement) => void;
+  staticElementEntriesState: readonly [readonly StaticElementEntry[]];
+};
+
+export const LiveRegionTwinContext = createContext<LiveRegionTwinContextType>(
+  new Proxy(
+    {},
+    {
+      get(_target, key: string) {
+        throw new Error(
+          `botframework-webchat: LiveRegionTwinContext.${key} can only be used inside of <LiveRegionTwinComposer>.`
+        );
+      }
+    }
+  ) as unknown as LiveRegionTwinContextType
+);
+
+const LiveRegionTwinComposer = createLiveRegionTwinComposer(LiveRegionTwinContext);
+
+export default LiveRegionTwinComposer;

package/src/providers/LiveRegionTwin/private/LiveRegionTwinContainer.tsx

@@ -1,29 +1,35 @@
-import PropTypes from 'prop-types';
+import { validateProps } from 'botframework-webchat-api/internal';
 import React, { Fragment } from 'react';
-
-import type { VFC } from 'react';
+import { literal, object, optional, pipe, readonly, string, union, type InferInput } from 'valibot';
 
 import useMarkAllAsRenderedEffect from './useMarkAllAsRenderedEffect';
 import useStaticElementEntries from './useStaticElementEntries';
 
-type LiveRegionTwinContainerProps = {
-  'aria-label'?: string;
-  'aria-live': 'assertive' | 'polite';
-  'aria-roledescription'?: string;
-  className?: string;
-  role?: string;
-  textElementClassName?: string;
-};
+const liveRegionTwinContainerPropsSchema = pipe(
+  object({
+    'aria-label': optional(string()),
+    'aria-live': union([literal('assertive'), literal('polite')]),
+    'aria-roledescription': optional(string()),
+    className: optional(string()),
+    role: optional(string()),
+    textElementClassName: optional(string())
+  }),
+  readonly()
+);
+
+type LiveRegionTwinContainerProps = InferInput<typeof liveRegionTwinContainerPropsSchema>;
 
 // This container is marked as private because we assume there is only one instance under the <LiveRegionTwinContext>.
-const LiveRegionTwinContainer: VFC<LiveRegionTwinContainerProps> = ({
-  'aria-label': ariaLabel,
-  'aria-live': ariaLive,
-  'aria-roledescription': ariaRoleDescription,
-  className,
-  role,
-  textElementClassName
-}) => {
+function LiveRegionTwinContainer(props: LiveRegionTwinContainerProps) {
+  const {
+    'aria-label': ariaLabel,
+    'aria-live': ariaLive,
+    'aria-roledescription': ariaRoleDescription,
+    className,
+    role,
+    textElementClassName
+  } = validateProps(liveRegionTwinContainerPropsSchema, props);
+
   const [staticElementEntries] = useStaticElementEntries();
 
   // We assume there is only one instance under the <LiveRegionTwinContext>.
@@ -52,25 +58,7 @@ const LiveRegionTwinContainer: VFC<LiveRegionTwinContainerProps> = ({
       })}
     </div>
   );
-};
-
-LiveRegionTwinContainer.defaultProps = {
-  'aria-label': undefined,
-  'aria-roledescription': undefined,
-  className: undefined,
-  role: undefined,
-  textElementClassName: undefined
-};
-
-LiveRegionTwinContainer.propTypes = {
-  'aria-label': PropTypes.string,
-  // PropTypes.oneOf() returns type of `string`, but not `'assertive' | 'polite'`.
-  // @ts-ignore
-  'aria-live': PropTypes.oneOf(['assertive', 'polite']).isRequired,
-  'aria-roledescription': PropTypes.string,
-  className: PropTypes.string,
-  role: PropTypes.string,
-  textElementClassName: PropTypes.string
-};
+}
 
 export default LiveRegionTwinContainer;
+export { liveRegionTwinContainerPropsSchema, type LiveRegionTwinContainerProps };

package/src/providers/LiveRegionTwin/private/createLiveRegionTwinComposer.tsx

@@ -0,0 +1,155 @@
+import { hooks } from 'botframework-webchat-api';
+import React, { memo, useCallback, useEffect, useMemo, useRef, useState, type Context, type ReactNode } from 'react';
+import { useRefFrom } from 'use-ref-from';
+
+import { type LiveRegionTwinContextType } from './LiveRegionTwinComposer';
+import LiveRegionTwinContainer from './LiveRegionTwinContainer';
+
+import type { StaticElement, StaticElementEntry } from './types';
+
+const { usePonyfill } = hooks;
+
+const DEFAULT_ARIA_LIVE = 'polite';
+const DEFAULT_FADE_AFTER = 1000;
+
+type LiveRegionTwinComposerProps = Readonly<{
+  /** 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;
+
+  children?: ReactNode | undefined;
+}>;
+
+/**
+ * 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 createLiveRegionTwinComposer = ({ Provider }: Context<LiveRegionTwinContextType>) => {
+  const LiveRegionTwinComposer = ({
+    'aria-label': ariaLabel,
+    'aria-live': ariaLive = DEFAULT_ARIA_LIVE,
+    'aria-roledescription': ariaRoleDescription,
+    children,
+    className,
+    fadeAfter = DEFAULT_FADE_AFTER,
+    role,
+    textElementClassName
+  }: LiveRegionTwinComposerProps) => {
+    const [{ clearTimeout, setTimeout }] = usePonyfill();
+    const [staticElementEntries, setStaticElementEntries] = useState<StaticElementEntry[]>([]);
+    const fadeAfterRef = useRefFrom(fadeAfter);
+    const markAllAsRenderedTimeoutIdRef = useRef<any>();
+    const nextKeyRef = useRef<number>(1);
+
+    const staticElementEntriesRef = useRefFrom(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 (
+      <Provider value={context}>
+        <LiveRegionTwinContainer
+          aria-label={ariaLabel}
+          aria-live={ariaLive}
+          aria-roledescription={ariaRoleDescription}
+          className={className}
+          role={role}
+          textElementClassName={textElementClassName}
+        />
+        {children}
+      </Provider>
+    );
+  };
+
+  LiveRegionTwinComposer.displayName = 'LiveRegionTwinComposer';
+
+  return memo(LiveRegionTwinComposer);
+};
+
+export default createLiveRegionTwinComposer;

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

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