@madflys/react 1.0.0

package/react/dist/node_modules/react-focus-lock/dist/cjs/Lock.js

@@ -0,0 +1,238 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = require("prop-types");
+
+var constants = _interopRequireWildcard(require("focus-lock/constants"));
+
+var _useCallbackRef = require("use-callback-ref");
+
+var _FocusGuard = require("./FocusGuard");
+
+var _medium = require("./medium");
+
+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) { (0, _defineProperty2["default"])(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; }
+
+var emptyArray = [];
+var FocusLock = /*#__PURE__*/React.forwardRef(function FocusLockUI(props, parentRef) {
+  var _objectSpread2;
+
+  var _React$useState = React.useState(),
+      _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+      realObserved = _React$useState2[0],
+      setObserved = _React$useState2[1];
+
+  var observed = React.useRef();
+  var isActive = React.useRef(false);
+  var originalFocusedElement = React.useRef(null);
+  var children = props.children,
+      disabled = props.disabled,
+      noFocusGuards = props.noFocusGuards,
+      persistentFocus = props.persistentFocus,
+      crossFrame = props.crossFrame,
+      autoFocus = props.autoFocus,
+      allowTextSelection = props.allowTextSelection,
+      group = props.group,
+      className = props.className,
+      whiteList = props.whiteList,
+      hasPositiveIndices = props.hasPositiveIndices,
+      _props$shards = props.shards,
+      shards = _props$shards === void 0 ? emptyArray : _props$shards,
+      _props$as = props.as,
+      Container = _props$as === void 0 ? 'div' : _props$as,
+      _props$lockProps = props.lockProps,
+      containerProps = _props$lockProps === void 0 ? {} : _props$lockProps,
+      SideCar = props.sideCar,
+      shouldReturnFocus = props.returnFocus,
+      focusOptions = props.focusOptions,
+      onActivationCallback = props.onActivation,
+      onDeactivationCallback = props.onDeactivation;
+
+  var _React$useState3 = React.useState({}),
+      _React$useState4 = (0, _slicedToArray2["default"])(_React$useState3, 1),
+      id = _React$useState4[0]; // SIDE EFFECT CALLBACKS
+
+
+  var onActivation = React.useCallback(function () {
+    originalFocusedElement.current = originalFocusedElement.current || document && document.activeElement;
+
+    if (observed.current && onActivationCallback) {
+      onActivationCallback(observed.current);
+    }
+
+    isActive.current = true;
+  }, [onActivationCallback]);
+  var onDeactivation = React.useCallback(function () {
+    isActive.current = false;
+
+    if (onDeactivationCallback) {
+      onDeactivationCallback(observed.current);
+    }
+  }, [onDeactivationCallback]);
+  (0, React.useEffect)(function () {
+    if (!disabled) {
+      // cleanup return focus on trap deactivation
+      // sideEffect/returnFocus should happen by this time
+      originalFocusedElement.current = null;
+    }
+  }, []);
+  var returnFocus = React.useCallback(function (allowDefer) {
+    var returnFocusTo = originalFocusedElement.current;
+
+    if (returnFocusTo && returnFocusTo.focus) {
+      var howToReturnFocus = typeof shouldReturnFocus === 'function' ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;
+
+      if (howToReturnFocus) {
+        var returnFocusOptions = (0, _typeof2["default"])(howToReturnFocus) === 'object' ? howToReturnFocus : undefined;
+        originalFocusedElement.current = null;
+
+        if (allowDefer) {
+          // React might return focus after update
+          // it's safer to defer the action
+          Promise.resolve().then(function () {
+            return returnFocusTo.focus(returnFocusOptions);
+          });
+        } else {
+          returnFocusTo.focus(returnFocusOptions);
+        }
+      }
+    }
+  }, [shouldReturnFocus]); // MEDIUM CALLBACKS
+
+  var onFocus = React.useCallback(function (event) {
+    if (isActive.current) {
+      _medium.mediumFocus.useMedium(event);
+    }
+  }, []);
+  var onBlur = _medium.mediumBlur.useMedium; // REF PROPAGATION
+  // not using real refs due to race conditions
+
+  var setObserveNode = React.useCallback(function (newObserved) {
+    if (observed.current !== newObserved) {
+      observed.current = newObserved;
+      setObserved(newObserved);
+    }
+  }, []);
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (typeof allowTextSelection !== 'undefined') {
+      // eslint-disable-next-line no-console
+      console.warn('React-Focus-Lock: allowTextSelection is deprecated and enabled by default');
+    }
+
+    React.useEffect(function () {
+      if (!observed.current) {
+        // eslint-disable-next-line no-console
+        console.error('FocusLock: could not obtain ref to internal node');
+      }
+    }, []);
+  }
+
+  var lockProps = _objectSpread((_objectSpread2 = {}, (0, _defineProperty2["default"])(_objectSpread2, constants.FOCUS_DISABLED, disabled && 'disabled'), (0, _defineProperty2["default"])(_objectSpread2, constants.FOCUS_GROUP, group), _objectSpread2), containerProps);
+
+  var hasLeadingGuards = noFocusGuards !== true;
+  var hasTailingGuards = hasLeadingGuards && noFocusGuards !== 'tail';
+  var mergedRef = (0, _useCallbackRef.useMergeRefs)([parentRef, setObserveNode]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, hasLeadingGuards && [
+  /*#__PURE__*/
+  // nearest focus guard
+  React.createElement("div", {
+    key: "guard-first",
+    "data-focus-guard": true,
+    tabIndex: disabled ? -1 : 0,
+    style: _FocusGuard.hiddenGuard
+  }), // first tabbed element guard
+  hasPositiveIndices ? /*#__PURE__*/React.createElement("div", {
+    key: "guard-nearest",
+    "data-focus-guard": true,
+    tabIndex: disabled ? -1 : 1,
+    style: _FocusGuard.hiddenGuard
+  }) : null], !disabled && /*#__PURE__*/React.createElement(SideCar, {
+    id: id,
+    sideCar: _medium.mediumSidecar,
+    observed: realObserved,
+    disabled: disabled,
+    persistentFocus: persistentFocus,
+    crossFrame: crossFrame,
+    autoFocus: autoFocus,
+    whiteList: whiteList,
+    shards: shards,
+    onActivation: onActivation,
+    onDeactivation: onDeactivation,
+    returnFocus: returnFocus,
+    focusOptions: focusOptions
+  }), /*#__PURE__*/React.createElement(Container, (0, _extends2["default"])({
+    ref: mergedRef
+  }, lockProps, {
+    className: className,
+    onBlur: onBlur,
+    onFocus: onFocus
+  }), children), hasTailingGuards && /*#__PURE__*/React.createElement("div", {
+    "data-focus-guard": true,
+    tabIndex: disabled ? -1 : 0,
+    style: _FocusGuard.hiddenGuard
+  }));
+});
+FocusLock.propTypes = process.env.NODE_ENV !== "production" ? {
+  children: _propTypes.node,
+  disabled: _propTypes.bool,
+  returnFocus: (0, _propTypes.oneOfType)([_propTypes.bool, _propTypes.object, _propTypes.func]),
+  focusOptions: _propTypes.object,
+  noFocusGuards: _propTypes.bool,
+  hasPositiveIndices: _propTypes.bool,
+  allowTextSelection: _propTypes.bool,
+  autoFocus: _propTypes.bool,
+  persistentFocus: _propTypes.bool,
+  crossFrame: _propTypes.bool,
+  group: _propTypes.string,
+  className: _propTypes.string,
+  whiteList: _propTypes.func,
+  shards: (0, _propTypes.arrayOf)(_propTypes.any),
+  as: (0, _propTypes.oneOfType)([_propTypes.string, _propTypes.func, _propTypes.object]),
+  lockProps: _propTypes.object,
+  onActivation: _propTypes.func,
+  onDeactivation: _propTypes.func,
+  sideCar: _propTypes.any.isRequired
+} : {};
+FocusLock.defaultProps = {
+  children: undefined,
+  disabled: false,
+  returnFocus: false,
+  focusOptions: undefined,
+  noFocusGuards: false,
+  autoFocus: true,
+  persistentFocus: false,
+  crossFrame: true,
+  hasPositiveIndices: undefined,
+  allowTextSelection: undefined,
+  group: undefined,
+  className: undefined,
+  whiteList: undefined,
+  shards: undefined,
+  as: 'div',
+  lockProps: {},
+  onActivation: undefined,
+  onDeactivation: undefined
+};
+var _default = FocusLock;
+exports["default"] = _default;

package/react/dist/node_modules/react-focus-lock/dist/cjs/MoveFocusInside.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.useFocusInside = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var constants = _interopRequireWildcard(require("focus-lock/constants"));
+
+var _util = require("./util");
+
+var _medium = require("./medium");
+
+var useFocusInside = function useFocusInside(observedRef) {
+  React.useEffect(function () {
+    var enabled = true;
+
+    _medium.mediumEffect.useMedium(function (car) {
+      var observed = observedRef && observedRef.current;
+
+      if (enabled && observed) {
+        if (!car.focusInside(observed)) {
+          car.moveFocusInside(observed, null);
+        }
+      }
+    });
+
+    return function () {
+      enabled = false;
+    };
+  }, [observedRef]);
+};
+
+exports.useFocusInside = useFocusInside;
+
+function MoveFocusInside(_ref) {
+  var isDisabled = _ref.disabled,
+      className = _ref.className,
+      children = _ref.children;
+  var ref = React.useRef(null);
+  useFocusInside(isDisabled ? undefined : ref);
+  return /*#__PURE__*/React.createElement("div", (0, _extends2["default"])({}, (0, _util.inlineProp)(constants.FOCUS_AUTO, !isDisabled), {
+    ref: ref,
+    className: className
+  }), children);
+}
+
+MoveFocusInside.propTypes = process.env.NODE_ENV !== "production" ? {
+  children: _propTypes["default"].node.isRequired,
+  disabled: _propTypes["default"].bool,
+  className: _propTypes["default"].string
+} : {};
+MoveFocusInside.defaultProps = {
+  disabled: false,
+  className: undefined
+};
+var _default = MoveFocusInside;
+exports["default"] = _default;

package/react/dist/node_modules/react-focus-lock/dist/cjs/Trap.js

@@ -0,0 +1,299 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _reactClientsideEffect = _interopRequireDefault(require("react-clientside-effect"));
+
+var _focusLock = _interopRequireWildcard(require("focus-lock"));
+
+var _util = require("./util");
+
+var _medium = require("./medium");
+
+var focusOnBody = function focusOnBody() {
+  return document && document.activeElement === document.body;
+};
+
+var isFreeFocus = function isFreeFocus() {
+  return focusOnBody() || (0, _focusLock.focusIsHidden)();
+};
+
+var lastActiveTrap = null;
+var lastActiveFocus = null;
+var lastPortaledElement = null;
+var focusWasOutsideWindow = false;
+
+var defaultWhitelist = function defaultWhitelist() {
+  return true;
+};
+
+var focusWhitelisted = function focusWhitelisted(activeElement) {
+  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);
+};
+
+var recordPortal = function recordPortal(observerNode, portaledElement) {
+  lastPortaledElement = {
+    observerNode: observerNode,
+    portaledElement: portaledElement
+  };
+};
+
+var focusIsPortaledPair = function focusIsPortaledPair(element) {
+  return lastPortaledElement && lastPortaledElement.portaledElement === element;
+};
+
+function autoGuard(startIndex, end, step, allNodes) {
+  var lastGuard = null;
+  var i = startIndex;
+
+  do {
+    var item = allNodes[i];
+
+    if (item.guard) {
+      if (item.node.dataset.focusAutoGuard) {
+        lastGuard = item;
+      }
+    } else if (item.lockItem) {
+      if (i !== startIndex) {
+        // we will tab to the next element
+        return;
+      }
+
+      lastGuard = null;
+    } else {
+      break;
+    }
+  } while ((i += step) !== end);
+
+  if (lastGuard) {
+    lastGuard.node.tabIndex = 0;
+  }
+}
+
+var extractRef = function extractRef(ref) {
+  return ref && 'current' in ref ? ref.current : ref;
+};
+
+var focusWasOutside = function focusWasOutside(crossFrameOption) {
+  if (crossFrameOption) {
+    // with cross frame return true for any value
+    return Boolean(focusWasOutsideWindow);
+  } // in other case return only of focus went a while aho
+
+
+  return focusWasOutsideWindow === 'meanwhile';
+};
+
+var checkInHost = function checkInHost(check, el, boundary) {
+  return el // find host equal to active element and check nested active element
+  && (el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) // dive up
+  || el.parentNode && checkInHost(check, el.parentNode, boundary));
+};
+
+var withinHost = function withinHost(activeElement, workingArea) {
+  return workingArea.some(function (area) {
+    return checkInHost(activeElement, area, area);
+  });
+};
+
+var activateTrap = function activateTrap() {
+  var result = false;
+
+  if (lastActiveTrap) {
+    var _lastActiveTrap = lastActiveTrap,
+        observed = _lastActiveTrap.observed,
+        persistentFocus = _lastActiveTrap.persistentFocus,
+        autoFocus = _lastActiveTrap.autoFocus,
+        shards = _lastActiveTrap.shards,
+        crossFrame = _lastActiveTrap.crossFrame,
+        focusOptions = _lastActiveTrap.focusOptions;
+    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;
+    var activeElement = document && document.activeElement;
+
+    if (workingNode) {
+      var workingArea = [workingNode].concat((0, _toConsumableArray2["default"])(shards.map(extractRef).filter(Boolean)));
+
+      if (!activeElement || focusWhitelisted(activeElement)) {
+        if (persistentFocus || focusWasOutside(crossFrame) || !isFreeFocus() || !lastActiveFocus && autoFocus) {
+          if (workingNode && !( // active element is "inside" working area
+          (0, _focusLock.focusInside)(workingArea) || // check for shadow-dom contained elements
+          activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement, workingNode))) {
+            if (document && !lastActiveFocus && activeElement && !autoFocus) {
+              // Check if blur() exists, which is missing on certain elements on IE
+              if (activeElement.blur) {
+                activeElement.blur();
+              }
+
+              document.body.focus();
+            } else {
+              result = (0, _focusLock["default"])(workingArea, lastActiveFocus, {
+                focusOptions: focusOptions
+              });
+              lastPortaledElement = {};
+            }
+          }
+
+          focusWasOutsideWindow = false;
+          lastActiveFocus = document && document.activeElement;
+        }
+      }
+
+      if (document) {
+        var newActiveElement = document && document.activeElement;
+        var allNodes = (0, _focusLock.getFocusabledIn)(workingArea);
+        var focusedIndex = allNodes.map(function (_ref) {
+          var node = _ref.node;
+          return node;
+        }).indexOf(newActiveElement);
+
+        if (focusedIndex > -1) {
+          // remove old focus
+          allNodes.filter(function (_ref2) {
+            var guard = _ref2.guard,
+                node = _ref2.node;
+            return guard && node.dataset.focusAutoGuard;
+          }).forEach(function (_ref3) {
+            var node = _ref3.node;
+            return node.removeAttribute('tabIndex');
+          });
+          autoGuard(focusedIndex, allNodes.length, +1, allNodes);
+          autoGuard(focusedIndex, -1, -1, allNodes);
+        }
+      }
+    }
+  }
+
+  return result;
+};
+
+var onTrap = function onTrap(event) {
+  if (activateTrap() && event) {
+    // prevent scroll jump
+    event.stopPropagation();
+    event.preventDefault();
+  }
+};
+
+var onBlur = function onBlur() {
+  return (0, _util.deferAction)(activateTrap);
+};
+
+var onFocus = function onFocus(event) {
+  // detect portal
+  var source = event.target;
+  var currentNode = event.currentTarget;
+
+  if (!currentNode.contains(source)) {
+    recordPortal(currentNode, source);
+  }
+};
+
+var FocusWatcher = function FocusWatcher() {
+  return null;
+};
+
+var FocusTrap = function FocusTrap(_ref4) {
+  var children = _ref4.children;
+  return /*#__PURE__*/React.createElement("div", {
+    onBlur: onBlur,
+    onFocus: onFocus
+  }, children);
+};
+
+FocusTrap.propTypes = process.env.NODE_ENV !== "production" ? {
+  children: _propTypes["default"].node.isRequired
+} : {};
+
+var onWindowBlur = function onWindowBlur() {
+  focusWasOutsideWindow = 'just'; // using setTimeout to set  this variable after React/sidecar reaction
+
+  setTimeout(function () {
+    focusWasOutsideWindow = 'meanwhile';
+  }, 0);
+};
+
+var attachHandler = function attachHandler() {
+  document.addEventListener('focusin', onTrap);
+  document.addEventListener('focusout', onBlur);
+  window.addEventListener('blur', onWindowBlur);
+};
+
+var detachHandler = function detachHandler() {
+  document.removeEventListener('focusin', onTrap);
+  document.removeEventListener('focusout', onBlur);
+  window.removeEventListener('blur', onWindowBlur);
+};
+
+function reducePropsToState(propsList) {
+  return propsList.filter(function (_ref5) {
+    var disabled = _ref5.disabled;
+    return !disabled;
+  });
+}
+
+function handleStateChangeOnClient(traps) {
+  var trap = traps.slice(-1)[0];
+
+  if (trap && !lastActiveTrap) {
+    attachHandler();
+  }
+
+  var lastTrap = lastActiveTrap;
+  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;
+  lastActiveTrap = trap;
+
+  if (lastTrap && !sameTrap) {
+    lastTrap.onDeactivation(); // return focus only of last trap was removed
+
+    if (!traps.filter(function (_ref6) {
+      var id = _ref6.id;
+      return id === lastTrap.id;
+    }).length) {
+      // allow defer is no other trap is awaiting restore
+      lastTrap.returnFocus(!trap);
+    }
+  }
+
+  if (trap) {
+    lastActiveFocus = null;
+
+    if (!sameTrap || lastTrap.observed !== trap.observed) {
+      trap.onActivation();
+    }
+
+    activateTrap(true);
+    (0, _util.deferAction)(activateTrap);
+  } else {
+    detachHandler();
+    lastActiveFocus = null;
+  }
+} // bind medium
+
+
+_medium.mediumFocus.assignSyncMedium(onFocus);
+
+_medium.mediumBlur.assignMedium(onBlur);
+
+_medium.mediumEffect.assignMedium(function (cb) {
+  return cb({
+    moveFocusInside: _focusLock["default"],
+    focusInside: _focusLock.focusInside
+  });
+});
+
+var _default = (0, _reactClientsideEffect["default"])(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);
+
+exports["default"] = _default;

package/react/dist/node_modules/react-focus-lock/dist/cjs/UI.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FocusLockUI", {
+  enumerable: true,
+  get: function get() {
+    return _Lock["default"];
+  }
+});
+Object.defineProperty(exports, "AutoFocusInside", {
+  enumerable: true,
+  get: function get() {
+    return _AutoFocusInside["default"];
+  }
+});
+Object.defineProperty(exports, "MoveFocusInside", {
+  enumerable: true,
+  get: function get() {
+    return _MoveFocusInside["default"];
+  }
+});
+Object.defineProperty(exports, "useFocusInside", {
+  enumerable: true,
+  get: function get() {
+    return _MoveFocusInside.useFocusInside;
+  }
+});
+Object.defineProperty(exports, "FreeFocusInside", {
+  enumerable: true,
+  get: function get() {
+    return _FreeFocusInside["default"];
+  }
+});
+Object.defineProperty(exports, "InFocusGuard", {
+  enumerable: true,
+  get: function get() {
+    return _FocusGuard["default"];
+  }
+});
+exports["default"] = void 0;
+
+var _Lock = _interopRequireDefault(require("./Lock"));
+
+var _AutoFocusInside = _interopRequireDefault(require("./AutoFocusInside"));
+
+var _MoveFocusInside = _interopRequireWildcard(require("./MoveFocusInside"));
+
+var _FreeFocusInside = _interopRequireDefault(require("./FreeFocusInside"));
+
+var _FocusGuard = _interopRequireDefault(require("./FocusGuard"));
+
+var _default = _Lock["default"];
+exports["default"] = _default;