devextreme
Version:
HTML5 JavaScript Component Suite for Responsive Web Development
1,139 lines (1,118 loc) • 9.33 MB
JavaScript
/*!
* DevExtreme (dx.web.debug.js)
* Version: 20.1.7
* Build date: Tue Aug 25 2020
*
* Copyright (c) 2012 - 2020 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
"use strict";
! 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() {
return module.default
} : function() {
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 = 919)
}([
/*!***************************************************!*\
!*** ./artifacts/transpiled/core/utils/extend.js ***!
\***************************************************/
/*! dynamic exports provided */
/*! all exports used */
function(module, exports, __webpack_require__) {
var isPlainObject = __webpack_require__( /*! ./type */ 1).isPlainObject;
var extendFromObject = function(target, source, overrideExistingValues) {
target = target || {};
for (var prop in source) {
if (Object.prototype.hasOwnProperty.call(source, prop)) {
var value = source[prop];
if (!(prop in target) || overrideExistingValues) {
target[prop] = value
}
}
}
return target
};
var extend = function extend(target) {
target = target || {};
var i = 1;
var deep = false;
if ("boolean" === typeof target) {
deep = target;
target = arguments[1] || {};
i++
}
for (; i < arguments.length; i++) {
var source = arguments[i];
if (null == source) {
continue
}
for (var key in source) {
var targetValue = target[key];
var sourceValue = source[key];
var sourceValueIsArray = false;
var clone = void 0;
if ("__proto__" === key || target === sourceValue) {
continue
}
if (deep && sourceValue && (isPlainObject(sourceValue) || (sourceValueIsArray = Array.isArray(sourceValue)))) {
if (sourceValueIsArray) {
clone = targetValue && Array.isArray(targetValue) ? targetValue : []
} else {
clone = targetValue && isPlainObject(targetValue) ? targetValue : {}
}
target[key] = extend(deep, clone, sourceValue)
} else {
if (void 0 !== sourceValue) {
target[key] = sourceValue
}
}
}
}
return target
};
exports.extend = extend;
exports.extendFromObject = extendFromObject
},
/*!*************************************************!*\
!*** ./artifacts/transpiled/core/utils/type.js ***!
\*************************************************/
/*! dynamic exports provided */
/*! all exports used */
function(module, exports, __webpack_require__) {
function _typeof(obj) {
"@babel/helpers - typeof";
if ("function" === typeof Symbol && "symbol" === typeof Symbol.iterator) {
_typeof = function(obj) {
return typeof obj
}
} else {
_typeof = function(obj) {
return obj && "function" === typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj
}
}
return _typeof(obj)
}
var types = {
"[object Array]": "array",
"[object Date]": "date",
"[object Object]": "object",
"[object String]": "string",
"[object Null]": "null"
};
var type = function(object) {
var typeOfObject = Object.prototype.toString.call(object);
return "object" === _typeof(object) ? types[typeOfObject] || "object" : _typeof(object)
};
var isBoolean = function(object) {
return "boolean" === typeof object
};
var isExponential = function(value) {
return isNumeric(value) && value.toString().indexOf("e") !== -1
};
var isDate = function(object) {
return "date" === type(object)
};
var isDefined = function(object) {
return null !== object && void 0 !== object
};
var isFunction = function(object) {
return "function" === typeof object
};
var isString = function(object) {
return "string" === typeof object
};
var isNumeric = function(object) {
return "number" === typeof object && isFinite(object) || !isNaN(object - parseFloat(object))
};
var isObject = function(object) {
return "object" === type(object)
};
var isEmptyObject = function(object) {
var property;
for (property in object) {
return false
}
return true
};
var isPlainObject = function(object) {
if (!object || "[object Object]" !== Object.prototype.toString.call(object)) {
return false
}
var proto = Object.getPrototypeOf(object);
var ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
return "function" === typeof ctor && Object.toString.call(ctor) === Object.toString.call(Object)
};
var isPrimitive = function(value) {
return ["object", "array", "function"].indexOf(type(value)) === -1
};
var isWindow = function(object) {
return null != object && object === object.window
};
var isRenderer = function(object) {
return !!(object.jquery || object.dxRenderer)
};
var isPromise = function(object) {
return object && isFunction(object.then)
};
var isDeferred = function(object) {
return object && isFunction(object.done) && isFunction(object.fail)
};
exports.isBoolean = isBoolean;
exports.isExponential = isExponential;
exports.isDate = isDate;
exports.isDefined = isDefined;
exports.isFunction = isFunction;
exports.isString = isString;
exports.isNumeric = isNumeric;
exports.isObject = isObject;
exports.isEmptyObject = isEmptyObject;
exports.isPlainObject = isPlainObject;
exports.isPrimitive = isPrimitive;
exports.isWindow = isWindow;
exports.isRenderer = isRenderer;
exports.isPromise = isPromise;
exports.isDeferred = isDeferred;
exports.type = type
},
/*!***********************************************!*\
!*** ./artifacts/transpiled/core/renderer.js ***!
\***********************************************/
/*! dynamic exports provided */
/*! all exports used */
function(module, exports, __webpack_require__) {
var rendererBase = __webpack_require__( /*! ./renderer_base */ 270);
module.exports = rendererBase.get()
},
/*!***************************************************!*\
!*** ./artifacts/transpiled/core/utils/common.js ***!
\***************************************************/
/*! dynamic exports provided */
/*! all exports used */
function(module, exports, __webpack_require__) {
var _config = __webpack_require__( /*! ../config */ 32);
var _config2 = _interopRequireDefault(_config);
var _guid = __webpack_require__( /*! ../guid */ 37);
var _guid2 = _interopRequireDefault(_guid);
var _deferred = __webpack_require__( /*! ../utils/deferred */ 6);
var _data = __webpack_require__( /*! ./data */ 21);
var _iterator = __webpack_require__( /*! ./iterator */ 4);
var _type = __webpack_require__( /*! ./type */ 1);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
"default": obj
}
}
function _typeof(obj) {
"@babel/helpers - typeof";
if ("function" === typeof Symbol && "symbol" === typeof Symbol.iterator) {
_typeof = function(obj) {
return typeof obj
}
} else {
_typeof = function(obj) {
return obj && "function" === typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj
}
}
return _typeof(obj)
}
var ensureDefined = function(value, defaultValue) {
return (0, _type.isDefined)(value) ? value : defaultValue
};
var executeAsync = function(action, context) {
var deferred = new _deferred.Deferred;
var normalizedContext = context || this;
var task = {
promise: deferred.promise(),
abort: function() {
clearTimeout(timerId);
deferred.rejectWith(normalizedContext)
}
};
var callback = function() {
var result = action.call(normalizedContext);
if (result && result.done && (0, _type.isFunction)(result.done)) {
result.done(function() {
deferred.resolveWith(normalizedContext)
})
} else {
deferred.resolveWith(normalizedContext)
}
};
var timerId = (arguments[2] || setTimeout)(callback, "number" === typeof context ? context : 0);
return task
};
var delayedFuncs = [];
var delayedNames = [];
var delayedDeferreds = [];
var executingName;
var deferExecute = function(name, func, deferred) {
if (executingName && executingName !== name) {
delayedFuncs.push(func);
delayedNames.push(name);
deferred = deferred || new _deferred.Deferred;
delayedDeferreds.push(deferred);
return deferred
} else {
var oldExecutingName = executingName;
var currentDelayedCount = delayedDeferreds.length;
executingName = name;
var result = func();
if (!result) {
if (delayedDeferreds.length > currentDelayedCount) {
result = _deferred.when.apply(this, delayedDeferreds.slice(currentDelayedCount))
} else {
if (deferred) {
deferred.resolve()
}
}
}
executingName = oldExecutingName;
if (deferred && result && result.done) {
result.done(deferred.resolve).fail(deferred.reject)
}
if (!executingName && delayedFuncs.length) {
("render" === delayedNames.shift() ? deferRender : deferUpdate)(delayedFuncs.shift(), delayedDeferreds.shift())
}
return result || (0, _deferred.when)()
}
};
var deferRender = function(func, deferred) {
return deferExecute("render", func, deferred)
};
var deferUpdate = function(func, deferred) {
return deferExecute("update", func, deferred)
};
var deferRenderer = function(func) {
return function() {
var that = this;
return deferExecute("render", function() {
return func.call(that)
})
}
};
var deferUpdater = function(func) {
return function() {
var that = this;
return deferExecute("update", function() {
return func.call(that)
})
}
};
var findBestMatches = function(targetFilter, items, mapFn) {
var bestMatches = [];
var maxMatchCount = 0;
(0, _iterator.each)(items, function(index, itemSrc) {
var matchCount = 0;
var item = mapFn ? mapFn(itemSrc) : itemSrc;
(0, _iterator.each)(targetFilter, function(paramName, targetValue) {
var value = item[paramName];
if (void 0 === value) {
return
}
if (match(value, targetValue)) {
matchCount++;
return
}
matchCount = -1;
return false
});
if (matchCount < maxMatchCount) {
return
}
if (matchCount > maxMatchCount) {
bestMatches.length = 0;
maxMatchCount = matchCount
}
bestMatches.push(itemSrc)
});
return bestMatches
};
var match = function(value, targetValue) {
if (Array.isArray(value) && Array.isArray(targetValue)) {
var mismatch = false;
(0, _iterator.each)(value, function(index, valueItem) {
if (valueItem !== targetValue[index]) {
mismatch = true;
return false
}
});
if (mismatch) {
return false
}
return true
}
if (value === targetValue) {
return true
}
return false
};
var splitPair = function(raw) {
switch (_typeof(raw)) {
case "string":
return raw.split(/\s+/, 2);
case "object":
return [raw.x || raw.h, raw.y || raw.v];
case "number":
return [raw];
default:
return raw
}
};
var normalizeKey = function(id) {
var key = (0, _type.isString)(id) ? id : id.toString();
var arr = key.match(/[^a-zA-Z0-9_]/g);
arr && (0, _iterator.each)(arr, function(_, sign) {
key = key.replace(sign, "__" + sign.charCodeAt() + "__")
});
return key
};
var denormalizeKey = function(key) {
var arr = key.match(/__\d+__/g);
arr && arr.forEach(function(char) {
var charCode = parseInt(char.replace("__", ""));
key = key.replace(char, String.fromCharCode(charCode))
});
return key
};
var pairToObject = function(raw, preventRound) {
var pair = splitPair(raw);
var h = preventRound ? parseFloat(pair && pair[0]) : parseInt(pair && pair[0], 10);
var v = preventRound ? parseFloat(pair && pair[1]) : parseInt(pair && pair[1], 10);
if (!isFinite(h)) {
h = 0
}
if (!isFinite(v)) {
v = h
}
return {
h: h,
v: v
}
};
var getKeyHash = function(key) {
if (key instanceof _guid2.default) {
return key.toString()
} else {
if ((0, _type.isObject)(key) || Array.isArray(key)) {
try {
var keyHash = JSON.stringify(key);
return "{}" === keyHash ? key : keyHash
} catch (e) {
return key
}
}
}
return key
};
var escapeRegExp = function(string) {
return string.replace(/[[\]{}\-()*+?.\\^$|\s]/g, "\\$&")
};
var applyServerDecimalSeparator = function(value) {
var separator = (0, _config2.default)().serverDecimalSeparator;
if ((0, _type.isDefined)(value)) {
value = value.toString().replace(".", separator)
}
return value
};
var noop = function() {};
var asyncNoop = function() {
return (new _deferred.Deferred).resolve().promise()
};
var grep = function(elements, checkFunction, invert) {
var result = [];
var check;
var expectedCheck = !invert;
for (var i = 0; i < elements.length; i++) {
check = !!checkFunction(elements[i], i);
if (check === expectedCheck) {
result.push(elements[i])
}
}
return result
};
var arraysEqualByValue = function(array1, array2, depth) {
if (array1.length !== array2.length) {
return false
}
for (var i = 0; i < array1.length; i++) {
if (!equalByValue(array1[i], array2[i], depth + 1)) {
return false
}
}
return true
};
var objectsEqualByValue = function(object1, object2, depth, strict) {
for (var propertyName in object1) {
if (Object.prototype.hasOwnProperty.call(object1, propertyName) && !equalByValue(object1[propertyName], object2[propertyName], depth + 1, strict)) {
return false
}
}
for (var _propertyName in object2) {
if (!(_propertyName in object1)) {
return false
}
}
return true
};
var maxEqualityDepth = 3;
var equalByValue = function(object1, object2) {
var depth = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0;
var strict = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : true;
object1 = (0, _data.toComparable)(object1, true);
object2 = (0, _data.toComparable)(object2, true);
var comparisonResult = strict ? object1 === object2 : object1 == object2;
if (comparisonResult || depth >= maxEqualityDepth) {
return true
}
if ((0, _type.isObject)(object1) && (0, _type.isObject)(object2)) {
return objectsEqualByValue(object1, object2, depth, strict)
} else {
if (Array.isArray(object1) && Array.isArray(object2)) {
return arraysEqualByValue(object1, object2, depth)
}
}
return false
};
exports.ensureDefined = ensureDefined;
exports.executeAsync = executeAsync;
exports.deferRender = deferRender;
exports.deferRenderer = deferRenderer;
exports.deferUpdate = deferUpdate;
exports.deferUpdater = deferUpdater;
exports.pairToObject = pairToObject;
exports.splitPair = splitPair;
exports.findBestMatches = findBestMatches;
exports.normalizeKey = normalizeKey;
exports.denormalizeKey = denormalizeKey;
exports.getKeyHash = getKeyHash;
exports.escapeRegExp = escapeRegExp;
exports.applyServerDecimalSeparator = applyServerDecimalSeparator;
exports.noop = noop;
exports.asyncNoop = asyncNoop;
exports.grep = grep;
exports.equalByValue = equalByValue
},
/*!*****************************************************!*\
!*** ./artifacts/transpiled/core/utils/iterator.js ***!
\*****************************************************/
/*! dynamic exports provided */
/*! all exports used */
function(module, exports, __webpack_require__) {
var map = function(values, callback) {
if (Array.isArray(values)) {
return values.map(callback)
}
var result = [];
for (var key in values) {
result.push(callback(values[key], key))
}
return result
};
var each = function(values, callback) {
if (!values) {
return
}
if ("length" in values) {
for (var i = 0; i < values.length; i++) {
if (false === callback.call(values[i], i, values[i])) {
break
}
}
} else {
for (var key in values) {
if (false === callback.call(values[key], key, values[key])) {
break
}
}
}
return values
};
var reverseEach = function(array, callback) {
if (!array || !("length" in array) || 0 === array.length) {
return
}
for (var i = array.length - 1; i >= 0; i--) {
if (false === callback.call(array[i], i, array[i])) {
break
}
}
};
exports.map = map;
exports.each = each;
exports.reverseEach = reverseEach
},
/*!***********************************************************!*\
!*** ./artifacts/transpiled/events/core/events_engine.js ***!
\***********************************************************/
/*! dynamic exports provided */
/*! all exports used */
function(module, exports, __webpack_require__) {
var _event_registrator_callbacks = __webpack_require__( /*! ./event_registrator_callbacks */ 139);
var _event_registrator_callbacks2 = _interopRequireDefault(_event_registrator_callbacks);
var _extend = __webpack_require__( /*! ../../core/utils/extend */ 0);
var _dom_adapter = __webpack_require__( /*! ../../core/dom_adapter */ 11);
var _dom_adapter2 = _interopRequireDefault(_dom_adapter);
var _window = __webpack_require__( /*! ../../core/utils/window */ 7);
var _window2 = _interopRequireDefault(_window);
var _dependency_injector = __webpack_require__( /*! ../../core/utils/dependency_injector */ 60);
var _dependency_injector2 = _interopRequireDefault(_dependency_injector);
var _type = __webpack_require__( /*! ../../core/utils/type */ 1);
var _type2 = _interopRequireDefault(_type);
var _callbacks = __webpack_require__( /*! ../../core/utils/callbacks */ 27);
var _callbacks2 = _interopRequireDefault(_callbacks);
var _errors = __webpack_require__( /*! ../../core/errors */ 23);
var _errors2 = _interopRequireDefault(_errors);
var _weak_map = __webpack_require__( /*! ../../core/polyfills/weak_map */ 197);
var _weak_map2 = _interopRequireDefault(_weak_map);
var _hook_touch_props = __webpack_require__( /*! ../../events/core/hook_touch_props */ 271);
var _hook_touch_props2 = _interopRequireDefault(_hook_touch_props);
var _call_once = __webpack_require__( /*! ../../core/utils/call_once */ 82);
var _call_once2 = _interopRequireDefault(_call_once);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : {
"default": obj
}
}
function _typeof(obj) {
"@babel/helpers - typeof";
if ("function" === typeof Symbol && "symbol" === typeof Symbol.iterator) {
_typeof = function(obj) {
return typeof obj
}
} else {
_typeof = function(obj) {
return obj && "function" === typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj
}
}
return _typeof(obj)
}
var window = _window2.default.getWindow();
var isWindow = _type2.default.isWindow;
var isFunction = _type2.default.isFunction;
var isString = _type2.default.isString;
var EMPTY_EVENT_NAME = "dxEmptyEventType";
var NATIVE_EVENTS_TO_SUBSCRIBE = {
mouseenter: "mouseover",
mouseleave: "mouseout",
pointerenter: "pointerover",
pointerleave: "pointerout"
};
var NATIVE_EVENTS_TO_TRIGGER = {
focusin: "focus",
focusout: "blur"
};
var NO_BUBBLE_EVENTS = ["blur", "focus", "load"];
var forcePassiveFalseEventNames = ["touchmove", "wheel", "mousewheel", "touchstart"];
function matchesSafe(target, selector) {
return !isWindow(target) && "#document" !== target.nodeName && _dom_adapter2.default.elementMatches(target, selector)
}
var elementDataMap = new _weak_map2.default;
var guid = 0;
var skipEvent;
var special = function() {
var specialData = {};
_event_registrator_callbacks2.default.add(function(eventName, eventObject) {
specialData[eventName] = eventObject
});
return {
getField: function(eventName, field) {
return specialData[eventName] && specialData[eventName][field]
},
callMethod: function(eventName, methodName, context, args) {
return specialData[eventName] && specialData[eventName][methodName] && specialData[eventName][methodName].apply(context, args)
}
}
}();
var eventsEngine = (0, _dependency_injector2.default)({
on: getHandler(normalizeOnArguments(iterate(function(element, eventName, selector, data, handler) {
var handlersController = getHandlersController(element, eventName);
handlersController.addHandler(handler, selector, data)
}))),
one: getHandler(normalizeOnArguments(function(element, eventName, selector, data, handler) {
var oneTimeHandler = function oneTimeHandler() {
eventsEngine.off(element, eventName, selector, oneTimeHandler);
handler.apply(this, arguments)
};
eventsEngine.on(element, eventName, selector, data, oneTimeHandler)
})),
off: getHandler(normalizeOffArguments(iterate(function(element, eventName, selector, handler) {
var handlersController = getHandlersController(element, eventName);
handlersController.removeHandler(handler, selector)
}))),
trigger: getHandler(normalizeTriggerArguments(function(element, event, extraParameters) {
var eventName = event.type;
var handlersController = getHandlersController(element, event.type);
special.callMethod(eventName, "trigger", element, [event, extraParameters]);
handlersController.callHandlers(event, extraParameters);
var noBubble = special.getField(eventName, "noBubble") || event.isPropagationStopped() || NO_BUBBLE_EVENTS.indexOf(eventName) !== -1;
if (!noBubble) {
var parents = [];
var getParents = function getParents(element) {
var parent = element.parentNode;
if (parent) {
parents.push(parent);
getParents(parent)
}
};
getParents(element);
parents.push(window);
var i = 0;
while (parents[i] && !event.isPropagationStopped()) {
var parentDataByEvent = getHandlersController(parents[i], event.type);
parentDataByEvent.callHandlers((0, _extend.extend)(event, {
currentTarget: parents[i]
}), extraParameters);
i++
}
}
if (element.nodeType || isWindow(element)) {
special.callMethod(eventName, "_default", element, [event, extraParameters]);
callNativeMethod(eventName, element)
}
})),
triggerHandler: getHandler(normalizeTriggerArguments(function(element, event, extraParameters) {
var handlersController = getHandlersController(element, event.type);
handlersController.callHandlers(event, extraParameters)
}))
});
function applyForEach(args, method) {
var element = args[0];
if (!element) {
return
}
if (_dom_adapter2.default.isNode(element) || isWindow(element)) {
method.apply(eventsEngine, args)
} else {
if (!isString(element) && "length" in element) {
var itemArgs = Array.prototype.slice.call(args, 0);
Array.prototype.forEach.call(element, function(itemElement) {
itemArgs[0] = itemElement;
applyForEach(itemArgs, method)
})
} else {
throw _errors2.default.Error("E0025")
}
}
}
function getHandler(method) {
return function() {
applyForEach(arguments, method)
}
}
function detectPassiveEventHandlersSupport() {
var isSupported = false;
try {
var options = Object.defineProperty({}, "passive", {
get: function() {
isSupported = true;
return true
}
});
window.addEventListener("test", null, options)
} catch (e) {}
return isSupported
}
var passiveEventHandlersSupported = (0, _call_once2.default)(detectPassiveEventHandlersSupport);
var contains = function contains(container, element) {
if (isWindow(container)) {
return contains(container.document, element)
}
return container.contains ? container.contains(element) : !!(element.compareDocumentPosition(container) & element.DOCUMENT_POSITION_CONTAINS)
};
function getHandlersController(element, eventName) {
var elementData = elementDataMap.get(element);
eventName = eventName || "";
var eventNameParts = eventName.split(".");
var namespaces = eventNameParts.slice(1);
var eventNameIsDefined = !!eventNameParts[0];
eventName = eventNameParts[0] || EMPTY_EVENT_NAME;
if (!elementData) {
elementData = {};
elementDataMap.set(element, elementData)
}
if (!elementData[eventName]) {
elementData[eventName] = {
handleObjects: [],
nativeHandler: null
}
}
var eventData = elementData[eventName];
return {
addHandler: function(handler, selector, data) {
var callHandler = function(e, extraParameters) {
var handlerArgs = [e];
var target = e.currentTarget;
var relatedTarget = e.relatedTarget;
var secondaryTargetIsInside;
var result;
if (eventName in NATIVE_EVENTS_TO_SUBSCRIBE) {
secondaryTargetIsInside = relatedTarget && target && (relatedTarget === target || contains(target, relatedTarget))
}
if (void 0 !== extraParameters) {
handlerArgs.push(extraParameters)
}
special.callMethod(eventName, "handle", element, [e, data]);
if (!secondaryTargetIsInside) {
result = handler.apply(target, handlerArgs)
}
if (false === result) {
e.preventDefault();
e.stopPropagation()
}
};
var wrappedHandler = function(e, extraParameters) {
if (skipEvent && e.type === skipEvent) {
return
}
e.data = data;
e.delegateTarget = element;
if (selector) {
var currentTarget = e.target;
while (currentTarget && currentTarget !== element) {
if (matchesSafe(currentTarget, selector)) {
e.currentTarget = currentTarget;
callHandler(e, extraParameters)
}
currentTarget = currentTarget.parentNode
}
} else {
e.currentTarget = e.delegateTarget || e.target;
callHandler(e, extraParameters)
}
};
var handleObject = {
handler: handler,
wrappedHandler: wrappedHandler,
selector: selector,
type: eventName,
data: data,
namespace: namespaces.join("."),
namespaces: namespaces,
guid: ++guid
};
eventData.handleObjects.push(handleObject);
var firstHandlerForTheType = 1 === eventData.handleObjects.length;
var shouldAddNativeListener = firstHandlerForTheType && eventNameIsDefined;
var nativeListenerOptions;
if (shouldAddNativeListener) {
shouldAddNativeListener = !special.callMethod(eventName, "setup", element, [data, namespaces, handler])
}
if (shouldAddNativeListener) {
eventData.nativeHandler = getNativeHandler(eventName);
if (passiveEventHandlersSupported() && forcePassiveFalseEventNames.indexOf(eventName) > -1) {
nativeListenerOptions = {
passive: false
}
}
eventData.removeListener = _dom_adapter2.default.listen(element, NATIVE_EVENTS_TO_SUBSCRIBE[eventName] || eventName, eventData.nativeHandler, nativeListenerOptions)
}
special.callMethod(eventName, "add", element, [handleObject])
},
removeHandler: function(handler, selector) {
var removeByEventName = function(eventName) {
var eventData = elementData[eventName];
if (!eventData.handleObjects.length) {
delete elementData[eventName];
return
}
var removedHandler;
eventData.handleObjects = eventData.handleObjects.filter(function(handleObject) {
var skip = namespaces.length && !isSubset(handleObject.namespaces, namespaces) || handler && handleObject.handler !== handler || selector && handleObject.selector !== selector;
if (!skip) {
removedHandler = handleObject.handler;
special.callMethod(eventName, "remove", element, [handleObject])
}
return skip
});
var lastHandlerForTheType = !eventData.handleObjects.length;
var shouldRemoveNativeListener = lastHandlerForTheType && eventName !== EMPTY_EVENT_NAME;
if (shouldRemoveNativeListener) {
special.callMethod(eventName, "teardown", element, [namespaces, removedHandler]);
if (eventData.nativeHandler) {
eventData.removeListener()
}
delete elementData[eventName]
}
};
if (eventNameIsDefined) {
removeByEventName(eventName)
} else {
for (var name in elementData) {
removeByEventName(name)
}
}
var elementDataIsEmpty = 0 === Object.keys(elementData).length;
if (elementDataIsEmpty) {
elementDataMap.delete(element)
}
},
callHandlers: function(event, extraParameters) {
var forceStop = false;
var handleCallback = function(handleObject) {
if (forceStop) {
return
}
if (!namespaces.length || isSubset(handleObject.namespaces, namespaces)) {
handleObject.wrappedHandler(event, extraParameters);
forceStop = event.isImmediatePropagationStopped()
}
};
eventData.handleObjects.forEach(handleCallback);
if (namespaces.length && elementData[EMPTY_EVENT_NAME]) {
elementData[EMPTY_EVENT_NAME].handleObjects.forEach(handleCallback)
}
}
}
}
function getNativeHandler(subscribeName) {
return function(event, extraParameters) {
var handlersController = getHandlersController(this, subscribeName);
event = eventsEngine.Event(event);
handlersController.callHandlers(event, extraParameters)
}
}
function isSubset(original, checked) {
for (var i = 0; i < checked.length; i++) {
if (original.indexOf(checked[i]) < 0) {
return false
}
}
return true
}
function normalizeOnArguments(callback) {
return function(element, eventName, selector, data, handler) {
if (!handler) {
handler = data;
data = void 0
}
if ("string" !== typeof selector) {
data = selector;
selector = void 0
}
if (!handler && "string" === typeof eventName) {
handler = data || selector;
selector = void 0;
data = void 0
}
callback(element, eventName, selector, data, handler)
}
}
function normalizeOffArguments(callback) {
return function(element, eventName, selector, handler) {
if ("function" === typeof selector) {
handler = selector;
selector = void 0
}
callback(element, eventName, selector, handler)
}
}
function normalizeTriggerArguments(callback) {
return function(element, src, extraParameters) {
if ("string" === typeof src) {
src = {
type: src
}
}
if (!src.target) {
src.target = element
}
src.currentTarget = element;
if (!src.delegateTarget) {
src.delegateTarget = element
}
if (!src.type && src.originalEvent) {
src.type = src.originalEvent.type
}
callback(element, src instanceof eventsEngine.Event ? src : eventsEngine.Event(src), extraParameters)
}
}
function normalizeEventArguments(callback) {
return function(src, config) {
if (!(this instanceof eventsEngine.Event)) {
return new eventsEngine.Event(src, config)
}
if (!src) {
src = {}
}
if ("string" === typeof src) {
src = {
type: src
}
}
if (!config) {
config = {}
}
callback.call(this, src, config)
}
}
function iterate(callback) {
var iterateEventNames = function(element, eventName) {
if (eventName && eventName.indexOf(" ") > -1) {
var args = Array.prototype.slice.call(arguments, 0);
eventName.split(" ").forEach(function(eventName) {
args[1] = eventName;
callback.apply(this, args)
})
} else {
callback.apply(this, arguments)
}
};
return function(element, eventName) {
if ("object" === _typeof(eventName)) {
var args = Array.prototype.slice.call(arguments, 0);
for (var name in eventName) {
args[1] = name;
args[args.length - 1] = eventName[name];
iterateEventNames.apply(this, args)
}
} else {
iterateEventNames.apply(this, arguments)
}
}
}
function callNativeMethod(eventName, element) {
var nativeMethodName = NATIVE_EVENTS_TO_TRIGGER[eventName] || eventName;
var isLinkClickEvent = function(eventName, element) {
return "click" === eventName && "a" === element.localName
};
if (isLinkClickEvent(eventName, element)) {
return
}
if (isFunction(element[nativeMethodName])) {
skipEvent = eventName;
element[nativeMethodName]();
skipEvent = void 0
}
}
function calculateWhich(event) {
var setForMouseEvent = function(event) {
var mouseEventRegex = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
return !event.which && void 0 !== event.button && mouseEventRegex.test(event.type)
};
var setForKeyEvent = function(event) {
return null == event.which && 0 === event.type.indexOf("key")
};
if (setForKeyEvent(event)) {
return null != event.charCode ? event.charCode : event.keyCode
}
if (setForMouseEvent(event)) {
var whichByButton = {
1: 1,
2: 3,
3: 1,
4: 2
};
return whichByButton[event.button]
}
return event.which
}
function initEvent(EventClass) {
if (EventClass) {
eventsEngine.Event = EventClass;
eventsEngine.Event.prototype = EventClass.prototype
}
}
initEvent(normalizeEventArguments(function(src, config) {
var that = this;
var propagationStopped = false;
var immediatePropagationStopped = false;
var defaultPrevented = false;
(0, _extend.extend)(that, src);
if (src instanceof eventsEngine.Event || _window2.default.hasWindow() && src instanceof window.Event) {
that.originalEvent = src;
that.currentTarget = void 0
}
if (!(src instanceof eventsEngine.Event)) {
(0, _extend.extend)(that, {
isPropagationStopped: function() {
return !!(propagationStopped || that.originalEvent && that.originalEvent.propagationStopped)
},
stopPropagation: function() {
propagationStopped = true;
that.originalEvent && that.originalEvent.stopPropagation()
},
isImmediatePropagationStopped: function() {
return immediatePropagationStopped
},
stopImmediatePropagation: function() {
this.stopPropagation();
immediatePropagationStopped = true;
that.originalEvent && that.originalEvent.stopImmediatePropagation()
},
isDefaultPrevented: function() {
return !!(defaultPrevented || that.originalEvent && that.originalEvent.defaultPrevented)
},
preventDefault: function() {
defaultPrevented = true;
that.originalEvent && that.originalEvent.preventDefault()
}
})
}
addProperty("which", calculateWhich, that);
if (0 === src.type.indexOf("touch")) {
delete config.pageX;
delete config.pageY
}(0, _extend.extend)(that, config);
that.guid = ++guid
}));
function addProperty(propName, hook, eventInstance) {
Object.defineProperty(eventInstance || eventsEngine.Event.prototype, propName, {
enumerable: true,
configurable: true,
get: function() {
return this.originalEvent && hook(this.originalEvent)
},
set: function(value) {
Object.defineProperty(this, propName, {
enumerable: true,
configurable: true,
writable: true,
value: value
})
}
})
}(0, _hook_touch_props2.default)(addProperty);
var beforeSetStrategy = (0, _callbacks2.default)();
var afterSetStrategy = (0, _callbacks2.default)();
eventsEngine.set = function(engine) {
beforeSetStrategy.fire();
eventsEngine.inject(engine);
initEvent(engine.Event);
afterSetStrategy.fire()
};
eventsE