botframework-webchat-component 4.14.0 → 4.15.1

package/lib/Styles/StyleSet/CarouselFilmStrip.js

@@ -9,7 +9,7 @@ var _mirrorStyle = _interopRequireDefault(require("../mirrorStyle"));
 
 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; }
 
@@ -93,4 +93,4 @@ function CarouselFilmStrip(_ref) {
     }))
   };
 }
-//# 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/Styles/StyleSet/CarouselFilmStripAttachment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CarouselFilmStripAttachment.d.ts","sourceRoot":"","sources":["../../../src/Styles/StyleSet/CarouselFilmStripAttachment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAI9D,MAAM,CAAC,OAAO,UAAU,2BAA2B,CAAC,EAClD,UAAU,EACV,cAAc,EACd,cAAc,EACd,cAAc,EACd,sCAAsC,EACtC,sCAAsC,EACtC,sCAAsC,EACtC,kBAAkB,EACnB,EAAE,kBAAkB,OAyCpB"}
+{"version":3,"file":"CarouselFilmStripAttachment.d.ts","sourceRoot":"","sources":["../../../src/Styles/StyleSet/CarouselFilmStripAttachment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAI9D,MAAM,CAAC,OAAO,UAAU,2BAA2B,CAAC,EAClD,UAAU,EACV,cAAc,EACd,cAAc,EACd,cAAc,EACd,sCAAsC,EACtC,sCAAsC,EACtC,sCAAsC,EACtC,kBAAkB,EACnB,EAAE,kBAAkB,OA0CpB"}

package/lib/Styles/StyleSet/CarouselFilmStripAttachment.js

@@ -9,7 +9,7 @@ var _mirrorStyle = _interopRequireDefault(require("../mirrorStyle"));
 
 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; }
 
@@ -60,4 +60,4 @@ function CarouselFilmStripAttachment(_ref) {
     }
   }));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9TdHlsZXMvU3R5bGVTZXQvQ2Fyb3VzZWxGaWxtU3RyaXBBdHRhY2htZW50LnRzIl0sIm5hbWVzIjpbIkNhcm91c2VsRmlsbVN0cmlwQXR0YWNobWVudCIsImF2YXRhclNpemUiLCJidWJibGVNYXhXaWR0aCIsImJ1YmJsZU1pbldpZHRoIiwicGFkZGluZ1JlZ3VsYXIiLCJ0cmFuc2NyaXB0VmlzdWFsS2V5Ym9hcmRJbmRpY2F0b3JDb2xvciIsInRyYW5zY3JpcHRWaXN1YWxLZXlib2FyZEluZGljYXRvclN0eWxlIiwidHJhbnNjcmlwdFZpc3VhbEtleWJvYXJkSW5kaWNhdG9yV2lkdGgiLCJ0cmFuc2l0aW9uRHVyYXRpb24iLCJtaW5XaWR0aCIsIm1heFdpZHRoIiwidHJhbnNpdGlvblByb3BlcnR5Iiwib3V0bGluZSIsImJvcmRlckNvbG9yIiwiYm9yZGVyU3R5bGUiLCJib3JkZXJXaWR0aCIsImJveFNpemluZyIsImhlaWdodCIsImxlZnQiLCJwb2ludGVyRXZlbnRzIiwicG9zaXRpb24iLCJ0b3AiLCJ3aWR0aCIsInBhZGRpbmdMZWZ0Il0sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBR0E7Ozs7Ozs7Ozs7QUFFZSxTQUFTQSwyQkFBVCxPQVNRO0FBQUEsTUFSckJDLFVBUXFCLFFBUnJCQSxVQVFxQjtBQUFBLE1BUHJCQyxjQU9xQixRQVByQkEsY0FPcUI7QUFBQSxNQU5yQkMsY0FNcUIsUUFOckJBLGNBTXFCO0FBQUEsTUFMckJDLGNBS3FCLFFBTHJCQSxjQUtxQjtBQUFBLE1BSnJCQyxzQ0FJcUIsUUFKckJBLHNDQUlxQjtBQUFBLE1BSHJCQyxzQ0FHcUIsUUFIckJBLHNDQUdxQjtBQUFBLE1BRnJCQyxzQ0FFcUIsUUFGckJBLHNDQUVxQjtBQUFBLE1BRHJCQyxrQkFDcUIsUUFEckJBLGtCQUNxQjtBQUNyQjtBQUNFLGdEQUE0QztBQUMxQ0MsTUFBQUEsUUFBUSxFQUFFTixjQURnQztBQUUxQ08sTUFBQUEsUUFBUSxFQUFFUixjQUZnQztBQUcxQ00sTUFBQUEsa0JBQWtCLEVBQWxCQSxrQkFIMEM7QUFJMUNHLE1BQUFBLGtCQUFrQixFQUFFLHNCQUpzQjtBQU0xQyxpQkFBVztBQUNUQyxRQUFBQSxPQUFPLEVBQUU7QUFEQSxPQU4rQjtBQVUxQyxnRUFBMEQ7QUFDeERDLFFBQUFBLFdBQVcsRUFBRVIsc0NBRDJDO0FBRXhEUyxRQUFBQSxXQUFXLEVBQUVSLHNDQUYyQztBQUd4RFMsUUFBQUEsV0FBVyxFQUFFUixzQ0FIMkM7QUFJeERTLFFBQUFBLFNBQVMsRUFBRSxZQUo2QztBQUt4REMsUUFBQUEsTUFBTSx3QkFBaUJWLHNDQUFqQixRQUxrRDtBQU14RFcsUUFBQUEsSUFBSSxFQUFFLENBTmtEO0FBT3hEQyxRQUFBQSxhQUFhLEVBQUUsTUFQeUM7QUFReERDLFFBQUFBLFFBQVEsRUFBRSxVQVI4QztBQVN4REMsUUFBQUEsR0FBRyxFQUFFLENBVG1EO0FBVXhEQyxRQUFBQSxLQUFLLHdCQUFpQmYsc0NBQWpCO0FBVm1EO0FBVmhCO0FBRDlDLEtBd0JLLDBCQUFZLCtDQUFaLEVBQTZEO0FBQzlEZ0IsSUFBQUEsV0FBVyxFQUFFbkIsY0FEaUQ7QUFHOUQsb0hBQWdIO0FBQzlHLHVCQUFpQjtBQUNmbUIsUUFBQUEsV0FBVyxFQUFFdEIsVUFBVSxHQUFHRyxjQUFjLEdBQUc7QUFENUI7QUFENkYsS0FIbEQ7QUFTOUQsOEdBQTBHO0FBQ3hHLHFJQUErSDtBQUM3SG1CLFFBQUFBLFdBQVcsRUFBRW5CLGNBQWMsR0FBRztBQUQrRjtBQUR2QjtBQVQ1QyxHQUE3RCxDQXhCTDtBQXdDRCIsInNvdXJjZVJvb3QiOiJjb21wb25lbnQ6Ly8vIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50IG5vLW1hZ2ljLW51bWJlcnM6IFtcImVycm9yXCIsIHsgXCJpZ25vcmVcIjogWzJdIH1dICovXG5pbXBvcnQgeyBTdHJpY3RTdHlsZU9wdGlvbnMgfSBmcm9tICdib3RmcmFtZXdvcmstd2ViY2hhdC1hcGknO1xuXG5pbXBvcnQgbWlycm9yU3R5bGUgZnJvbSAnLi4vbWlycm9yU3R5bGUnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBDYXJvdXNlbEZpbG1TdHJpcEF0dGFjaG1lbnQoe1xuICBhdmF0YXJTaXplLFxuICBidWJibGVNYXhXaWR0aCxcbiAgYnViYmxlTWluV2lkdGgsXG4gIHBhZGRpbmdSZWd1bGFyLFxuICB0cmFuc2NyaXB0VmlzdWFsS2V5Ym9hcmRJbmRpY2F0b3JDb2xvcixcbiAgdHJhbnNjcmlwdFZpc3VhbEtleWJvYXJkSW5kaWNhdG9yU3R5bGUsXG4gIHRyYW5zY3JpcHRWaXN1YWxLZXlib2FyZEluZGljYXRvcldpZHRoLFxuICB0cmFuc2l0aW9uRHVyYXRpb25cbn06IFN0cmljdFN0eWxlT3B0aW9ucykge1xuICByZXR1cm4ge1xuICAgICcmLndlYmNoYXRfX2Nhcm91c2VsLWZpbG1zdHJpcC1hdHRhY2htZW50Jzoge1xuICAgICAgbWluV2lkdGg6IGJ1YmJsZU1pbldpZHRoLFxuICAgICAgbWF4V2lkdGg6IGJ1YmJsZU1heFdpZHRoLFxuICAgICAgdHJhbnNpdGlvbkR1cmF0aW9uLFxuICAgICAgdHJhbnNpdGlvblByb3BlcnR5OiAnbWF4LXdpZHRoLCBtaW4td2lkdGgnLFxuXG4gICAgICAnJjpmb2N1cyc6IHtcbiAgICAgICAgb3V0bGluZTogMFxuICAgICAgfSxcblxuICAgICAgJyY6Zm9jdXMgLndlYmNoYXRfX2Nhcm91c2VsLWZpbG1zdHJpcC1hdHRhY2htZW50LS1mb2N1cyc6IHtcbiAgICAgICAgYm9yZGVyQ29sb3I6IHRyYW5zY3JpcHRWaXN1YWxLZXlib2FyZEluZGljYXRvckNvbG9yLFxuICAgICAgICBib3JkZXJTdHlsZTogdHJhbnNjcmlwdFZpc3VhbEtleWJvYXJkSW5kaWNhdG9yU3R5bGUsXG4gICAgICAgIGJvcmRlcldpZHRoOiB0cmFuc2NyaXB0VmlzdWFsS2V5Ym9hcmRJbmRpY2F0b3JXaWR0aCxcbiAgICAgICAgYm94U2l6aW5nOiAnYm9yZGVyLWJveCcsXG4gICAgICAgIGhlaWdodDogYGNhbGMoMTAwJSAtICR7dHJhbnNjcmlwdFZpc3VhbEtleWJvYXJkSW5kaWNhdG9yV2lkdGh9cHgpYCxcbiAgICAgICAgbGVmdDogMCxcbiAgICAgICAgcG9pbnRlckV2ZW50czogJ25vbmUnLFxuICAgICAgICBwb3NpdGlvbjogJ2Fic29sdXRlJyxcbiAgICAgICAgdG9wOiAwLFxuICAgICAgICB3aWR0aDogYGNhbGMoMTAwJSAtICR7dHJhbnNjcmlwdFZpc3VhbEtleWJvYXJkSW5kaWNhdG9yV2lkdGh9cHgpYFxuICAgICAgfVxuICAgIH0sXG4gICAgLi4ubWlycm9yU3R5bGUoJyYud2ViY2hhdF9fY2Fyb3VzZWwtZmlsbXN0cmlwLWF0dGFjaG1lbnQtLXJ0bCcsIHtcbiAgICAgIHBhZGRpbmdMZWZ0OiBwYWRkaW5nUmVndWxhcixcblxuICAgICAgJyYud2ViY2hhdF9fY2Fyb3VzZWwtZmlsbXN0cmlwLWF0dGFjaG1lbnQtLWhpZGUtYXZhdGFyLCAmLndlYmNoYXRfX2Nhcm91c2VsLWZpbG1zdHJpcC1hdHRhY2htZW50LS1zaG93LWF2YXRhcic6IHtcbiAgICAgICAgJyY6Zmlyc3QtY2hpbGQnOiB7XG4gICAgICAgICAgcGFkZGluZ0xlZnQ6IGF2YXRhclNpemUgKyBwYWRkaW5nUmVndWxhciAqIDJcbiAgICAgICAgfVxuICAgICAgfSxcblxuICAgICAgJyYud2ViY2hhdF9fY2Fyb3VzZWwtZmlsbXN0cmlwLWF0dGFjaG1lbnQtLWhpZGUtbnViLCAmLndlYmNoYXRfX2Nhcm91c2VsLWZpbG1zdHJpcC1hdHRhY2htZW50LS1zaG93LW51Yic6IHtcbiAgICAgICAgJyY6bm90KC53ZWJjaGF0X19jYXJvdXNlbC1maWxtc3RyaXAtYXR0YWNobWVudC0taGlkZS1hdmF0YXIud2ViY2hhdF9fY2Fyb3VzZWwtZmlsbXN0cmlwLWF0dGFjaG1lbnQtLXNob3ctYXZhdGFyKTpmaXJzdC1jaGlsZCc6IHtcbiAgICAgICAgICBwYWRkaW5nTGVmdDogcGFkZGluZ1JlZ3VsYXIgKiAyXG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9KVxuICB9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Styles/StyleSet/KeyboardHelp.d.ts

@@ -0,0 +1,123 @@
+import { StrictStyleOptions } from 'botframework-webchat-api';
+export default function createKeyboardHelpStyleSet({ paddingRegular, primaryFont }: StrictStyleOptions): {
+    '&.webchat__keyboard-help': {
+        fontFamily: string;
+        fontSize: number;
+        height: string;
+        margin: number;
+        outline: number;
+        '&:not(.webchat__keyboard-help--shown)': {
+            height: number;
+            margin: number;
+            overflow: string;
+            pointerEvents: string;
+            width: number;
+        };
+        '& .webchat__keyboard-help__box': {
+            borderRadius: number;
+            boxShadow: string;
+            boxSizing: string;
+            height: string;
+            padding: number;
+            position: string;
+            '@media (forced-colors: active)': {
+                boxShadow: string;
+                outlineColor: string;
+                outlineStyle: string;
+                outlineWidth: number;
+            };
+            '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+                boxShadow: string;
+            };
+        };
+        '& .webchat__keyboard-help__close-button': {
+            appearance: string;
+            backgroundColor: string;
+            borderColor: string;
+            borderRadius: number;
+            borderStyle: string;
+            borderWidth: number;
+            color: string;
+            height: number;
+            padding: number;
+            position: string;
+            right: number;
+            top: number;
+            width: number;
+            '@media (forced-colors: none) and (prefers-color-scheme: light)': {
+                '&:active': {
+                    backgroundColor: string;
+                };
+                '&:not(:active):hover': {
+                    backgroundColor: string;
+                };
+            };
+            '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+                borderColor: string;
+                '&:active': {
+                    backgroundColor: string;
+                };
+                '&:not(:active):hover': {
+                    backgroundColor: string;
+                };
+            };
+        };
+        '& .webchat__keyboard-help__close-button_image': {
+            fill: string;
+            height: number;
+            width: number;
+            '@media (forced-colors: active)': {
+                fill: string;
+            };
+            '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+                fill: string;
+            };
+        };
+        '& .webchat__keyboard-help__header, & .webchat__keyboard-help__sub-header': {
+            marginBottom: number;
+            marginTop: number;
+        };
+        '& .webchat__keyboard-help__section': {
+            marginBottom: number;
+        };
+        '& .webchat__keyboard-help__two-panes': {
+            alignItems: string;
+            display: string;
+        };
+        '& .webchat__keyboard-help__image': {
+            flexShrink: number;
+            paddingRight: number;
+        };
+        '& .webchat__keyboard-help__image--dark, & .webchat__keyboard-help__image--high-contrast': {
+            display: string;
+        };
+        '@media (forced-colors: active)': {
+            '& .webchat__keyboard-help__image--dark, & .webchat__keyboard-help__image--light': {
+                display: string;
+            };
+            '& .webchat__keyboard-help__image--high-contrast': {
+                display: string;
+            };
+        };
+        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+            backgroundColor: string;
+            color: string;
+            '& .webchat__keyboard-help__image--light': {
+                display: string;
+            };
+            '& .webchat__keyboard-help__image--dark': {
+                display: string;
+            };
+        };
+        '& .webchat__keyboard-help__notes': {
+            marginBottom: number;
+        };
+        '& .webchat__keyboard-help__notes-header': {
+            margin: number;
+        };
+        '& .webchat__keyboard-help__notes-text': {
+            margin: number;
+        };
+    };
+};
+//# sourceMappingURL=KeyboardHelp.d.ts.map

package/lib/Styles/StyleSet/KeyboardHelp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyboardHelp.d.ts","sourceRoot":"","sources":["../../../src/Styles/StyleSet/KeyboardHelp.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAAC,EAAE,cAAc,EAAE,WAAW,EAAE,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuJrG"}

package/lib/Styles/StyleSet/KeyboardHelp.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createKeyboardHelpStyleSet;
+
+// Numbers are commonly used in CSS.
+
+/* eslint-disable no-magic-numbers */
+function createKeyboardHelpStyleSet(_ref) {
+  var paddingRegular = _ref.paddingRegular,
+      primaryFont = _ref.primaryFont;
+  return {
+    '&.webchat__keyboard-help': {
+      fontFamily: primaryFont,
+      fontSize: 14,
+      height: '100%',
+      margin: paddingRegular,
+      outline: 0,
+      '&:not(.webchat__keyboard-help--shown)': {
+        height: 0,
+        margin: 0,
+        overflow: 'hidden',
+        pointerEvents: 'none',
+        width: 0
+      },
+      '& .webchat__keyboard-help__box': {
+        // From Power BI:
+        // boxShadow: '0 6.4px 14.4px rgb(0 0 0 / 13%), 0 1.2px 3.6px rgb(0 0 0 / 11%)',
+        // From Fluent (depth-16 for teaching callouts):
+        borderRadius: 2,
+        boxShadow: '0px 8px 16px rgba(0, 0, 0, 0.14), 0px 0px 2px rgba(0, 0, 0, 0.12)',
+        boxSizing: 'border-box',
+        height: '100%',
+        padding: paddingRegular * 2,
+        position: 'relative',
+        '@media (forced-colors: active)': {
+          boxShadow: 'none',
+          outlineColor: 'white',
+          outlineStyle: 'solid',
+          outlineWidth: 4
+        },
+        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+          boxShadow: '0px 8px 16px rgba(0, 0, 0, 0.28), 0px 0px 2px rgba(0, 0, 0, 0.24)'
+        }
+      },
+      '& .webchat__keyboard-help__close-button': {
+        appearance: 'none',
+        backgroundColor: 'transparent',
+        borderColor: 'black',
+        borderRadius: 4,
+        borderStyle: 'solid',
+        borderWidth: 2,
+        color: '#999',
+        height: 34,
+        padding: 0,
+        position: 'absolute',
+        right: paddingRegular,
+        top: paddingRegular,
+        width: 34,
+        '@media (forced-colors: none) and (prefers-color-scheme: light)': {
+          '&:active': {
+            backgroundColor: '#EDEBE9' // neutralLight (gray30)
+
+          },
+          '&:not(:active):hover': {
+            backgroundColor: '#F3F2F1' // neutralLighter (gray20)
+
+          }
+        },
+        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+          borderColor: 'white',
+          '&:active': {
+            backgroundColor: '#292827' // neutralLight (gray30)
+
+          },
+          '&:not(:active):hover': {
+            backgroundColor: '#252423' // neutralLight (gray30)
+
+          }
+        }
+      },
+      '& .webchat__keyboard-help__close-button_image': {
+        fill: '#323130',
+        // neutralPrimary (gray160)
+        height: 10,
+        width: 10,
+        '@media (forced-colors: active)': {
+          fill: 'White'
+        },
+        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+          fill: '#F3F2F1' // neutralPrimary (gray160)
+
+        }
+      },
+      '& .webchat__keyboard-help__header, & .webchat__keyboard-help__sub-header': {
+        marginBottom: paddingRegular / 2,
+        marginTop: 0
+      },
+      '& .webchat__keyboard-help__section': {
+        marginBottom: paddingRegular
+      },
+      '& .webchat__keyboard-help__two-panes': {
+        alignItems: 'flex-start',
+        display: 'flex'
+      },
+      '& .webchat__keyboard-help__image': {
+        flexShrink: 10000,
+        paddingRight: paddingRegular
+      },
+      '& .webchat__keyboard-help__image--dark, & .webchat__keyboard-help__image--high-contrast': {
+        display: 'none'
+      },
+      '@media (forced-colors: active)': {
+        '& .webchat__keyboard-help__image--dark, & .webchat__keyboard-help__image--light': {
+          display: 'none'
+        },
+        '& .webchat__keyboard-help__image--high-contrast': {
+          display: 'unset'
+        }
+      },
+      '@media (forced-colors: none) and (prefers-color-scheme: dark)': {
+        backgroundColor: 'black',
+        color: '#F3F2F1',
+        '& .webchat__keyboard-help__image--light': {
+          display: 'none'
+        },
+        '& .webchat__keyboard-help__image--dark': {
+          display: 'unset'
+        }
+      },
+      '& .webchat__keyboard-help__notes': {
+        marginBottom: paddingRegular
+      },
+      '& .webchat__keyboard-help__notes-header': {
+        margin: 0
+      },
+      '& .webchat__keyboard-help__notes-text': {
+        margin: 0
+      }
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/Styles/StyleSet/KeyboardHelp.ts"],"names":["createKeyboardHelpStyleSet","paddingRegular","primaryFont","fontFamily","fontSize","height","margin","outline","overflow","pointerEvents","width","borderRadius","boxShadow","boxSizing","padding","position","outlineColor","outlineStyle","outlineWidth","appearance","backgroundColor","borderColor","borderStyle","borderWidth","color","right","top","fill","marginBottom","marginTop","alignItems","display","flexShrink","paddingRight"],"mappings":"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","sourceRoot":"component:///","sourcesContent":["// Numbers are commonly used in CSS.\n/* eslint-disable no-magic-numbers */\n\nimport { StrictStyleOptions } from 'botframework-webchat-api';\n\nexport default function createKeyboardHelpStyleSet({ paddingRegular, primaryFont }: StrictStyleOptions) {\n  return {\n    '&.webchat__keyboard-help': {\n      fontFamily: primaryFont,\n      fontSize: 14,\n      height: '100%',\n      margin: paddingRegular,\n      outline: 0,\n\n      '&:not(.webchat__keyboard-help--shown)': {\n        height: 0,\n        margin: 0,\n        overflow: 'hidden',\n        pointerEvents: 'none',\n        width: 0\n      },\n\n      '& .webchat__keyboard-help__box': {\n        // From Power BI:\n        // boxShadow: '0 6.4px 14.4px rgb(0 0 0 / 13%), 0 1.2px 3.6px rgb(0 0 0 / 11%)',\n        // From Fluent (depth-16 for teaching callouts):\n        borderRadius: 2,\n        boxShadow: '0px 8px 16px rgba(0, 0, 0, 0.14), 0px 0px 2px rgba(0, 0, 0, 0.12)',\n        boxSizing: 'border-box',\n        height: '100%',\n        padding: paddingRegular * 2,\n        position: 'relative',\n\n        '@media (forced-colors: active)': {\n          boxShadow: 'none',\n          outlineColor: 'white',\n          outlineStyle: 'solid',\n          outlineWidth: 4\n        },\n\n        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {\n          boxShadow: '0px 8px 16px rgba(0, 0, 0, 0.28), 0px 0px 2px rgba(0, 0, 0, 0.24)'\n        }\n      },\n\n      '& .webchat__keyboard-help__close-button': {\n        appearance: 'none',\n        backgroundColor: 'transparent',\n        borderColor: 'black',\n        borderRadius: 4,\n        borderStyle: 'solid',\n        borderWidth: 2,\n        color: '#999',\n        height: 34,\n        padding: 0,\n        position: 'absolute',\n        right: paddingRegular,\n        top: paddingRegular,\n        width: 34,\n\n        '@media (forced-colors: none) and (prefers-color-scheme: light)': {\n          '&:active': {\n            backgroundColor: '#EDEBE9' // neutralLight (gray30)\n          },\n\n          '&:not(:active):hover': {\n            backgroundColor: '#F3F2F1' // neutralLighter (gray20)\n          }\n        },\n\n        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {\n          borderColor: 'white',\n\n          '&:active': {\n            backgroundColor: '#292827' // neutralLight (gray30)\n          },\n\n          '&:not(:active):hover': {\n            backgroundColor: '#252423' // neutralLight (gray30)\n          }\n        }\n      },\n\n      '& .webchat__keyboard-help__close-button_image': {\n        fill: '#323130', // neutralPrimary (gray160)\n        height: 10,\n        width: 10,\n\n        '@media (forced-colors: active)': {\n          fill: 'White'\n        },\n\n        '@media (forced-colors: none) and (prefers-color-scheme: dark)': {\n          fill: '#F3F2F1' // neutralPrimary (gray160)\n        }\n      },\n\n      '& .webchat__keyboard-help__header, & .webchat__keyboard-help__sub-header': {\n        marginBottom: paddingRegular / 2,\n        marginTop: 0\n      },\n\n      '& .webchat__keyboard-help__section': {\n        marginBottom: paddingRegular\n      },\n\n      '& .webchat__keyboard-help__two-panes': {\n        alignItems: 'flex-start',\n        display: 'flex'\n      },\n\n      '& .webchat__keyboard-help__image': {\n        flexShrink: 10000,\n        paddingRight: paddingRegular\n      },\n\n      '& .webchat__keyboard-help__image--dark, & .webchat__keyboard-help__image--high-contrast': {\n        display: 'none'\n      },\n\n      '@media (forced-colors: active)': {\n        '& .webchat__keyboard-help__image--dark, & .webchat__keyboard-help__image--light': {\n          display: 'none'\n        },\n\n        '& .webchat__keyboard-help__image--high-contrast': {\n          display: 'unset'\n        }\n      },\n\n      '@media (forced-colors: none) and (prefers-color-scheme: dark)': {\n        backgroundColor: 'black',\n        color: '#F3F2F1',\n\n        '& .webchat__keyboard-help__image--light': {\n          display: 'none'\n        },\n\n        '& .webchat__keyboard-help__image--dark': {\n          display: 'unset'\n        }\n      },\n\n      '& .webchat__keyboard-help__notes': {\n        marginBottom: paddingRegular\n      },\n\n      '& .webchat__keyboard-help__notes-header': {\n        margin: 0\n      },\n\n      '& .webchat__keyboard-help__notes-text': {\n        margin: 0\n      }\n    }\n  };\n}\n"]}

package/lib/Styles/StyleSet/ScrollToEndButton.d.ts

@@ -1,7 +1,7 @@
 import { StrictStyleOptions } from 'botframework-webchat-api';
 export default function createScrollToEndButtonStyle({ paddingRegular, primaryFont, scrollToEndButtonFontSize, transcriptOverlayButtonBackground, transcriptOverlayButtonBackgroundOnFocus, transcriptOverlayButtonBackgroundOnHover, transcriptOverlayButtonColor, transcriptOverlayButtonColorOnFocus, transcriptOverlayButtonColorOnHover }: StrictStyleOptions): {
     '&.webchat__scroll-to-end-button': {
-        '@media screen and (-ms-high-contrast: active)': {
+        '@media screen and (forced-colors: active)': {
             borderWidth: string;
             outline: string;
         };

package/lib/Styles/StyleSet/ScrollToEndButton.js

@@ -18,7 +18,7 @@ function createScrollToEndButtonStyle(_ref) {
   return {
     '&.webchat__scroll-to-end-button': {
       // TODO: [P3] Can we not to unset borderWidth and outline earlier?
-      '@media screen and (-ms-high-contrast: active)': {
+      '@media screen and (forced-colors: active)': {
         borderWidth: 'initial',
         outline: 'initial'
       },
@@ -52,4 +52,4 @@ function createScrollToEndButtonStyle(_ref) {
     }
   };
 }
-//# 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/Styles/StyleSet/SendBoxButton.d.ts

@@ -1,32 +1,78 @@
 import { StrictStyleOptions } from 'botframework-webchat-api';
-export default function createSendBoxButtonStyle({ sendBoxButtonColor, sendBoxButtonColorOnDisabled, sendBoxButtonColorOnFocus, sendBoxButtonColorOnHover, sendBoxHeight, subtle }: StrictStyleOptions): {
+export default function createSendBoxButtonStyle({ sendBoxButtonColor, sendBoxButtonColorOnActive, sendBoxButtonColorOnDisabled, sendBoxButtonColorOnFocus, sendBoxButtonColorOnHover, sendBoxButtonKeyboardFocusIndicatorBorderColor, sendBoxButtonKeyboardFocusIndicatorBorderRadius, sendBoxButtonKeyboardFocusIndicatorBorderStyle, sendBoxButtonKeyboardFocusIndicatorBorderWidth, sendBoxButtonKeyboardFocusIndicatorInset, sendBoxButtonShadeBorderRadius, sendBoxButtonShadeColor, sendBoxButtonShadeColorOnActive, sendBoxButtonShadeColorOnDisabled, sendBoxButtonShadeColorOnFocus, sendBoxButtonShadeColorOnHover, sendBoxButtonShadeInset, sendBoxHeight, subtle }: StrictStyleOptions): {
     '&.webchat__icon-button': {
         alignItems: string;
+        appearance: string;
         backgroundColor: string;
         border: number;
         display: string;
+        fill: string;
         justifyContent: string;
         outline: number;
         padding: number;
+        position: string;
         width: string | number;
         '&:not(.webchat__icon-button--stretch)': {
             height: string | number;
         };
+        '&:disabled, &[aria-disabled="true"]': {
+            fill: string;
+            '& .webchat__icon-button__shade': {
+                backgroundColor: string;
+            };
+        };
         '&:not(:disabled):not([aria-disabled="true"])': {
-            '&:focus svg': {
+            '&:active': {
                 fill: string;
+                '& .webchat__icon-button__shade': {
+                    backgroundColor: string;
+                };
             };
-            '&:hover svg': {
-                fill: string;
+            '&:not(:active)': {
+                '&:hover': {
+                    fill: string;
+                    '& .webchat__icon-button__shade': {
+                        backgroundColor: string;
+                    };
+                };
+                '&:not(:hover)': {
+                    '&:focus': {
+                        fill: string;
+                        '& .webchat__icon-button__shade': {
+                            backgroundColor: string;
+                        };
+                    };
+                };
             };
         };
-        '& svg': {
-            fill: string;
+        '&:not(:focus-visible) .webchat__icon-button__keyboard-focus-indicator': {
+            display: string;
         };
-        '&:disabled, &[aria-disabled="true"]': {
-            '& svg': {
-                fill: string;
-            };
+        '&:not(.webchat__icon-button--focus-visible) .webchat__icon-button__keyboard-focus-indicator': {
+            display: string;
+        };
+        '& > *': {
+            position: string;
+        };
+        '& .webchat__icon-button__shade': {
+            backgroundColor: string;
+            borderRadius: number;
+            bottom: number;
+            left: number;
+            position: string;
+            right: number;
+            top: number;
+        };
+        '& .webchat__icon-button__keyboard-focus-indicator': {
+            borderColor: string;
+            borderRadius: string | number;
+            borderStyle: string;
+            borderWidth: number;
+            bottom: number;
+            left: number;
+            position: string;
+            right: number;
+            top: number;
         };
     };
 };

package/lib/Styles/StyleSet/SendBoxButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SendBoxButton.d.ts","sourceRoot":"","sources":["../../../src/Styles/StyleSet/SendBoxButton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,EAC/C,kBAAkB,EAClB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,aAAa,EACb,MAAM,EACP,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCpB"}
+{"version":3,"file":"SendBoxButton.d.ts","sourceRoot":"","sources":["../../../src/Styles/StyleSet/SendBoxButton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,EAC/C,kBAAkB,EAClB,0BAA0B,EAC1B,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,8CAA8C,EAC9C,+CAA+C,EAC/C,8CAA8C,EAC9C,8CAA8C,EAC9C,wCAAwC,EACxC,8BAA8B,EAC9B,uBAAuB,EACvB,+BAA+B,EAC/B,iCAAiC,EACjC,8BAA8B,EAC9B,8BAA8B,EAC9B,uBAAuB,EACvB,aAAa,EACb,MAAM,EACP,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiGpB"}