266 lines
8.3 KiB
JavaScript
266 lines
8.3 KiB
JavaScript
"use strict";
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.ariaHidden = ariaHidden;
|
|
exports.default = void 0;
|
|
|
|
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
|
|
|
|
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _getScrollbarSize = _interopRequireDefault(require("../utils/getScrollbarSize"));
|
|
|
|
var _ownerDocument = _interopRequireDefault(require("../utils/ownerDocument"));
|
|
|
|
var _ownerWindow = _interopRequireDefault(require("../utils/ownerWindow"));
|
|
|
|
// Is a vertical scrollbar displayed?
|
|
function isOverflowing(container) {
|
|
var doc = (0, _ownerDocument.default)(container);
|
|
|
|
if (doc.body === container) {
|
|
return (0, _ownerWindow.default)(doc).innerWidth > doc.documentElement.clientWidth;
|
|
}
|
|
|
|
return container.scrollHeight > container.clientHeight;
|
|
}
|
|
|
|
function ariaHidden(node, show) {
|
|
if (show) {
|
|
node.setAttribute('aria-hidden', 'true');
|
|
} else {
|
|
node.removeAttribute('aria-hidden');
|
|
}
|
|
}
|
|
|
|
function getPaddingRight(node) {
|
|
return parseInt(window.getComputedStyle(node)['padding-right'], 10) || 0;
|
|
}
|
|
|
|
function ariaHiddenSiblings(container, mountNode, currentNode) {
|
|
var nodesToExclude = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
|
|
var show = arguments.length > 4 ? arguments[4] : undefined;
|
|
var blacklist = [mountNode, currentNode].concat((0, _toConsumableArray2.default)(nodesToExclude));
|
|
var blacklistTagNames = ['TEMPLATE', 'SCRIPT', 'STYLE'];
|
|
[].forEach.call(container.children, function (node) {
|
|
if (node.nodeType === 1 && blacklist.indexOf(node) === -1 && blacklistTagNames.indexOf(node.tagName) === -1) {
|
|
ariaHidden(node, show);
|
|
}
|
|
});
|
|
}
|
|
|
|
function findIndexOf(containerInfo, callback) {
|
|
var idx = -1;
|
|
containerInfo.some(function (item, index) {
|
|
if (callback(item)) {
|
|
idx = index;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
});
|
|
return idx;
|
|
}
|
|
|
|
function handleContainer(containerInfo, props) {
|
|
var restoreStyle = [];
|
|
var restorePaddings = [];
|
|
var container = containerInfo.container;
|
|
var fixedNodes;
|
|
|
|
if (!props.disableScrollLock) {
|
|
if (isOverflowing(container)) {
|
|
// Compute the size before applying overflow hidden to avoid any scroll jumps.
|
|
var scrollbarSize = (0, _getScrollbarSize.default)();
|
|
restoreStyle.push({
|
|
value: container.style.paddingRight,
|
|
key: 'padding-right',
|
|
el: container
|
|
}); // Use computed style, here to get the real padding to add our scrollbar width.
|
|
|
|
container.style['padding-right'] = "".concat(getPaddingRight(container) + scrollbarSize, "px"); // .mui-fixed is a global helper.
|
|
|
|
fixedNodes = (0, _ownerDocument.default)(container).querySelectorAll('.mui-fixed');
|
|
[].forEach.call(fixedNodes, function (node) {
|
|
restorePaddings.push(node.style.paddingRight);
|
|
node.style.paddingRight = "".concat(getPaddingRight(node) + scrollbarSize, "px");
|
|
});
|
|
} // Improve Gatsby support
|
|
// https://css-tricks.com/snippets/css/force-vertical-scrollbar/
|
|
|
|
|
|
var parent = container.parentElement;
|
|
var scrollContainer = parent.nodeName === 'HTML' && window.getComputedStyle(parent)['overflow-y'] === 'scroll' ? parent : container; // Block the scroll even if no scrollbar is visible to account for mobile keyboard
|
|
// screensize shrink.
|
|
|
|
restoreStyle.push({
|
|
value: scrollContainer.style.overflow,
|
|
key: 'overflow',
|
|
el: scrollContainer
|
|
});
|
|
scrollContainer.style.overflow = 'hidden';
|
|
}
|
|
|
|
var restore = function restore() {
|
|
if (fixedNodes) {
|
|
[].forEach.call(fixedNodes, function (node, i) {
|
|
if (restorePaddings[i]) {
|
|
node.style.paddingRight = restorePaddings[i];
|
|
} else {
|
|
node.style.removeProperty('padding-right');
|
|
}
|
|
});
|
|
}
|
|
|
|
restoreStyle.forEach(function (_ref) {
|
|
var value = _ref.value,
|
|
el = _ref.el,
|
|
key = _ref.key;
|
|
|
|
if (value) {
|
|
el.style.setProperty(key, value);
|
|
} else {
|
|
el.style.removeProperty(key);
|
|
}
|
|
});
|
|
};
|
|
|
|
return restore;
|
|
}
|
|
|
|
function getHiddenSiblings(container) {
|
|
var hiddenSiblings = [];
|
|
[].forEach.call(container.children, function (node) {
|
|
if (node.getAttribute && node.getAttribute('aria-hidden') === 'true') {
|
|
hiddenSiblings.push(node);
|
|
}
|
|
});
|
|
return hiddenSiblings;
|
|
}
|
|
/**
|
|
* @ignore - do not document.
|
|
*
|
|
* Proper state management for containers and the modals in those containers.
|
|
* Simplified, but inspired by react-overlay's ModalManager class.
|
|
* Used by the Modal to ensure proper styling of containers.
|
|
*/
|
|
|
|
|
|
var ModalManager = /*#__PURE__*/function () {
|
|
function ModalManager() {
|
|
(0, _classCallCheck2.default)(this, ModalManager);
|
|
// this.modals[modalIndex] = modal
|
|
this.modals = []; // this.containers[containerIndex] = {
|
|
// modals: [],
|
|
// container,
|
|
// restore: null,
|
|
// }
|
|
|
|
this.containers = [];
|
|
}
|
|
|
|
(0, _createClass2.default)(ModalManager, [{
|
|
key: "add",
|
|
value: function add(modal, container) {
|
|
var modalIndex = this.modals.indexOf(modal);
|
|
|
|
if (modalIndex !== -1) {
|
|
return modalIndex;
|
|
}
|
|
|
|
modalIndex = this.modals.length;
|
|
this.modals.push(modal); // If the modal we are adding is already in the DOM.
|
|
|
|
if (modal.modalRef) {
|
|
ariaHidden(modal.modalRef, false);
|
|
}
|
|
|
|
var hiddenSiblingNodes = getHiddenSiblings(container);
|
|
ariaHiddenSiblings(container, modal.mountNode, modal.modalRef, hiddenSiblingNodes, true);
|
|
var containerIndex = findIndexOf(this.containers, function (item) {
|
|
return item.container === container;
|
|
});
|
|
|
|
if (containerIndex !== -1) {
|
|
this.containers[containerIndex].modals.push(modal);
|
|
return modalIndex;
|
|
}
|
|
|
|
this.containers.push({
|
|
modals: [modal],
|
|
container: container,
|
|
restore: null,
|
|
hiddenSiblingNodes: hiddenSiblingNodes
|
|
});
|
|
return modalIndex;
|
|
}
|
|
}, {
|
|
key: "mount",
|
|
value: function mount(modal, props) {
|
|
var containerIndex = findIndexOf(this.containers, function (item) {
|
|
return item.modals.indexOf(modal) !== -1;
|
|
});
|
|
var containerInfo = this.containers[containerIndex];
|
|
|
|
if (!containerInfo.restore) {
|
|
containerInfo.restore = handleContainer(containerInfo, props);
|
|
}
|
|
}
|
|
}, {
|
|
key: "remove",
|
|
value: function remove(modal) {
|
|
var modalIndex = this.modals.indexOf(modal);
|
|
|
|
if (modalIndex === -1) {
|
|
return modalIndex;
|
|
}
|
|
|
|
var containerIndex = findIndexOf(this.containers, function (item) {
|
|
return item.modals.indexOf(modal) !== -1;
|
|
});
|
|
var containerInfo = this.containers[containerIndex];
|
|
containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);
|
|
this.modals.splice(modalIndex, 1); // If that was the last modal in a container, clean up the container.
|
|
|
|
if (containerInfo.modals.length === 0) {
|
|
// The modal might be closed before it had the chance to be mounted in the DOM.
|
|
if (containerInfo.restore) {
|
|
containerInfo.restore();
|
|
}
|
|
|
|
if (modal.modalRef) {
|
|
// In case the modal wasn't in the DOM yet.
|
|
ariaHidden(modal.modalRef, true);
|
|
}
|
|
|
|
ariaHiddenSiblings(containerInfo.container, modal.mountNode, modal.modalRef, containerInfo.hiddenSiblingNodes, false);
|
|
this.containers.splice(containerIndex, 1);
|
|
} else {
|
|
// Otherwise make sure the next top modal is visible to a screen reader.
|
|
var nextTop = containerInfo.modals[containerInfo.modals.length - 1]; // as soon as a modal is adding its modalRef is undefined. it can't set
|
|
// aria-hidden because the dom element doesn't exist either
|
|
// when modal was unmounted before modalRef gets null
|
|
|
|
if (nextTop.modalRef) {
|
|
ariaHidden(nextTop.modalRef, false);
|
|
}
|
|
}
|
|
|
|
return modalIndex;
|
|
}
|
|
}, {
|
|
key: "isTopModal",
|
|
value: function isTopModal(modal) {
|
|
return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;
|
|
}
|
|
}]);
|
|
return ModalManager;
|
|
}();
|
|
|
|
exports.default = ModalManager; |