coral-spectrum/coral-base-overlay/src/scripts/BaseOverlay.js
/**
* Copyright 2019 Adobe. All rights reserved.
* This file is licensed to you 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 REPRESENTATIONS
* OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*/
import base from '../templates/base';
import Vent from '@adobe/vent';
import {validate, transform, commons} from '../../../coral-utils';
import {trapFocus, returnFocus, focusOnShow, scrollOnFocus, FADETIME} from './enums';
const CLASSNAME = '_coral-BaseOverlay';
// Includes overlay itself
const COMPONENTS_WITH_OVERLAY = `
coral-actionbar,
coral-autocomplete,
coral-colorinput,
coral-cyclebutton,
coral-datepicker,
coral-dialog,
coral-overlay,
coral-popover,
coral-quickactions,
coral-select,
coral-tooltip
`;
// The tab capture element that lives at the top of the body
let topTabCaptureEl;
let bottomTabCaptureEl;
// A reference to the backdrop element
let backdropEl;
// The starting zIndex for overlays
const startZIndex = 10000;
// Tab keycode
const TAB_KEY = 9;
// A stack interface for overlays
const overlayStack = [];
let OverlayManager = {};
/**
Return focus option
*/
function preventScroll(instance) {
return {preventScroll: instance.scrollOnFocus === scrollOnFocus.OFF};
}
/**
Cancel the backdrop hide mid-animation.
*/
let fadeTimeout;
function cancelBackdropHide() {
window.clearTimeout(fadeTimeout);
}
/**
Set aria-hidden on every immediate child except the one passed, which should not be hidden.
*/
function hideEverythingBut(instance) {
// ARIA: Hide all the things
const children = document.body.children;
for (let i = 0 ; i < children.length ; i++) {
const child = children[i];
// If it's not a parent of or not the instance itself, it needs to be hidden
if (child !== instance && child.contains && !child.contains(instance)) {
const currentAriaHidden = child.getAttribute('aria-hidden');
if (currentAriaHidden) {
// Store the previous value of aria-hidden if present
// Don't blow away the previously stored value
child._previousAriaHidden = child._previousAriaHidden || currentAriaHidden;
if (currentAriaHidden === 'true') {
// It's already true, don't bother setting
continue;
}
} else {
// Nothing is hidden by default, store that
child._previousAriaHidden = 'false';
}
// Hide it
child.setAttribute('aria-hidden', 'true');
}
}
// Always show ourselves
instance.setAttribute('aria-hidden', 'false');
}
/**
Actually reposition the backdrop to be under the topmost overlay.
*/
function doRepositionBackdrop() {
// Position under the topmost overlay
const top = OverlayManager.top();
if (top) {
// The backdrop, if shown, should be positioned under the topmost overlay that does have a backdrop
for (let i = overlayStack.length - 1 ; i > -1 ; i--) {
if (overlayStack[i].backdrop) {
backdropEl.style.zIndex = overlayStack[i].zIndex - 1;
break;
}
}
// ARIA: Set hidden properly
hideEverythingBut(top.instance);
}
}
OverlayManager = {
pop(instance) {
// Get overlay index
const index = this.indexOf(instance);
if (index === -1) {
return null;
}
// Get the overlay
const overlay = overlayStack[index];
// Remove from the stack
overlayStack.splice(index, 1);
// Return the passed overlay or the found overlay
return overlay;
},
push(instance) {
// Pop overlay
const overlay = this.pop(instance) || {instance};
// Get the new highest zIndex
const zIndex = this.getHighestZIndex() + 10;
// Store the zIndex
overlay.zIndex = zIndex;
instance.style.zIndex = zIndex;
// Push it
overlayStack.push(overlay);
if (overlay.backdrop) {
// If the backdrop is shown, we'll need to reposition it
// Generally, a component will not call _pushOverlay unnecessarily
// However, attachedCallback is asynchronous in polyfilld environments,
// so _pushOverlay will be called when shown and when attached
doRepositionBackdrop();
}
return overlay;
},
indexOf(instance) {
// Loop over stack
// Find overlay
// Return index
for (let i = 0 ; i < overlayStack.length ; i++) {
if (overlayStack[i].instance === instance) {
return i;
}
}
return -1;
},
get(instance) {
// Get overlay index
const index = this.indexOf(instance);
// Return overlay
return index === -1 ? null : overlayStack[index];
},
top() {
const length = overlayStack.length;
return length === 0 ? null : overlayStack[length - 1];
},
getHighestZIndex() {
const overlay = this.top();
return overlay ? overlay.zIndex : startZIndex;
},
some(...args) {
return overlayStack.some(...args);
},
forEach(...args) {
return overlayStack.forEach(...args);
}
};
/**
Create the global tab capture element.
*/
function createDocumentTabCaptureEls() {
if (!topTabCaptureEl) {
topTabCaptureEl = document.createElement('div');
topTabCaptureEl.setAttribute('coral-tabcapture', '');
topTabCaptureEl.setAttribute('role', 'presentation');
topTabCaptureEl.tabIndex = 0;
document.body.insertBefore(topTabCaptureEl, document.body.firstChild);
topTabCaptureEl.addEventListener('focus', () => {
const top = OverlayManager.top();
if (top && top.instance.trapFocus === trapFocus.ON) {
// Focus on the first tabbable element of the top overlay
Array.prototype.some.call(top.instance.querySelectorAll(commons.TABBABLE_ELEMENT_SELECTOR), (item) => {
if (item.offsetParent !== null && !item.hasAttribute('coral-tabcapture')) {
item.focus(preventScroll(top));
return true;
}
return false;
});
}
});
bottomTabCaptureEl = document.createElement('div');
bottomTabCaptureEl.setAttribute('coral-tabcapture', '');
bottomTabCaptureEl.setAttribute('role', 'presentation');
bottomTabCaptureEl.tabIndex = 0;
document.body.appendChild(bottomTabCaptureEl);
bottomTabCaptureEl.addEventListener('focus', () => {
const top = OverlayManager.top();
if (top && top.instance.trapFocus === trapFocus.ON) {
const tabbableElement = Array.prototype.filter.call(top.instance.querySelectorAll(commons.TABBABLE_ELEMENT_SELECTOR), (item) => item.offsetParent !== null && !item.hasAttribute('coral-tabcapture')).pop();
// Focus on the last tabbable element of the top overlay
if (tabbableElement) {
tabbableElement.focus(preventScroll(top));
}
}
});
} else {
if (document.body.firstElementChild !== topTabCaptureEl) {
// Make sure we stay at the very top
document.body.insertBefore(topTabCaptureEl, document.body.firstChild);
}
if (document.body.lastElementChild !== bottomTabCaptureEl) {
// Make sure we stay at the very bottom
document.body.appendChild(bottomTabCaptureEl);
}
}
// Make sure the tab capture elemenst are shown
topTabCaptureEl.style.display = 'inline';
bottomTabCaptureEl.style.display = 'inline';
}
/**
Called after all overlays are hidden and we shouldn't capture the first tab into the page.
*/
function hideDocumentTabCaptureEls() {
if (topTabCaptureEl) {
topTabCaptureEl.style.display = 'none';
bottomTabCaptureEl.style.display = 'none';
}
}
/**
Show or restore the aria-hidden state of every child of body.
*/
function showEverything() {
// ARIA: Show all the things
const children = document.body.children;
for (let i = 0 ; i < children.length ; i++) {
const child = children[i];
// Restore the previous aria-hidden value
child.setAttribute('aria-hidden', child._previousAriaHidden || 'false');
}
}
/**
Actually hide the backdrop.
*/
function doBackdropHide() {
document.body.classList.remove('u-coral-noscroll');
// Start animation
window.requestAnimationFrame(() => {
backdropEl.classList.remove('is-open');
cancelBackdropHide();
fadeTimeout = window.setTimeout(() => {
backdropEl.style.display = 'none';
}, FADETIME);
});
// Set flag for testing
backdropEl._isOpen = false;
// Wait for animation to complete
showEverything();
}
/**
Hide the backdrop if no overlays are using it.
*/
function hideOrRepositionBackdrop() {
if (!backdropEl || !backdropEl._isOpen) {
// Do nothing if the backdrop isn't shown
return;
}
// Loop over all overlays
const keepBackdrop = OverlayManager.some((overlay) => {
// Check for backdrop usage
return !!overlay.backdrop;
});
if (!keepBackdrop) {
// Hide the backdrop
doBackdropHide();
} else {
// Reposition the backdrop
doRepositionBackdrop();
}
// Hide/create the document-level tab capture element as necessary
// This only applies to modal overlays (those that have backdrops)
const top = OverlayManager.top();
if (!top || !(top.instance.trapFocus === trapFocus.ON && top.instance._requestedBackdrop)) {
hideDocumentTabCaptureEls();
} else if (top && top.instance.trapFocus === trapFocus.ON && top.instance._requestedBackdrop) {
createDocumentTabCaptureEls();
}
}
/**
Handles clicks to the backdrop, calling backdropClickedCallback for every overlay
*/
function handleBackdropClick(event) {
OverlayManager.forEach((overlay) => {
if (typeof overlay.instance.backdropClickedCallback === 'function') {
overlay.instance.backdropClickedCallback(event);
}
});
}
/**
Actually show the backdrop.
*/
function doBackdropShow(zIndex, instance) {
document.body.classList.add('u-coral-noscroll');
if (!backdropEl) {
backdropEl = document.createElement('div');
backdropEl.className = '_coral-Underlay';
document.body.appendChild(backdropEl);
backdropEl.addEventListener('click', handleBackdropClick);
}
// Show just under the provided zIndex
// Since we always increment by 10, this will never collide
backdropEl.style.zIndex = zIndex - 1;
// Set flag for testing
backdropEl._isOpen = true;
// Start animation
backdropEl.style.display = '';
window.requestAnimationFrame(() => {
// Add the class on the next animation frame so backdrop has time to exist
// Otherwise, the animation for opacity will not work.
backdropEl.classList.add('is-open');
cancelBackdropHide();
});
hideEverythingBut(instance);
}
/**
@base BaseOverlay
@classdesc The base element for Overlay components
*/
class BaseOverlay extends superClass {
/** @ignore */
constructor() {
super();
// Templates
this._elements = {};
base.call(this._elements);
}
/**
Whether to trap tabs and keep them within the overlay. See {@link OverlayTrapFocusEnum}.
@type {String}
@default OverlayTrapFocusEnum.OFF
@htmlattribute trapfocus
*/
get trapFocus() {
return this._trapFocus || trapFocus.OFF;
}
set trapFocus(value) {
value = transform.string(value).toLowerCase();
this._trapFocus = validate.enumeration(trapFocus)(value) && value || trapFocus.OFF;
if (this._trapFocus === trapFocus.ON) {
// Give ourselves tabIndex if we are not focusable
if (this.tabIndex < 0) {
/** @ignore */
this.tabIndex = 0;
}
// Insert elements
this.insertBefore(this._elements.topTabCapture, this.firstElementChild);
this.appendChild(this._elements.intermediateTabCapture);
this.appendChild(this._elements.bottomTabCapture);
// Add listeners
this._handleTabCaptureFocus = this._handleTabCaptureFocus.bind(this);
this._handleRootKeypress = this._handleRootKeypress.bind(this);
this._vent.on('keydown', this._handleRootKeypress);
this._vent.on('focus', '[coral-tabcapture]', this._handleTabCaptureFocus);
} else if (this._trapFocus === trapFocus.OFF) {
// Remove elements
this._elements.topTabCapture && this._elements.topTabCapture.remove();
this._elements.intermediateTabCapture && this._elements.intermediateTabCapture.remove();
this._elements.bottomTabCapture && this._elements.bottomTabCapture.remove();
// Remove listeners
this._vent.off('keydown', this._handleRootKeypress);
this._vent.off('focus', '[coral-tabcapture]', this._handleTabCaptureFocus);
}
}
/**
Whether to return focus to the previously focused element when closed. See {@link OverlayReturnFocusEnum}.
@type {String}
@default OverlayReturnFocusEnum.OFF
@htmlattribute returnfocus
*/
get returnFocus() {
return this._returnFocus || returnFocus.OFF;
}
set returnFocus(value) {
value = transform.string(value).toLowerCase();
this._returnFocus = validate.enumeration(returnFocus)(value) && value || returnFocus.OFF;
}
/**
returns element that will receive focus when overlay is closed
@returns {HTMLElement}element passed via returnFocusTo()
*/
get returnFocusToElement() {
return this._returnFocusToElement;
}
/**
returns element that will receive focus when overlay is hidden
@returns {HTMLElement} element cached
*/
get elementToFocusWhenHidden() {
return this._elementToFocusWhenHidden;
}
/**
Whether the browser should scroll the document to bring the newly-focused element into view. See {@link OverlayScrollOnFocusEnum}.
@type {String}
@default OverlayScrollOnFocusEnum.ON
@htmlattribute scrollonfocus
*/
get scrollOnFocus() {
return this._scrollOnFocus || scrollOnFocus.ON;
}
set scrollOnFocus(value) {
value = transform.string(value).toLowerCase();
this._scrollOnFocus = validate.enumeration(scrollOnFocus)(value) && value || scrollOnFocus.ON;
}
/**
Whether to focus the overlay, when opened or not. By default the overlay itself will get the focus. It also accepts
an instance of HTMLElement or a selector like ':first-child' or 'button:last-of-type'. If the selector returns
multiple elements, it will focus the first element inside the overlay that matches the selector.
See {@link OverlayFocusOnShowEnum}.
@type {HTMLElement|String}
@default OverlayFocusOnShowEnum.ON
@htmlattribute focusonshow
*/
get focusOnShow() {
return this._focusOnShow || focusOnShow.ON;
}
set focusOnShow(value) {
if (typeof value === 'string' || value instanceof HTMLElement) {
this._focusOnShow = value;
}
}
/**
Whether this overlay is open or not.
@type {Boolean}
@default false
@htmlattribute open
@htmlattributereflected
@emits {coral-overlay:open}
@emits {coral-overlay:close}
@emits {coral-overlay:beforeopen}
@emits {coral-overlay:beforeclose}
*/
get open() {
return this._open || false;
}
set open(value) {
const silenced = this._silenced;
value = transform.booleanAttr(value);
// Used for global animations
this.trigger('coral-overlay:_animate');
const beforeEvent = this.trigger(value ? 'coral-overlay:beforeopen' : 'coral-overlay:beforeclose');
if (!beforeEvent.defaultPrevented) {
const open = this._open = value;
this._reflectAttribute('open', open);
// Remove aria-hidden attribute before we show.
// Otherwise, screen readers will not announce
// Doesn't matter when we set aria-hidden true (nothing being announced)
if (open) {
this.removeAttribute('aria-hidden');
} else {
this.setAttribute('aria-hidden', !open);
}
// Don't do anything if we're not in the DOM yet
// This prevents errors related to allocating a zIndex we don't need
if (this.parentNode) {
// Do this check afterwards as we may have been appended inside of _show()
if (open) {
// Set z-index
this._pushOverlay();
if (this.returnFocus === returnFocus.ON) {
this._elementToFocusWhenHidden =
// cached element
this._elementToFocusWhenHidden ||
// element passed via returnFocusTo()
this._returnFocusToElement ||
// element that had focus before opening the overlay
(document.activeElement === document.body ? null : document.activeElement);
}
} else {
// Release zIndex
this._popOverlay();
}
}
// Don't force reflow
window.requestAnimationFrame(() => {
// Keep it silenced
this._silenced = silenced;
if (open) {
if (this.trapFocus === trapFocus.ON) {
// Make sure tab capture elements are positioned correctly
if (
// Tab capture elements are no longer at the bottom
this._elements.topTabCapture !== this.firstElementChild ||
this._elements.bottomTabCapture !== this.lastElementChild ||
// Tab capture elements have been separated
this._elements.bottomTabCapture.previousElementSibling !== this._elements.intermediateTabCapture
) {
this.insertBefore(this._elements.intermediateTabCapture, this.firstElementChild);
this.appendChild(this._elements.intermediateTabCapture);
this.appendChild(this._elements.bottomTabCapture);
}
}
// visibility should revert to whatever is specified in CSS, so that transition renders.
this.style.visibility = '';
// The default style should be display: none for overlays
// Show ourselves first for centering calculations etc
this.style.display = '';
// Do it in the next frame to make the animation happen
window.requestAnimationFrame(() => {
this.classList.add('is-open');
});
const openComplete = () => {
if (this.open) {
this._debounce(() => {
// handles the focus behavior based on accessibility recommendations
this._handleFocus();
this.trigger('coral-overlay:open');
this._silenced = false;
});
}
};
if (this._overlayAnimationTime) {
// Wait for animation to complete
commons.transitionEnd(this, openComplete);
} else {
// Execute immediately
openComplete();
}
} else {
// Fade out
this.classList.remove('is-open');
const closeComplete = () => {
if (!this.open) {
// When the CSS transition has finished, set visibility to browser default, `visibility: visible`,
// to ensure that the overlay will be included in accessibility name or description
// of an element that references it using `aria-labelledby` or `aria-describedby`.
this.style.visibility = 'visible';
// makes sure the focus is returned per accessibility recommendations
this._handleReturnFocus();
// Hide self
this.style.display = 'none';
this._debounce(() => {
// Inform child overlays that we're closing
this._closeChildOverlays();
this.trigger('coral-overlay:close');
this._silenced = false;
});
}
};
if (this._overlayAnimationTime) {
// Wait for animation to complete
commons.transitionEnd(this, closeComplete);
} else {
// Execute immediately
closeComplete();
}
}
});
}
}
_closeChildOverlays() {
const components = this.querySelectorAll(COMPONENTS_WITH_OVERLAY);
// Close all children overlays and components with overlays
for (let i = 0 ; i < components.length ; i++) {
const component = components[i];
// Overlay component
if (component.hasAttribute('open')) {
component.removeAttribute('open');
}
// Component that uses an overlay
else if (component._elements && component._elements.overlay && component._elements.overlay.hasAttribute('open')) {
component._elements.overlay.removeAttribute('open');
}
}
}
/** @private */
_debounce(f) {
// Used to avoid triggering open/close event continuously
window.clearTimeout(this._debounceId);
this._debounceId = window.setTimeout(() => {
f();
}, 10);
}
/**
Check if this overlay is the topmost.
@protected
*/
_isTopOverlay() {
const top = OverlayManager.top();
return top && top.instance === this;
}
/**
Push the overlay to the top of the stack.
@protected
*/
_pushOverlay() {
OverlayManager.push(this);
}
/**
Remove the overlay from the stack.
@protected
*/
_popOverlay() {
OverlayManager.pop(this);
// Automatically hide the backdrop if required
hideOrRepositionBackdrop();
}
/**
Show the backdrop.
@protected
*/
_showBackdrop() {
const overlay = OverlayManager.get(this);
// Overlay is not tracked unless the component is in the DOM
// Hence, we need to check
if (overlay) {
overlay.backdrop = true;
doBackdropShow(overlay.zIndex, this);
}
// Mark on the instance that the backdrop has been requested for this overlay
this._requestedBackdrop = true;
// Mark that the backdrop was requested when not attached to the DOM
// This allows us to know whether to push the overlay when the component is attached
if (!this.parentNode) {
this._showBackdropOnAttached = true;
}
if (this.trapFocus === trapFocus.ON) {
createDocumentTabCaptureEls();
}
}
/**
Show the backdrop.
@protected
*/
_hideBackdrop() {
const overlay = OverlayManager.get(this);
if (overlay) {
overlay.backdrop = false;
// If that was the last overlay using the backdrop, hide it
hideOrRepositionBackdrop();
}
// Mark on the instance that the backdrop is no longer needed
this._requestedBackdrop = false;
}
/**
Handles keypresses on the root of the overlay and marshalls focus accordingly.
@protected
*/
_handleRootKeypress(event) {
if (event.target === this && event.keyCode === TAB_KEY) {
// Skip the top tabcapture and focus on the first focusable element
this._focusOn('first');
// Stop the normal tab behavior
event.preventDefault();
}
}
/**
Handles focus events on tab capture elements.
@protected
*/
_handleTabCaptureFocus(event) {
// Avoid moving around if we're trying to focus on coral-tabcapture
if (this._ignoreTabCapture) {
this._ignoreTabCapture = false;
return;
}
// Focus on the correct tabbable element
const target = event.target;
const which = target === this._elements.intermediateTabCapture ? 'first' : 'last';
this._focusOn(which);
}
/**
Handles the focus behavior. When "on" is specified it would try to find the first tababble descendent in the
content and if there are no valid candidates it will focus the element itself.
@protected
*/
_handleFocus() {
// ON handles the focusing per accessibility recommendations
if (this.focusOnShow === focusOnShow.ON) {
this._focusOn('first');
} else if (this.focusOnShow instanceof HTMLElement) {
this.focusOnShow.focus(preventScroll(this));
} else if (typeof this.focusOnShow === 'string' && this.focusOnShow !== focusOnShow.OFF) {
// we need to add :not([coral-tabcapture]) to avoid selecting the tab captures
const selectedElement = this.querySelector(`${this.focusOnShow}:not([coral-tabcapture])`);
if (selectedElement) {
selectedElement.focus(preventScroll(this));
}
// in case the selector does not match, it should fallback to the default behavior
else {
this._focusOn('first');
}
}
}
/**
@protected
*/
_handleReturnFocus() {
if (this.returnFocus === returnFocus.ON && this._elementToFocusWhenHidden) {
if (document.activeElement && !this.contains(document.activeElement)) {
// Don't return focus if the user focused outside of the overlay
return;
}
// Return focus, ignoring tab capture if it is an overlay
this._elementToFocusWhenHidden._ignoreTabCapture = true;
this._elementToFocusWhenHidden.focus(preventScroll(this));
this._elementToFocusWhenHidden._ignoreTabCapture = false;
// Drop the reference to avoid memory leaks
this._elementToFocusWhenHidden = null;
}
}
/**
Focus on the first or last element.
@param {String} which
one of "first" or "last"
@protected
*/
_focusOn(which) {
const focusableTarget = this._getFocusableElement(which);
// if we found a focusing target we focus it
if (focusableTarget) {
focusableTarget.focus(preventScroll(this));
}
// otherwise the element itself should get focus
else {
this.focus(preventScroll(this));
}
}
_getFocusableElements() {
return Array.prototype.filter.call(this.querySelectorAll(commons.FOCUSABLE_ELEMENT_SELECTOR), item => item.offsetParent !== null && !item.hasAttribute('coral-tabcapture'));
}
_getFocusableElement(which) {
let focusableTarget;
if (which === 'first' || which === 'last') {
const focusableElements = this._getFocusableElements();
focusableTarget = focusableElements[which === 'first' ? 'shift' : 'pop']();
}
return focusableTarget;
}
/**
Open the overlay and set the z-index accordingly.
@returns {BaseOverlay} this, chainable
*/
show() {
this.open = true;
return this;
}
/**
Close the overlay.
@returns {BaseOverlay} this, chainable
*/
hide() {
this.open = false;
return this;
}
/**
Set the element that focus should be returned to when the overlay is hidden.
@param {HTMLElement} element
The element to return focus to. This must be a DOM element, not a jQuery object or selector.
@returns {BaseOverlay} this, chainable
*/
returnFocusTo(element) {
if (this.returnFocus === returnFocus.OFF) {
// Switch on returning focus if it's off
this.returnFocus = returnFocus.ON;
}
// If the element is not focusable,
if (!element.matches(commons.FOCUSABLE_ELEMENT_SELECTOR)) {
// add tabindex so that it is programmatically focusable.
element.setAttribute('tabindex', -1);
// On blur, restore element to its prior, not-focusable state
const tempVent = new Vent(element);
tempVent.on('blur.afterFocus', (event) => {
// Wait a frame before testing whether focus has moved to an open overlay or to some other element.
window.requestAnimationFrame(() => {
// If overlay remains open, don't remove tabindex event handler until after it has been closed
const top = OverlayManager.top();
if (top && top.instance.contains(document.activeElement)) {
return;
}
tempVent.off('blur.afterFocus');
event.matchedTarget.removeAttribute('tabindex');
});
}, true);
}
this._returnFocusToElement = element;
return this;
}
static get _OverlayManager() {
return OverlayManager;
}
/**
Returns {@link BaseOverlay} trap focus options.
@return {OverlayTrapFocusEnum}
*/
static get trapFocus() {
return trapFocus;
}
/**
Returns {@link BaseOverlay} return focus options.
@return {OverlayReturnFocusEnum}
*/
static get returnFocus() {
return returnFocus;
}
/**
Returns {@link BaseOverlay} scroll focus options.
@return {OverlayScrollOnFocusEnum}
*/
static get scrollOnFocus() {
return scrollOnFocus;
}
/**
Returns {@link BaseOverlay} focus on show options.
@return {OverlayFocusOnShowEnum}
*/
static get focusOnShow() {
return focusOnShow;
}
/**
Returns {@link BaseOverlay} fadetime in milliseconds.
@return {Number}
*/
static get FADETIME() {
return FADETIME;
}
static get _attributePropertyMap() {
return commons.extend(super._attributePropertyMap, {
trapfocus: 'trapFocus',
returnfocus: 'returnFocus',
focusonshow: 'focusOnShow',
});
}
/** @ignore */
static get observedAttributes() {
return super.observedAttributes.concat([
'trapfocus',
'returnfocus',
'focusonshow',
'open'
]);
}
/** @ignore */
connectedCallback() {
super.connectedCallback();
if (!this.hasAttribute('trapfocus')) {
this.trapFocus = this.trapFocus;
}
if (!this.hasAttribute('returnfocus')) {
this.returnFocus = this.returnFocus;
}
if (!this.hasAttribute('focusonshow')) {
this.focusOnShow = this.focusOnShow;
}
if (!this.hasAttribute('scrollonfocus')) {
this.scrollOnFocus = this.scrollOnFocus;
}
if (this.open) {
this._pushOverlay();
if (this._showBackdropOnAttached) {
// Show the backdrop again
this._showBackdrop();
}
} else {
// If overlay is closed, make sure that it is hidden with `display: none`,
// but set `visibility: visible` to ensure that the overlay will be included in accessibility name or description
// of an element that references it using `aria-labelledby` or `aria-describedby`.
this.style.display = 'none';
this.style.visibility = 'visible';
}
}
/** @ignore */
render() {
super.render();
this.classList.add(CLASSNAME);
}
/** @ignore */
disconnectedCallback() {
super.disconnectedCallback();
if (this.open) {
// Release zIndex as we're not in the DOM any longer
// When we're re-added, we'll get a new zIndex
this._popOverlay();
if (this._requestedBackdrop) {
// Mark that we'll need to show the backdrop when attached
this._showBackdropOnAttached = true;
}
}
}
/**
Called when the {@link BaseOverlay} is clicked.
@function backdropClickedCallback
@protected
*/
/**
Triggered before the {@link BaseOverlay} is opened with <code>show()</code> or <code>instance.open = true</code>.
@typedef {CustomEvent} coral-overlay:beforeopen
@property {function} preventDefault
Call to stop the overlay from opening.
*/
/**
Triggered after the {@link BaseOverlay} is opened with <code>show()</code> or <code>instance.open = true</code>
@typedef {CustomEvent} coral-overlay:open
*/
/**
Triggered before the {@link BaseOverlay} is closed with <code>hide()</code> or <code>instance.open = false</code>.
@typedef {CustomEvent} coral-overlay:beforeclose
@property {function} preventDefault
Call to stop the overlay from closing.
*/
/**
Triggered after the {@link BaseOverlay} is closed with <code>hide()</code> or <code>instance.open = false</code>
@typedef {CustomEvent} coral-overlay:close
*/
};
export default BaseOverlay;