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

package/lib/index.d.ts

@@ -0,0 +1,330 @@
+/// <reference types="node" />
+import { hooks as apiHooks, concatMiddleware, localize } from 'botframework-webchat-api';
+import { type WebChatActivity } from 'botframework-webchat-core';
+import ReactWebChat, { ReactWebChatProps } from './ReactWebChat';
+import { ComposerProps } from './Composer';
+import { BasicWebChatProps } from './BasicWebChat';
+import createCoreAttachmentMiddleware from './Attachment/createMiddleware';
+import createCoreActivityMiddleware from './Middleware/Activity/createCoreMiddleware';
+import createCoreActivityStatusMiddleware from './Middleware/ActivityStatus/createCoreMiddleware';
+import createStyleSet from './Styles/createStyleSet';
+import getTabIndex from './Utils/TypeFocusSink/getTabIndex';
+import Context from './hooks/internal/WebChatUIContext';
+import withEmoji from './withEmoji/withEmoji';
+import * as componentHooks from './hooks/index';
+export { type SendBoxFocusOptions } from './hooks/index';
+declare const hooks: {
+    useDictateAbortable: typeof componentHooks.useDictateAbortable;
+    useFocus: typeof componentHooks.useFocus;
+    useMakeThumbnail: typeof componentHooks.useMakeThumbnail;
+    useMicrophoneButtonClick: typeof componentHooks.useMicrophoneButtonClick;
+    useMicrophoneButtonDisabled: typeof componentHooks.useMicrophoneButtonDisabled;
+    useObserveScrollPosition: typeof componentHooks.useObserveScrollPosition;
+    useObserveTranscriptFocus: typeof componentHooks.useObserveTranscriptFocus;
+    useRegisterFocusSendBox: (listener: (value: componentHooks.SendBoxFocusOptions) => void) => void;
+    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;
+    useSendMessage: typeof componentHooks.useSendMessage;
+    useStyleSet: typeof componentHooks.useStyleSet;
+    useTextBoxSubmit: typeof componentHooks.useTextBoxSubmit;
+    useTextBoxValue: typeof componentHooks.useTextBoxValue;
+    useTypingIndicatorVisible: typeof componentHooks.useTypingIndicatorVisible;
+    useWebSpeechPonyfill: typeof componentHooks.useWebSpeechPonyfill;
+    useActiveTyping: (expireAfter?: number) => readonly [Readonly<Record<string, import("botframework-webchat-api").Typing>>];
+    useActivities: () => [WebChatActivity[]];
+    useActivityKeys: () => readonly [readonly string[]];
+    useActivityKeysByRead: () => readonly [readonly string[], readonly string[]];
+    useAvatarForBot: () => [{
+        image: string;
+        initials: string;
+    }];
+    useAvatarForUser: () => [{
+        image: string;
+        initials: string;
+    }];
+    useByteFormatter: () => (bytes: number) => string;
+    useConnectivityStatus: () => [string];
+    useCreateActivityRenderer: () => import("botframework-webchat-api").ActivityComponentFactory;
+    useCreateActivityStatusRenderer: () => import("botframework-webchat-api").ActivityStatusRenderer;
+    useCreateAttachmentForScreenReaderRenderer: () => import("botframework-webchat-api").AttachmentForScreenReaderComponentFactory;
+    useCreateAvatarRenderer: () => ({ activity }: {
+        activity: WebChatActivity;
+    }) => false | (() => import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal);
+    useCreateScrollToEndButtonRenderer: () => import("botframework-webchat-api").ScrollToEndButtonComponentFactory;
+    useDateFormatter: () => (date: string | number | Date) => string;
+    useDebouncedNotifications: () => [import("botframework-webchat-api").DebouncedNotifications];
+    useDictateInterims: () => [string[], (interims: string[]) => void];
+    useDictateState: () => [number];
+    useDirection: () => ["auto" | "ltr" | "rtl"];
+    useDisabled: () => [boolean];
+    useDismissNotification: () => (id: string) => void;
+    useEmitTypingIndicator: () => () => void;
+    useGetActivitiesByKey: () => (key?: string) => readonly WebChatActivity[];
+    useGetActivityByKey: () => (key?: string) => WebChatActivity;
+    useGetHasAcknowledgedByActivityKey: typeof apiHooks.useGetHasAcknowledgedByActivityKey;
+    useGetKeyByActivity: () => (activity?: WebChatActivity) => string;
+    useGetKeyByActivityId: () => (activityId?: string) => string;
+    useGetSendTimeoutForActivity: () => ({ activity }: {
+        activity: WebChatActivity;
+    }) => number;
+    useGrammars: () => [any];
+    useGroupActivities: () => ({ activities }: {
+        activities: WebChatActivity[];
+    }) => {
+        sender: WebChatActivity[][];
+        status: WebChatActivity[][];
+    };
+    useGroupTimestamp: () => [number | boolean];
+    useLanguage: (options?: "speech") => [string];
+    useLastAcknowledgedActivityKey: () => readonly [string];
+    useLastReadActivityKey: () => readonly [string];
+    useLocalizer: ({ plural }?: {
+        plural?: boolean;
+    }) => (id: string | {
+        zero?: string;
+        one?: string;
+        two?: string;
+        few?: string;
+        many?: string;
+        other: string;
+    }, args_0?: string | number, ...args_1: string[]) => any;
+    useMarkActivityAsSpoken: () => (activity: WebChatActivity) => void;
+    useMarkActivityKeyAsRead: () => (activityKey: string) => void;
+    useMarkAllAsAcknowledged: () => () => void;
+    useNotifications: () => [import("botframework-webchat-api").Notification[]];
+    usePerformCardAction: () => import("botframework-webchat-api").PerformCardAction;
+    usePonyfill: () => readonly [{
+        cancelAnimationFrame?: typeof cancelAnimationFrame;
+        cancelIdleCallback?: typeof cancelIdleCallback;
+        clearImmediate?: typeof clearImmediate;
+        clearInterval: typeof clearInterval;
+        clearTimeout: typeof clearTimeout;
+        Date: DateConstructor;
+        requestAnimationFrame?: typeof requestAnimationFrame;
+        requestIdleCallback?: typeof requestIdleCallback;
+        setImmediate?: typeof setImmediate;
+        setInterval: typeof setInterval;
+        setTimeout: typeof setTimeout;
+    }];
+    usePostActivity: () => (activity: WebChatActivity) => import("botframework-webchat-core").Observable<string>;
+    useReferenceGrammarID: () => [string];
+    useRelativeTimeFormatter: () => (dateOrString: string | Date) => string;
+    useRenderAttachment: () => import("botframework-webchat-api").RenderAttachment;
+    useRenderToast: () => import("botframework-webchat-api").RenderToast;
+    useRenderTypingIndicator: () => import("botframework-webchat-api").RenderTypingIndicator;
+    useSendBoxAttachments: () => readonly [readonly Readonly<{
+        blob: Blob | File;
+        thumbnailURL?: URL;
+    }>[], (attachments: readonly Readonly<{
+        blob: Blob | File;
+        thumbnailURL?: URL;
+    }>[]) => void];
+    useSendBoxValue: () => [string, (value: string) => void];
+    useSendEvent: () => (name: string, value: any) => void;
+    useSendMessageBack: () => (value: any, text?: string, displayText?: string) => void;
+    useSendPostBack: () => (value?: any) => void;
+    useSendStatusByActivityKey: typeof apiHooks.useSendStatusByActivityKey;
+    useSendTimeoutForActivity: (activity: WebChatActivity) => number;
+    useSendTypingIndicator: () => [boolean];
+    useSetNotification: () => (notification: import("botframework-webchat-api").Notification) => void;
+    useShouldSpeakIncomingActivity: () => [boolean, (value: boolean) => void];
+    useStartDictate: () => () => void;
+    useStopDictate: () => () => void;
+    useStyleOptions: () => [import("botframework-webchat-api").StrictStyleOptions];
+    useSubmitSendBox: () => (method?: string, { channelData }?: {
+        channelData: any;
+    }) => void;
+    useSuggestedActions: () => [import("botframework-webchat-core").DirectLineCardAction[], (suggestedActions: never[]) => void];
+    useTimeoutForSend: () => [number | ((activity: WebChatActivity) => number)];
+    useTrackDimension: () => (name: string, data: any) => void;
+    useTrackEvent: () => {
+        (name: string, data: any): void;
+        debug: (name: string, data: any) => void;
+        error: (name: string, data: any) => void;
+        info: (name: string, data: any) => void;
+        warn: (name: string, data: any) => void;
+    };
+    useTrackException: () => (error: Error, fatal: boolean) => void;
+    useTrackTiming: <T>() => (name: string, functionOrPromise: (() => T) | Promise<T>) => Promise<T>;
+    useUserID: () => [string];
+    useUsername: () => [string];
+    useVoiceSelector: (activity: any) => (voices: {
+        new (): SpeechSynthesisVoice;
+        prototype: SpeechSynthesisVoice;
+    }[]) => {
+        new (): SpeechSynthesisVoice;
+        prototype: SpeechSynthesisVoice;
+    };
+};
+declare const version: string;
+declare const buildInfo: {
+    buildTool: string;
+    moduleFormat: string;
+    version: string;
+};
+declare const Components: {
+    BasicWebChat: import("react").FC<BasicWebChatProps>;
+    Composer: {
+        ({ activityMiddleware, activityStatusMiddleware, attachmentForScreenReaderMiddleware, attachmentMiddleware, avatarMiddleware, cardActionMiddleware, children, extraStyleSet, renderMarkdown, scrollToEndButtonMiddleware, sendBoxMiddleware: sendBoxMiddlewareFromProps, sendBoxToolbarMiddleware: sendBoxToolbarMiddlewareFromProps, styleOptions, styleSet, suggestedActionsAccessKey, toastMiddleware, typingIndicatorMiddleware, webSpeechPonyfillFactory, ...composerProps }: ComposerProps): import("react").JSX.Element;
+        defaultProps: {
+            children: any;
+            extraStyleSet: any;
+            nonce: any;
+            renderMarkdown: any;
+            styleSet: any;
+            suggestedActionsAccessKey: string;
+            webSpeechPonyfillFactory: any;
+            internalRenderErrorBox: any;
+            onTelemetry: any;
+            ponyfill: any;
+            store: any;
+        };
+        propTypes: {
+            children: import("prop-types").Requireable<any>;
+            extraStyleSet: import("prop-types").Requireable<any>;
+            nonce: import("prop-types").Requireable<string>;
+            renderMarkdown: import("prop-types").Requireable<(...args: any[]) => any>;
+            styleSet: import("prop-types").Requireable<any>;
+            suggestedActionsAccessKey: import("prop-types").Requireable<NonNullable<string | boolean>>;
+            webSpeechPonyfillFactory: import("prop-types").Requireable<(...args: any[]) => any>;
+            internalRenderErrorBox: import("prop-types").Requireable<any>;
+            onTelemetry: import("prop-types").Requireable<(...args: any[]) => any>;
+            ponyfill: import("prop-types").Requireable<any>;
+            store: import("prop-types").Requireable<any>;
+        };
+    };
+    ThemeProvider: import("react").MemoExoticComponent<({ children, activityMiddleware, activityStatusMiddleware, attachmentForScreenReaderMiddleware, attachmentMiddleware, avatarMiddleware, cardActionMiddleware, groupActivitiesMiddleware, scrollToEndButtonMiddleware, sendBoxMiddleware, sendBoxToolbarMiddleware, styleOptions, toastMiddleware, typingIndicatorMiddleware }: Readonly<{
+        children?: import("react").ReactNode;
+    } & Partial<import("./providers/Theme/private/Context").ContextType>>) => import("react").JSX.Element>;
+    AccessKeySinkSurface: any;
+    BasicConnectivityStatus: any;
+    BasicSendBox: import("react").FC<Readonly<{
+        className?: string;
+    }>>;
+    BasicSendBoxToolbar: import("react").MemoExoticComponent<({ className }: {
+        className?: string;
+    }) => import("react").JSX.Element>;
+    BasicToaster: any;
+    BasicTranscript: import("react").NamedExoticComponent<{
+        className?: string;
+    }>;
+    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<Readonly<{
+        activity: WebChatActivity;
+        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").NamedExoticComponent<{
+        '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: WebChatActivity;
+        sendStatus: import("./types/internal/SendStatus").SendStatus;
+    }>;
+    SpeakActivity: import("react").NamedExoticComponent<{
+        activity: WebChatActivity;
+    }>;
+    Timestamp: import("react").FC<{
+        timestamp: string;
+    }>;
+    DictationInterims: import("react").FC<{
+        className?: string;
+    }>;
+    MicrophoneButton: import("react").FC<{
+        className?: string;
+    }>;
+    SendButton: import("react").FC<{
+        className?: string;
+    }>;
+    SendTextBox: ({ className }: Readonly<{
+        className?: string;
+    }>) => import("react").JSX.Element;
+    SuggestedActions: ({ className }: Readonly<{
+        className?: string;
+    }>) => import("react").JSX.Element;
+    UploadButton: import("react").FC<{
+        className?: string;
+    }>;
+    LocalizedString: import("react").MemoExoticComponent<(props: Readonly<{
+        className?: string;
+        linkClassName?: string;
+        onDecorateLink?: (href: string, textContent: string) => import("./Utils/betterLinks").LinkOptions;
+    }> & (Readonly<{
+        stringIds: {
+            zero?: string;
+            one?: string;
+            two?: string;
+            few?: string;
+            many?: string;
+            other: string;
+        };
+        values: readonly [number, ...(string | number)[]];
+    }> | Readonly<{
+        stringIds: string;
+        values?: readonly (string | number)[];
+    }>)) => import("react").JSX.Element>;
+};
+export default ReactWebChat;
+export { Components, Context, buildInfo, concatMiddleware, createCoreActivityMiddleware, createCoreActivityStatusMiddleware, createCoreAttachmentMiddleware, createStyleSet, getTabIndex, hooks, localize, version, withEmoji };
+export type { BasicWebChatProps, ComposerProps, ReactWebChatProps, WebChatActivity };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,IAAI,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,YAAY,EAAE,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOrD,OAAqB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA6BjE,OAAO,8BAA8B,MAAM,+BAA+B,CAAC;AAC3E,OAAO,4BAA4B,MAAM,4CAA4C,CAAC;AACtF,OAAO,kCAAkC,MAAM,kDAAkD,CAAC;AAClG,OAAO,cAAc,MAAM,yBAAyB,CAAC;AACrD,OAAO,WAAW,MAAM,mCAAmC,CAAC;AAC5D,OAAO,OAAO,MAAM,mCAAmC,CAAC;AAExD,OAAO,SAAS,MAAM,uBAAuB,CAAC;AAE9C,OAAO,KAAK,cAAc,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGV,CAAC;AAIF,QAAA,MAAM,OAAO,QAAkC,CAAC;AAEhD,QAAA,MAAM,SAAS;;;;CAAuC,CAAC;AAEvD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCf,CAAC;AAEF,eAAe,YAAY,CAAC;AAE5B,OAAO,EACL,UAAU,EACV,OAAO,EACP,SAAS,EACT,gBAAgB,EAChB,4BAA4B,EAC5B,kCAAkC,EAClC,8BAA8B,EAC9B,cAAc,EACd,WAAW,EACX,KAAK,EACL,QAAQ,EACR,OAAO,EACP,SAAS,EACV,CAAC;AAEF,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC"}

package/lib/index.js

@@ -0,0 +1,164 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Components = void 0;
+Object.defineProperty(exports, "Context", {
+  enumerable: true,
+  get: function get() {
+    return _WebChatUIContext.default;
+  }
+});
+exports.buildInfo = void 0;
+Object.defineProperty(exports, "concatMiddleware", {
+  enumerable: true,
+  get: function get() {
+    return _botframeworkWebchatApi.concatMiddleware;
+  }
+});
+Object.defineProperty(exports, "createCoreActivityMiddleware", {
+  enumerable: true,
+  get: function get() {
+    return _createCoreMiddleware.default;
+  }
+});
+Object.defineProperty(exports, "createCoreActivityStatusMiddleware", {
+  enumerable: true,
+  get: function get() {
+    return _createCoreMiddleware2.default;
+  }
+});
+Object.defineProperty(exports, "createCoreAttachmentMiddleware", {
+  enumerable: true,
+  get: function get() {
+    return _createMiddleware.default;
+  }
+});
+Object.defineProperty(exports, "createStyleSet", {
+  enumerable: true,
+  get: function get() {
+    return _createStyleSet.default;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "getTabIndex", {
+  enumerable: true,
+  get: function get() {
+    return _getTabIndex.default;
+  }
+});
+exports.hooks = void 0;
+Object.defineProperty(exports, "localize", {
+  enumerable: true,
+  get: function get() {
+    return _botframeworkWebchatApi.localize;
+  }
+});
+exports.version = void 0;
+Object.defineProperty(exports, "withEmoji", {
+  enumerable: true,
+  get: function get() {
+    return _withEmoji.default;
+  }
+});
+var _botframeworkWebchatApi = require("botframework-webchat-api");
+var _ReactWebChat = _interopRequireDefault(require("./ReactWebChat"));
+var _Composer = _interopRequireDefault(require("./Composer"));
+var _Surface = _interopRequireDefault(require("./Utils/AccessKeySink/Surface"));
+var _BasicConnectivityStatus = _interopRequireDefault(require("./BasicConnectivityStatus"));
+var _BasicToaster = _interopRequireDefault(require("./BasicToaster"));
+var _BasicTranscript = _interopRequireDefault(require("./BasicTranscript"));
+var _BasicWebChat = _interopRequireDefault(require("./BasicWebChat"));
+var _BasicSendBox = _interopRequireDefault(require("./SendBox/BasicSendBox"));
+var _BasicSendBoxToolbar = _interopRequireDefault(require("./SendBoxToolbar/BasicSendBoxToolbar"));
+var _Avatar = _interopRequireDefault(require("./Activity/Avatar"));
+var _Bubble = _interopRequireDefault(require("./Activity/Bubble"));
+var _Speak = _interopRequireDefault(require("./Activity/Speak"));
+var _SendStatus = _interopRequireDefault(require("./ActivityStatus/SendStatus/SendStatus"));
+var _Timestamp = _interopRequireDefault(require("./ActivityStatus/Timestamp"));
+var _ErrorBox = _interopRequireDefault(require("./ErrorBox"));
+var _LocalizedString = _interopRequireDefault(require("./Utils/LocalizedString"));
+var _AudioContent = _interopRequireDefault(require("./Attachment/AudioContent"));
+var _FileContent = _interopRequireDefault(require("./Attachment/FileContent"));
+var _HTMLVideoContent = _interopRequireDefault(require("./Attachment/HTMLVideoContent"));
+var _ImageContent = _interopRequireDefault(require("./Attachment/ImageContent"));
+var _TextContent = _interopRequireDefault(require("./Attachment/Text/TextContent"));
+var _VideoContent = _interopRequireDefault(require("./Attachment/VideoContent"));
+var _VimeoContent = _interopRequireDefault(require("./Attachment/VimeoContent"));
+var _YouTubeContent = _interopRequireDefault(require("./Attachment/YouTubeContent"));
+var _DictationInterims = _interopRequireDefault(require("./SendBox/DictationInterims"));
+var _MicrophoneButton = _interopRequireDefault(require("./SendBox/MicrophoneButton"));
+var _SendButton = _interopRequireDefault(require("./SendBox/SendButton"));
+var _SuggestedActions = _interopRequireDefault(require("./SendBox/SuggestedActions"));
+var _TextBox = _interopRequireDefault(require("./SendBox/TextBox"));
+var _UploadButton = _interopRequireDefault(require("./SendBoxToolbar/UploadButton"));
+var _createMiddleware = _interopRequireDefault(require("./Attachment/createMiddleware"));
+var _createCoreMiddleware = _interopRequireDefault(require("./Middleware/Activity/createCoreMiddleware"));
+var _createCoreMiddleware2 = _interopRequireDefault(require("./Middleware/ActivityStatus/createCoreMiddleware"));
+var _createStyleSet = _interopRequireDefault(require("./Styles/createStyleSet"));
+var _getTabIndex = _interopRequireDefault(require("./Utils/TypeFocusSink/getTabIndex"));
+var _WebChatUIContext = _interopRequireDefault(require("./hooks/internal/WebChatUIContext"));
+var _ThemeProvider = _interopRequireDefault(require("./providers/Theme/ThemeProvider"));
+var _withEmoji = _interopRequireDefault(require("./withEmoji/withEmoji"));
+var componentHooks = _interopRequireWildcard(require("./hooks/index"));
+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 _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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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);
+exports.hooks = hooks;
+var buildTool = "babel";
+var moduleFormat = "commonjs";
+var version = "4.18.2";
+exports.version = version;
+var buildInfo = {
+  buildTool: buildTool,
+  moduleFormat: moduleFormat,
+  version: version
+};
+exports.buildInfo = buildInfo;
+var Components = {
+  BasicWebChat: _BasicWebChat.default,
+  Composer: _Composer.default,
+  ThemeProvider: _ThemeProvider.default,
+  // Components for restructuring BasicWebChat
+  AccessKeySinkSurface: _Surface.default,
+  BasicConnectivityStatus: _BasicConnectivityStatus.default,
+  BasicSendBox: _BasicSendBox.default,
+  BasicSendBoxToolbar: _BasicSendBoxToolbar.default,
+  BasicToaster: _BasicToaster.default,
+  BasicTranscript: _BasicTranscript.default,
+  // Components for recomposing activities and attachments
+  AudioContent: _AudioContent.default,
+  FileContent: _FileContent.default,
+  HTMLVideoContent: _HTMLVideoContent.default,
+  ImageContent: _ImageContent.default,
+  TextContent: _TextContent.default,
+  VideoContent: _VideoContent.default,
+  VimeoContent: _VimeoContent.default,
+  YouTubeContent: _YouTubeContent.default,
+  // Components for recomposing transcript
+  Avatar: _Avatar.default,
+  Bubble: _Bubble.default,
+  ErrorBox: _ErrorBox.default,
+  SendStatus: _SendStatus.default,
+  SpeakActivity: _Speak.default,
+  Timestamp: _Timestamp.default,
+  // Components for recomposing send box
+  DictationInterims: _DictationInterims.default,
+  MicrophoneButton: _MicrophoneButton.default,
+  SendButton: _SendButton.default,
+  SendTextBox: _TextBox.default,
+  SuggestedActions: _SuggestedActions.default,
+  UploadButton: _UploadButton.default,
+  // Components for localization
+  LocalizedString: _LocalizedString.default
+};
+exports.Components = Components;
+var _default = _ReactWebChat.default;
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_botframeworkWebchatApi","require","_ReactWebChat","_interopRequireDefault","_Composer","_Surface","_BasicConnectivityStatus","_BasicToaster","_BasicTranscript","_BasicWebChat","_BasicSendBox","_BasicSendBoxToolbar","_Avatar","_Bubble","_Speak","_SendStatus","_Timestamp","_ErrorBox","_LocalizedString","_AudioContent","_FileContent","_HTMLVideoContent","_ImageContent","_TextContent","_VideoContent","_VimeoContent","_YouTubeContent","_DictationInterims","_MicrophoneButton","_SendButton","_SuggestedActions","_TextBox","_UploadButton","_createMiddleware","_createCoreMiddleware","_createCoreMiddleware2","_createStyleSet","_getTabIndex","_WebChatUIContext","_ThemeProvider","_withEmoji","componentHooks","_interopRequireWildcard","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","value","configurable","writable","hooks","apiHooks","exports","buildTool","moduleFormat","version","buildInfo","Components","BasicWebChat","Composer","ThemeProvider","AccessKeySinkSurface","BasicConnectivityStatus","BasicSendBox","BasicSendBoxToolbar","BasicToaster","BasicTranscript","AudioContent","FileContent","HTMLVideoContent","ImageContent","TextContent","VideoContent","VimeoContent","YouTubeContent","Avatar","Bubble","ErrorBox","SendStatus","SpeakActivity","Timestamp","DictationInterims","MicrophoneButton","SendButton","SendTextBox","SuggestedActions","UploadButton","LocalizedString","_default","ReactWebChat"],"sourceRoot":"component:///","sources":["../src/index.ts"],"sourcesContent":["import { hooks as apiHooks, concatMiddleware, localize } from 'botframework-webchat-api';\nimport { type WebChatActivity } from 'botframework-webchat-core';\n\nimport ReactWebChat, { ReactWebChatProps } from './ReactWebChat';\n\nimport Composer, { ComposerProps } from './Composer';\n\nimport AccessKeySinkSurface from './Utils/AccessKeySink/Surface';\n\nimport BasicConnectivityStatus from './BasicConnectivityStatus';\nimport BasicToaster from './BasicToaster';\nimport BasicTranscript from './BasicTranscript';\nimport BasicWebChat, { BasicWebChatProps } from './BasicWebChat';\nimport BasicSendBox from './SendBox/BasicSendBox';\nimport BasicSendBoxToolbar from './SendBoxToolbar/BasicSendBoxToolbar';\n\nimport Avatar from './Activity/Avatar';\nimport Bubble from './Activity/Bubble';\nimport SpeakActivity from './Activity/Speak';\nimport SendStatus from './ActivityStatus/SendStatus/SendStatus';\nimport Timestamp from './ActivityStatus/Timestamp';\nimport ErrorBox from './ErrorBox';\n\nimport LocalizedString from './Utils/LocalizedString';\n\nimport AudioContent from './Attachment/AudioContent';\nimport FileContent from './Attachment/FileContent';\nimport HTMLVideoContent from './Attachment/HTMLVideoContent';\nimport ImageContent from './Attachment/ImageContent';\nimport TextContent from './Attachment/Text/TextContent';\nimport VideoContent from './Attachment/VideoContent';\nimport VimeoContent from './Attachment/VimeoContent';\nimport YouTubeContent from './Attachment/YouTubeContent';\n\nimport DictationInterims from './SendBox/DictationInterims';\nimport MicrophoneButton from './SendBox/MicrophoneButton';\nimport SendButton from './SendBox/SendButton';\nimport SuggestedActions from './SendBox/SuggestedActions';\nimport SendTextBox from './SendBox/TextBox';\nimport UploadButton from './SendBoxToolbar/UploadButton';\n\nimport createCoreAttachmentMiddleware from './Attachment/createMiddleware';\nimport createCoreActivityMiddleware from './Middleware/Activity/createCoreMiddleware';\nimport createCoreActivityStatusMiddleware from './Middleware/ActivityStatus/createCoreMiddleware';\nimport createStyleSet from './Styles/createStyleSet';\nimport getTabIndex from './Utils/TypeFocusSink/getTabIndex';\nimport Context from './hooks/internal/WebChatUIContext';\nimport ThemeProvider from './providers/Theme/ThemeProvider';\nimport withEmoji from './withEmoji/withEmoji';\n\nimport * as componentHooks from './hooks/index';\n\nexport { type SendBoxFocusOptions } from './hooks/index';\n\nconst hooks = {\n  ...apiHooks,\n  ...componentHooks\n};\n\nconst buildTool = process.env.build_tool;\nconst moduleFormat = process.env.module_format;\nconst version = process.env.npm_package_version;\n\nconst buildInfo = { buildTool, moduleFormat, version };\n\nconst Components = {\n  BasicWebChat,\n  Composer,\n  ThemeProvider,\n\n  // Components for restructuring BasicWebChat\n  AccessKeySinkSurface,\n  BasicConnectivityStatus,\n  BasicSendBox,\n  BasicSendBoxToolbar,\n  BasicToaster,\n  BasicTranscript,\n\n  // Components for recomposing activities and attachments\n  AudioContent,\n  FileContent,\n  HTMLVideoContent,\n  ImageContent,\n  TextContent,\n  VideoContent,\n  VimeoContent,\n  YouTubeContent,\n\n  // Components for recomposing transcript\n  Avatar,\n  Bubble,\n  ErrorBox,\n  SendStatus,\n  SpeakActivity,\n  Timestamp,\n\n  // Components for recomposing send box\n  DictationInterims,\n  MicrophoneButton,\n  SendButton,\n  SendTextBox,\n  SuggestedActions,\n  UploadButton,\n\n  // Components for localization\n  LocalizedString\n};\n\nexport default ReactWebChat;\n\nexport {\n  Components,\n  Context,\n  buildInfo,\n  concatMiddleware,\n  createCoreActivityMiddleware,\n  createCoreActivityStatusMiddleware,\n  createCoreAttachmentMiddleware,\n  createStyleSet,\n  getTabIndex,\n  hooks,\n  localize,\n  version,\n  withEmoji\n};\n\nexport type { BasicWebChatProps, ComposerProps, ReactWebChatProps, WebChatActivity };\n"],"mappings":"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"}

package/lib/internal.d.ts

@@ -0,0 +1,4 @@
+import parseDocumentFromString from './Utils/parseDocumentFromString';
+import serializeDocumentIntoString from './Utils/serializeDocumentIntoString';
+export { parseDocumentFromString, serializeDocumentIntoString };
+//# sourceMappingURL=internal.d.ts.map

package/lib/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA,OAAO,uBAAuB,MAAM,iCAAiC,CAAC;AACtE,OAAO,2BAA2B,MAAM,qCAAqC,CAAC;AAE9E,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,CAAC"}

package/lib/internal.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "parseDocumentFromString", {
+  enumerable: true,
+  get: function get() {
+    return _parseDocumentFromString.default;
+  }
+});
+Object.defineProperty(exports, "serializeDocumentIntoString", {
+  enumerable: true,
+  get: function get() {
+    return _serializeDocumentIntoString.default;
+  }
+});
+var _parseDocumentFromString = _interopRequireDefault(require("./Utils/parseDocumentFromString"));
+var _serializeDocumentIntoString = _interopRequireDefault(require("./Utils/serializeDocumentIntoString"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcGFyc2VEb2N1bWVudEZyb21TdHJpbmciLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9zZXJpYWxpemVEb2N1bWVudEludG9TdHJpbmciLCJvYmoiLCJfX2VzTW9kdWxlIiwiZGVmYXVsdCJdLCJzb3VyY2VSb290IjoiY29tcG9uZW50Oi8vLyIsInNvdXJjZXMiOlsiLi4vc3JjL2ludGVybmFsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBwYXJzZURvY3VtZW50RnJvbVN0cmluZyBmcm9tICcuL1V0aWxzL3BhcnNlRG9jdW1lbnRGcm9tU3RyaW5nJztcbmltcG9ydCBzZXJpYWxpemVEb2N1bWVudEludG9TdHJpbmcgZnJvbSAnLi9VdGlscy9zZXJpYWxpemVEb2N1bWVudEludG9TdHJpbmcnO1xuXG5leHBvcnQgeyBwYXJzZURvY3VtZW50RnJvbVN0cmluZywgc2VyaWFsaXplRG9jdW1lbnRJbnRvU3RyaW5nIH07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsSUFBQUEsd0JBQUEsR0FBQUMsc0JBQUEsQ0FBQUMsT0FBQTtBQUNBLElBQUFDLDRCQUFBLEdBQUFGLHNCQUFBLENBQUFDLE9BQUE7QUFBOEUsU0FBQUQsdUJBQUFHLEdBQUEsV0FBQUEsR0FBQSxJQUFBQSxHQUFBLENBQUFDLFVBQUEsR0FBQUQsR0FBQSxLQUFBRSxPQUFBLEVBQUFGLEdBQUEifQ==

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

@@ -0,0 +1,7 @@
+import React, { type ReactNode } from 'react';
+type ActivityTreeComposerProps = Readonly<{
+    children?: ReactNode | undefined;
+}>;
+declare const ActivityTreeComposer: ({ children }: ActivityTreeComposerProps) => React.JSX.Element;
+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":"AAEA,OAAO,KAAK,EAAE,EAAW,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAWvD,KAAK,yBAAyB,GAAG,QAAQ,CAAC;IAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;CAAE,CAAC,CAAC;AAIhF,QAAA,MAAM,oBAAoB,iBAAkB,yBAAyB,sBAsEpE,CAAC;AAEF,eAAe,oBAAoB,CAAC"}