@material/tabs
Version:
The Material Components for the web tabs component
1,004 lines (1,003 loc) • 116 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://github.com/material-components/material-components-web/blob/master/LICENSE
*/
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === "object" && typeof module === "object") module.exports = factory(); else if (typeof define === "function" && define.amd) define([], factory); else if (typeof exports === "object") exports["tabs"] = factory(); else root["mdc"] = root["mdc"] || {},
root["mdc"]["tabs"] = factory();
})(this, function() {
return function(modules) {
var installedModules = {};
function __webpack_require__(moduleId) {
if (installedModules[moduleId]) {
return installedModules[moduleId].exports;
}
var module = installedModules[moduleId] = {
i: moduleId,
l: false,
exports: {}
};
modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
module.l = true;
return module.exports;
}
__webpack_require__.m = modules;
__webpack_require__.c = installedModules;
__webpack_require__.d = function(exports, name, getter) {
if (!__webpack_require__.o(exports, name)) {
Object.defineProperty(exports, name, {
configurable: false,
enumerable: true,
get: getter
});
}
};
__webpack_require__.n = function(module) {
var getter = module && module.__esModule ? function getDefault() {
return module["default"];
} : function getModuleExports() {
return module;
};
__webpack_require__.d(getter, "a", getter);
return getter;
};
__webpack_require__.o = function(object, property) {
return Object.prototype.hasOwnProperty.call(object, property);
};
__webpack_require__.p = "";
return __webpack_require__(__webpack_require__.s = 163);
}({
0: function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var MDCFoundation = function() {
function MDCFoundation(adapter) {
if (adapter === void 0) {
adapter = {};
}
this.adapter_ = adapter;
}
Object.defineProperty(MDCFoundation, "cssClasses", {
get: function get() {
return {};
},
enumerable: true,
configurable: true
});
Object.defineProperty(MDCFoundation, "strings", {
get: function get() {
return {};
},
enumerable: true,
configurable: true
});
Object.defineProperty(MDCFoundation, "numbers", {
get: function get() {
return {};
},
enumerable: true,
configurable: true
});
Object.defineProperty(MDCFoundation, "defaultAdapter", {
get: function get() {
return {};
},
enumerable: true,
configurable: true
});
MDCFoundation.prototype.init = function() {};
MDCFoundation.prototype.destroy = function() {};
return MDCFoundation;
}();
exports.MDCFoundation = MDCFoundation;
exports.default = MDCFoundation;
},
1: function(module, exports, __webpack_require__) {
"use strict";
var __read = this && this.__read || function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
ar.push(r.value);
}
} catch (error) {
e = {
error: error
};
} finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
};
var __spread = this && this.__spread || function() {
for (var ar = [], i = 0; i < arguments.length; i++) {
ar = ar.concat(__read(arguments[i]));
}
return ar;
};
Object.defineProperty(exports, "__esModule", {
value: true
});
var foundation_1 = __webpack_require__(0);
var MDCComponent = function() {
function MDCComponent(root, foundation) {
var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
args[_i - 2] = arguments[_i];
}
this.root_ = root;
this.initialize.apply(this, __spread(args));
this.foundation_ = foundation === undefined ? this.getDefaultFoundation() : foundation;
this.foundation_.init();
this.initialSyncWithDOM();
}
MDCComponent.attachTo = function(root) {
return new MDCComponent(root, new foundation_1.MDCFoundation({}));
};
MDCComponent.prototype.initialize = function() {
var _args = [];
for (var _i = 0; _i < arguments.length; _i++) {
_args[_i] = arguments[_i];
}
};
MDCComponent.prototype.getDefaultFoundation = function() {
throw new Error("Subclasses must override getDefaultFoundation to return a properly configured " + "foundation class");
};
MDCComponent.prototype.initialSyncWithDOM = function() {};
MDCComponent.prototype.destroy = function() {
this.foundation_.destroy();
};
MDCComponent.prototype.listen = function(evtType, handler) {
this.root_.addEventListener(evtType, handler);
};
MDCComponent.prototype.unlisten = function(evtType, handler) {
this.root_.removeEventListener(evtType, handler);
};
MDCComponent.prototype.emit = function(evtType, evtData, shouldBubble) {
if (shouldBubble === void 0) {
shouldBubble = false;
}
var evt;
if (typeof CustomEvent === "function") {
evt = new CustomEvent(evtType, {
bubbles: shouldBubble,
detail: evtData
});
} else {
evt = document.createEvent("CustomEvent");
evt.initCustomEvent(evtType, shouldBubble, false, evtData);
}
this.root_.dispatchEvent(evt);
};
return MDCComponent;
}();
exports.MDCComponent = MDCComponent;
exports.default = MDCComponent;
},
11: function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var cssPropertyNameMap = {
animation: {
prefixed: "-webkit-animation",
standard: "animation"
},
transform: {
prefixed: "-webkit-transform",
standard: "transform"
},
transition: {
prefixed: "-webkit-transition",
standard: "transition"
}
};
var jsEventTypeMap = {
animationend: {
cssProperty: "animation",
prefixed: "webkitAnimationEnd",
standard: "animationend"
},
animationiteration: {
cssProperty: "animation",
prefixed: "webkitAnimationIteration",
standard: "animationiteration"
},
animationstart: {
cssProperty: "animation",
prefixed: "webkitAnimationStart",
standard: "animationstart"
},
transitionend: {
cssProperty: "transition",
prefixed: "webkitTransitionEnd",
standard: "transitionend"
}
};
function isWindow(windowObj) {
return Boolean(windowObj.document) && typeof windowObj.document.createElement === "function";
}
function getCorrectPropertyName(windowObj, cssProperty) {
if (isWindow(windowObj) && cssProperty in cssPropertyNameMap) {
var el = windowObj.document.createElement("div");
var _a = cssPropertyNameMap[cssProperty], standard = _a.standard, prefixed = _a.prefixed;
var isStandard = standard in el.style;
return isStandard ? standard : prefixed;
}
return cssProperty;
}
exports.getCorrectPropertyName = getCorrectPropertyName;
function getCorrectEventName(windowObj, eventType) {
if (isWindow(windowObj) && eventType in jsEventTypeMap) {
var el = windowObj.document.createElement("div");
var _a = jsEventTypeMap[eventType], standard = _a.standard, prefixed = _a.prefixed, cssProperty = _a.cssProperty;
var isStandard = cssProperty in el.style;
return isStandard ? standard : prefixed;
}
return eventType;
}
exports.getCorrectEventName = getCorrectEventName;
},
163: function(module, exports, __webpack_require__) {
"use strict";
function __export(m) {
for (var p in m) {
if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
}
Object.defineProperty(exports, "__esModule", {
value: true
});
__export(__webpack_require__(164));
__export(__webpack_require__(165));
__export(__webpack_require__(166));
},
164: function(module, exports, __webpack_require__) {
"use strict";
function __export(m) {
for (var p in m) {
if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
}
Object.defineProperty(exports, "__esModule", {
value: true
});
__export(__webpack_require__(93));
__export(__webpack_require__(51));
var constants_1 = __webpack_require__(50);
exports.tabCssClasses = constants_1.cssClasses;
exports.tabStrings = constants_1.strings;
},
165: function(module, exports, __webpack_require__) {
"use strict";
function __export(m) {
for (var p in m) {
if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
}
Object.defineProperty(exports, "__esModule", {
value: true
});
__export(__webpack_require__(94));
__export(__webpack_require__(95));
var constants_1 = __webpack_require__(96);
exports.tabBarCssClasses = constants_1.cssClasses;
exports.tabBarStrings = constants_1.strings;
},
166: function(module, exports, __webpack_require__) {
"use strict";
function __export(m) {
for (var p in m) {
if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
}
Object.defineProperty(exports, "__esModule", {
value: true
});
__export(__webpack_require__(167));
__export(__webpack_require__(97));
var constants_1 = __webpack_require__(98);
exports.tabBarScrollerCssClasses = constants_1.cssClasses;
exports.tabBarScrollerStrings = constants_1.strings;
},
167: function(module, exports, __webpack_require__) {
"use strict";
var __extends = this && this.__extends || function() {
var _extendStatics = function extendStatics(d, b) {
_extendStatics = Object.setPrototypeOf || {
__proto__: []
} instanceof Array && function(d, b) {
d.__proto__ = b;
} || function(d, b) {
for (var p in b) {
if (b.hasOwnProperty(p)) d[p] = b[p];
}
};
return _extendStatics(d, b);
};
return function(d, b) {
_extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
Object.defineProperty(exports, "__esModule", {
value: true
});
var util_1 = __webpack_require__(11);
var component_1 = __webpack_require__(1);
var component_2 = __webpack_require__(94);
var foundation_1 = __webpack_require__(97);
var MDCTabBarScroller = function(_super) {
__extends(MDCTabBarScroller, _super);
function MDCTabBarScroller() {
return _super !== null && _super.apply(this, arguments) || this;
}
MDCTabBarScroller.attachTo = function(root) {
return new MDCTabBarScroller(root);
};
Object.defineProperty(MDCTabBarScroller.prototype, "tabBar", {
get: function get() {
return this.tabBar_;
},
enumerable: true,
configurable: true
});
MDCTabBarScroller.prototype.initialize = function(tabBarFactory) {
if (tabBarFactory === void 0) {
tabBarFactory = function tabBarFactory(el) {
return new component_2.MDCTabBar(el);
};
}
this.scrollFrame_ = this.root_.querySelector(foundation_1.MDCTabBarScrollerFoundation.strings.FRAME_SELECTOR);
this.tabBarEl_ = this.root_.querySelector(foundation_1.MDCTabBarScrollerFoundation.strings.TABS_SELECTOR);
this.forwardIndicator_ = this.root_.querySelector(foundation_1.MDCTabBarScrollerFoundation.strings.INDICATOR_FORWARD_SELECTOR);
this.backIndicator_ = this.root_.querySelector(foundation_1.MDCTabBarScrollerFoundation.strings.INDICATOR_BACK_SELECTOR);
this.tabBar_ = tabBarFactory(this.tabBarEl_);
};
MDCTabBarScroller.prototype.getDefaultFoundation = function() {
var _this = this;
var adapter = {
addClass: function addClass(className) {
return _this.root_.classList.add(className);
},
removeClass: function removeClass(className) {
return _this.root_.classList.remove(className);
},
eventTargetHasClass: function eventTargetHasClass(target, className) {
return target.classList.contains(className);
},
addClassToForwardIndicator: function addClassToForwardIndicator(className) {
return _this.forwardIndicator_.classList.add(className);
},
removeClassFromForwardIndicator: function removeClassFromForwardIndicator(className) {
return _this.forwardIndicator_.classList.remove(className);
},
addClassToBackIndicator: function addClassToBackIndicator(className) {
return _this.backIndicator_.classList.add(className);
},
removeClassFromBackIndicator: function removeClassFromBackIndicator(className) {
return _this.backIndicator_.classList.remove(className);
},
isRTL: function isRTL() {
return getComputedStyle(_this.root_).getPropertyValue("direction") === "rtl";
},
registerBackIndicatorClickHandler: function registerBackIndicatorClickHandler(handler) {
return _this.backIndicator_.addEventListener("click", handler);
},
deregisterBackIndicatorClickHandler: function deregisterBackIndicatorClickHandler(handler) {
return _this.backIndicator_.removeEventListener("click", handler);
},
registerForwardIndicatorClickHandler: function registerForwardIndicatorClickHandler(handler) {
return _this.forwardIndicator_.addEventListener("click", handler);
},
deregisterForwardIndicatorClickHandler: function deregisterForwardIndicatorClickHandler(handler) {
return _this.forwardIndicator_.removeEventListener("click", handler);
},
registerCapturedInteractionHandler: function registerCapturedInteractionHandler(evt, handler) {
return _this.root_.addEventListener(evt, handler, true);
},
deregisterCapturedInteractionHandler: function deregisterCapturedInteractionHandler(evt, handler) {
return _this.root_.removeEventListener(evt, handler, true);
},
registerWindowResizeHandler: function registerWindowResizeHandler(handler) {
return window.addEventListener("resize", handler);
},
deregisterWindowResizeHandler: function deregisterWindowResizeHandler(handler) {
return window.removeEventListener("resize", handler);
},
getNumberOfTabs: function getNumberOfTabs() {
return _this.tabBar.tabs.length;
},
getComputedWidthForTabAtIndex: function getComputedWidthForTabAtIndex(index) {
return _this.tabBar.tabs[index].computedWidth;
},
getComputedLeftForTabAtIndex: function getComputedLeftForTabAtIndex(index) {
return _this.tabBar.tabs[index].computedLeft;
},
getOffsetWidthForScrollFrame: function getOffsetWidthForScrollFrame() {
return _this.scrollFrame_.offsetWidth;
},
getScrollLeftForScrollFrame: function getScrollLeftForScrollFrame() {
return _this.scrollFrame_.scrollLeft;
},
setScrollLeftForScrollFrame: function setScrollLeftForScrollFrame(scrollLeftAmount) {
return _this.scrollFrame_.scrollLeft = scrollLeftAmount;
},
getOffsetWidthForTabBar: function getOffsetWidthForTabBar() {
return _this.tabBarEl_.offsetWidth;
},
setTransformStyleForTabBar: function setTransformStyleForTabBar(value) {
_this.tabBarEl_.style.setProperty(util_1.getCorrectPropertyName(window, "transform"), value);
},
getOffsetLeftForEventTarget: function getOffsetLeftForEventTarget(target) {
return target.offsetLeft;
},
getOffsetWidthForEventTarget: function getOffsetWidthForEventTarget(target) {
return target.offsetWidth;
}
};
return new foundation_1.MDCTabBarScrollerFoundation(adapter);
};
MDCTabBarScroller.prototype.layout = function() {
this.foundation_.layout();
};
return MDCTabBarScroller;
}(component_1.MDCComponent);
exports.MDCTabBarScroller = MDCTabBarScroller;
},
2: function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function closest(element, selector) {
if (element.closest) {
return element.closest(selector);
}
var el = element;
while (el) {
if (matches(el, selector)) {
return el;
}
el = el.parentElement;
}
return null;
}
exports.closest = closest;
function matches(element, selector) {
var nativeMatches = element.matches || element.webkitMatchesSelector || element.msMatchesSelector;
return nativeMatches.call(element, selector);
}
exports.matches = matches;
},
3: function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var supportsCssVariables_;
var supportsPassive_;
function detectEdgePseudoVarBug(windowObj) {
var document = windowObj.document;
var node = document.createElement("div");
node.className = "mdc-ripple-surface--test-edge-var-bug";
document.body.appendChild(node);
var computedStyle = windowObj.getComputedStyle(node);
var hasPseudoVarBug = computedStyle !== null && computedStyle.borderTopStyle === "solid";
if (node.parentNode) {
node.parentNode.removeChild(node);
}
return hasPseudoVarBug;
}
function supportsCssVariables(windowObj, forceRefresh) {
if (forceRefresh === void 0) {
forceRefresh = false;
}
var CSS = windowObj.CSS;
var supportsCssVars = supportsCssVariables_;
if (typeof supportsCssVariables_ === "boolean" && !forceRefresh) {
return supportsCssVariables_;
}
var supportsFunctionPresent = CSS && typeof CSS.supports === "function";
if (!supportsFunctionPresent) {
return false;
}
var explicitlySupportsCssVars = CSS.supports("--css-vars", "yes");
var weAreFeatureDetectingSafari10plus = CSS.supports("(--css-vars: yes)") && CSS.supports("color", "#00000000");
if (explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus) {
supportsCssVars = !detectEdgePseudoVarBug(windowObj);
} else {
supportsCssVars = false;
}
if (!forceRefresh) {
supportsCssVariables_ = supportsCssVars;
}
return supportsCssVars;
}
exports.supportsCssVariables = supportsCssVariables;
function applyPassive(globalObj, forceRefresh) {
if (globalObj === void 0) {
globalObj = window;
}
if (forceRefresh === void 0) {
forceRefresh = false;
}
if (supportsPassive_ === undefined || forceRefresh) {
var isSupported_1 = false;
try {
globalObj.document.addEventListener("test", function() {
return undefined;
}, {
get passive() {
isSupported_1 = true;
return isSupported_1;
}
});
} catch (e) {}
supportsPassive_ = isSupported_1;
}
return supportsPassive_ ? {
passive: true
} : false;
}
exports.applyPassive = applyPassive;
function getNormalizedEventCoords(evt, pageOffset, clientRect) {
if (!evt) {
return {
x: 0,
y: 0
};
}
var x = pageOffset.x, y = pageOffset.y;
var documentX = x + clientRect.left;
var documentY = y + clientRect.top;
var normalizedX;
var normalizedY;
if (evt.type === "touchstart") {
var touchEvent = evt;
normalizedX = touchEvent.changedTouches[0].pageX - documentX;
normalizedY = touchEvent.changedTouches[0].pageY - documentY;
} else {
var mouseEvent = evt;
normalizedX = mouseEvent.pageX - documentX;
normalizedY = mouseEvent.pageY - documentY;
}
return {
x: normalizedX,
y: normalizedY
};
}
exports.getNormalizedEventCoords = getNormalizedEventCoords;
},
4: function(module, exports, __webpack_require__) {
"use strict";
var __extends = this && this.__extends || function() {
var _extendStatics = function extendStatics(d, b) {
_extendStatics = Object.setPrototypeOf || {
__proto__: []
} instanceof Array && function(d, b) {
d.__proto__ = b;
} || function(d, b) {
for (var p in b) {
if (b.hasOwnProperty(p)) d[p] = b[p];
}
};
return _extendStatics(d, b);
};
return function(d, b) {
_extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
var __assign = this && this.__assign || function() {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) {
if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", {
value: true
});
var foundation_1 = __webpack_require__(0);
var constants_1 = __webpack_require__(5);
var util_1 = __webpack_require__(3);
var ACTIVATION_EVENT_TYPES = [ "touchstart", "pointerdown", "mousedown", "keydown" ];
var POINTER_DEACTIVATION_EVENT_TYPES = [ "touchend", "pointerup", "mouseup", "contextmenu" ];
var activatedTargets = [];
var MDCRippleFoundation = function(_super) {
__extends(MDCRippleFoundation, _super);
function MDCRippleFoundation(adapter) {
var _this = _super.call(this, __assign({}, MDCRippleFoundation.defaultAdapter, adapter)) || this;
_this.activationAnimationHasEnded_ = false;
_this.activationTimer_ = 0;
_this.fgDeactivationRemovalTimer_ = 0;
_this.fgScale_ = "0";
_this.frame_ = {
width: 0,
height: 0
};
_this.initialSize_ = 0;
_this.layoutFrame_ = 0;
_this.maxRadius_ = 0;
_this.unboundedCoords_ = {
left: 0,
top: 0
};
_this.activationState_ = _this.defaultActivationState_();
_this.activationTimerCallback_ = function() {
_this.activationAnimationHasEnded_ = true;
_this.runDeactivationUXLogicIfReady_();
};
_this.activateHandler_ = function(e) {
return _this.activate_(e);
};
_this.deactivateHandler_ = function() {
return _this.deactivate_();
};
_this.focusHandler_ = function() {
return _this.handleFocus();
};
_this.blurHandler_ = function() {
return _this.handleBlur();
};
_this.resizeHandler_ = function() {
return _this.layout();
};
return _this;
}
Object.defineProperty(MDCRippleFoundation, "cssClasses", {
get: function get() {
return constants_1.cssClasses;
},
enumerable: true,
configurable: true
});
Object.defineProperty(MDCRippleFoundation, "strings", {
get: function get() {
return constants_1.strings;
},
enumerable: true,
configurable: true
});
Object.defineProperty(MDCRippleFoundation, "numbers", {
get: function get() {
return constants_1.numbers;
},
enumerable: true,
configurable: true
});
Object.defineProperty(MDCRippleFoundation, "defaultAdapter", {
get: function get() {
return {
addClass: function addClass() {
return undefined;
},
browserSupportsCssVars: function browserSupportsCssVars() {
return true;
},
computeBoundingRect: function computeBoundingRect() {
return {
top: 0,
right: 0,
bottom: 0,
left: 0,
width: 0,
height: 0
};
},
containsEventTarget: function containsEventTarget() {
return true;
},
deregisterDocumentInteractionHandler: function deregisterDocumentInteractionHandler() {
return undefined;
},
deregisterInteractionHandler: function deregisterInteractionHandler() {
return undefined;
},
deregisterResizeHandler: function deregisterResizeHandler() {
return undefined;
},
getWindowPageOffset: function getWindowPageOffset() {
return {
x: 0,
y: 0
};
},
isSurfaceActive: function isSurfaceActive() {
return true;
},
isSurfaceDisabled: function isSurfaceDisabled() {
return true;
},
isUnbounded: function isUnbounded() {
return true;
},
registerDocumentInteractionHandler: function registerDocumentInteractionHandler() {
return undefined;
},
registerInteractionHandler: function registerInteractionHandler() {
return undefined;
},
registerResizeHandler: function registerResizeHandler() {
return undefined;
},
removeClass: function removeClass() {
return undefined;
},
updateCssVariable: function updateCssVariable() {
return undefined;
}
};
},
enumerable: true,
configurable: true
});
MDCRippleFoundation.prototype.init = function() {
var _this = this;
var supportsPressRipple = this.supportsPressRipple_();
this.registerRootHandlers_(supportsPressRipple);
if (supportsPressRipple) {
var _a = MDCRippleFoundation.cssClasses, ROOT_1 = _a.ROOT, UNBOUNDED_1 = _a.UNBOUNDED;
requestAnimationFrame(function() {
_this.adapter_.addClass(ROOT_1);
if (_this.adapter_.isUnbounded()) {
_this.adapter_.addClass(UNBOUNDED_1);
_this.layoutInternal_();
}
});
}
};
MDCRippleFoundation.prototype.destroy = function() {
var _this = this;
if (this.supportsPressRipple_()) {
if (this.activationTimer_) {
clearTimeout(this.activationTimer_);
this.activationTimer_ = 0;
this.adapter_.removeClass(MDCRippleFoundation.cssClasses.FG_ACTIVATION);
}
if (this.fgDeactivationRemovalTimer_) {
clearTimeout(this.fgDeactivationRemovalTimer_);
this.fgDeactivationRemovalTimer_ = 0;
this.adapter_.removeClass(MDCRippleFoundation.cssClasses.FG_DEACTIVATION);
}
var _a = MDCRippleFoundation.cssClasses, ROOT_2 = _a.ROOT, UNBOUNDED_2 = _a.UNBOUNDED;
requestAnimationFrame(function() {
_this.adapter_.removeClass(ROOT_2);
_this.adapter_.removeClass(UNBOUNDED_2);
_this.removeCssVars_();
});
}
this.deregisterRootHandlers_();
this.deregisterDeactivationHandlers_();
};
MDCRippleFoundation.prototype.activate = function(evt) {
this.activate_(evt);
};
MDCRippleFoundation.prototype.deactivate = function() {
this.deactivate_();
};
MDCRippleFoundation.prototype.layout = function() {
var _this = this;
if (this.layoutFrame_) {
cancelAnimationFrame(this.layoutFrame_);
}
this.layoutFrame_ = requestAnimationFrame(function() {
_this.layoutInternal_();
_this.layoutFrame_ = 0;
});
};
MDCRippleFoundation.prototype.setUnbounded = function(unbounded) {
var UNBOUNDED = MDCRippleFoundation.cssClasses.UNBOUNDED;
if (unbounded) {
this.adapter_.addClass(UNBOUNDED);
} else {
this.adapter_.removeClass(UNBOUNDED);
}
};
MDCRippleFoundation.prototype.handleFocus = function() {
var _this = this;
requestAnimationFrame(function() {
return _this.adapter_.addClass(MDCRippleFoundation.cssClasses.BG_FOCUSED);
});
};
MDCRippleFoundation.prototype.handleBlur = function() {
var _this = this;
requestAnimationFrame(function() {
return _this.adapter_.removeClass(MDCRippleFoundation.cssClasses.BG_FOCUSED);
});
};
MDCRippleFoundation.prototype.supportsPressRipple_ = function() {
return this.adapter_.browserSupportsCssVars();
};
MDCRippleFoundation.prototype.defaultActivationState_ = function() {
return {
activationEvent: undefined,
hasDeactivationUXRun: false,
isActivated: false,
isProgrammatic: false,
wasActivatedByPointer: false,
wasElementMadeActive: false
};
};
MDCRippleFoundation.prototype.registerRootHandlers_ = function(supportsPressRipple) {
var _this = this;
if (supportsPressRipple) {
ACTIVATION_EVENT_TYPES.forEach(function(evtType) {
_this.adapter_.registerInteractionHandler(evtType, _this.activateHandler_);
});
if (this.adapter_.isUnbounded()) {
this.adapter_.registerResizeHandler(this.resizeHandler_);
}
}
this.adapter_.registerInteractionHandler("focus", this.focusHandler_);
this.adapter_.registerInteractionHandler("blur", this.blurHandler_);
};
MDCRippleFoundation.prototype.registerDeactivationHandlers_ = function(evt) {
var _this = this;
if (evt.type === "keydown") {
this.adapter_.registerInteractionHandler("keyup", this.deactivateHandler_);
} else {
POINTER_DEACTIVATION_EVENT_TYPES.forEach(function(evtType) {
_this.adapter_.registerDocumentInteractionHandler(evtType, _this.deactivateHandler_);
});
}
};
MDCRippleFoundation.prototype.deregisterRootHandlers_ = function() {
var _this = this;
ACTIVATION_EVENT_TYPES.forEach(function(evtType) {
_this.adapter_.deregisterInteractionHandler(evtType, _this.activateHandler_);
});
this.adapter_.deregisterInteractionHandler("focus", this.focusHandler_);
this.adapter_.deregisterInteractionHandler("blur", this.blurHandler_);
if (this.adapter_.isUnbounded()) {
this.adapter_.deregisterResizeHandler(this.resizeHandler_);
}
};
MDCRippleFoundation.prototype.deregisterDeactivationHandlers_ = function() {
var _this = this;
this.adapter_.deregisterInteractionHandler("keyup", this.deactivateHandler_);
POINTER_DEACTIVATION_EVENT_TYPES.forEach(function(evtType) {
_this.adapter_.deregisterDocumentInteractionHandler(evtType, _this.deactivateHandler_);
});
};
MDCRippleFoundation.prototype.removeCssVars_ = function() {
var _this = this;
var rippleStrings = MDCRippleFoundation.strings;
var keys = Object.keys(rippleStrings);
keys.forEach(function(key) {
if (key.indexOf("VAR_") === 0) {
_this.adapter_.updateCssVariable(rippleStrings[key], null);
}
});
};
MDCRippleFoundation.prototype.activate_ = function(evt) {
var _this = this;
if (this.adapter_.isSurfaceDisabled()) {
return;
}
var activationState = this.activationState_;
if (activationState.isActivated) {
return;
}
var previousActivationEvent = this.previousActivationEvent_;
var isSameInteraction = previousActivationEvent && evt !== undefined && previousActivationEvent.type !== evt.type;
if (isSameInteraction) {
return;
}
activationState.isActivated = true;
activationState.isProgrammatic = evt === undefined;
activationState.activationEvent = evt;
activationState.wasActivatedByPointer = activationState.isProgrammatic ? false : evt !== undefined && (evt.type === "mousedown" || evt.type === "touchstart" || evt.type === "pointerdown");
var hasActivatedChild = evt !== undefined && activatedTargets.length > 0 && activatedTargets.some(function(target) {
return _this.adapter_.containsEventTarget(target);
});
if (hasActivatedChild) {
this.resetActivationState_();
return;
}
if (evt !== undefined) {
activatedTargets.push(evt.target);
this.registerDeactivationHandlers_(evt);
}
activationState.wasElementMadeActive = this.checkElementMadeActive_(evt);
if (activationState.wasElementMadeActive) {
this.animateActivation_();
}
requestAnimationFrame(function() {
activatedTargets = [];
if (!activationState.wasElementMadeActive && evt !== undefined && (evt.key === " " || evt.keyCode === 32)) {
activationState.wasElementMadeActive = _this.checkElementMadeActive_(evt);
if (activationState.wasElementMadeActive) {
_this.animateActivation_();
}
}
if (!activationState.wasElementMadeActive) {
_this.activationState_ = _this.defaultActivationState_();
}
});
};
MDCRippleFoundation.prototype.checkElementMadeActive_ = function(evt) {
return evt !== undefined && evt.type === "keydown" ? this.adapter_.isSurfaceActive() : true;
};
MDCRippleFoundation.prototype.animateActivation_ = function() {
var _this = this;
var _a = MDCRippleFoundation.strings, VAR_FG_TRANSLATE_START = _a.VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END = _a.VAR_FG_TRANSLATE_END;
var _b = MDCRippleFoundation.cssClasses, FG_DEACTIVATION = _b.FG_DEACTIVATION, FG_ACTIVATION = _b.FG_ACTIVATION;
var DEACTIVATION_TIMEOUT_MS = MDCRippleFoundation.numbers.DEACTIVATION_TIMEOUT_MS;
this.layoutInternal_();
var translateStart = "";
var translateEnd = "";
if (!this.adapter_.isUnbounded()) {
var _c = this.getFgTranslationCoordinates_(), startPoint = _c.startPoint, endPoint = _c.endPoint;
translateStart = startPoint.x + "px, " + startPoint.y + "px";
translateEnd = endPoint.x + "px, " + endPoint.y + "px";
}
this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_START, translateStart);
this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_END, translateEnd);
clearTimeout(this.activationTimer_);
clearTimeout(this.fgDeactivationRemovalTimer_);
this.rmBoundedActivationClasses_();
this.adapter_.removeClass(FG_DEACTIVATION);
this.adapter_.computeBoundingRect();
this.adapter_.addClass(FG_ACTIVATION);
this.activationTimer_ = setTimeout(function() {
return _this.activationTimerCallback_();
}, DEACTIVATION_TIMEOUT_MS);
};
MDCRippleFoundation.prototype.getFgTranslationCoordinates_ = function() {
var _a = this.activationState_, activationEvent = _a.activationEvent, wasActivatedByPointer = _a.wasActivatedByPointer;
var startPoint;
if (wasActivatedByPointer) {
startPoint = util_1.getNormalizedEventCoords(activationEvent, this.adapter_.getWindowPageOffset(), this.adapter_.computeBoundingRect());
} else {
startPoint = {
x: this.frame_.width / 2,
y: this.frame_.height / 2
};
}
startPoint = {
x: startPoint.x - this.initialSize_ / 2,
y: startPoint.y - this.initialSize_ / 2
};
var endPoint = {
x: this.frame_.width / 2 - this.initialSize_ / 2,
y: this.frame_.height / 2 - this.initialSize_ / 2
};
return {
startPoint: startPoint,
endPoint: endPoint
};
};
MDCRippleFoundation.prototype.runDeactivationUXLogicIfReady_ = function() {
var _this = this;
var FG_DEACTIVATION = MDCRippleFoundation.cssClasses.FG_DEACTIVATION;
var _a = this.activationState_, hasDeactivationUXRun = _a.hasDeactivationUXRun, isActivated = _a.isActivated;
var activationHasEnded = hasDeactivationUXRun || !isActivated;
if (activationHasEnded && this.activationAnimationHasEnded_) {
this.rmBoundedActivationClasses_();
this.adapter_.addClass(FG_DEACTIVATION);
this.fgDeactivationRemovalTimer_ = setTimeout(function() {