From 635a6cfd22f55a9fcad685302e59e7eb753e9282 Mon Sep 17 00:00:00 2001 From: Rob Dodson Date: Fri, 16 Sep 2016 14:29:52 -0700 Subject: [PATCH] Add transpiling build process. Fixes #19 (#24) * Add transpiling build process * tidy up --- README.md | 5 + dist/inert.js | 892 ++++++++++++++++++++++++++++++++++++++++++++++ dist/inert.min.js | 1 + gulpfile.js | 43 +++ inert.html | 2 +- package.json | 10 +- test/index.html | 2 +- 7 files changed, 952 insertions(+), 3 deletions(-) create mode 100644 dist/inert.js create mode 100644 dist/inert.min.js create mode 100644 gulpfile.js diff --git a/README.md b/README.md index 67baac5..5b7038c 100644 --- a/README.md +++ b/README.md @@ -185,6 +185,11 @@ implementers may get useful functionality into the hands of developers sooner wh ## Notes on the polyfill +The `dist` directory contains two versions of the polyfill. `inert.js` is the debug version, containing an inlined sourcemap, `inert.min.js` is +the production version, minified to be as small as possible. These are both +generated from the ES6 version of `inert.js` which lives in the root directory, +and can be used if you don't need to worry about transpilation. + The polyfill attempts to provide a reasonable fidelity polyfill for the `inert` attribute, however please note: - It relies on mutation observers to detect the addition of the `inert` attribute, and to detect dynamically added content within inert subtrees. diff --git a/dist/inert.js b/dist/inert.js new file mode 100644 index 0000000..bc37e95 --- /dev/null +++ b/dist/inert.js @@ -0,0 +1,892 @@ +'use strict'; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * + * Copyright 2016 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +(function (document) { + + /** @type {string} */ + var _focusableElementsString = ['a[href]', 'area[href]', 'input:not([disabled])', 'select:not([disabled])', 'textarea:not([disabled])', 'button:not([disabled])', 'iframe', 'object', 'embed', '[contenteditable]'].join(','); + + /** + * `InertRoot` manages a single inert subtree, i.e. a DOM subtree whose root element has an `inert` + * attribute. + * + * Its main functions are: + * + * - to create and maintain a set of managed `InertNode`s, including when mutations occur in the + * subtree. The `makeSubtreeUnfocusable()` method handles collecting `InertNode`s via registering + * each focusable node in the subtree with the singleton `InertManager` which manages all known + * focusable nodes within inert subtrees. `InertManager` ensures that a single `InertNode` + * instance exists for each focusable node which has at least one inert root as an ancestor. + * + * - to notify all managed `InertNode`s when this subtree stops being inert (i.e. when the `inert` + * attribute is removed from the root node). This is handled in the destructor, which calls the + * `deregister` method on `InertManager` for each managed inert node. + */ + + var InertRoot = function () { + /** + * @param {Element} rootElement The Element at the root of the inert subtree. + * @param {InertManager} inertManager The global singleton InertManager object. + */ + function InertRoot(rootElement, inertManager) { + _classCallCheck(this, InertRoot); + + /** @type {InertManager} */ + this._inertManager = inertManager; + + /** @type {Element} */ + this._rootElement = rootElement; + + /** + * @type {Set} + * All managed focusable nodes in this InertRoot's subtree. + */ + this._managedNodes = new Set([]); + + // Make the subtree hidden from assistive technology + this._rootElement.setAttribute('aria-hidden', 'true'); + + // Make all focusable elements in the subtree unfocusable and add them to _managedNodes + this._makeSubtreeUnfocusable(this._rootElement); + + // Watch for: + // - any additions in the subtree: make them unfocusable too + // - any removals from the subtree: remove them from this inert root's managed nodes + // - attribute changes: if `tabindex` is added, or removed from an intrinsically focusable element, + // make that node a managed node. + this._observer = new MutationObserver(this._onMutation.bind(this)); + this._observer.observe(this._rootElement, { attributes: true, childList: true, subtree: true }); + } + + /** + * Call this whenever this object is about to become obsolete. This unwinds all of the state + * stored in this object and updates the state of all of the managed nodes. + */ + + + _createClass(InertRoot, [{ + key: 'destructor', + value: function destructor() { + this._observer.disconnect(); + delete this._observer; + + if (this._rootElement) this._rootElement.removeAttribute('aria-hidden'); + delete this._rootElement; + + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = this._managedNodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var inertNode = _step.value; + + this._unmanageNode(inertNode.node); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + delete this._managedNodes; + + delete this._inertManager; + } + + /** + * @return {Set} A copy of this InertRoot's managed nodes set. + */ + + }, { + key: '_makeSubtreeUnfocusable', + + + /** + * @param {Node} startNode + */ + value: function _makeSubtreeUnfocusable(startNode) { + var _this = this; + + composedTreeWalk(startNode, function (node) { + _this._visitNode(node); + }); + } + + /** + * @param {Node} node + */ + + }, { + key: '_visitNode', + value: function _visitNode(node) { + if (node.nodeType !== Node.ELEMENT_NODE) return; + + // If a descendant inert root becomes un-inert, its descendants will still be inert because of this + // inert root, so all of its managed nodes need to be adopted by this InertRoot. + if (node !== this._rootElement && node.hasAttribute('inert')) this._adoptInertRoot(node); + + if (node.matches(_focusableElementsString) || node.hasAttribute('tabindex')) this._manageNode(node); + } + + /** + * Register the given node with this InertRoot and with InertManager. + * @param {Node} node + */ + + }, { + key: '_manageNode', + value: function _manageNode(node) { + var inertNode = this._inertManager.register(node, this); + this._managedNodes.add(inertNode); + } + + /** + * Unregister the given node with this InertRoot and with InertManager. + * @param {Node} node + */ + + }, { + key: '_unmanageNode', + value: function _unmanageNode(node) { + var inertNode = this._inertManager.deregister(node, this); + if (inertNode) this._managedNodes.delete(inertNode); + } + + /** + * Unregister the entire subtree starting at `startNode`. + * @param {Node} startNode + */ + + }, { + key: '_unmanageSubtree', + value: function _unmanageSubtree(startNode) { + var _this2 = this; + + composedTreeWalk(startNode, function (node) { + _this2._unmanageNode(node); + }); + } + + /** + * If a descendant node is found with an `inert` attribute, adopt its managed nodes. + * @param {Node} node + */ + + }, { + key: '_adoptInertRoot', + value: function _adoptInertRoot(node) { + var inertSubroot = this._inertManager.getInertRoot(node); + + // During initialisation this inert root may not have been registered yet, + // so register it now if need be. + if (!inertSubroot) { + this._inertManager.setInert(node, true); + inertSubroot = this._inertManager.getInertRoot(node); + } + + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = inertSubroot.managedNodes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var savedInertNode = _step2.value; + + this._manageNode(savedInertNode.node); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + } + + /** + * Callback used when mutation observer detects subtree additions, removals, or attribute changes. + * @param {MutationRecord} records + * @param {MutationObserver} self + */ + + }, { + key: '_onMutation', + value: function _onMutation(records, self) { + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = undefined; + + try { + for (var _iterator3 = records[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var record = _step3.value; + + var target = record.target; + if (record.type === 'childList') { + // Manage added nodes + var _iteratorNormalCompletion4 = true; + var _didIteratorError4 = false; + var _iteratorError4 = undefined; + + try { + for (var _iterator4 = Array.from(record.addedNodes)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + var node = _step4.value; + + this._makeSubtreeUnfocusable(node); + } // Un-manage removed nodes + } catch (err) { + _didIteratorError4 = true; + _iteratorError4 = err; + } finally { + try { + if (!_iteratorNormalCompletion4 && _iterator4.return) { + _iterator4.return(); + } + } finally { + if (_didIteratorError4) { + throw _iteratorError4; + } + } + } + + var _iteratorNormalCompletion5 = true; + var _didIteratorError5 = false; + var _iteratorError5 = undefined; + + try { + for (var _iterator5 = Array.from(record.removedNodes)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) { + var _node = _step5.value; + + this._unmanageSubtree(_node); + } + } catch (err) { + _didIteratorError5 = true; + _iteratorError5 = err; + } finally { + try { + if (!_iteratorNormalCompletion5 && _iterator5.return) { + _iterator5.return(); + } + } finally { + if (_didIteratorError5) { + throw _iteratorError5; + } + } + } + } else if (record.type === 'attributes') { + if (record.attributeName === 'tabindex') { + // Re-initialise inert node if tabindex changes + this._manageNode(target); + } else if (target !== this._rootElement && record.attributeName === 'inert' && target.hasAttribute('inert')) { + // If a new inert root is added, adopt its managed nodes and make sure it knows about the + // already managed nodes from this inert subroot. + this._adoptInertRoot(target); + var inertSubroot = this._inertManager.getInertRoot(target); + var _iteratorNormalCompletion6 = true; + var _didIteratorError6 = false; + var _iteratorError6 = undefined; + + try { + for (var _iterator6 = this._managedNodes[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) { + var managedNode = _step6.value; + + if (target.contains(managedNode.node)) inertSubroot._manageNode(managedNode.node); + } + } catch (err) { + _didIteratorError6 = true; + _iteratorError6 = err; + } finally { + try { + if (!_iteratorNormalCompletion6 && _iterator6.return) { + _iterator6.return(); + } + } finally { + if (_didIteratorError6) { + throw _iteratorError6; + } + } + } + } + } + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } + } + }, { + key: 'managedNodes', + get: function get() { + return new Set(this._managedNodes); + } + }]); + + return InertRoot; + }(); + + /** + * `InertNode` initialises and manages a single inert node. + * A node is inert if it is a descendant of one or more inert root elements. + * + * On construction, `InertNode` saves the existing `tabindex` value for the node, if any, and + * either removes the `tabindex` attribute or sets it to `-1`, depending on whether the element + * is intrinsically focusable or not. + * + * `InertNode` maintains a set of `InertRoot`s which are descendants of this `InertNode`. When an + * `InertRoot` is destroyed, and calls `InertManager.deregister()`, the `InertManager` notifies the + * `InertNode` via `removeInertRoot()`, which in turn destroys the `InertNode` if no `InertRoot`s + * remain in the set. On destruction, `InertNode` reinstates the stored `tabindex` if one exists, + * or removes the `tabindex` attribute if the element is intrinsically focusable. + */ + + + var InertNode = function () { + /** + * @param {Node} node A focusable element to be made inert. + * @param {InertRoot} inertRoot The inert root element associated with this inert node. + */ + function InertNode(node, inertRoot) { + _classCallCheck(this, InertNode); + + /** @type {Node} */ + this._node = node; + + /** @type {boolean} */ + this._overrodeFocusMethod = false; + + /** + * @type {Set} The set of descendant inert roots. + * If and only if this set becomes empty, this node is no longer inert. + */ + this._inertRoots = new Set([inertRoot]); + + /** @type {boolean} */ + this._destroyed = false; + + // Save any prior tabindex info and make this node untabbable + this.ensureUntabbable(); + } + + /** + * Call this whenever this object is about to become obsolete. + * This makes the managed node focusable again and deletes all of the previously stored state. + */ + + + _createClass(InertNode, [{ + key: 'destructor', + value: function destructor() { + this._throwIfDestroyed(); + + if (this._node) { + if (this.hasSavedTabIndex) this._node.setAttribute('tabindex', this.savedTabIndex);else this._node.removeAttribute('tabindex'); + + if (this._overrodeFocusMethod) delete this._node.focus; + } + delete this._node; + delete this._inertRoots; + + this._destroyed = true; + } + + /** + * @type {boolean} Whether this object is obsolete because the managed node is no longer inert. + * If the object has been destroyed, any attempt to access it will cause an exception. + */ + + }, { + key: '_throwIfDestroyed', + value: function _throwIfDestroyed() { + if (this.destroyed) throw new Error("Trying to access destroyed InertNode"); + } + + /** @return {boolean} */ + + }, { + key: 'ensureUntabbable', + + + /** Save the existing tabindex value and make the node untabbable and unfocusable */ + value: function ensureUntabbable() { + var node = this.node; + node.blur(); // TODO(alice): is this right? + if (node.matches(_focusableElementsString)) { + if (node.tabIndex === -1 && this.hasSavedTabIndex) return; + + if (node.hasAttribute('tabindex')) this._savedTabIndex = node.tabIndex; + node.setAttribute('tabindex', '-1'); + if (node.nodeType === Node.ELEMENT_NODE) { + node.focus = function () {}; + this._overrodeFocusMethod = true; + } + } else if (node.hasAttribute('tabindex')) { + this._savedTabIndex = node.tabIndex; + node.removeAttribute('tabindex'); + } + } + + /** + * Add another inert root to this inert node's set of managing inert roots. + * @param {InertRoot} inertRoot + */ + + }, { + key: 'addInertRoot', + value: function addInertRoot(inertRoot) { + this._throwIfDestroyed(); + this._inertRoots.add(inertRoot); + } + + /** + * Remove the given inert root from this inert node's set of managing inert roots. + * If the set of managing inert roots becomes empty, this node is no longer inert, + * so the object should be destroyed. + * @param {InertRoot} inertRoot + */ + + }, { + key: 'removeInertRoot', + value: function removeInertRoot(inertRoot) { + this._throwIfDestroyed(); + this._inertRoots.delete(inertRoot); + if (this._inertRoots.size === 0) this.destructor(); + } + }, { + key: 'destroyed', + get: function get() { + return this._destroyed; + } + }, { + key: 'hasSavedTabIndex', + get: function get() { + return '_savedTabIndex' in this; + } + + /** @return {Node} */ + + }, { + key: 'node', + get: function get() { + this._throwIfDestroyed(); + return this._node; + } + + /** @param {number} tabIndex */ + + }, { + key: 'savedTabIndex', + set: function set(tabIndex) { + this._throwIfDestroyed(); + this._savedTabIndex = tabIndex; + } + + /** @return {number} */ + , + get: function get() { + this._throwIfDestroyed(); + return this._savedTabIndex; + } + }]); + + return InertNode; + }(); + + /** + * InertManager is a per-document singleton object which manages all inert roots and nodes. + * + * When an element becomes an inert root by having an `inert` attribute set and/or its `inert` + * property set to `true`, the `setInert` method creates an `InertRoot` object for the element. + * The `InertRoot` in turn registers itself as managing all of the element's focusable descendant + * nodes via the `register()` method. The `InertManager` ensures that a single `InertNode` instance + * is created for each such node, via the `_managedNodes` map. + */ + + + var InertManager = function () { + /** + * @param {Document} document + */ + function InertManager(document) { + _classCallCheck(this, InertManager); + + if (!document) throw new Error('Missing required argument; InertManager needs to wrap a document.'); + + /** @type {Document} */ + this._document = document; + + /** + * All managed nodes known to this InertManager. In a map to allow looking up by Node. + * @type {Map} + */ + this._managedNodes = new Map(); + + /** + * All inert roots known to this InertManager. In a map to allow looking up by Node. + * @type {Map} + */ + this._inertRoots = new Map(); + + // Find all inert roots in document and make them actually inert. + var inertElements = Array.from(document.querySelectorAll('[inert]')); + var _iteratorNormalCompletion7 = true; + var _didIteratorError7 = false; + var _iteratorError7 = undefined; + + try { + for (var _iterator7 = inertElements[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) { + var inertElement = _step7.value; + + this.setInert(inertElement, true); + } // Comment these two lines out to use programmatic API only + } catch (err) { + _didIteratorError7 = true; + _iteratorError7 = err; + } finally { + try { + if (!_iteratorNormalCompletion7 && _iterator7.return) { + _iterator7.return(); + } + } finally { + if (_didIteratorError7) { + throw _iteratorError7; + } + } + } + + this._observer = new MutationObserver(this._watchForInert.bind(this)); + this._observer.observe(document.body, { attributes: true, subtree: true, childList: true }); + } + + /** + * Set whether the given element should be an inert root or not. + * @param {Element} root + * @param {boolean} inert + */ + + + _createClass(InertManager, [{ + key: 'setInert', + value: function setInert(root, inert) { + if (inert) { + if (this._inertRoots.has(root)) // element is already inert + return; + + var inertRoot = new InertRoot(root, this); + root.setAttribute('inert', ''); + this._inertRoots.set(root, inertRoot); + // If not contained in the document, it must be in a shadowRoot. + // Ensure inert styles are added there. + if (!this._document.body.contains(root)) { + var parent = root.parentNode; + while (parent) { + if (parent.nodeType === 11) { + addInertStyle(parent); + } + parent = parent.parentNode; + } + } + } else { + if (!this._inertRoots.has(root)) // element is already non-inert + return; + + var _inertRoot = this._inertRoots.get(root); + _inertRoot.destructor(); + this._inertRoots.delete(root); + root.removeAttribute('inert'); + } + } + + /** + * Get the InertRoot object corresponding to the given inert root element, if any. + * @param {Element} element + * @return {InertRoot?} + */ + + }, { + key: 'getInertRoot', + value: function getInertRoot(element) { + return this._inertRoots.get(element); + } + + /** + * Register the given InertRoot as managing the given node. + * In the case where the node has a previously existing inert root, this inert root will + * be added to its set of inert roots. + * @param {Node} node + * @param {InertRoot} inertRoot + * @return {InertNode} inertNode + */ + + }, { + key: 'register', + value: function register(node, inertRoot) { + var inertNode = this._managedNodes.get(node); + if (inertNode !== undefined) { + // node was already in an inert subtree + inertNode.addInertRoot(inertRoot); + // Update saved tabindex value if necessary + inertNode.ensureUntabbable(); + } else { + inertNode = new InertNode(node, inertRoot); + } + + this._managedNodes.set(node, inertNode); + + return inertNode; + } + + /** + * De-register the given InertRoot as managing the given inert node. + * Removes the inert root from the InertNode's set of managing inert roots, and remove the inert + * node from the InertManager's set of managed nodes if it is destroyed. + * If the node is not currently managed, this is essentially a no-op. + * @param {Node} node + * @param {InertRoot} inertRoot + * @return {InertNode?} The potentially destroyed InertNode associated with this node, if any. + */ + + }, { + key: 'deregister', + value: function deregister(node, inertRoot) { + var inertNode = this._managedNodes.get(node); + if (!inertNode) return null; + + inertNode.removeInertRoot(inertRoot); + if (inertNode.destroyed) this._managedNodes.delete(node); + + return inertNode; + } + + /** + * Callback used when mutation observer detects attribute changes. + * @param {MutationRecord} records + * @param {MutationObserver} self + */ + + }, { + key: '_watchForInert', + value: function _watchForInert(records, self) { + var _iteratorNormalCompletion8 = true; + var _didIteratorError8 = false; + var _iteratorError8 = undefined; + + try { + for (var _iterator8 = records[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) { + var record = _step8.value; + + switch (record.type) { + case 'childList': + var _iteratorNormalCompletion9 = true; + var _didIteratorError9 = false; + var _iteratorError9 = undefined; + + try { + for (var _iterator9 = Array.from(record.addedNodes)[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) { + var node = _step9.value; + + if (node.nodeType !== Node.ELEMENT_NODE) continue; + var inertElements = Array.from(node.querySelectorAll('[inert]')); + if (node.matches('[inert]')) inertElements.unshift(node); + var _iteratorNormalCompletion10 = true; + var _didIteratorError10 = false; + var _iteratorError10 = undefined; + + try { + for (var _iterator10 = inertElements[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) { + var inertElement = _step10.value; + + this.setInert(inertElement, true); + } + } catch (err) { + _didIteratorError10 = true; + _iteratorError10 = err; + } finally { + try { + if (!_iteratorNormalCompletion10 && _iterator10.return) { + _iterator10.return(); + } + } finally { + if (_didIteratorError10) { + throw _iteratorError10; + } + } + } + } + } catch (err) { + _didIteratorError9 = true; + _iteratorError9 = err; + } finally { + try { + if (!_iteratorNormalCompletion9 && _iterator9.return) { + _iterator9.return(); + } + } finally { + if (_didIteratorError9) { + throw _iteratorError9; + } + } + } + + break; + case 'attributes': + if (record.attributeName !== 'inert') continue; + var target = record.target; + var inert = target.hasAttribute('inert'); + this.setInert(target, inert); + break; + } + } + } catch (err) { + _didIteratorError8 = true; + _iteratorError8 = err; + } finally { + try { + if (!_iteratorNormalCompletion8 && _iterator8.return) { + _iterator8.return(); + } + } finally { + if (_didIteratorError8) { + throw _iteratorError8; + } + } + } + } + }]); + + return InertManager; + }(); + + /** + * Recursively walk the composed tree from |node|. + * @param {Node} node + * @param {(function (Element))=} callback Callback to be called for each element traversed, + * before descending into child nodes. + * @param {ShadowRoot=} shadowRootAncestor The nearest ShadowRoot ancestor, if any. + */ + + + function composedTreeWalk(node, callback, shadowRootAncestor) { + if (node.nodeType == Node.ELEMENT_NODE) { + var element = /** @type {Element} */node; + if (callback) callback(element); + + // Descend into node: + // If it has a ShadowRoot, ignore all child elements - these will be picked + // up by the or elements. Descend straight into the + // ShadowRoot. + var shadowRoot = element.shadowRoot || element.webkitShadowRoot; + if (shadowRoot) { + composedTreeWalk(shadowRoot, callback, shadowRoot); + return; + } + + // If it is a element, descend into distributed elements - these + // are elements from outside the shadow root which are rendered inside the + // shadow DOM. + if (element.localName == 'content') { + var content = /** @type {HTMLContentElement} */element; + // Verifies if ShadowDom v0 is supported. + var distributedNodes = content.getDistributedNodes ? content.getDistributedNodes() : []; + for (var i = 0; i < distributedNodes.length; i++) { + composedTreeWalk(distributedNodes[i], callback, shadowRootAncestor); + } + return; + } + + // If it is a element, descend into assigned nodes - these + // are elements from outside the shadow root which are rendered inside the + // shadow DOM. + if (element.localName == 'slot') { + var slot = /** @type {HTMLSlotElement} */element; + // Verify if ShadowDom v1 is supported. + var _distributedNodes = slot.assignedNodes ? slot.assignedNodes({ flatten: true }) : []; + for (var _i = 0; _i < _distributedNodes.length; _i++) { + composedTreeWalk(_distributedNodes[_i], callback, shadowRootAncestor); + } + return; + } + } + + // If it is neither the parent of a ShadowRoot, a element, a + // element, nor a element recurse normally. + var child = node.firstChild; + while (child != null) { + composedTreeWalk(child, callback, shadowRootAncestor); + child = child.nextSibling; + } + } + + /** + * Adds a style element to the node containing the inert specific styles + * @param {Node} node + */ + function addInertStyle(node) { + if (node.querySelector('style#inert-style')) { + return; + } + var style = document.createElement('style'); + style.setAttribute('id', 'inert-style'); + style.textContent = "\n" + "[inert] {\n" + " pointer-events: none;\n" + " cursor: default;\n" + "}\n" + "\n" + "[inert], [inert] * {\n" + " user-select: none;\n" + " -webkit-user-select: none;\n" + " -moz-user-select: none;\n" + " -ms-user-select: none;\n" + "}\n"; + node.appendChild(style); + } + + var inertManager = new InertManager(document); + Object.defineProperty(Element.prototype, 'inert', { + enumerable: true, + get: function get() { + return this.hasAttribute('inert'); + }, + set: function set(inert) { + inertManager.setInert(this, inert); + } + }); + + addInertStyle(document.body); +})(document); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["inert.js"],"names":[],"mappings":"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","file":"inert.js","sourcesContent":["/**\n *\n * Copyright 2016 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n(function(document) {\n\n/** @type {string} */\nconst _focusableElementsString = ['a[href]',\n                                  'area[href]',\n                                  'input:not([disabled])',\n                                  'select:not([disabled])',\n                                  'textarea:not([disabled])',\n                                  'button:not([disabled])',\n                                  'iframe',\n                                  'object',\n                                  'embed',\n                                  '[contenteditable]'].join(',');\n\n/**\n * `InertRoot` manages a single inert subtree, i.e. a DOM subtree whose root element has an `inert`\n * attribute.\n *\n * Its main functions are:\n *\n * - to create and maintain a set of managed `InertNode`s, including when mutations occur in the\n *   subtree. The `makeSubtreeUnfocusable()` method handles collecting `InertNode`s via registering\n *   each focusable node in the subtree with the singleton `InertManager` which manages all known\n *   focusable nodes within inert subtrees. `InertManager` ensures that a single `InertNode`\n *   instance exists for each focusable node which has at least one inert root as an ancestor.\n *\n * - to notify all managed `InertNode`s when this subtree stops being inert (i.e. when the `inert`\n *   attribute is removed from the root node). This is handled in the destructor, which calls the\n *   `deregister` method on `InertManager` for each managed inert node.\n */\nclass InertRoot {\n  /**\n   * @param {Element} rootElement The Element at the root of the inert subtree.\n   * @param {InertManager} inertManager The global singleton InertManager object.\n   */\n  constructor(rootElement, inertManager) {\n    /** @type {InertManager} */\n    this._inertManager = inertManager;\n\n    /** @type {Element} */\n    this._rootElement = rootElement;\n\n    /**\n     * @type {Set<Node>}\n     * All managed focusable nodes in this InertRoot's subtree.\n     */\n    this._managedNodes = new Set([]);\n\n    // Make the subtree hidden from assistive technology\n    this._rootElement.setAttribute('aria-hidden', 'true');\n\n    // Make all focusable elements in the subtree unfocusable and add them to _managedNodes\n    this._makeSubtreeUnfocusable(this._rootElement);\n\n    // Watch for:\n    // - any additions in the subtree: make them unfocusable too\n    // - any removals from the subtree: remove them from this inert root's managed nodes\n    // - attribute changes: if `tabindex` is added, or removed from an intrinsically focusable element,\n    //   make that node a managed node.\n    this._observer = new MutationObserver(this._onMutation.bind(this));\n    this._observer.observe(this._rootElement, { attributes: true, childList: true, subtree: true });\n  }\n\n  /**\n   * Call this whenever this object is about to become obsolete.  This unwinds all of the state\n   * stored in this object and updates the state of all of the managed nodes.\n   */\n  destructor() {\n    this._observer.disconnect();\n    delete this._observer;\n\n    if (this._rootElement)\n      this._rootElement.removeAttribute('aria-hidden');\n    delete this._rootElement;\n\n    for (let inertNode of this._managedNodes)\n      this._unmanageNode(inertNode.node);\n\n    delete this._managedNodes;\n\n    delete this._inertManager;\n  }\n\n  /**\n   * @return {Set<InertNode>} A copy of this InertRoot's managed nodes set.\n   */\n  get managedNodes() {\n    return new Set(this._managedNodes);\n  }\n\n  /**\n   * @param {Node} startNode\n   */\n  _makeSubtreeUnfocusable(startNode) {\n    composedTreeWalk(startNode, (node) => { this._visitNode(node); });\n  }\n\n  /**\n   * @param {Node} node\n   */\n  _visitNode(node) {\n    if (node.nodeType !== Node.ELEMENT_NODE)\n      return;\n\n    // If a descendant inert root becomes un-inert, its descendants will still be inert because of this\n    // inert root, so all of its managed nodes need to be adopted by this InertRoot.\n    if (node !== this._rootElement && node.hasAttribute('inert'))\n      this._adoptInertRoot(node);\n\n    if (node.matches(_focusableElementsString) || node.hasAttribute('tabindex'))\n      this._manageNode(node);\n  }\n\n  /**\n   * Register the given node with this InertRoot and with InertManager.\n   * @param {Node} node\n   */\n  _manageNode(node) {\n    const inertNode = this._inertManager.register(node, this);\n    this._managedNodes.add(inertNode);\n  }\n\n  /**\n   * Unregister the given node with this InertRoot and with InertManager.\n   * @param {Node} node\n   */\n  _unmanageNode(node) {\n    const inertNode = this._inertManager.deregister(node, this);\n    if (inertNode)\n      this._managedNodes.delete(inertNode);\n  }\n\n  /**\n   * Unregister the entire subtree starting at `startNode`.\n   * @param {Node} startNode\n   */\n  _unmanageSubtree(startNode) {\n    composedTreeWalk(startNode, (node) => { this._unmanageNode(node); });\n  }\n\n  /**\n   * If a descendant node is found with an `inert` attribute, adopt its managed nodes.\n   * @param {Node} node\n   */\n  _adoptInertRoot(node) {\n    let inertSubroot = this._inertManager.getInertRoot(node);\n\n    // During initialisation this inert root may not have been registered yet,\n    // so register it now if need be.\n    if (!inertSubroot) {\n      this._inertManager.setInert(node, true);\n      inertSubroot = this._inertManager.getInertRoot(node);\n    }\n\n    for (let savedInertNode of inertSubroot.managedNodes)\n      this._manageNode(savedInertNode.node);\n  }\n\n  /**\n   * Callback used when mutation observer detects subtree additions, removals, or attribute changes.\n   * @param {MutationRecord} records\n   * @param {MutationObserver} self\n   */\n  _onMutation(records, self) {\n    for (let record of records) {\n      const target = record.target;\n      if (record.type === 'childList') {\n        // Manage added nodes\n        for (let node of Array.from(record.addedNodes))\n          this._makeSubtreeUnfocusable(node);\n\n        // Un-manage removed nodes\n        for (let node of Array.from(record.removedNodes))\n          this._unmanageSubtree(node);\n      } else if (record.type === 'attributes') {\n        if (record.attributeName === 'tabindex') {\n          // Re-initialise inert node if tabindex changes\n          this._manageNode(target);\n        } else if (target !== this._rootElement &&\n                   record.attributeName === 'inert' &&\n                   target.hasAttribute('inert')) {\n          // If a new inert root is added, adopt its managed nodes and make sure it knows about the\n          // already managed nodes from this inert subroot.\n          this._adoptInertRoot(target);\n          let inertSubroot = this._inertManager.getInertRoot(target);\n          for (let managedNode of this._managedNodes) {\n            if (target.contains(managedNode.node))\n              inertSubroot._manageNode(managedNode.node);\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * `InertNode` initialises and manages a single inert node.\n * A node is inert if it is a descendant of one or more inert root elements.\n *\n * On construction, `InertNode` saves the existing `tabindex` value for the node, if any, and\n * either removes the `tabindex` attribute or sets it to `-1`, depending on whether the element\n * is intrinsically focusable or not.\n *\n * `InertNode` maintains a set of `InertRoot`s which are descendants of this `InertNode`. When an\n * `InertRoot` is destroyed, and calls `InertManager.deregister()`, the `InertManager` notifies the\n * `InertNode` via `removeInertRoot()`, which in turn destroys the `InertNode` if no `InertRoot`s\n * remain in the set. On destruction, `InertNode` reinstates the stored `tabindex` if one exists,\n * or removes the `tabindex` attribute if the element is intrinsically focusable.\n */\nclass InertNode {\n  /**\n   * @param {Node} node A focusable element to be made inert.\n   * @param {InertRoot} inertRoot The inert root element associated with this inert node.\n   */\n  constructor(node, inertRoot) {\n    /** @type {Node} */\n    this._node = node;\n\n    /** @type {boolean} */\n    this._overrodeFocusMethod = false;\n\n    /**\n     * @type {Set<InertRoot>} The set of descendant inert roots.\n     *    If and only if this set becomes empty, this node is no longer inert.\n     */\n    this._inertRoots = new Set([inertRoot]);\n\n    /** @type {boolean} */\n    this._destroyed = false;\n\n    // Save any prior tabindex info and make this node untabbable\n    this.ensureUntabbable();\n  }\n\n  /**\n   * Call this whenever this object is about to become obsolete.\n   * This makes the managed node focusable again and deletes all of the previously stored state.\n   */\n  destructor() {\n    this._throwIfDestroyed();\n\n    if (this._node) {\n      if (this.hasSavedTabIndex)\n        this._node.setAttribute('tabindex', this.savedTabIndex);\n      else\n        this._node.removeAttribute('tabindex');\n\n      if (this._overrodeFocusMethod)\n        delete this._node.focus;\n    }\n    delete this._node;\n    delete this._inertRoots;\n\n    this._destroyed = true;\n  }\n\n  /**\n   * @type {boolean} Whether this object is obsolete because the managed node is no longer inert.\n   * If the object has been destroyed, any attempt to access it will cause an exception.\n   */\n  get destroyed() {\n    return this._destroyed;\n  }\n\n  _throwIfDestroyed() {\n    if (this.destroyed)\n      throw new Error(\"Trying to access destroyed InertNode\");\n  }\n\n  /** @return {boolean} */\n  get hasSavedTabIndex() {\n    return '_savedTabIndex' in this;\n  }\n\n  /** @return {Node} */\n  get node() {\n    this._throwIfDestroyed();\n    return this._node;\n  }\n\n  /** @param {number} tabIndex */\n  set savedTabIndex(tabIndex) {\n    this._throwIfDestroyed();\n    this._savedTabIndex = tabIndex;\n  }\n\n  /** @return {number} */\n  get savedTabIndex() {\n    this._throwIfDestroyed();\n    return this._savedTabIndex;\n  }\n\n  /** Save the existing tabindex value and make the node untabbable and unfocusable */\n  ensureUntabbable() {\n    const node = this.node;\n    node.blur();  // TODO(alice): is this right?\n    if (node.matches(_focusableElementsString)) {\n      if (node.tabIndex === -1 && this.hasSavedTabIndex)\n        return;\n\n      if (node.hasAttribute('tabindex'))\n        this._savedTabIndex = node.tabIndex;\n      node.setAttribute('tabindex', '-1');\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        node.focus = function() {};\n        this._overrodeFocusMethod = true;\n      }\n    } else if (node.hasAttribute('tabindex')) {\n      this._savedTabIndex = node.tabIndex;\n      node.removeAttribute('tabindex');\n    }\n  }\n\n  /**\n   * Add another inert root to this inert node's set of managing inert roots.\n   * @param {InertRoot} inertRoot\n   */\n  addInertRoot(inertRoot) {\n    this._throwIfDestroyed();\n    this._inertRoots.add(inertRoot);\n  }\n\n  /**\n   * Remove the given inert root from this inert node's set of managing inert roots.\n   * If the set of managing inert roots becomes empty, this node is no longer inert,\n   * so the object should be destroyed.\n   * @param {InertRoot} inertRoot\n   */\n  removeInertRoot(inertRoot) {\n    this._throwIfDestroyed();\n    this._inertRoots.delete(inertRoot);\n    if (this._inertRoots.size === 0)\n      this.destructor();\n  }\n}\n\n/**\n * InertManager is a per-document singleton object which manages all inert roots and nodes.\n *\n * When an element becomes an inert root by having an `inert` attribute set and/or its `inert`\n * property set to `true`, the `setInert` method creates an `InertRoot` object for the element.\n * The `InertRoot` in turn registers itself as managing all of the element's focusable descendant\n * nodes via the `register()` method. The `InertManager` ensures that a single `InertNode` instance\n * is created for each such node, via the `_managedNodes` map.\n */\nclass InertManager {\n  /**\n   * @param {Document} document\n   */\n  constructor(document) {\n    if (!document)\n      throw new Error('Missing required argument; InertManager needs to wrap a document.');\n\n    /** @type {Document} */\n    this._document = document;\n\n    /**\n     * All managed nodes known to this InertManager. In a map to allow looking up by Node.\n     * @type {Map<Node, InertNode>}\n     */\n    this._managedNodes = new Map();\n\n    /**\n     * All inert roots known to this InertManager. In a map to allow looking up by Node.\n     * @type {Map<Node, InertRoot>}\n     */\n    this._inertRoots = new Map();\n\n    // Find all inert roots in document and make them actually inert.\n    let inertElements = Array.from(document.querySelectorAll('[inert]'));\n    for (let inertElement of inertElements)\n      this.setInert(inertElement, true);\n\n    // Comment these two lines out to use programmatic API only\n    this._observer = new MutationObserver(this._watchForInert.bind(this));\n    this._observer.observe(document.body, { attributes: true, subtree: true, childList: true });\n  }\n\n  /**\n   * Set whether the given element should be an inert root or not.\n   * @param {Element} root\n   * @param {boolean} inert\n   */\n  setInert(root, inert) {\n    if (inert) {\n      if (this._inertRoots.has(root))   // element is already inert\n        return;\n\n      let inertRoot = new InertRoot(root, this);\n      root.setAttribute('inert', '');\n      this._inertRoots.set(root, inertRoot);\n      // If not contained in the document, it must be in a shadowRoot.\n      // Ensure inert styles are added there.\n      if (!this._document.body.contains(root)) {\n        let parent = root.parentNode;\n        while (parent) {\n          if (parent.nodeType === 11) {\n            addInertStyle(parent);\n          }\n          parent = parent.parentNode;\n        }\n      }\n    } else {\n      if (!this._inertRoots.has(root))  // element is already non-inert\n        return;\n\n      let inertRoot = this._inertRoots.get(root);\n      inertRoot.destructor();\n      this._inertRoots.delete(root);\n      root.removeAttribute('inert');\n    }\n  }\n\n  /**\n   * Get the InertRoot object corresponding to the given inert root element, if any.\n   * @param {Element} element\n   * @return {InertRoot?}\n   */\n  getInertRoot(element) {\n    return this._inertRoots.get(element);\n  }\n\n  /**\n   * Register the given InertRoot as managing the given node.\n   * In the case where the node has a previously existing inert root, this inert root will\n   * be added to its set of inert roots.\n   * @param {Node} node\n   * @param {InertRoot} inertRoot\n   * @return {InertNode} inertNode\n   */\n  register(node, inertRoot) {\n    let inertNode = this._managedNodes.get(node);\n    if (inertNode !== undefined) {  // node was already in an inert subtree\n      inertNode.addInertRoot(inertRoot);\n      // Update saved tabindex value if necessary\n      inertNode.ensureUntabbable();\n    } else {\n      inertNode = new InertNode(node, inertRoot);\n    }\n\n    this._managedNodes.set(node, inertNode);\n\n    return inertNode;\n  }\n\n  /**\n   * De-register the given InertRoot as managing the given inert node.\n   * Removes the inert root from the InertNode's set of managing inert roots, and remove the inert\n   * node from the InertManager's set of managed nodes if it is destroyed.\n   * If the node is not currently managed, this is essentially a no-op.\n   * @param {Node} node\n   * @param {InertRoot} inertRoot\n   * @return {InertNode?} The potentially destroyed InertNode associated with this node, if any.\n   */\n  deregister(node, inertRoot) {\n    const inertNode = this._managedNodes.get(node);\n    if (!inertNode)\n      return null;\n\n    inertNode.removeInertRoot(inertRoot);\n    if (inertNode.destroyed)\n      this._managedNodes.delete(node);\n\n    return inertNode;\n  }\n\n\n  /**\n   * Callback used when mutation observer detects attribute changes.\n   * @param {MutationRecord} records\n   * @param {MutationObserver} self\n   */\n  _watchForInert(records, self) {\n    for (let record of records) {\n      switch (record.type) {\n      case 'childList':\n        for (let node of Array.from(record.addedNodes)) {\n          if (node.nodeType !== Node.ELEMENT_NODE)\n            continue;\n          let inertElements = Array.from(node.querySelectorAll('[inert]'));\n          if (node.matches('[inert]'))\n            inertElements.unshift(node);\n          for (let inertElement of inertElements)\n            this.setInert(inertElement, true);\n        }\n        break;\n      case 'attributes':\n        if (record.attributeName !== 'inert')\n          continue;\n        let target = record.target;\n        let inert = target.hasAttribute('inert');\n        this.setInert(target, inert);\n        break;\n      }\n    }\n  }\n}\n\n /**\n  * Recursively walk the composed tree from |node|.\n  * @param {Node} node\n  * @param {(function (Element))=} callback Callback to be called for each element traversed,\n  *     before descending into child nodes.\n  * @param {ShadowRoot=} shadowRootAncestor The nearest ShadowRoot ancestor, if any.\n  */\nfunction composedTreeWalk(node, callback, shadowRootAncestor) {\n  if (node.nodeType == Node.ELEMENT_NODE) {\n    const element = /** @type {Element} */ (node);\n    if (callback)\n      callback(element)\n\n    // Descend into node:\n    // If it has a ShadowRoot, ignore all child elements - these will be picked\n    // up by the <content> or <shadow> elements. Descend straight into the\n    // ShadowRoot.\n    const shadowRoot = element.shadowRoot || element.webkitShadowRoot;\n    if (shadowRoot) {\n      composedTreeWalk(shadowRoot, callback, shadowRoot);\n      return;\n    }\n\n    // If it is a <content> element, descend into distributed elements - these\n    // are elements from outside the shadow root which are rendered inside the\n    // shadow DOM.\n    if (element.localName == 'content') {\n      const content = /** @type {HTMLContentElement} */ (element);\n      // Verifies if ShadowDom v0 is supported.\n      const distributedNodes = content.getDistributedNodes ?\n        content.getDistributedNodes() : [];\n      for (let i = 0; i < distributedNodes.length; i++) {\n        composedTreeWalk(distributedNodes[i], callback, shadowRootAncestor);\n      }\n      return;\n    }\n\n    // If it is a <slot> element, descend into assigned nodes - these\n    // are elements from outside the shadow root which are rendered inside the\n    // shadow DOM.\n    if (element.localName == 'slot') {\n      const slot = /** @type {HTMLSlotElement} */ (element);\n      // Verify if ShadowDom v1 is supported.\n      const distributedNodes = slot.assignedNodes ?\n        slot.assignedNodes({ flatten: true }) : [];\n      for (let i = 0; i < distributedNodes.length; i++) {\n        composedTreeWalk(distributedNodes[i], callback, shadowRootAncestor);\n      }\n      return;\n    }\n  }\n\n  // If it is neither the parent of a ShadowRoot, a <content> element, a <slot>\n  // element, nor a <shadow> element recurse normally.\n  let child = node.firstChild;\n  while (child != null) {\n    composedTreeWalk(child, callback, shadowRootAncestor);\n    child = child.nextSibling;\n  }\n}\n\n/**\n * Adds a style element to the node containing the inert specific styles\n * @param {Node} node\n */\nfunction addInertStyle(node) {\n  if (node.querySelector('style#inert-style')) {\n    return;\n  }\n  let style = document.createElement('style');\n  style.setAttribute('id', 'inert-style');\n  style.textContent = \"\\n\"+\n                      \"[inert] {\\n\" +\n                      \"  pointer-events: none;\\n\" +\n                      \"  cursor: default;\\n\" +\n                      \"}\\n\" +\n                      \"\\n\" +\n                      \"[inert], [inert] * {\\n\" +\n                      \"  user-select: none;\\n\" +\n                      \"  -webkit-user-select: none;\\n\" +\n                      \"  -moz-user-select: none;\\n\" +\n                      \"  -ms-user-select: none;\\n\" +\n                      \"}\\n\";\n  node.appendChild(style);\n}\n\n\nlet inertManager = new InertManager(document);\nObject.defineProperty(Element.prototype, 'inert', {\n                        enumerable: true,\n                        get: function() { return this.hasAttribute('inert'); },\n                        set: function(inert) { inertManager.setInert(this, inert) }\n                      });\n\naddInertStyle(document.body);\n\n})(document);\n"],"sourceRoot":"/source/"} diff --git a/dist/inert.min.js b/dist/inert.min.js new file mode 100644 index 0000000..87bed8a --- /dev/null +++ b/dist/inert.min.js @@ -0,0 +1 @@ +"use strict";function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function e(e,t){for(var r=0;r inert polyfill test page -