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

package/lib/hooks/internal/useMemoized.spec.jsx

@@ -0,0 +1,159 @@
+/** @jest-environment jsdom */
+/* eslint-disable react/prop-types */
+/* eslint-disable no-undef */
+/* eslint no-magic-numbers: "off" */
+import React from 'react';
+import { render } from 'react-dom';
+import { act } from 'react-dom/test-utils';
+import useMemoized from './useMemoized';
+
+const testHook = fun => {
+  let state;
+  const UseComponent = ({ useTest }) => {
+    useTest();
+    return null;
+  };
+  const TestComponent = () => {
+    state = React.useState();
+    const [useTest] = state;
+    if (useTest) {
+      return <UseComponent useTest={useTest} />;
+    }
+
+    return <React.Fragment />;
+  };
+
+  const root = document.createElement('div');
+  render(<TestComponent />, root);
+
+  return (...args) => {
+    const [_useTest, setTest] = state;
+    return new Promise(resolve => {
+      act(() => {
+        setTest(() => () => resolve(fun(...args)));
+      });
+    });
+  };
+};
+
+test('useMemoized should cache result across runs', async () => {
+  const expensiveSum = jest.fn((x, y) => x + y);
+
+  const render = testHook(doMemoChecks => {
+    // Start a run, all calls to sum() will be cached.
+    const sum = useMemoized(expensiveSum, []);
+    doMemoChecks(sum);
+  });
+
+  await render(sum => {
+    expect(sum(1, 2)).toBe(3); // Not cached, return 3.
+    expect(sum(1, 2)).toBe(3); // Cached, return 3.
+    expect(sum(2, 4)).toBe(6); // Not cached, return 6.
+    expect(sum(1, 2)).toBe(3); // Cached, return 3. This is cached because it is inside the same run.
+  });
+  expect(expensiveSum).toHaveBeenCalledTimes(2);
+
+  expect(expensiveSum.mock.calls[0]).toEqual([1, 2]);
+  expect(expensiveSum.mock.calls[1]).toEqual([2, 4]);
+
+  // After the run, 1 + 2 = 3, and 2 + 4 = 6 is cached.
+
+  // Start another run with previous cache
+  await render(sum => {
+    expect(sum(1, 2)).toBe(3); // Cached from previous run, return 3.
+    expect(sum(3, 6)).toBe(9); // Not cached, return 9.
+  });
+
+  expect(expensiveSum).toHaveBeenCalledTimes(3);
+  expect(expensiveSum.mock.calls[2]).toEqual([3, 6]);
+
+  // After the run, only 1 + 2 = 3 and 3 + 6 = 9 is cached. 2 + 4 is dropped.
+
+  // Start another run with previous cache
+  await render(sum => {
+    expect(sum(2, 4)).toBe(6); // Not cached, return 6
+  });
+
+  expect(expensiveSum).toHaveBeenCalledTimes(4);
+  expect(expensiveSum.mock.calls[3]).toEqual([2, 4]);
+});
+
+test('useMemoized should flush cache if deps change', async () => {
+  const expensiveSum = jest.fn((x, y) => x + y);
+
+  const render = testHook((doMemoChecks, deps) => {
+    // Start a run, all calls to sum() will be cached.
+    const sum = useMemoized(expensiveSum, deps);
+    doMemoChecks(sum);
+  });
+
+  // Start a run, all calls to sum() will be cached.
+  await render(
+    sum => {
+      expect(sum(1, 2)).toBe(3); // Not cached, return 3.
+      expect(sum(1, 2)).toBe(3); // Cached, return 3.
+      expect(sum(2, 4)).toBe(6); // Not cached, return 6.
+      expect(sum(1, 2)).toBe(3); // Cached, return 3. This is cached because it is inside the same run.
+    },
+    [{}]
+  );
+
+  expect(expensiveSum).toHaveBeenCalledTimes(2);
+
+  expect(expensiveSum.mock.calls[0]).toEqual([1, 2]);
+  expect(expensiveSum.mock.calls[1]).toEqual([2, 4]);
+
+  // Start another run without the previous cache
+  await render(
+    sum => {
+      expect(sum(1, 2)).toBe(3); // Not cached, deps changed
+      expect(sum(3, 6)).toBe(9); // Not cached, return 9.
+    },
+    [null]
+  );
+
+  expect(expensiveSum).toHaveBeenCalledTimes(4);
+  expect(expensiveSum.mock.calls[2]).toEqual([1, 2]);
+  expect(expensiveSum.mock.calls[3]).toEqual([3, 6]);
+
+  // After the run, only 1 + 2 = 3 and 3 + 6 = 9 is cached. 2 + 4 is dropped.
+
+  // Start another run with previous cache
+  await render(
+    sum => {
+      expect(sum(1, 2)).toBe(3); // Cached from previous run, return 3.
+      expect(sum(2, 4)).toBe(6); // Not cached, return 6
+    },
+    [null]
+  );
+
+  expect(expensiveSum).toHaveBeenCalledTimes(5);
+  expect(expensiveSum.mock.calls[4]).toEqual([2, 4]);
+});
+
+test('useMemoized should not share cache across hooks', async () => {
+  const expensiveSum = jest.fn((x, y) => x + y);
+
+  const render = testHook(doMemoChecks => {
+    // Start a run, all calls to sum() will be cached.
+    const sum1 = useMemoized(expensiveSum, []);
+    doMemoChecks(sum1);
+    const sum2 = useMemoized(expensiveSum, []);
+    doMemoChecks(sum2);
+  });
+
+  // Start a run, all calls to sum() will be cached.
+  await render(sum => {
+    expect(sum(1, 2)).toBe(3); // Not cached, return 3.
+    expect(sum(1, 2)).toBe(3); // Cached, return 3.
+    expect(sum(2, 4)).toBe(6); // Not cached, return 6.
+    expect(sum(1, 2)).toBe(3); // Cached, return 3. This is cached because it is inside the same run.
+  });
+
+  expect(expensiveSum).toHaveBeenCalledTimes(4);
+
+  expect(expensiveSum.mock.calls[0]).toEqual([1, 2]);
+  expect(expensiveSum.mock.calls[1]).toEqual([2, 4]);
+  expect(expensiveSum.mock.calls[2]).toEqual(expensiveSum.mock.calls[0]);
+  expect(expensiveSum.mock.calls[3]).toEqual(expensiveSum.mock.calls[1]);
+});

package/lib/hooks/internal/useNavigatorPlatform.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useNavigatorPlatform;
+var _react = require("react");
+var ANDROID_PATTERN = /^(android|linux armv7l)/gi;
+var APPLE_PATTERN = /^(mac|ipad|iphone|ipod)/gi;
+var LINUX_PATTERN = /^linux/gi;
+var WINDOWS_PATTERN = /^win/gi;
+function useNavigatorPlatform() {
+  var _window = window,
+    platform = _window.navigator.platform;
+  return (0, _react.useMemo)(function () {
+    // This list is very limited. Please use with care. Please refer to this link for details.
+    // https://stackoverflow.com/questions/19877924/what-is-the-list-of-possible-values-for-navigator-platform-as-of-today
+
+    var android = ANDROID_PATTERN.test(platform);
+    var apple = APPLE_PATTERN.test(platform);
+    var windows = WINDOWS_PATTERN.test(platform);
+    var linux = !android && LINUX_PATTERN.test(platform);
+    return [{
+      android: android,
+      apple: apple,
+      linux: linux,
+      windows: windows
+    }];
+  }, [platform]);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/internal/useNonce.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useNonce;
+var _useWebChatUIContext2 = _interopRequireDefault(require("./useWebChatUIContext"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function useNonce() {
+  var _useWebChatUIContext = (0, _useWebChatUIContext2.default)(),
+    nonce = _useWebChatUIContext.nonce;
+  return [nonce];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfdXNlV2ViQ2hhdFVJQ29udGV4dDIiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIm9iaiIsIl9fZXNNb2R1bGUiLCJkZWZhdWx0IiwidXNlTm9uY2UiLCJfdXNlV2ViQ2hhdFVJQ29udGV4dCIsInVzZVdlYkNoYXRVSUNvbnRleHQiLCJub25jZSJdLCJzb3VyY2VSb290IjoiY29tcG9uZW50Oi8vLyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL2ludGVybmFsL3VzZU5vbmNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB1c2VXZWJDaGF0VUlDb250ZXh0IGZyb20gJy4vdXNlV2ViQ2hhdFVJQ29udGV4dCc7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZU5vbmNlKCkge1xuICBjb25zdCB7IG5vbmNlIH0gPSB1c2VXZWJDaGF0VUlDb250ZXh0KCk7XG5cbiAgcmV0dXJuIFtub25jZV07XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLElBQUFBLHFCQUFBLEdBQUFDLHNCQUFBLENBQUFDLE9BQUE7QUFBd0QsU0FBQUQsdUJBQUFFLEdBQUEsV0FBQUEsR0FBQSxJQUFBQSxHQUFBLENBQUFDLFVBQUEsR0FBQUQsR0FBQSxLQUFBRSxPQUFBLEVBQUFGLEdBQUE7QUFFekMsU0FBU0csUUFBUUEsQ0FBQSxFQUFHO0VBQ2pDLElBQUFDLG9CQUFBLEdBQWtCLElBQUFDLDZCQUFtQixFQUFDLENBQUM7SUFBL0JDLEtBQUssR0FBQUYsb0JBQUEsQ0FBTEUsS0FBSztFQUViLE9BQU8sQ0FBQ0EsS0FBSyxDQUFDO0FBQ2hCIn0=

package/lib/hooks/internal/useObserveFocusVisible.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+export default function useObserveFocusVisible(targetRef: RefObject<HTMLElement>, onFocusVisible: () => void): void;
+//# sourceMappingURL=useObserveFocusVisible.d.ts.map

package/lib/hooks/internal/useObserveFocusVisible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useObserveFocusVisible.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/useObserveFocusVisible.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,SAAS,EAA2C,MAAM,OAAO,CAAC;AAkP7F,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,SAAS,EAAE,SAAS,CAAC,WAAW,CAAC,EAAE,cAAc,EAAE,MAAM,IAAI,QAqB3G"}

package/lib/hooks/internal/useObserveFocusVisible.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useObserveFocusVisible;
+var _botframeworkWebchatApi = require("botframework-webchat-api");
+var _react = require("react");
+var _supportPseudoClass = _interopRequireDefault(require("../../Utils/supportPseudoClass"));
+var _useNonce3 = _interopRequireDefault(require("./useNonce"));
+var _useValueRef = _interopRequireDefault(require("./useValueRef"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+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 usePonyfill = _botframeworkWebchatApi.hooks.usePonyfill;
+var INPUT_TYPES_ALLOW_LIST = ['date', 'datetime-local', 'datetime', 'email', 'month', 'number', 'password', 'search', 'tel', 'text', 'time', 'url', 'week'];
+
+/**
+ * Computes whether the given element should automatically trigger the
+ * `focus-visible` class being added, i.e. whether it should always match
+ * `:focus-visible` when focused.
+ * @param {Element} el
+ * @return {boolean}
+ */
+function focusTriggersKeyboardModality(el) {
+  var isContentEditable = el.isContentEditable,
+    readOnly = el.readOnly,
+    tagName = el.tagName,
+    type = el.type;
+  return tagName === 'INPUT' && INPUT_TYPES_ALLOW_LIST.includes(type) && !readOnly || tagName === 'TEXTAREA' && !readOnly || isContentEditable;
+}
+function createEventSubscription(target, types, handler) {
+  var subscribed;
+  var subscribe = function subscribe() {
+    if (!subscribed) {
+      types.forEach(function (type) {
+        return target.addEventListener(type, handler);
+      });
+      subscribed = true;
+    }
+  };
+  var unsubscribe = function unsubscribe() {
+    if (subscribed) {
+      types.forEach(function (type) {
+        return target.removeEventListener(type, handler);
+      });
+      subscribed = undefined;
+    }
+  };
+  return {
+    pause: unsubscribe,
+    resume: subscribe
+  };
+}
+
+// TODO: Add tests
+//       1. Focus via keyboard vs. mouse
+//       2. Focus via keyboard, switch app, switch back (expect to get another focusVisible after switch back)
+//       3. Focus via mouse, switch app, switch back (do NOT expect to get another focusVisible after switch back)
+function useObserveFocusVisibleForLegacyBrowsers(targetRef, onFocusVisibleRef) {
+  var _usePonyfill = usePonyfill(),
+    _usePonyfill2 = _slicedToArray(_usePonyfill, 1),
+    Date = _usePonyfill2[0].Date;
+  // This polyfill algorithm is adopted from https://github.com/WICG/focus-visible.
+  var blurSinceRef = (0, _react.useRef)(0);
+  var hadKeyboardEventRef = (0, _react.useRef)(true);
+  var hasFocusVisibleRef = (0, _react.useRef)(false);
+  var eventSubscription = (0, _react.useMemo)(function () {
+    return createEventSubscription(document, ['mousemove', 'mousedown', 'mouseup', 'pointermove', 'pointerdown', 'pointerup', 'touchmove', 'touchstart', 'touchend'], function (event) {
+      var _nodeName;
+      if (((_nodeName = event.target.nodeName) === null || _nodeName === void 0 ? void 0 : _nodeName.toLowerCase()) !== 'html') {
+        hadKeyboardEventRef.current = false;
+        eventSubscription.pause();
+      }
+    });
+  }, [hadKeyboardEventRef]);
+  var setHasFocusVisible = (0, _react.useCallback)(function (nextHasFocusVisible) {
+    if (hasFocusVisibleRef.current !== nextHasFocusVisible) {
+      hasFocusVisibleRef.current = nextHasFocusVisible;
+      nextHasFocusVisible && (onFocusVisibleRef === null || onFocusVisibleRef === void 0 ? void 0 : onFocusVisibleRef.current());
+    }
+  }, [hasFocusVisibleRef, onFocusVisibleRef]);
+  var handleKeyDown = (0, _react.useCallback)(function (event) {
+    if (event.altKey || event.ctrlKey || event.metaKey) {
+      return;
+    }
+    if (event.target === targetRef.current) {
+      setHasFocusVisible(true);
+    }
+    hadKeyboardEventRef.current = true;
+  }, [hadKeyboardEventRef, setHasFocusVisible, targetRef]);
+  var handlePointerDown = (0, _react.useCallback)(function () {
+    hadKeyboardEventRef.current = false;
+  }, [hadKeyboardEventRef]);
+  var handleFocus = (0, _react.useCallback)(function (_ref) {
+    var target = _ref.target;
+    target === targetRef.current && (hadKeyboardEventRef.current || focusTriggersKeyboardModality(target)) && setHasFocusVisible(true);
+  }, [hadKeyboardEventRef, setHasFocusVisible, targetRef]);
+  var handleBlur = (0, _react.useCallback)(function (event) {
+    if (event.target === targetRef.current && hasFocusVisibleRef.current) {
+      blurSinceRef.current = Date.now();
+      setHasFocusVisible(false);
+    }
+  }, [blurSinceRef, Date, hasFocusVisibleRef, setHasFocusVisible, targetRef]);
+  var handleVisibilityChange = (0, _react.useCallback)(function () {
+    if (document.visibilityState === 'hidden') {
+      // The element is blurred due to "visibilityState" set to "hidden".
+      // 100ms is referenced from the WICG polyfill.
+      // eslint-disable-next-line no-magic-numbers
+      if (Date.now() - blurSinceRef.current < 100) {
+        hadKeyboardEventRef.current = true;
+      }
+      eventSubscription.resume();
+    }
+  }, [blurSinceRef, Date, eventSubscription, hadKeyboardEventRef]);
+  (0, _react.useEffect)(function () {
+    document.addEventListener('keydown', handleKeyDown, true);
+    document.addEventListener('mousedown', handlePointerDown, true);
+    document.addEventListener('pointerdown', handlePointerDown, true);
+    document.addEventListener('touchstart', handlePointerDown, true);
+    document.addEventListener('visibilitychange', handleVisibilityChange, true);
+    return function () {
+      document.removeEventListener('keydown', handleKeyDown);
+      document.removeEventListener('mousedown', handlePointerDown);
+      document.removeEventListener('pointerdown', handlePointerDown);
+      document.removeEventListener('touchstart', handlePointerDown);
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+    };
+  }, [handleKeyDown, handlePointerDown, handleVisibilityChange]);
+  (0, _react.useEffect)(function () {
+    var target = targetRef.current;
+    target.addEventListener('blur', handleBlur, true);
+    target.addEventListener('focus', handleFocus, true);
+    return function () {
+      target.removeEventListener('blur', handleBlur);
+      target.removeEventListener('focus', handleFocus);
+    };
+
+    // We specifically add "targetRef.current" here.
+    // If the target element changed, we should reattach our event listeners.
+  }, [handleBlur, handleFocus, targetRef]);
+  (0, _react.useEffect)(function () {
+    eventSubscription.resume();
+    return function () {
+      return eventSubscription.pause();
+    };
+  }, [eventSubscription]);
+}
+function useObserveFocusVisibleForModernBrowsers(targetRef, onFocusVisibleRef) {
+  var handleFocus = (0, _react.useCallback)(function () {
+    var current = targetRef.current;
+    if (
+    // "msMatchesSelector" is vendor-prefixed version of "matches".
+    // eslint-disable-next-line dot-notation
+    (current.matches || current['msMatchesSelector']).call(current, ':focus-visible')) {
+      onFocusVisibleRef === null || onFocusVisibleRef === void 0 ? void 0 : onFocusVisibleRef.current();
+    }
+  }, [onFocusVisibleRef, targetRef]);
+  (0, _react.useEffect)(function () {
+    var target = targetRef.current;
+    target.addEventListener('focus', handleFocus);
+    return function () {
+      return target.removeEventListener('focus', handleFocus);
+    };
+
+    // We specifically add "targetRef.current" here.
+    // If the target element changed, we should reattach our event listeners.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [handleFocus, targetRef, targetRef.current]);
+}
+function useObserveFocusVisible(targetRef, onFocusVisible) {
+  var _useNonce = (0, _useNonce3.default)(),
+    _useNonce2 = _slicedToArray(_useNonce, 1),
+    nonce = _useNonce2[0];
+  var onFocusVisibleRef = (0, _useValueRef.default)(onFocusVisible);
+
+  // The nonce is use for browser capabilities. Just in case the "nonce" had changed unexpectedly, the capabilities of the browser should never change.
+  // Thus, we are using an initial version of "nonce". In case web devs changed the "nonce" to an invalid value, we won't break rules of hooks (as stated below).
+  var nonceRef = (0, _react.useRef)(nonce);
+
+  // ":focus-visible" selector is supported from Chrome/Edge 86+ and not supported in IE11 or Safari.
+  // Doing a capability check on pseudo classes requires injecting a stylesheet, thus nonce is needed.
+  var supportFocusVisible = (0, _react.useMemo)(function () {
+    return (0, _supportPseudoClass.default)(':focus-visible', nonceRef.current);
+  }, [nonceRef]);
+
+  // Since "supportPseudoClass" is a browser capability, the result should be constant during the page lifetime.
+  // Thus, running hooks conditionally is okay here.
+  if (supportFocusVisible) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useObserveFocusVisibleForModernBrowsers(targetRef, onFocusVisibleRef);
+  } else {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useObserveFocusVisibleForLegacyBrowsers(targetRef, onFocusVisibleRef);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_botframeworkWebchatApi","require","_react","_supportPseudoClass","_interopRequireDefault","_useNonce3","_useValueRef","obj","__esModule","default","_slicedToArray","arr","i","_arrayWithHoles","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","TypeError","o","minLen","_arrayLikeToArray","n","Object","prototype","toString","call","slice","constructor","name","Array","from","test","len","length","arr2","_i","Symbol","iterator","_arr","_n","_d","_s","_e","next","done","push","value","err","isArray","usePonyfill","hooks","INPUT_TYPES_ALLOW_LIST","focusTriggersKeyboardModality","el","isContentEditable","readOnly","tagName","type","includes","createEventSubscription","target","types","handler","subscribed","subscribe","forEach","addEventListener","unsubscribe","removeEventListener","undefined","pause","resume","useObserveFocusVisibleForLegacyBrowsers","targetRef","onFocusVisibleRef","_usePonyfill","_usePonyfill2","Date","blurSinceRef","useRef","hadKeyboardEventRef","hasFocusVisibleRef","eventSubscription","useMemo","document","event","_nodeName","nodeName","toLowerCase","current","setHasFocusVisible","useCallback","nextHasFocusVisible","handleKeyDown","altKey","ctrlKey","metaKey","handlePointerDown","handleFocus","_ref","handleBlur","now","handleVisibilityChange","visibilityState","useEffect","useObserveFocusVisibleForModernBrowsers","matches","useObserveFocusVisible","onFocusVisible","_useNonce","useNonce","_useNonce2","nonce","useValueRef","nonceRef","supportFocusVisible","supportPseudoClass"],"sourceRoot":"component:///","sources":["../../../src/hooks/internal/useObserveFocusVisible.ts"],"sourcesContent":["import { hooks } from 'botframework-webchat-api';\nimport { MutableRefObject, RefObject, useCallback, useEffect, useMemo, useRef } from 'react';\n\nimport supportPseudoClass from '../../Utils/supportPseudoClass';\nimport useNonce from './useNonce';\nimport useValueRef from './useValueRef';\n\nconst { usePonyfill } = hooks;\n\nconst INPUT_TYPES_ALLOW_LIST = [\n  'date',\n  'datetime-local',\n  'datetime',\n  'email',\n  'month',\n  'number',\n  'password',\n  'search',\n  'tel',\n  'text',\n  'time',\n  'url',\n  'week'\n];\n\n/**\n * Computes whether the given element should automatically trigger the\n * `focus-visible` class being added, i.e. whether it should always match\n * `:focus-visible` when focused.\n * @param {Element} el\n * @return {boolean}\n */\nfunction focusTriggersKeyboardModality(el: HTMLInputElement | HTMLTextAreaElement): boolean {\n  const { isContentEditable, readOnly, tagName, type } = el;\n\n  return (\n    (tagName === 'INPUT' && INPUT_TYPES_ALLOW_LIST.includes(type) && !readOnly) ||\n    (tagName === 'TEXTAREA' && !readOnly) ||\n    isContentEditable\n  );\n}\n\nfunction createEventSubscription(\n  target: Element | Node,\n  types: string[],\n  handler: (event: Event) => void\n): {\n  pause: () => void;\n  resume: () => void;\n} {\n  let subscribed: true;\n\n  const subscribe = () => {\n    if (!subscribed) {\n      types.forEach(type => target.addEventListener(type, handler));\n      subscribed = true;\n    }\n  };\n\n  const unsubscribe = () => {\n    if (subscribed) {\n      types.forEach(type => target.removeEventListener(type, handler));\n      subscribed = undefined;\n    }\n  };\n\n  return {\n    pause: unsubscribe,\n    resume: subscribe\n  };\n}\n\n// TODO: Add tests\n//       1. Focus via keyboard vs. mouse\n//       2. Focus via keyboard, switch app, switch back (expect to get another focusVisible after switch back)\n//       3. Focus via mouse, switch app, switch back (do NOT expect to get another focusVisible after switch back)\nfunction useObserveFocusVisibleForLegacyBrowsers(\n  targetRef: RefObject<HTMLElement>,\n  onFocusVisibleRef: MutableRefObject<() => void>\n) {\n  const [{ Date }] = usePonyfill();\n  // This polyfill algorithm is adopted from https://github.com/WICG/focus-visible.\n  const blurSinceRef = useRef(0);\n  const hadKeyboardEventRef = useRef(true);\n  const hasFocusVisibleRef = useRef(false);\n\n  const eventSubscription = useMemo(\n    () =>\n      createEventSubscription(\n        document,\n        [\n          'mousemove',\n          'mousedown',\n          'mouseup',\n          'pointermove',\n          'pointerdown',\n          'pointerup',\n          'touchmove',\n          'touchstart',\n          'touchend'\n        ],\n        event => {\n          if ((event.target as HTMLElement).nodeName?.toLowerCase() !== 'html') {\n            hadKeyboardEventRef.current = false;\n            eventSubscription.pause();\n          }\n        }\n      ),\n    [hadKeyboardEventRef]\n  );\n\n  const setHasFocusVisible = useCallback(\n    nextHasFocusVisible => {\n      if (hasFocusVisibleRef.current !== nextHasFocusVisible) {\n        hasFocusVisibleRef.current = nextHasFocusVisible;\n        nextHasFocusVisible && onFocusVisibleRef?.current();\n      }\n    },\n    [hasFocusVisibleRef, onFocusVisibleRef]\n  );\n\n  const handleKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      if (event.altKey || event.ctrlKey || event.metaKey) {\n        return;\n      }\n\n      if (event.target === targetRef.current) {\n        setHasFocusVisible(true);\n      }\n\n      hadKeyboardEventRef.current = true;\n    },\n    [hadKeyboardEventRef, setHasFocusVisible, targetRef]\n  );\n\n  const handlePointerDown = useCallback(() => {\n    hadKeyboardEventRef.current = false;\n  }, [hadKeyboardEventRef]);\n\n  const handleFocus = useCallback(\n    ({ target }: Event) => {\n      target === targetRef.current &&\n        (hadKeyboardEventRef.current || focusTriggersKeyboardModality(target as HTMLInputElement)) &&\n        setHasFocusVisible(true);\n    },\n    [hadKeyboardEventRef, setHasFocusVisible, targetRef]\n  );\n\n  const handleBlur = useCallback(\n    (event: Event) => {\n      if (event.target === targetRef.current && hasFocusVisibleRef.current) {\n        blurSinceRef.current = Date.now();\n\n        setHasFocusVisible(false);\n      }\n    },\n    [blurSinceRef, Date, hasFocusVisibleRef, setHasFocusVisible, targetRef]\n  );\n\n  const handleVisibilityChange = useCallback(() => {\n    if (document.visibilityState === 'hidden') {\n      // The element is blurred due to \"visibilityState\" set to \"hidden\".\n      // 100ms is referenced from the WICG polyfill.\n      // eslint-disable-next-line no-magic-numbers\n      if (Date.now() - blurSinceRef.current < 100) {\n        hadKeyboardEventRef.current = true;\n      }\n\n      eventSubscription.resume();\n    }\n  }, [blurSinceRef, Date, eventSubscription, hadKeyboardEventRef]);\n\n  useEffect(() => {\n    document.addEventListener('keydown', handleKeyDown, true);\n    document.addEventListener('mousedown', handlePointerDown, true);\n    document.addEventListener('pointerdown', handlePointerDown, true);\n    document.addEventListener('touchstart', handlePointerDown, true);\n    document.addEventListener('visibilitychange', handleVisibilityChange, true);\n\n    return () => {\n      document.removeEventListener('keydown', handleKeyDown);\n      document.removeEventListener('mousedown', handlePointerDown);\n      document.removeEventListener('pointerdown', handlePointerDown);\n      document.removeEventListener('touchstart', handlePointerDown);\n      document.removeEventListener('visibilitychange', handleVisibilityChange);\n    };\n  }, [handleKeyDown, handlePointerDown, handleVisibilityChange]);\n\n  useEffect(() => {\n    const { current: target } = targetRef;\n\n    target.addEventListener('blur', handleBlur, true);\n    target.addEventListener('focus', handleFocus, true);\n\n    return () => {\n      target.removeEventListener('blur', handleBlur);\n      target.removeEventListener('focus', handleFocus);\n    };\n\n    // We specifically add \"targetRef.current\" here.\n    // If the target element changed, we should reattach our event listeners.\n  }, [handleBlur, handleFocus, targetRef]);\n\n  useEffect(() => {\n    eventSubscription.resume();\n\n    return () => eventSubscription.pause();\n  }, [eventSubscription]);\n}\n\nfunction useObserveFocusVisibleForModernBrowsers(\n  targetRef: RefObject<HTMLElement>,\n  onFocusVisibleRef: MutableRefObject<() => void>\n) {\n  const handleFocus = useCallback(() => {\n    const { current } = targetRef;\n\n    if (\n      // \"msMatchesSelector\" is vendor-prefixed version of \"matches\".\n      // eslint-disable-next-line dot-notation\n      (current.matches || (current['msMatchesSelector'] as (selector: string) => boolean)).call(\n        current,\n        ':focus-visible'\n      )\n    ) {\n      onFocusVisibleRef?.current();\n    }\n  }, [onFocusVisibleRef, targetRef]);\n\n  useEffect(() => {\n    const { current: target } = targetRef;\n\n    target.addEventListener('focus', handleFocus);\n\n    return () => target.removeEventListener('focus', handleFocus);\n\n    // We specifically add \"targetRef.current\" here.\n    // If the target element changed, we should reattach our event listeners.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [handleFocus, targetRef, targetRef.current]);\n}\n\nexport default function useObserveFocusVisible(targetRef: RefObject<HTMLElement>, onFocusVisible: () => void) {\n  const [nonce] = useNonce();\n  const onFocusVisibleRef = useValueRef(onFocusVisible);\n\n  // The nonce is use for browser capabilities. Just in case the \"nonce\" had changed unexpectedly, the capabilities of the browser should never change.\n  // Thus, we are using an initial version of \"nonce\". In case web devs changed the \"nonce\" to an invalid value, we won't break rules of hooks (as stated below).\n  const nonceRef = useRef(nonce);\n\n  // \":focus-visible\" selector is supported from Chrome/Edge 86+ and not supported in IE11 or Safari.\n  // Doing a capability check on pseudo classes requires injecting a stylesheet, thus nonce is needed.\n  const supportFocusVisible = useMemo(() => supportPseudoClass(':focus-visible', nonceRef.current), [nonceRef]);\n\n  // Since \"supportPseudoClass\" is a browser capability, the result should be constant during the page lifetime.\n  // Thus, running hooks conditionally is okay here.\n  if (supportFocusVisible) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useObserveFocusVisibleForModernBrowsers(targetRef, onFocusVisibleRef);\n  } else {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useObserveFocusVisibleForLegacyBrowsers(targetRef, onFocusVisibleRef);\n  }\n}\n"],"mappings":"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"}

package/lib/hooks/internal/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export default function usePrevious<T>(value: T): T;
+//# sourceMappingURL=usePrevious.d.ts.map

package/lib/hooks/internal/usePrevious.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrevious.d.ts","sourceRoot":"","sources":["../../../src/hooks/internal/usePrevious.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAQlD"}

package/lib/hooks/internal/usePrevious.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = usePrevious;
+var _react = require("react");
+// TODO: [P0] #4133 Don't copy.
+
+function usePrevious(value) {
+  var ref = (0, _react.useRef)();
+  (0, _react.useEffect)(function () {
+    ref.current = value;
+  });
+  return ref.current;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVhY3QiLCJyZXF1aXJlIiwidXNlUHJldmlvdXMiLCJ2YWx1ZSIsInJlZiIsInVzZVJlZiIsInVzZUVmZmVjdCIsImN1cnJlbnQiXSwic291cmNlUm9vdCI6ImNvbXBvbmVudDovLy8iLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ob29rcy9pbnRlcm5hbC91c2VQcmV2aW91cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBUT0RPOiBbUDBdICM0MTMzIERvbid0IGNvcHkuXG5pbXBvcnQgeyB1c2VFZmZlY3QsIHVzZVJlZiB9IGZyb20gJ3JlYWN0JztcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdXNlUHJldmlvdXM8VD4odmFsdWU6IFQpOiBUIHtcbiAgY29uc3QgcmVmID0gdXNlUmVmPFQ+KCk7XG5cbiAgdXNlRWZmZWN0KCgpID0+IHtcbiAgICByZWYuY3VycmVudCA9IHZhbHVlO1xuICB9KTtcblxuICByZXR1cm4gcmVmLmN1cnJlbnQ7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUNBLElBQUFBLE1BQUEsR0FBQUMsT0FBQTtBQURBOztBQUdlLFNBQVNDLFdBQVdBLENBQUlDLEtBQVEsRUFBSztFQUNsRCxJQUFNQyxHQUFHLEdBQUcsSUFBQUMsYUFBTSxFQUFJLENBQUM7RUFFdkIsSUFBQUMsZ0JBQVMsRUFBQyxZQUFNO0lBQ2RGLEdBQUcsQ0FBQ0csT0FBTyxHQUFHSixLQUFLO0VBQ3JCLENBQUMsQ0FBQztFQUVGLE9BQU9DLEdBQUcsQ0FBQ0csT0FBTztBQUNwQiJ9

package/lib/hooks/internal/useRegisterFocusTranscript.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRegisterFocusTranscript;
+var _react = require("react");
+var _removeInline = _interopRequireDefault(require("../../Utils/removeInline"));
+var _useWebChatUIContext2 = _interopRequireDefault(require("./useWebChatUIContext"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This hook is for registering and unregister a callback, used by <BasicTranscript>.
+// When called, the callback should focus on the transcript.
+
+function useRegisterFocusTranscript(callback) {
+  var _useWebChatUIContext = (0, _useWebChatUIContext2.default)(),
+    focusTranscriptCallbacksRef = _useWebChatUIContext.focusTranscriptCallbacksRef;
+  (0, _react.useEffect)(function () {
+    if (callback) {
+      var focusTranscriptCallbacks = focusTranscriptCallbacksRef.current;
+      focusTranscriptCallbacks.push(callback);
+      return function () {
+        return (0, _removeInline.default)(focusTranscriptCallbacks, callback);
+      };
+    }
+  }, [callback, focusTranscriptCallbacksRef]);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/internal/useRegisterScrollTo.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRegisterScrollTo;
+var _react = require("react");
+var _removeInline = _interopRequireDefault(require("../../Utils/removeInline"));
+var _useWebChatUIContext2 = _interopRequireDefault(require("./useWebChatUIContext"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This hook is for registering and unregister a callback, used by <BasicTranscript>.
+// When called, the callback should scroll the transcript to a specific position, for example, to an activity of specified ID.
+
+function useRegisterScrollTo(callback) {
+  var _useWebChatUIContext = (0, _useWebChatUIContext2.default)(),
+    scrollToCallbacksRef = _useWebChatUIContext.scrollToCallbacksRef;
+  (0, _react.useEffect)(function () {
+    if (callback) {
+      var scrollToCallbacks = scrollToCallbacksRef.current;
+      scrollToCallbacks.push(callback);
+      return function () {
+        return (0, _removeInline.default)(scrollToCallbacks, callback);
+      };
+    }
+  }, [callback, scrollToCallbacksRef]);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/internal/useRegisterScrollToEnd.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useRegisterScrollTo;
+var _react = require("react");
+var _removeInline = _interopRequireDefault(require("../../Utils/removeInline"));
+var _useWebChatUIContext2 = _interopRequireDefault(require("./useWebChatUIContext"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This hook is for registering and unregister a callback, used by <BasicTranscript>.
+// When called, the callback should scroll the transcript to the end.
+
+function useRegisterScrollTo(callback) {
+  var _useWebChatUIContext = (0, _useWebChatUIContext2.default)(),
+    scrollToEndCallbacksRef = _useWebChatUIContext.scrollToEndCallbacksRef;
+  (0, _react.useEffect)(function () {
+    var scrollToEndCallbacks = scrollToEndCallbacksRef.current;
+    scrollToEndCallbacks.push(callback);
+    return function () {
+      return (0, _removeInline.default)(scrollToEndCallbacks, callback);
+    };
+  }, [callback, scrollToEndCallbacksRef]);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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