botframework-webchat-component 4.13.0 → 4.15.0

package/lib/index.d.ts

@@ -1,26 +1,223 @@
-import { FC } from 'react';
-import { StyleOptions } from 'botframework-webchat-api';
-declare type Expando<T> = Omit<any, keyof T> & T;
-/** Creates a set of styles */
-declare function createStyleSet(styleOptions: StyleOptions): any;
-declare type ComposerProps = {
-    /** Text directionality */
-    dir?: 'ltr' | 'rtl' | 'auto';
-    /** Style options */
-    styleOptions?: StyleOptions;
+import { concatMiddleware, hooks as apiHooks, localize } from 'botframework-webchat-api';
+import ReactWebChat, { ReactWebChatProps } from './ReactWebChat';
+import { ComposerProps } from './Composer';
+import { BasicWebChatProps } from './BasicWebChat';
+import connectToWebChat from './connectToWebChat';
+import Context from './hooks/internal/WebChatUIContext';
+import createCoreActivityMiddleware from './Middleware/Activity/createCoreMiddleware';
+import createCoreActivityStatusMiddleware from './Middleware/ActivityStatus/createCoreMiddleware';
+import createCoreAttachmentMiddleware from './Middleware/Attachment/createCoreMiddleware';
+import createStyleSet from './Styles/createStyleSet';
+import getTabIndex from './Utils/TypeFocusSink/getTabIndex';
+import * as componentHooks from './hooks/index';
+declare const hooks: {
+    useDictateAbortable: typeof componentHooks.useDictateAbortable;
+    useFocus: typeof componentHooks.useFocus;
+    useFocusSendBox: typeof componentHooks.useFocusSendBox;
+    useMicrophoneButtonClick: typeof componentHooks.useMicrophoneButtonClick;
+    useMicrophoneButtonDisabled: typeof componentHooks.useMicrophoneButtonDisabled;
+    useObserveScrollPosition: typeof componentHooks.useObserveScrollPosition;
+    useObserveTranscriptFocus: typeof componentHooks.useObserveTranscriptFocus;
+    useRenderMarkdownAsHTML: typeof componentHooks.useRenderMarkdownAsHTML;
+    useScrollDown: typeof componentHooks.useScrollDown;
+    useScrollTo: typeof componentHooks.useScrollTo;
+    useScrollToEnd: typeof componentHooks.useScrollToEnd;
+    useScrollUp: typeof componentHooks.useScrollUp;
+    useSendBoxSpeechInterimsVisible: typeof componentHooks.useSendBoxSpeechInterimsVisible;
+    useSendFiles: typeof componentHooks.useSendFiles;
+    useStyleSet: typeof componentHooks.useStyleSet;
+    useTextBoxSubmit: typeof componentHooks.useTextBoxSubmit;
+    useTextBoxValue: typeof componentHooks.useTextBoxValue;
+    useTypingIndicatorVisible: typeof componentHooks.useTypingIndicatorVisible;
+    useWebSpeechPonyfill: typeof componentHooks.useWebSpeechPonyfill;
+    useActiveTyping: typeof apiHooks.useActiveTyping;
+    useActivities: typeof apiHooks.useActivities;
+    useActivityKeys: typeof apiHooks.useActivityKeys;
+    useActivityKeysByRead: typeof apiHooks.useActivityKeysByRead;
+    useAvatarForBot: typeof apiHooks.useAvatarForBot;
+    useAvatarForUser: typeof apiHooks.useAvatarForUser;
+    useByteFormatter: typeof apiHooks.useByteFormatter;
+    useConnectivityStatus: typeof apiHooks.useConnectivityStatus;
+    useCreateActivityRenderer: typeof apiHooks.useCreateActivityRenderer;
+    useCreateActivityStatusRenderer: typeof apiHooks.useCreateActivityStatusRenderer;
+    useCreateAttachmentForScreenReaderRenderer: any;
+    useCreateAvatarRenderer: typeof apiHooks.useCreateAvatarRenderer;
+    useCreateScrollToEndButtonRenderer: typeof apiHooks.useCreateScrollToEndButtonRenderer;
+    useDateFormatter: typeof apiHooks.useDateFormatter;
+    useDebouncedNotifications: typeof apiHooks.useDebouncedNotifications;
+    useDictateInterims: typeof apiHooks.useDictateInterims;
+    useDictateState: typeof apiHooks.useDictateState;
+    useDirection: typeof apiHooks.useDirection;
+    useDisabled: typeof apiHooks.useDisabled;
+    useDismissNotification: typeof apiHooks.useDismissNotification;
+    useEmitTypingIndicator: typeof apiHooks.useEmitTypingIndicator;
+    useGetActivityByKey: typeof apiHooks.useGetActivityByKey;
+    useGetHasAcknowledgedByActivityKey: typeof apiHooks.useGetHasAcknowledgedByActivityKey;
+    useGetKeyByActivity: typeof apiHooks.useGetKeyByActivity;
+    useGetKeyByActivityId: typeof apiHooks.useGetKeyByActivityId;
+    useGetSendTimeoutForActivity: typeof apiHooks.useGetSendTimeoutForActivity;
+    useGrammars: typeof apiHooks.useGrammars;
+    useGroupActivities: typeof apiHooks.useGroupActivities;
+    useGroupTimestamp: typeof apiHooks.useGroupTimestamp;
+    useLanguage: typeof apiHooks.useLanguage;
+    useLastAcknowledgedActivityKey: typeof apiHooks.useLastAcknowledgedActivityKey;
+    useLastReadActivityKey: typeof apiHooks.useLastReadActivityKey;
+    useLastTypingAt: typeof apiHooks.useLastTypingAt;
+    useLocalize: typeof apiHooks.useLocalize;
+    useLocalizeDate: typeof apiHooks.useLocalizeDate;
+    useLocalizer: typeof apiHooks.useLocalizer;
+    useMarkActivityAsSpoken: typeof apiHooks.useMarkActivityAsSpoken;
+    useMarkActivityKeyAsRead: typeof apiHooks.useMarkActivityKeyAsRead;
+    useMarkAllAsAcknowledged: typeof apiHooks.useMarkAllAsAcknowledged;
+    usePerformCardAction: typeof apiHooks.usePerformCardAction;
+    usePostActivity: typeof apiHooks.usePostActivity;
+    useReferenceGrammarID: typeof apiHooks.useReferenceGrammarID;
+    useRelativeTimeFormatter: typeof apiHooks.useRelativeTimeFormatter;
+    useRenderActivity: any;
+    useRenderActivityStatus: any;
+    useRenderAttachment: any;
+    useRenderAvatar: any;
+    useRenderToast: typeof apiHooks.useRenderToast;
+    useRenderTypingIndicator: typeof apiHooks.useRenderTypingIndicator;
+    useSendBoxValue: typeof apiHooks.useSendBoxValue;
+    useSendEvent: typeof apiHooks.useSendEvent;
+    useSendMessage: typeof apiHooks.useSendMessage;
+    useSendMessageBack: typeof apiHooks.useSendMessageBack;
+    useSendPostBack: typeof apiHooks.useSendPostBack;
+    useSendTimeoutForActivity: typeof apiHooks.useSendTimeoutForActivity;
+    useSendTypingIndicator: typeof apiHooks.useSendTypingIndicator;
+    useSetNotification: typeof apiHooks.useSetNotification;
+    useShouldSpeakIncomingActivity: typeof apiHooks.useShouldSpeakIncomingActivity;
+    useStartDictate: typeof apiHooks.useStartDictate;
+    useStopDictate: typeof apiHooks.useStopDictate;
+    useStyleOptions: typeof apiHooks.useStyleOptions;
+    useSubmitSendBox: typeof apiHooks.useSubmitSendBox;
+    useSuggestedActions: typeof apiHooks.useSuggestedActions;
+    useTimeoutForSend: typeof apiHooks.useTimeoutForSend;
+    useTrackDimension: typeof apiHooks.useTrackDimension;
+    useTrackEvent: typeof apiHooks.useTrackEvent;
+    useTrackException: typeof apiHooks.useTrackException;
+    useTrackTiming: typeof apiHooks.useTrackTiming;
+    useUserID: typeof apiHooks.useUserID;
+    useUsername: typeof apiHooks.useUsername;
+    useVoiceSelector: typeof apiHooks.useVoiceSelector;
 };
-declare type ReactWebChatProps = {
-    /** Text directionality */
-    dir?: 'ltr' | 'rtl' | 'auto';
-    /** Style options */
-    styleOptions?: StyleOptions;
+declare const version: string;
+declare const Components: {
+    BasicWebChat: import("react").FC<BasicWebChatProps>;
+    Composer: import("react").FC<ComposerProps>;
+    Localize: ({ args, text }: {
+        args: [(string | number)?, ...string[]];
+        text: any;
+    }) => any;
+    AudioContent: import("react").FC<{
+        alt?: string;
+        autoPlay?: boolean;
+        loop?: boolean;
+        poster?: string;
+        src: string;
+    }>;
+    FileContent: import("react").FC<{
+        className?: string;
+        fileName: string;
+        href?: string;
+        size?: number;
+    }>;
+    HTMLVideoContent: import("react").FC<{
+        alt?: string;
+        autoPlay?: boolean;
+        loop?: boolean;
+        poster?: string;
+        src: string;
+    }>;
+    ImageContent: import("react").FC<{
+        alt?: string;
+        src: string;
+    }>;
+    TextContent: import("react").FC<{
+        contentType?: string;
+        text: string;
+    }>;
+    VideoContent: import("react").FC<{
+        alt?: string;
+        autoPlay?: boolean;
+        loop?: boolean;
+        poster?: string;
+        src: string;
+    }>;
+    VimeoContent: import("react").FC<{
+        alt?: string;
+        autoPlay?: boolean;
+        embedID: string;
+        loop?: boolean;
+    }>;
+    YouTubeContent: import("react").FC<{
+        alt?: string;
+        autoPlay?: boolean;
+        embedID: string;
+        loop?: boolean;
+    }>;
+    Avatar: import("react").VFC<{
+        'aria-hidden'?: boolean;
+        className?: string;
+        fromUser?: boolean;
+    }>;
+    Bubble: import("react").FC<{
+        'aria-hidden'?: boolean;
+        children?: import("react").ReactNode;
+        className?: string;
+        fromUser?: boolean;
+        nub?: boolean | "hidden";
+    }>;
+    ErrorBox: import("react").FC<{
+        error: Error;
+        type?: string;
+    }>;
+    SendStatus: import("react").FC<{
+        activity: any;
+        sendState: "sending" | "send failed" | "sent";
+    }>;
+    SpeakActivity: import("react").FC<{
+        activity: any;
+    }>;
+    Timestamp: import("react").FC<{
+        activity: any;
+        className?: string;
+    }>;
+    connectSendStatus: (...selectors: any[]) => any;
+    connectSpeakActivity: (...selectors: any[]) => any;
+    DictationInterims: import("react").FC<{
+        className?: string;
+    }>;
+    MicrophoneButton: import("react").FC<{
+        className?: string;
+    }>;
+    SendButton: import("react").FC<{
+        className?: string;
+    }>;
+    SendTextBox: {
+        ({ className }: {
+            className: any;
+        }): JSX.Element;
+        defaultProps: {
+            className: string;
+        };
+        propTypes: {
+            className: import("prop-types").Requireable<string>;
+        };
+    };
+    SuggestedActions: any;
+    UploadButton: import("react").FC<{
+        className?: string;
+    }>;
+    connectDictationInterims: (...selectors: any[]) => any;
+    connectMicrophoneButton: (...selectors: any[]) => any;
+    connectSendButton: (...selectors: any[]) => any;
+    connectSendTextBox: (...selectors: any[]) => any;
+    connectSuggestedActions: (...selectors: any[]) => any;
+    connectUploadButton: (...selectors: any[]) => any;
 };
-/** React-based Web Chat */
-declare const ReactWebChat: FC<Expando<ReactWebChatProps>>;
-declare const Components: Expando<{
-    Composer: FC<Expando<ComposerProps>>;
-}>;
 export default ReactWebChat;
-export { Components, createStyleSet };
-export type { ComposerProps, ReactWebChatProps };
+export { Components, concatMiddleware, connectToWebChat, Context, createCoreActivityMiddleware, createCoreActivityStatusMiddleware, createCoreAttachmentMiddleware, createStyleSet, getTabIndex, hooks, localize, version };
+export type { BasicWebChatProps, ComposerProps, ReactWebChatProps };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,aAAK,OAAO,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;AAEzC,8BAA8B;AAE9B,OAAO,UAAU,cAAc,CAAC,YAAY,EAAE,YAAY,GAAG,GAAG,CAAC;AAEjE,aAAK,aAAa,GAAG;IACnB,0BAA0B;IAC1B,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAE7B,oBAAoB;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,aAAK,iBAAiB,GAAG;IACvB,0BAA0B;IAC1B,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAE7B,oBAAoB;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,2BAA2B;AAC3B,OAAO,CAAC,MAAM,YAAY,EAAE,EAAE,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAE3D,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,CAAC;IAChC,QAAQ,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC;CACtC,CAAC,CAAC;AAEH,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,IAAI,QAAQ,EAAY,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEnG,OAAO,YAAY,EAAE,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAErD,OAAqB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAyBjE,OAAO,gBAAgB,MAAM,oBAAoB,CAAC;AAClD,OAAO,OAAO,MAAM,mCAAmC,CAAC;AACxD,OAAO,4BAA4B,MAAM,4CAA4C,CAAC;AACtF,OAAO,kCAAkC,MAAM,kDAAkD,CAAC;AAClG,OAAO,8BAA8B,MAAM,8CAA8C,CAAC;AAC1F,OAAO,cAAc,MAAM,yBAAyB,CAAC;AACrD,OAAO,WAAW,MAAM,mCAAmC,CAAC;AAE5D,OAAO,KAAK,cAAc,MAAM,eAAe,CAAC;AAEhD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGV,CAAC;AAEF,QAAA,MAAM,OAAO,QAAkC,CAAC;AAEhD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCf,CAAC;AAEF,eAAe,YAAY,CAAC;AAE5B,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,OAAO,EACP,4BAA4B,EAC5B,kCAAkC,EAClC,8BAA8B,EAC9B,cAAc,EACd,WAAW,EACX,KAAK,EACL,QAAQ,EACR,OAAO,EACR,CAAC;AAEF,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAC"}

package/lib/index.js

@@ -5,16 +5,23 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "connectToWebChat", {
+exports.Components = void 0;
+Object.defineProperty(exports, "Context", {
   enumerable: true,
   get: function get() {
-    return _connectToWebChat.default;
+    return _WebChatUIContext.default;
   }
 });
-Object.defineProperty(exports, "Context", {
+Object.defineProperty(exports, "concatMiddleware", {
   enumerable: true,
   get: function get() {
-    return _WebChatUIContext.default;
+    return _botframeworkWebchatApi.concatMiddleware;
+  }
+});
+Object.defineProperty(exports, "connectToWebChat", {
+  enumerable: true,
+  get: function get() {
+    return _connectToWebChat.default;
   }
 });
 Object.defineProperty(exports, "createCoreActivityMiddleware", {
@@ -41,25 +48,23 @@ Object.defineProperty(exports, "createStyleSet", {
     return _createStyleSet.default;
   }
 });
+exports.default = void 0;
 Object.defineProperty(exports, "getTabIndex", {
   enumerable: true,
   get: function get() {
     return _getTabIndex.default;
   }
 });
-Object.defineProperty(exports, "concatMiddleware", {
-  enumerable: true,
-  get: function get() {
-    return _botframeworkWebchatApi.concatMiddleware;
-  }
-});
+exports.hooks = void 0;
 Object.defineProperty(exports, "localize", {
   enumerable: true,
   get: function get() {
     return _botframeworkWebchatApi.localize;
   }
 });
-exports.version = exports.hooks = exports.Components = exports.default = void 0;
+exports.version = void 0;
+
+var _botframeworkWebchatApi = require("botframework-webchat-api");
 
 var _ReactWebChat = _interopRequireDefault(require("./ReactWebChat"));
 
@@ -121,27 +126,24 @@ var _createStyleSet = _interopRequireDefault(require("./Styles/createStyleSet"))
 
 var _getTabIndex = _interopRequireDefault(require("./Utils/TypeFocusSink/getTabIndex"));
 
-var _botframeworkWebchatApi = require("botframework-webchat-api");
-
 var componentHooks = _interopRequireWildcard(require("./hooks/index"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-var hooks = _objectSpread(_objectSpread({}, _botframeworkWebchatApi.hooks), componentHooks); // eslint-disable-next-line no-undef
-
+var hooks = _objectSpread(_objectSpread({}, _botframeworkWebchatApi.hooks), componentHooks);
 
 exports.hooks = hooks;
-var version = "4.13.0";
+var version = "4.15.0";
 exports.version = version;
 var Components = {
   BasicWebChat: _BasicWebChat.default,
@@ -182,4 +184,4 @@ var Components = {
 exports.Components = Components;
 var _default = _ReactWebChat.default;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/providers/ActivityTree/ActivityTreeComposer.d.ts

@@ -0,0 +1,5 @@
+import type { FC, PropsWithChildren } from 'react';
+declare type ActivityTreeComposerProps = PropsWithChildren<{}>;
+declare const ActivityTreeComposer: FC<ActivityTreeComposerProps>;
+export default ActivityTreeComposer;
+//# sourceMappingURL=ActivityTreeComposer.d.ts.map

package/lib/providers/ActivityTree/ActivityTreeComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityTreeComposer.d.ts","sourceRoot":"","sources":["../../../src/providers/ActivityTree/ActivityTreeComposer.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAWnD,aAAK,yBAAyB,GAAG,iBAAiB,CAAC,EAAE,CAAC,CAAC;AAIvD,QAAA,MAAM,oBAAoB,EAAE,EAAE,CAAC,yBAAyB,CAmDvD,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/lib/providers/ActivityTree/ActivityTreeComposer.js

@@ -0,0 +1,86 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _botframeworkWebchatApi = require("botframework-webchat-api");
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _Context = _interopRequireDefault(require("./private/Context"));
+
+var _useActivitiesWithRenderer = _interopRequireDefault(require("./private/useActivitiesWithRenderer"));
+
+var _useContext = _interopRequireDefault(require("./private/useContext"));
+
+var _useActivityTreeWithRenderer = _interopRequireDefault(require("./private/useActivityTreeWithRenderer"));
+
+var _useMemoWithPrevious = _interopRequireDefault(require("../../hooks/internal/useMemoWithPrevious"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var useActivities = _botframeworkWebchatApi.hooks.useActivities,
+    useCreateActivityRenderer = _botframeworkWebchatApi.hooks.useCreateActivityRenderer;
+
+var ActivityTreeComposer = function ActivityTreeComposer(_ref) {
+  var children = _ref.children;
+  var existingContext = (0, _useContext.default)(false);
+
+  if (existingContext) {
+    throw new Error('botframework-webchat internal: <ActivityTreeComposer> should not be nested.');
+  }
+
+  var _useActivities = useActivities(),
+      _useActivities2 = _slicedToArray(_useActivities, 1),
+      activities = _useActivities2[0];
+
+  var createActivityRenderer = useCreateActivityRenderer();
+  var activitiesWithRenderer = (0, _useActivitiesWithRenderer.default)(activities, createActivityRenderer);
+  var activityTreeWithRenderer = (0, _useActivityTreeWithRenderer.default)(activitiesWithRenderer);
+  var flattenedActivityTreeWithRenderer = (0, _useMemoWithPrevious.default)(function (prevFlattenedActivityTree) {
+    var nextFlattenedActivityTree = Object.freeze(activityTreeWithRenderer.reduce(function (intermediate, entriesWithSameSender) {
+      return entriesWithSameSender.reduce(function (intermediate, entriesWithSameSenderAndStatus) {
+        return entriesWithSameSenderAndStatus.reduce(function (intermediate, entry) {
+          intermediate.push(entry);
+          return intermediate;
+        }, intermediate);
+      }, intermediate);
+    }, []));
+    return nextFlattenedActivityTree.length === (prevFlattenedActivityTree === null || prevFlattenedActivityTree === void 0 ? void 0 : prevFlattenedActivityTree.length) && nextFlattenedActivityTree.every(function (item, index) {
+      return item === prevFlattenedActivityTree[+index];
+    }) ? prevFlattenedActivityTree : nextFlattenedActivityTree;
+  }, [activityTreeWithRenderer]);
+  var contextValue = (0, _react.useMemo)(function () {
+    return {
+      activityTreeWithRendererState: Object.freeze([activityTreeWithRenderer]),
+      flattenedActivityTreeWithRendererState: Object.freeze([flattenedActivityTreeWithRenderer])
+    };
+  }, [activityTreeWithRenderer, flattenedActivityTreeWithRenderer]);
+  return /*#__PURE__*/_react.default.createElement(_Context.default.Provider, {
+    value: contextValue
+  }, children);
+};
+
+var _default = ActivityTreeComposer;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/providers/ActivityTree/private/Context.d.ts

@@ -0,0 +1,9 @@
+import type { ActivityWithRenderer, ReadonlyActivityTree } from './types';
+declare type ActivityTreeContextType = {
+    activityTreeWithRendererState: readonly [ReadonlyActivityTree];
+    flattenedActivityTreeWithRendererState: readonly [readonly ActivityWithRenderer[]];
+};
+declare const _default: import("react").Context<ActivityTreeContextType>;
+export default _default;
+export type { ActivityTreeContextType };
+//# sourceMappingURL=Context.d.ts.map

package/lib/providers/ActivityTree/private/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../../../src/providers/ActivityTree/private/Context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE1E,aAAK,uBAAuB,GAAG;IAC7B,6BAA6B,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;IAC/D,sCAAsC,EAAE,SAAS,CAAC,SAAS,oBAAoB,EAAE,CAAC,CAAC;CACpF,CAAC;;AAEF,wBAAiE;AAEjE,YAAY,EAAE,uBAAuB,EAAE,CAAC"}

package/lib/providers/ActivityTree/private/Context.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = require("react");
+
+var _default = /*#__PURE__*/(0, _react.createContext)(undefined);
+
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wcm92aWRlcnMvQWN0aXZpdHlUcmVlL3ByaXZhdGUvQ29udGV4dC50cyJdLCJuYW1lcyI6WyJ1bmRlZmluZWQiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQTs7NEJBU2UsMEJBQXVDQSxTQUF2QyxDIiwic291cmNlUm9vdCI6ImNvbXBvbmVudDovLy8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjcmVhdGVDb250ZXh0IH0gZnJvbSAncmVhY3QnO1xuXG5pbXBvcnQgdHlwZSB7IEFjdGl2aXR5V2l0aFJlbmRlcmVyLCBSZWFkb25seUFjdGl2aXR5VHJlZSB9IGZyb20gJy4vdHlwZXMnO1xuXG50eXBlIEFjdGl2aXR5VHJlZUNvbnRleHRUeXBlID0ge1xuICBhY3Rpdml0eVRyZWVXaXRoUmVuZGVyZXJTdGF0ZTogcmVhZG9ubHkgW1JlYWRvbmx5QWN0aXZpdHlUcmVlXTtcbiAgZmxhdHRlbmVkQWN0aXZpdHlUcmVlV2l0aFJlbmRlcmVyU3RhdGU6IHJlYWRvbmx5IFtyZWFkb25seSBBY3Rpdml0eVdpdGhSZW5kZXJlcltdXTtcbn07XG5cbmV4cG9ydCBkZWZhdWx0IGNyZWF0ZUNvbnRleHQ8QWN0aXZpdHlUcmVlQ29udGV4dFR5cGU+KHVuZGVmaW5lZCk7XG5cbmV4cG9ydCB0eXBlIHsgQWN0aXZpdHlUcmVlQ29udGV4dFR5cGUgfTtcbiJdfQ==

package/lib/providers/ActivityTree/private/types.d.ts

@@ -0,0 +1,10 @@
+import type { ActivityComponentFactory } from 'botframework-webchat-api';
+import type { DirectLineActivity } from 'botframework-webchat-core';
+declare type ActivityWithRenderer = {
+    activity: DirectLineActivity;
+    renderActivity: Exclude<ReturnType<ActivityComponentFactory>, false>;
+};
+declare type ActivityTree = ActivityWithRenderer[][][];
+declare type ReadonlyActivityTree = readonly (readonly (readonly ActivityWithRenderer[])[])[];
+export type { ActivityTree, ActivityWithRenderer, ReadonlyActivityTree };
+//# sourceMappingURL=types.d.ts.map

package/lib/providers/ActivityTree/private/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/providers/ActivityTree/private/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,aAAK,oBAAoB,GAAG;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC,EAAE,KAAK,CAAC,CAAC;CACtE,CAAC;AAEF,aAAK,YAAY,GAAG,oBAAoB,EAAE,EAAE,EAAE,CAAC;AAC/C,aAAK,oBAAoB,GAAG,SAAS,CAAC,SAAS,CAAC,SAAS,oBAAoB,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAEtF,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,CAAC"}

package/lib/providers/ActivityTree/private/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZVJvb3QiOiJjb21wb25lbnQ6Ly8vIiwic291cmNlc0NvbnRlbnQiOltdfQ==

package/lib/providers/ActivityTree/private/useActivitiesWithRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { DirectLineActivity } from 'botframework-webchat-core';
+import type { ActivityWithRenderer } from './types';
+export default function useActivitiesWithRenderer(activities: readonly DirectLineActivity[], createActivityRenderer: any): readonly ActivityWithRenderer[];
+//# sourceMappingURL=useActivitiesWithRenderer.d.ts.map

package/lib/providers/ActivityTree/private/useActivitiesWithRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActivitiesWithRenderer.d.ts","sourceRoot":"","sources":["../../../../src/providers/ActivityTree/private/useActivitiesWithRenderer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC/C,UAAU,EAAE,SAAS,kBAAkB,EAAE,EACzC,sBAAsB,KAAA,GACrB,SAAS,oBAAoB,EAAE,CAsDjC"}

package/lib/providers/ActivityTree/private/useActivitiesWithRenderer.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useActivitiesWithRenderer;
+
+var _react = require("react");
+
+var _useMemoize = _interopRequireDefault(require("../../../hooks/internal/useMemoize"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function useActivitiesWithRenderer(activities, createActivityRenderer) {
+  var createActivityRendererWithLiteralArgs = (0, _react.useCallback)(function (activity, nextVisibleActivity) {
+    return createActivityRenderer({
+      activity: activity,
+      nextVisibleActivity: nextVisibleActivity
+    });
+  }, [createActivityRenderer]); // Create a memoized context of the createActivityRenderer function.
+  // TODO: [P2] Rename useMemoize to useMemoAll
+
+  var entries = (0, _useMemoize.default)(createActivityRendererWithLiteralArgs, function (createActivityRendererWithLiteralArgsMemoized) {
+    // All calls to createActivityRendererWithLiteralArgsMemoized() in this function will be memoized (LRU = 1).
+    // In the next render cycle, calls to createActivityRendererWithLiteralArgsMemoized() might return the memoized result instead.
+    // This is an improvement to React useMemo(), because it only allows 1 memoization.
+    // useMemoize() allows any number of memoization.
+    var activitiesWithRenderer = [];
+    var nextVisibleActivity;
+
+    for (var index = activities.length - 1; index >= 0; index--) {
+      var activity = activities[+index];
+      var renderActivity = createActivityRendererWithLiteralArgsMemoized(activity, nextVisibleActivity);
+
+      if (renderActivity) {
+        activitiesWithRenderer.splice(0, 0, {
+          activity: activity,
+          renderActivity: renderActivity
+        });
+        nextVisibleActivity = activity;
+      }
+    }
+
+    return Object.freeze(activitiesWithRenderer);
+  }, [activities]);
+  var prevEntriesRef = (0, _react.useRef)([]);
+  var prevEntries = prevEntriesRef.current;
+
+  if (prevEntries.length !== entries.length || prevEntries.some(function (prevEntry, index) {
+    var entry = entries[+index];
+    return entry.activity !== prevEntry.activity || entry.renderActivity !== prevEntry.renderActivity;
+  })) {
+    prevEntriesRef.current = entries;
+  }
+
+  return prevEntriesRef.current;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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