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

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

@@ -1,19 +0,0 @@
-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

@@ -1,35 +0,0 @@
-/// <reference types="jest" />
-
-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

@@ -1,20 +0,0 @@
-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: T[] = [];
-  const right: T[] = [];
-
-  for (const item of Array.from(array)) {
-    if (pickArray.includes(item)) {
-      right.push(item);
-    } else {
-      left.push(item);
-    }
-  }
-
-  return Object.freeze([Object.freeze(left), Object.freeze(right)]);
-}

package/src/providers/GroupedRenderingActivities/useGroupedRenderingActivities.ts

@@ -1,6 +0,0 @@
-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

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

package/src/providers/HTMLContentTransformCOR/HTMLContentTransformComposer.tsx

@@ -1,41 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

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

package/src/providers/HTMLContentTransformCOR/useTransformHTMLContent.ts

@@ -1,187 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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/createLiveRegionTwinComposer.tsx

@@ -1,155 +0,0 @@
-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/useLiveRegion.ts

@@ -1,27 +0,0 @@
-import { useMemo, type DependencyList, type ReactElement } from 'react';
-import { useRefFrom } from 'use-ref-from';
-
-import useQueueStaticElement from './useQueueStaticElement';
-
-/**
- * Pushes a node to the live region.
- *
- * Once the node is pushed, it cannot be undoed.
- *
- * @param createNode Create node to be pushed to the live region.
- * @param deps Will push a new node if the values in the list change.
- */
-export default function useLiveRegion(
-  createNode: () => false | null | ReactElement | string | undefined,
-  deps: DependencyList
-) {
-  const createNodeRef = useRefFrom(createNode);
-  const queueStaticElement = useQueueStaticElement();
-
-  useMemo(() => {
-    const node = createNodeRef?.current();
-
-    node && queueStaticElement(node);
-    // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/use-memo
-  }, [...deps, createNodeRef, queueStaticElement]);
-}

package/src/providers/ReducedMotion/ReducedMotionComposer.tsx

@@ -1,35 +0,0 @@
-import React, { memo, useEffect, useMemo, useState, type ReactNode } from 'react';
-
-import { type ContextOf } from '../../types/ContextOf';
-import Context from './private/Context';
-
-type ContextType = ContextOf<typeof Context>;
-
-type ReducedMotionComposerProps = Readonly<{
-  children?: ReactNode | undefined;
-}>;
-
-const ReducedMotionComposer = memo(({ children }: ReducedMotionComposerProps) => {
-  const shouldReduceMotionQueryList = useMemo(() => matchMedia?.('(prefers-reduced-motion: reduce)'), []);
-  const [shouldReduceMotion, setShouldReduceMotion] = useState<boolean>(
-    () => shouldReduceMotionQueryList?.matches ?? false
-  );
-
-  const shouldReduceMotionState = useMemo(() => Object.freeze([shouldReduceMotion] as const), [shouldReduceMotion]);
-
-  const context = useMemo<ContextType>(() => Object.freeze({ shouldReduceMotionState }), [shouldReduceMotionState]);
-
-  useEffect(() => {
-    const handleChange = ({ matches }: MediaQueryListEvent) => setShouldReduceMotion(matches);
-
-    shouldReduceMotionQueryList.addEventListener('change', handleChange);
-
-    return () => shouldReduceMotionQueryList.removeEventListener('change', handleChange);
-  }, [setShouldReduceMotion, shouldReduceMotionQueryList]);
-
-  return <Context.Provider value={context}>{children}</Context.Provider>;
-});
-
-ReducedMotionComposer.displayName = 'ReducedMotionComposer';
-
-export default ReducedMotionComposer;

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

@@ -1,22 +0,0 @@
-import { createContext } from 'react';
-
-type ContextType = Readonly<{
-  shouldReduceMotionState: readonly [boolean];
-}>;
-
-type ContextAsGetter<T extends Record<string, unknown>> =
-  T extends Record<infer K, infer V> ? Record<K, { get(): V }> : never;
-
-const defaultContextValue: ContextAsGetter<ContextType> = {
-  shouldReduceMotionState: {
-    get() {
-      throw new Error('shouldReduceMotionState cannot be used outside of <ReducedMotionComposer>.');
-    }
-  }
-};
-
-const Context = createContext<ContextType>(Object.create({}, defaultContextValue));
-
-Context.displayName = 'ReducedMotionComposer';
-
-export default Context;

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

@@ -1,8 +0,0 @@
-import { useContext as useReactContext } from 'react';
-
-import { type ContextOf } from '../../../types/ContextOf';
-import Context from './Context';
-
-export default function useContext(): ContextOf<typeof Context> {
-  return useReactContext(Context);
-}

package/src/providers/ReducedMotion/useShouldReduceMotion.ts

@@ -1,5 +0,0 @@
-import useContext from './private/useContext';
-
-export default function useShouldReduceMotion(): ReturnType<typeof useContext>['shouldReduceMotionState'] {
-  return useContext().shouldReduceMotionState;
-}