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

package/src/providers/GroupActivities/GroupActivitiesComposer.tsx

@@ -0,0 +1,115 @@
+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[];
+}>;
+
+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 groupActivitiesByGroupRef = useRefFrom(groupActivitiesByGroup);
+  const groupActivitiesByRef = useRefFrom(groupActivitiesBy);
+
+  const groupActivitiesByName = useCallback<
+    (activities: readonly WebChatActivity[], groupingName: string) => readonly (readonly WebChatActivity[])[]
+  >(
+    (activities, groupingName) => {
+      const group = groupActivitiesByGroupRef.current.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])));
+    },
+    [groupActivitiesByGroupRef, 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

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

@@ -0,0 +1,93 @@
+import { type GlobalScopePonyfill, type WebChatActivity } from 'botframework-webchat-core';
+
+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 sending(activity: WebChatActivity): SendStatus | undefined {
+  if (activity.from.role === 'user') {
+    const {
+      channelData: { 'webchat:send-status': sendStatus }
+    } = activity;
+
+    return sendStatus;
+  }
+}
+
+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 (sending(activityX) !== sending(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
+  ]);
+}

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

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

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

package/src/providers/GroupActivities/useGroupActivities.ts

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

@@ -0,0 +1,17 @@
+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/tsconfig.json

@@ -1,15 +1,11 @@
 {
   "compilerOptions": {
     "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "declarationDir": "../lib",
-    "declarationMap": true,
     "downlevelIteration": true,
-    "emitDeclarationOnly": true,
     "jsx": "react",
     "module": "ESNext",
     "moduleResolution": "Bundler",
-    "preserveWatchOutput": true,
+    "noEmit": true,
     "pretty": true,
     "resolveJsonModule": true, // Required for localization files
     "skipLibCheck": true,

package/src/types/AttachmentForScreenReaderMiddleware.ts

@@ -1,4 +1,4 @@
-import type { DirectLineAttachment, WebChatActivity } from 'botframework-webchat-core';
+import { type DirectLineAttachment, type WebChatActivity } from 'botframework-webchat-core';
 
 // TODO: We should consider using a prop for "attachmentMiddleware" to render for screen reader, instead of having another middleware.
 
@@ -11,11 +11,18 @@ type AttachmentForScreenReaderComponentFactoryOptions = [
   }
 ];
 
-type AttachmentForScreenReaderComponentFactory = ComponentFactory<AttachmentForScreenReaderComponentFactoryOptions, {}>;
+type AttachmentForScreenReaderComponentFactory = ComponentFactory<
+  AttachmentForScreenReaderComponentFactoryOptions,
+  // Following @types/react to use {} for props.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  {}
+>;
 
 type AttachmentForScreenReaderMiddleware = ComponentMiddleware<
   [],
   AttachmentForScreenReaderComponentFactoryOptions,
+  // Following @types/react to use {} for props.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   {}
 >;
 

package/src/types/AvatarMiddleware.ts

@@ -1,4 +1,4 @@
-import type { WebChatActivity } from 'botframework-webchat-core';
+import { type WebChatActivity } from 'botframework-webchat-core';
 
 import { StrictStyleOptions } from '../StyleOptions';
 import ComponentMiddleware, { ComponentFactory } from './ComponentMiddleware';
@@ -11,8 +11,12 @@ type AvatarComponentFactoryArguments = [
   }
 ];
 
+// Following @types/react to use {} for props.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 type AvatarComponentFactory = ComponentFactory<AvatarComponentFactoryArguments, {}>;
 
+// Following @types/react to use {} for props.
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 type AvatarMiddleware = ComponentMiddleware<[], AvatarComponentFactoryArguments, {}>;
 
 export default AvatarMiddleware;

package/src/types/CardActionMiddleware.ts

@@ -13,6 +13,8 @@ type CardActionMiddleware = FunctionMiddleware<
       target: any;
     }
   ],
+  // Following @types/react to use {} for props.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   {}
 >;
 

package/src/types/ComponentMiddleware.ts

@@ -30,7 +30,7 @@ type ComponentEnhancer<TComponentFactoryArguments extends any[], TProps> = (
  * The signature of the middleware is:
  *
  * ```
- * (...args: SetupArguments) => (next: Enhancer) => (...args: ComponentFactoryArguments) => false | React.FC<Props>
+ * (...args: SetupArguments) => (next: Enhancer) => (...args: ComponentFactoryArguments) => false | React.ComponentType<Props>
  * ```
  */
 type ComponentMiddleware<TSetupArguments extends any[], TComponentFactoryArguments extends any[], TProps> = (

package/src/types/GroupActivitiesMiddleware.ts

@@ -2,21 +2,17 @@ import type { WebChatActivity } from 'botframework-webchat-core';
 
 import FunctionMiddleware, { CallFunction } from './FunctionMiddleware';
 
+type GroupedActivities = readonly (readonly WebChatActivity[])[];
+
 type GroupActivities = CallFunction<
-  [{ activities: WebChatActivity[] }],
-  {
-    sender: WebChatActivity[][];
-    status: WebChatActivity[][];
-  }
+  [Readonly<{ activities: readonly WebChatActivity[] }>],
+  { [key: string]: GroupedActivities }
 >;
 
 type GroupActivitiesMiddleware = FunctionMiddleware<
-  [],
-  [{ activities: WebChatActivity[] }],
-  {
-    sender: WebChatActivity[][];
-    status: WebChatActivity[][];
-  }
+  [string],
+  [Readonly<{ activities: readonly WebChatActivity[] }>],
+  { [key: string]: GroupedActivities }
 >;
 
 export default GroupActivitiesMiddleware;

package/src/utils/validateProps.spec.ts

@@ -0,0 +1,74 @@
+import { number, object } from 'valibot';
+import validateProps from './validateProps';
+
+beforeEach(() =>
+  jest.spyOn(console, 'error').mockImplementation(() => {
+    // Intentionally left blank.
+  })
+);
+
+afterEach(() => jest.restoreAllMocks());
+
+test('when isolation is not specified then success should return as-is', () => {
+  const props = { one: 1, two: 2 };
+  const result = validateProps(object({ one: number() }), props);
+
+  expect(result).toBe(props);
+});
+
+test('when no isolation then success should return as-is', () => {
+  const props = { one: 1, two: 2 };
+  const result = validateProps(object({ one: number() }), props, 'no isolation');
+
+  expect(result).toBe(props);
+});
+
+test('when in strict isolation then success should return isolated result', () => {
+  const props = { one: 1, two: 2 };
+  const result = validateProps(object({ one: number() }), props, 'strict');
+
+  expect(result).not.toBe(props);
+  expect(result).toEqual({ one: 1 });
+});
+
+test('when isolation is not specified then failure should throw', () => {
+  const props = { two: 2 };
+
+  expect(() => validateProps(object({ one: number() }), props)).toThrow();
+});
+
+test('when no isolation then failure should throw', () => {
+  const props = { two: 2 };
+
+  expect(() => validateProps(object({ one: number() }), props, 'no isolation')).toThrow();
+});
+
+test('when in strict isolation then failure should throw', () => {
+  const props = { two: 2 };
+
+  expect(() => validateProps(object({ one: number() }), props, 'strict')).toThrow();
+});
+
+test('when under production mode and isolation is not specified then failure should warn', () => {
+  process.env.NODE_ENV = 'production';
+
+  const props = { two: 2 };
+
+  expect(validateProps(object({ one: number() }), props, 'strict')).toBe(props);
+});
+
+test('when under production mode and no isolation then failure should warn', () => {
+  process.env.NODE_ENV = 'production';
+
+  const props = { two: 2 };
+
+  expect(validateProps(object({ one: number() }), props, 'strict')).toBe(props);
+});
+
+test('when under production mode and in strict isolation then failure should warn', () => {
+  process.env.NODE_ENV = 'production';
+
+  const props = { two: 2 };
+
+  expect(validateProps(object({ one: number() }), props, 'strict')).toBe(props);
+});

package/src/utils/validateProps.ts

@@ -0,0 +1,56 @@
+import { parse, safeParse, type BaseIssue, type BaseSchema, type InferInput, type InferOutput } from 'valibot';
+
+/**
+ * Specifies the props isolation mode.
+ *
+ * - `"no isolation"` will return the props as-is without cloning or modifications
+ * - `"strict"` will isolate the props using `valibot.parse()`
+ *    - Depends on schema design, it could clone object instances, remove extraneous properties from objects, or fill in optional fields
+ */
+type IsolationMode = 'no isolation' | 'strict';
+
+export default function validateProps<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(
+  propsSchema: TSchema,
+  props: unknown,
+  isolationMode?: 'no isolation' | undefined
+): InferInput<TSchema>;
+
+export default function validateProps<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(
+  propsSchema: TSchema,
+  props: unknown,
+  isolationMode?: 'strict'
+): InferOutput<TSchema>;
+
+/**
+ * Validates props against the specified valibot schema when running under development mode.
+ *
+ * This function will not perform any validations when running under production mode.
+ *
+ * @param propsSchema validation schema
+ * @param props props to validate
+ * @param mode specifies the isolation mode, default to `"no isolation"`
+ * @returns
+ */
+export default function validateProps<const TSchema extends BaseSchema<unknown, unknown, BaseIssue<unknown>>>(
+  propsSchema: TSchema,
+  props: InferInput<TSchema>,
+  isolationMode?: IsolationMode | undefined
+): InferInput<TSchema> | InferOutput<TSchema> {
+  if (process.env.NODE_ENV === 'production') {
+    return props as unknown as InferInput<TSchema>;
+  }
+
+  if (isolationMode !== 'strict' && safeParse(propsSchema, props).success) {
+    return props as unknown as InferInput<TSchema>;
+  }
+
+  // Code path hit here when under strict isolation, or no isolation and failed earlier.
+
+  try {
+    return parse(propsSchema, props);
+  } catch (error) {
+    console.error('botframework-webchat: Validation error while parsing props.', error.issues);
+
+    throw error;
+  }
+}

package/dist/chunk-2S76JUVM.mjs

@@ -1,3 +0,0 @@
-import{warnOnce as l}from"botframework-webchat-core";import{createChainOfResponsibility as u}from"react-chain-of-responsibility";import{any as y,array as f,custom as m,safeParse as c}from"valibot";var w=Object.freeze([]);function M(i){let d=f(y([m(e=>typeof e=="function","Middleware must be a function.")])),a=e=>c(d,e).success,o=l(`"${i}" prop is invalid`),s=(e,p)=>{if(e){if(a(e))return Object.freeze(e?.map(t=>t(p)).filter(t=>!!t).map(t=>()=>t));o()}return w},{Provider:r,Proxy:n}=u();return r.displayName=`${i}Provider`,n.displayName=`${i}Proxy`,{initMiddleware:s,Provider:r,Proxy:n,types:{init:void 0,middleware:void 0,props:void 0,request:void 0}}}export{M as a};
-/*! For license information please see chunk-2S76JUVM.mjs.LEGAL.txt */
-//# sourceMappingURL=chunk-2S76JUVM.mjs.map

package/dist/chunk-2S76JUVM.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/decorator/private/templateMiddleware.ts"],"sourcesContent":["import { warnOnce } from 'botframework-webchat-core';\nimport { createChainOfResponsibility, type ComponentMiddleware } from 'react-chain-of-responsibility';\nimport { type EmptyObject } from 'type-fest';\nimport { any, array, custom, safeParse, type Output } from 'valibot';\n\nexport type MiddlewareWithInit<M extends ComponentMiddleware<any, any, any>, I> = (init: I) => ReturnType<M> | false;\n\nconst EMPTY_ARRAY = Object.freeze([]);\n\nexport default function templateMiddleware<Init, Request = any, Props extends {} = EmptyObject>(name: string) {\n  type Middleware = ComponentMiddleware<Request, Props>;\n\n  const middlewareSchema = array(\n    any([custom<Middleware>(input => typeof input === 'function', 'Middleware must be a function.')])\n  );\n\n  const isMiddleware = (middleware: unknown): middleware is Output<typeof middlewareSchema> =>\n    safeParse(middlewareSchema, middleware).success;\n\n  const warnInvalid = warnOnce(`\"${name}\" prop is invalid`);\n\n  const initMiddleware = (\n    middleware: readonly MiddlewareWithInit<Middleware, Init>[],\n    init?: Init\n  ): readonly Middleware[] => {\n    if (middleware) {\n      if (isMiddleware(middleware)) {\n        return Object.freeze(\n          middleware\n            ?.map(middleware => middleware(init))\n            .filter((enhancer): enhancer is ReturnType<Middleware> => !!enhancer)\n            .map(enhancer => () => enhancer)\n        );\n      }\n\n      warnInvalid();\n    }\n\n    return EMPTY_ARRAY;\n  };\n\n  const { Provider, Proxy } = createChainOfResponsibility<Request, Props>();\n\n  Provider.displayName = `${name}Provider`;\n  Proxy.displayName = `${name}Proxy`;\n\n  return {\n    initMiddleware,\n    Provider,\n    Proxy,\n    types: {\n      init: undefined as Init,\n      middleware: undefined as Middleware,\n      props: undefined as Props,\n      request: undefined as Request\n    }\n  };\n}\n"],"mappings":"AAAA,OAAS,YAAAA,MAAgB,4BACzB,OAAS,+BAAAC,MAA6D,gCAEtE,OAAS,OAAAC,EAAK,SAAAC,EAAO,UAAAC,EAAQ,aAAAC,MAA8B,UAI3D,IAAMC,EAAc,OAAO,OAAO,CAAC,CAAC,EAErB,SAARC,EAAyFC,EAAc,CAG5G,IAAMC,EAAmBN,EACvBD,EAAI,CAACE,EAAmBM,GAAS,OAAOA,GAAU,WAAY,gCAAgC,CAAC,CAAC,CAClG,EAEMC,EAAgBC,GACpBP,EAAUI,EAAkBG,CAAU,EAAE,QAEpCC,EAAcb,EAAS,IAAIQ,CAAI,mBAAmB,EAElDM,EAAiB,CACrBF,EACAG,IAC0B,CAC1B,GAAIH,EAAY,CACd,GAAID,EAAaC,CAAU,EACzB,OAAO,OAAO,OACZA,GACI,IAAIA,GAAcA,EAAWG,CAAI,CAAC,EACnC,OAAQC,GAAiD,CAAC,CAACA,CAAQ,EACnE,IAAIA,GAAY,IAAMA,CAAQ,CACnC,EAGFH,EAAY,CACd,CAEA,OAAOP,CACT,EAEM,CAAE,SAAAW,EAAU,MAAAC,CAAM,EAAIjB,EAA4C,EAExE,OAAAgB,EAAS,YAAc,GAAGT,CAAI,WAC9BU,EAAM,YAAc,GAAGV,CAAI,QAEpB,CACL,eAAAM,EACA,SAAAG,EACA,MAAAC,EACA,MAAO,CACL,KAAM,OACN,WAAY,OACZ,MAAO,OACP,QAAS,MACX,CACF,CACF","names":["warnOnce","createChainOfResponsibility","any","array","custom","safeParse","EMPTY_ARRAY","templateMiddleware","name","middlewareSchema","input","isMiddleware","middleware","warnInvalid","initMiddleware","init","enhancer","Provider","Proxy"]}

package/dist/chunk-J6D5YEY6.mjs

@@ -1,3 +0,0 @@
-var g=Object.create;var e=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var j=Object.getPrototypeOf,k=Object.prototype.hasOwnProperty;var m=(b,a)=>()=>(a||b((a={exports:{}}).exports,a),a.exports),n=(b,a)=>{for(var c in a)e(b,c,{get:a[c],enumerable:!0})},l=(b,a,c,f)=>{if(a&&typeof a=="object"||typeof a=="function")for(let d of i(a))!k.call(b,d)&&d!==c&&e(b,d,{get:()=>a[d],enumerable:!(f=h(a,d))||f.enumerable});return b};var o=(b,a,c)=>(c=b!=null?g(j(b)):{},l(a||!b||!b.__esModule?e(c,"default",{value:b,enumerable:!0}):c,b));export{m as a,n as b,o as c};
-/*! For license information please see chunk-J6D5YEY6.mjs.LEGAL.txt */
-//# sourceMappingURL=chunk-J6D5YEY6.mjs.map

package/dist/chunk-J6D5YEY6.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-ZAMHKQQC.mjs

@@ -1,3 +0,0 @@
-import{createContext as o}from"react";var e=o(void 0);e.displayName="WebChatAPIContext";var i=e;import{useContext as n}from"react";function r(){let t=n(i);if(!t)throw new Error("This hook can only be used on a component that is a descendant of <Composer>");return t}export{i as a,r as b};
-/*! For license information please see chunk-ZAMHKQQC.mjs.LEGAL.txt */
-//# sourceMappingURL=chunk-ZAMHKQQC.mjs.map

package/dist/chunk-ZAMHKQQC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hooks/internal/WebChatAPIContext.ts","../src/hooks/internal/useWebChatAPIContext.ts"],"sourcesContent":["import {\n  type DirectLineJSBotConnection,\n  type Observable,\n  type WebChatActivity,\n  type sendFiles,\n  type sendMessage,\n  type setSendBoxAttachments\n} from 'botframework-webchat-core';\nimport { createContext } from 'react';\n\nimport { StrictStyleOptions } from '../../StyleOptions';\nimport { LegacyActivityRenderer } from '../../types/ActivityMiddleware';\nimport { RenderActivityStatus } from '../../types/ActivityStatusMiddleware';\nimport { AttachmentForScreenReaderComponentFactory } from '../../types/AttachmentForScreenReaderMiddleware';\nimport { RenderAttachment } from '../../types/AttachmentMiddleware';\nimport { AvatarComponentFactory } from '../../types/AvatarMiddleware';\nimport { PerformCardAction } from '../../types/CardActionMiddleware';\nimport { GroupActivities } from '../../types/GroupActivitiesMiddleware';\nimport LocalizedStrings from '../../types/LocalizedStrings';\nimport { type Notification } from '../../types/Notification';\nimport PrecompiledGlobalize from '../../types/PrecompiledGlobalize';\nimport { ScrollToEndButtonComponentFactory } from '../../types/ScrollToEndButtonMiddleware';\nimport TelemetryMeasurementEvent from '../../types/TelemetryMeasurementEvent';\nimport { RenderToast } from '../../types/ToastMiddleware';\n\ntype WebChatAPIContext = {\n  activityRenderer?: LegacyActivityRenderer;\n  activityStatusRenderer: RenderActivityStatus;\n  attachmentForScreenReaderRenderer?: AttachmentForScreenReaderComponentFactory;\n  attachmentRenderer?: RenderAttachment;\n  avatarRenderer: AvatarComponentFactory;\n  clearSuggestedActions?: () => void;\n  dir?: string;\n  directLine?: DirectLineJSBotConnection;\n  disabled?: boolean;\n  dismissNotification?: (id: string) => void;\n  downscaleImageToDataURL?: (\n    blob: Blob,\n    maxWidth: number,\n    maxHeight: number,\n    type: string,\n    quality: number\n  ) => Promise<URL>;\n  emitTypingIndicator?: () => void;\n  grammars?: any;\n  groupActivities?: GroupActivities;\n  internalErrorBoxClass?: React.Component | Function;\n  language?: string;\n  localizedGlobalizeState?: PrecompiledGlobalize[];\n  localizedStrings?: { [language: string]: LocalizedStrings };\n  markActivity?: (activity: { id: string }, name: string, value?: any) => void;\n  onCardAction?: PerformCardAction;\n  onTelemetry?: (event: TelemetryMeasurementEvent) => void;\n  postActivity?: (activity: WebChatActivity) => Observable<string>;\n  renderMarkdown?: (\n    markdown: string,\n    newLineOptions: { markdownRespectCRLF: boolean },\n    linkOptions: { externalLinkAlt: string }\n  ) => string;\n  scrollToEndButtonRenderer?: ScrollToEndButtonComponentFactory;\n  selectVoice?: (\n    voices: (typeof window.SpeechSynthesisVoice)[],\n    activity: WebChatActivity\n  ) => typeof window.SpeechSynthesisVoice;\n  sendEvent?: (name: string, value: any) => void;\n  sendFiles?: (...args: Parameters<typeof sendFiles>) => void;\n  sendMessage?: (...args: Parameters<typeof sendMessage>) => void;\n  sendMessageBack?: (value: any, text?: string, displayText?: string) => void;\n  sendPostBack?: (value?: any) => void;\n  sendTypingIndicator?: boolean;\n  setDictateInterims?: (interims: string[]) => void;\n  setDictateState?: (dictateState: number) => void;\n  setNotification?: (notification: Notification) => void;\n  setSendBox?: (value: string) => void;\n  setSendBoxAttachments?: (...args: Parameters<typeof setSendBoxAttachments>) => void;\n  setSendTimeout?: (timeout: number) => void;\n  startDictate?: () => void;\n  startSpeakingActivity?: () => void;\n  stopDictate?: () => void;\n  stopSpeakingActivity?: () => void;\n  styleOptions?: StrictStyleOptions;\n  submitSendBox?: (method?: string, { channelData }?: { channelData: any }) => void;\n  telemetryDimensionsRef?: React.Ref<any>;\n  toastRenderer?: RenderToast;\n  trackDimension?: (name: string, data: any) => void;\n  typingIndicatorRenderer?: any; // TODO\n  userID?: string;\n  username?: string;\n};\n\nconst context = createContext<WebChatAPIContext>(undefined);\n\ncontext.displayName = 'WebChatAPIContext';\n\nexport default context;\n","import { useContext } from 'react';\n\nimport WebChatAPIContext from './WebChatAPIContext';\n\nexport default function useWebChatAPIContext() {\n  const context = useContext(WebChatAPIContext);\n\n  if (!context) {\n    throw new Error('This hook can only be used on a component that is a descendant of <Composer>');\n  }\n\n  return context;\n}\n"],"mappings":"AAQA,OAAS,iBAAAA,MAAqB,QAkF9B,IAAMC,EAAUD,EAAiC,MAAS,EAE1DC,EAAQ,YAAc,oBAEtB,IAAOC,EAAQD,EC9Ff,OAAS,cAAAE,MAAkB,QAIZ,SAARC,GAAwC,CAC7C,IAAMC,EAAUC,EAAWC,CAAiB,EAE5C,GAAI,CAACF,EACH,MAAM,IAAI,MAAM,8EAA8E,EAGhG,OAAOA,CACT","names":["createContext","context","WebChatAPIContext_default","useContext","useWebChatAPIContext","context","useContext","WebChatAPIContext_default"]}