handsontable 0.0.0-next-9ec04ce-20221121

package/editors/timeEditor/timeEditor.js

@@ -0,0 +1,70 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.reflect.get.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/es.symbol.iterator.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+exports.__esModule = true;
+exports.TimeEditor = exports.EDITOR_TYPE = void 0;
+require("core-js/modules/es.object.set-prototype-of.js");
+require("core-js/modules/es.object.get-prototype-of.js");
+var _textEditor = require("../textEditor");
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var EDITOR_TYPE = 'time';
+
+/**
+ * @private
+ * @class TimeEditor
+ */
+exports.EDITOR_TYPE = EDITOR_TYPE;
+var TimeEditor = /*#__PURE__*/function (_TextEditor) {
+  _inherits(TimeEditor, _TextEditor);
+  var _super = _createSuper(TimeEditor);
+  function TimeEditor() {
+    _classCallCheck(this, TimeEditor);
+    return _super.apply(this, arguments);
+  }
+  _createClass(TimeEditor, [{
+    key: "prepare",
+    value:
+    /**
+     * Prepares editor's meta data.
+     *
+     * @param {number} row The visual row index.
+     * @param {number} col The visual column index.
+     * @param {number|string} prop The column property (passed when datasource is an array of objects).
+     * @param {HTMLTableCellElement} td The rendered cell element.
+     * @param {*} value The rendered value.
+     * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}).
+     */
+    function prepare(row, col, prop, td, value, cellProperties) {
+      _get(_getPrototypeOf(TimeEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties);
+      this.TEXTAREA.dir = 'ltr';
+    }
+  }], [{
+    key: "EDITOR_TYPE",
+    get: function get() {
+      return EDITOR_TYPE;
+    }
+  }]);
+  return TimeEditor;
+}(_textEditor.TextEditor);
+exports.TimeEditor = TimeEditor;

package/editors/timeEditor/timeEditor.mjs

@@ -0,0 +1,64 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+import "core-js/modules/es.object.set-prototype-of.js";
+import "core-js/modules/es.object.get-prototype-of.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.reflect.construct.js";
+import "core-js/modules/es.reflect.get.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { TextEditor } from "../textEditor/index.mjs";
+export var EDITOR_TYPE = 'time';
+
+/**
+ * @private
+ * @class TimeEditor
+ */
+export var TimeEditor = /*#__PURE__*/function (_TextEditor) {
+  _inherits(TimeEditor, _TextEditor);
+  var _super = _createSuper(TimeEditor);
+  function TimeEditor() {
+    _classCallCheck(this, TimeEditor);
+    return _super.apply(this, arguments);
+  }
+  _createClass(TimeEditor, [{
+    key: "prepare",
+    value:
+    /**
+     * Prepares editor's meta data.
+     *
+     * @param {number} row The visual row index.
+     * @param {number} col The visual column index.
+     * @param {number|string} prop The column property (passed when datasource is an array of objects).
+     * @param {HTMLTableCellElement} td The rendered cell element.
+     * @param {*} value The rendered value.
+     * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}).
+     */
+    function prepare(row, col, prop, td, value, cellProperties) {
+      _get(_getPrototypeOf(TimeEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties);
+      this.TEXTAREA.dir = 'ltr';
+    }
+  }], [{
+    key: "EDITOR_TYPE",
+    get: function get() {
+      return EDITOR_TYPE;
+    }
+  }]);
+  return TimeEditor;
+}(TextEditor);

package/eventManager.d.ts

@@ -0,0 +1,13 @@
+export function getListenersCounter(): number;
+export default class EventManager {
+  constructor(context?: object);
+
+  context: any;
+
+  addEventListener(element: Element, eventName: string, callback: (event: Event) => void, options?: boolean | AddEventListenerOptions): () => void;
+  removeEventListener(element: Element, eventName: string, callback: () => void, onlyOwnEvents?: boolean): void;
+  clear(): void;
+  destroy(): void;
+  destroyWithOwnEventsOnly(): void;
+  fireEvent(element: Element, eventName: string): void;
+}

package/eventManager.js

@@ -0,0 +1,236 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+exports.getListenersCounter = getListenersCounter;
+require("core-js/modules/es.array.splice.js");
+var _feature = require("./helpers/feature");
+var _event = require("./helpers/dom/event");
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+/**
+ * Counter which tracks unregistered listeners (useful for detecting memory leaks).
+ *
+ * @type {number}
+ */
+var listenersCounter = 0;
+
+/**
+ * Event DOM manager for internal use in Handsontable.
+ *
+ * @class EventManager
+ * @util
+ */
+var EventManager = /*#__PURE__*/function () {
+  /**
+   * @param {object} [context=null] An object to which event listeners will be stored.
+   * @private
+   */
+  function EventManager() {
+    var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    _classCallCheck(this, EventManager);
+    this.context = context || this;
+
+    // TODO it modify external object. Rethink that.
+    if (!this.context.eventListeners) {
+      this.context.eventListeners = []; // TODO perf It would be more performant if every instance of EventManager tracked its own listeners only
+    }
+  }
+
+  /**
+   * Register specified listener (`eventName`) to the element.
+   *
+   * @param {Element} element Target element.
+   * @param {string} eventName Event name.
+   * @param {Function} callback Function which will be called after event occur.
+   * @param {AddEventListenerOptions|boolean} [options] Listener options if object or useCapture if boolean.
+   * @returns {Function} Returns function which you can easily call to remove that event.
+   */
+  _createClass(EventManager, [{
+    key: "addEventListener",
+    value: function addEventListener(element, eventName, callback) {
+      var _this = this;
+      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      /**
+       * @param {Event} event The event object.
+       */
+      function callbackProxy(event) {
+        callback.call(this, extendEvent(event));
+      }
+      if (typeof options !== 'boolean' && !(0, _feature.isPassiveEventSupported)()) {
+        options = false;
+      }
+      this.context.eventListeners.push({
+        element: element,
+        event: eventName,
+        callback: callback,
+        callbackProxy: callbackProxy,
+        options: options,
+        eventManager: this
+      });
+      element.addEventListener(eventName, callbackProxy, options);
+      listenersCounter += 1;
+      return function () {
+        _this.removeEventListener(element, eventName, callback);
+      };
+    }
+
+    /**
+     * Remove the event listener previously registered.
+     *
+     * @param {Element} element Target element.
+     * @param {string} eventName Event name.
+     * @param {Function} callback Function to remove from the event target. It must be the same as during registration listener.
+     * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager.
+     */
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(element, eventName, callback) {
+      var onlyOwnEvents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var len = this.context.eventListeners.length;
+      var tmpEvent;
+      while (len) {
+        len -= 1;
+        tmpEvent = this.context.eventListeners[len];
+        if (tmpEvent.event === eventName && tmpEvent.element === element) {
+          if (callback && callback !== tmpEvent.callback) {
+            /* eslint-disable no-continue */
+            continue;
+          }
+          // TODO rethink that, main bulk is that it needs multi instances to handle same context, but with a different scopes.
+          // TODO I suppose much more efficient way will be comparing string with scope id, or any similar approach.
+          if (onlyOwnEvents && tmpEvent.eventManager !== this) {
+            continue;
+          }
+          this.context.eventListeners.splice(len, 1);
+          tmpEvent.element.removeEventListener(tmpEvent.event, tmpEvent.callbackProxy, tmpEvent.options);
+          listenersCounter -= 1;
+        }
+      }
+    }
+
+    /**
+     * Clear all previously registered events.
+     *
+     * @private
+     * @since 0.15.0-beta3
+     * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager.
+     */
+  }, {
+    key: "clearEvents",
+    value: function clearEvents() {
+      var onlyOwnEvents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      if (!this.context) {
+        return;
+      }
+      var len = this.context.eventListeners.length;
+      while (len) {
+        len -= 1;
+        var event = this.context.eventListeners[len];
+        if (onlyOwnEvents && event.eventManager !== this) {
+          continue;
+        }
+        this.context.eventListeners.splice(len, 1);
+        event.element.removeEventListener(event.event, event.callbackProxy, event.options);
+        listenersCounter -= 1;
+      }
+    }
+
+    /**
+     * Clear all previously registered events.
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.clearEvents();
+    }
+
+    /**
+     * Destroy instance of EventManager, clearing all events of the context.
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.clearEvents();
+      this.context = null;
+    }
+
+    /**
+     * Destroy instance of EventManager, clearing only the own events.
+     */
+  }, {
+    key: "destroyWithOwnEventsOnly",
+    value: function destroyWithOwnEventsOnly() {
+      this.clearEvents(true);
+      this.context = null;
+    }
+
+    /**
+     * Trigger event at the specified target element.
+     *
+     * @param {Element} element Target element.
+     * @param {string} eventName Event name.
+     */
+  }, {
+    key: "fireEvent",
+    value: function fireEvent(element, eventName) {
+      var rootDocument = element.document;
+      var rootWindow = element;
+      if (!rootDocument) {
+        rootDocument = element.ownerDocument ? element.ownerDocument : element;
+        rootWindow = rootDocument.defaultView;
+      }
+      var options = {
+        bubbles: true,
+        cancelable: eventName !== 'mousemove',
+        view: rootWindow,
+        detail: 0,
+        screenX: 0,
+        screenY: 0,
+        clientX: 1,
+        clientY: 1,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+        metaKey: false,
+        button: 0,
+        relatedTarget: undefined
+      };
+      var event;
+      if (rootDocument.createEvent) {
+        event = rootDocument.createEvent('MouseEvents');
+        event.initMouseEvent(eventName, options.bubbles, options.cancelable, options.view, options.detail, options.screenX, options.screenY, options.clientX, options.clientY, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.button, options.relatedTarget || rootDocument.body.parentNode);
+      } else {
+        event = rootDocument.createEventObject();
+      }
+      if (element.dispatchEvent) {
+        element.dispatchEvent(event);
+      } else {
+        element.fireEvent("on".concat(eventName), event);
+      }
+    }
+  }]);
+  return EventManager;
+}();
+/**
+ * @private
+ * @param {Event} event The event object.
+ * @returns {Event}
+ */
+function extendEvent(event) {
+  var nativeStopImmediatePropagation = event.stopImmediatePropagation;
+  event.stopImmediatePropagation = function () {
+    nativeStopImmediatePropagation.apply(this);
+    (0, _event.stopImmediatePropagation)(this);
+  };
+  return event;
+}
+var _default = EventManager;
+/**
+ * @returns {number}
+ */
+exports.default = _default;
+function getListenersCounter() {
+  return listenersCounter;
+}

package/eventManager.mjs

@@ -0,0 +1,231 @@
+import "core-js/modules/es.array.splice.js";
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+import { isPassiveEventSupported } from "./helpers/feature.mjs";
+import { stopImmediatePropagation as _stopImmediatePropagation } from "./helpers/dom/event.mjs";
+/**
+ * Counter which tracks unregistered listeners (useful for detecting memory leaks).
+ *
+ * @type {number}
+ */
+var listenersCounter = 0;
+
+/**
+ * Event DOM manager for internal use in Handsontable.
+ *
+ * @class EventManager
+ * @util
+ */
+var EventManager = /*#__PURE__*/function () {
+  /**
+   * @param {object} [context=null] An object to which event listeners will be stored.
+   * @private
+   */
+  function EventManager() {
+    var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    _classCallCheck(this, EventManager);
+    this.context = context || this;
+
+    // TODO it modify external object. Rethink that.
+    if (!this.context.eventListeners) {
+      this.context.eventListeners = []; // TODO perf It would be more performant if every instance of EventManager tracked its own listeners only
+    }
+  }
+
+  /**
+   * Register specified listener (`eventName`) to the element.
+   *
+   * @param {Element} element Target element.
+   * @param {string} eventName Event name.
+   * @param {Function} callback Function which will be called after event occur.
+   * @param {AddEventListenerOptions|boolean} [options] Listener options if object or useCapture if boolean.
+   * @returns {Function} Returns function which you can easily call to remove that event.
+   */
+  _createClass(EventManager, [{
+    key: "addEventListener",
+    value: function addEventListener(element, eventName, callback) {
+      var _this = this;
+      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      /**
+       * @param {Event} event The event object.
+       */
+      function callbackProxy(event) {
+        callback.call(this, extendEvent(event));
+      }
+      if (typeof options !== 'boolean' && !isPassiveEventSupported()) {
+        options = false;
+      }
+      this.context.eventListeners.push({
+        element: element,
+        event: eventName,
+        callback: callback,
+        callbackProxy: callbackProxy,
+        options: options,
+        eventManager: this
+      });
+      element.addEventListener(eventName, callbackProxy, options);
+      listenersCounter += 1;
+      return function () {
+        _this.removeEventListener(element, eventName, callback);
+      };
+    }
+
+    /**
+     * Remove the event listener previously registered.
+     *
+     * @param {Element} element Target element.
+     * @param {string} eventName Event name.
+     * @param {Function} callback Function to remove from the event target. It must be the same as during registration listener.
+     * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager.
+     */
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(element, eventName, callback) {
+      var onlyOwnEvents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var len = this.context.eventListeners.length;
+      var tmpEvent;
+      while (len) {
+        len -= 1;
+        tmpEvent = this.context.eventListeners[len];
+        if (tmpEvent.event === eventName && tmpEvent.element === element) {
+          if (callback && callback !== tmpEvent.callback) {
+            /* eslint-disable no-continue */
+            continue;
+          }
+          // TODO rethink that, main bulk is that it needs multi instances to handle same context, but with a different scopes.
+          // TODO I suppose much more efficient way will be comparing string with scope id, or any similar approach.
+          if (onlyOwnEvents && tmpEvent.eventManager !== this) {
+            continue;
+          }
+          this.context.eventListeners.splice(len, 1);
+          tmpEvent.element.removeEventListener(tmpEvent.event, tmpEvent.callbackProxy, tmpEvent.options);
+          listenersCounter -= 1;
+        }
+      }
+    }
+
+    /**
+     * Clear all previously registered events.
+     *
+     * @private
+     * @since 0.15.0-beta3
+     * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager.
+     */
+  }, {
+    key: "clearEvents",
+    value: function clearEvents() {
+      var onlyOwnEvents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      if (!this.context) {
+        return;
+      }
+      var len = this.context.eventListeners.length;
+      while (len) {
+        len -= 1;
+        var event = this.context.eventListeners[len];
+        if (onlyOwnEvents && event.eventManager !== this) {
+          continue;
+        }
+        this.context.eventListeners.splice(len, 1);
+        event.element.removeEventListener(event.event, event.callbackProxy, event.options);
+        listenersCounter -= 1;
+      }
+    }
+
+    /**
+     * Clear all previously registered events.
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.clearEvents();
+    }
+
+    /**
+     * Destroy instance of EventManager, clearing all events of the context.
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.clearEvents();
+      this.context = null;
+    }
+
+    /**
+     * Destroy instance of EventManager, clearing only the own events.
+     */
+  }, {
+    key: "destroyWithOwnEventsOnly",
+    value: function destroyWithOwnEventsOnly() {
+      this.clearEvents(true);
+      this.context = null;
+    }
+
+    /**
+     * Trigger event at the specified target element.
+     *
+     * @param {Element} element Target element.
+     * @param {string} eventName Event name.
+     */
+  }, {
+    key: "fireEvent",
+    value: function fireEvent(element, eventName) {
+      var rootDocument = element.document;
+      var rootWindow = element;
+      if (!rootDocument) {
+        rootDocument = element.ownerDocument ? element.ownerDocument : element;
+        rootWindow = rootDocument.defaultView;
+      }
+      var options = {
+        bubbles: true,
+        cancelable: eventName !== 'mousemove',
+        view: rootWindow,
+        detail: 0,
+        screenX: 0,
+        screenY: 0,
+        clientX: 1,
+        clientY: 1,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+        metaKey: false,
+        button: 0,
+        relatedTarget: undefined
+      };
+      var event;
+      if (rootDocument.createEvent) {
+        event = rootDocument.createEvent('MouseEvents');
+        event.initMouseEvent(eventName, options.bubbles, options.cancelable, options.view, options.detail, options.screenX, options.screenY, options.clientX, options.clientY, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.button, options.relatedTarget || rootDocument.body.parentNode);
+      } else {
+        event = rootDocument.createEventObject();
+      }
+      if (element.dispatchEvent) {
+        element.dispatchEvent(event);
+      } else {
+        element.fireEvent("on".concat(eventName), event);
+      }
+    }
+  }]);
+  return EventManager;
+}();
+/**
+ * @private
+ * @param {Event} event The event object.
+ * @returns {Event}
+ */
+function extendEvent(event) {
+  var nativeStopImmediatePropagation = event.stopImmediatePropagation;
+  event.stopImmediatePropagation = function () {
+    nativeStopImmediatePropagation.apply(this);
+    _stopImmediatePropagation(this);
+  };
+  return event;
+}
+export default EventManager;
+
+/**
+ * @returns {number}
+ */
+export function getListenersCounter() {
+  return listenersCounter;
+}

package/helpers/array.d.ts

@@ -0,0 +1,18 @@
+export function to2dArray(arr: any[]): void;
+export function extendArray(arr: any[], extension: any[]): void;
+export function pivot(arr: any[]): any[];
+export function arrayReduce(array: any[], iteratee: (value: any, index: number, array: any[])
+  => void, accumulator: any, initFromArray: boolean): any;
+export function arrayFilter(array: any[], predicate: (value: any, index: number, array: any[]) => void): any[];
+export function arrayMap(array: any[], iteratee: (value: any, index: number, array: any[]) => void): any[];
+export function arrayEach(array: any[], iteratee: (value: any, index: number, array: any[]) => void): any[];
+export function arraySum(array: any[]): number;
+export function arrayMax(array: any[]): number;
+export function arrayMin(array: any[]): number;
+export function arrayAvg(array: any[]): number;
+export function arrayFlatten(array: any[]): any[];
+export function arrayUnique(array: any[]): any[];
+export function getDifferenceOfArrays(...arrays: Array<Array<string | number>>): string[] | number[];
+export function getIntersectionOfArrays(...arrays: Array<Array<string | number>>): string[] | number[];
+export function getUnionOfArrays(...arrays: Array<Array<string | number>>): string[] | number[];
+export function stringToArray(value: string, delimiter?: string | RegExp): string[];