@webalternatif/js-core 1.5.4 → 1.6.0

package/dist/cjs/index.js

@@ -51,10 +51,9 @@ var math = _interopRequireWildcard(require("./math.js"));
 exports.math = math;
 var utils = _interopRequireWildcard(require("./utils.js"));
 exports.utils = utils;
-var _Translator = _interopRequireWildcard(require("./Translator.js"));
-var i18n = _Translator;
 var _eventDispatcher = _interopRequireDefault(require("./eventDispatcher.js"));
 var _Mouse = _interopRequireDefault(require("./Mouse.js"));
+var _Translator = _interopRequireDefault(require("./Translator.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
@@ -63,11 +62,70 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var webf = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, stringFunctions), arrayFunctions), traversal), is), random), {}, {
-  dom: _dom["default"],
+/**
+ * Main entry point of js-core.
+ *
+ * Provides pure JavaScript utility functions such as string, array,
+ * type checking, traversal, math and other helpers.
+ *
+ * @module webf
+ */
+var webf = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, stringFunctions), arrayFunctions), traversal), is), random), {}, {
   isWindow: _dom.isWindow,
   isDocument: _dom.isDocument,
   isDomElement: _dom.isDomElement,
   getStyle: _dom.getStyle
-}, math), utils), i18n);
-var _default = exports["default"] = webf;
+}, math), utils);
+
+/**
+ * Default export containing pure utility functions.
+ *
+ * @example
+ * import webf from '@webalternatif/js-core'
+ * webf.unique([1,2,2])
+ */
+var _default = exports["default"] = webf;
+/**
+ * String utility functions.
+ * @module stringFunctions
+ */
+/**
+ * Array utility functions.
+ * @module arrayFunctions
+ */
+/**
+ * DOM manipulation and event helpers.
+ * Must be imported explicitly.
+ *
+ * @example
+ * import { dom } from '@webalternatif/js-core'
+ * dom.on(el, 'click', (ev) => {
+ *     doSomething(ev.currentTarget)
+ * })
+ *
+ * @module dom
+ */
+/**
+ * Lightweight custom event dispatcher (pub/sub).
+ *
+ * @example
+ * import { eventDispatcher } from '@webalternatif/js-core'
+ * const dispatcher = eventDispatcher()
+ * dispatcher.addListener('save', (eventName, arg1, arg2) => {})
+ * dispatcher.dispatch('save', arg1, arg2)
+ *
+ * @module eventDispatcher
+ */
+/**
+ * Mouse utilities.
+ * @module Mouse
+ */
+/**
+ * Simple translation utility.
+ *
+ * @example
+ * import { Translator } from '@webalternatif/js-core'
+ * const t = new Translator({ en: { hi: 'Hello' } })
+ *
+ * @module Translator
+ */

package/dist/cjs/is.js

@@ -6,15 +6,34 @@ Object.defineProperty(exports, "__esModule", {
 exports.isUndefined = exports.isTouchDevice = exports.isString = exports.isScalar = exports.isPlainObject = exports.isObject = exports.isInteger = exports.isInt = exports.isFunction = exports.isFloat = exports.isEventSupported = exports.isEvent = exports.isDate = exports.isBoolean = exports.isBool = exports.isArrayLike = exports.isArray = void 0;
 var _array = require("./array.js");
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/**
+ * @param {any} str
+ * @returns {boolean}
+ */
 var isString = exports.isString = function isString(str) {
   return typeof str == 'string' || Object.prototype.toString.call(str) === '[object String]';
 };
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 var isObject = exports.isObject = function isObject(o) {
   return !!o && !isArray(o) && _typeof(o) === 'object';
 };
+
+/**
+ * @param {any} f
+ * @returns {boolean}
+ */
 var isFunction = exports.isFunction = function isFunction(f) {
   return !!f && typeof f === 'function';
 };
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 var isPlainObject = exports.isPlainObject = function isPlainObject(o) {
   if (false === isObject(o)) return false;
   if (undefined === o.constructor) return true;
@@ -22,38 +41,88 @@ var isPlainObject = exports.isPlainObject = function isPlainObject(o) {
   if (o.constructor.prototype.hasOwnProperty('isPrototypeOf') === false) return false;
   return true;
 };
+
+/**
+ * @param {any} b
+ * @returns {boolean}
+ */
 var isBoolean = exports.isBoolean = function isBoolean(b) {
   return b === true || b === false;
 };
 var isBool = exports.isBool = isBoolean;
+
+/**
+ * @param {any} v
+ * @returns {boolean}
+ */
 var isUndefined = exports.isUndefined = function isUndefined(v) {
   return typeof v === 'undefined';
 };
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 var isArrayLike = exports.isArrayLike = function isArrayLike(o) {
   return !!o && !isString(o) && !isFunction(o) && isInt(o.length)
   // && o.length >= 0
   && Number.isFinite(o.length);
 };
+
+/**
+ * @param {any} a
+ * @returns {boolean}
+ */
 var isArray = exports.isArray = function isArray(a) {
   return Array.isArray(a);
 };
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 var isDate = exports.isDate = function isDate(o) {
   return !!o && Object.prototype.toString.call(o) === '[object Date]';
 };
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 var isEvent = exports.isEvent = function isEvent(o) {
   return isObject(o) && (!!o.preventDefault || /\[object Event\]/.test(o.constructor.toString()));
 };
+
+/**
+ * @param {any} n
+ * @returns {boolean}
+ */
 var isInteger = exports.isInteger = function isInteger(n) {
-  return /^[\-]?\d+$/.test(n + '');
+  return /^[\-+]?\d+$/.test(n + '');
 };
 var isInt = exports.isInt = isInteger;
+
+/**
+ * @param {any} n
+ * @returns {boolean}
+ */
 var isFloat = exports.isFloat = function isFloat(n) {
-  return /^[\-]?\d+(\.\d+)?$/.test(n + '');
+  return /^[\-+]?\d+(\.\d+)?$/.test(n + '');
 };
-var isScalar = exports.isScalar = function isScalar(value) {
-  var type = _typeof(value);
-  return value === null || (0, _array.inArray)(type, ['string', 'number', 'bigint', 'symbol', 'boolean']);
+
+/**
+ * @param {any} v
+ * @returns {boolean}
+ */
+var isScalar = exports.isScalar = function isScalar(v) {
+  var type = _typeof(v);
+  return null === v || (0, _array.inArray)(type, ['string', 'number', 'bigint', 'symbol', 'boolean']);
 };
+
+/**
+ * @param {string} eventName
+ * @returns {boolean}
+ */
 var isEventSupported = exports.isEventSupported = function () {
   var TAGNAMES = {
     select: 'input',
@@ -73,6 +142,10 @@ var isEventSupported = exports.isEventSupported = function () {
   }
   return isEventSupported;
 }();
+
+/**
+ * @returns {boolean}
+ */
 var isTouchDevice = exports.isTouchDevice = function isTouchDevice() {
   return isEventSupported('touchstart');
 };

package/dist/cjs/onOff.js

@@ -0,0 +1,308 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.__resetCustomEventsForTests = __resetCustomEventsForTests;
+exports.off = off;
+exports.on = on;
+var _is = require("./is.js");
+var _traversal = require("./traversal.js");
+var _array = require("./array.js");
+var _Mouse = _interopRequireDefault(require("./Mouse.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+var LISTENERS = new Map();
+var CUSTOM_EVENTS = ['longtap', 'dbltap'];
+var ENABLED_EVENTS = new Set();
+var _teardownLongTap = null;
+var _teardownDblTap = null;
+var supplyEvent = function supplyEvent(event) {
+  if (ENABLED_EVENTS !== null && ENABLED_EVENTS !== void 0 && ENABLED_EVENTS.has(event)) return;
+  if (event === 'longtap') enableLongTap();
+  if (event === 'dbltap') enableDblTap();
+  ENABLED_EVENTS.add(event);
+};
+var enableLongTap = function enableLongTap() {
+  var LONGPRESS_DELAY = 800;
+  var MOVE_TOLERANCE = 40;
+  var timer = null;
+  var startX = 0;
+  var startY = 0;
+  var target = null;
+  var start = function start(ev) {
+    target = ev.target;
+    var pos = _Mouse["default"].getViewportPosition(ev);
+    startX = pos.x;
+    startY = pos.y;
+    timer = setTimeout(function () {
+      target.dispatchEvent(new CustomEvent('longtap', {
+        bubbles: true,
+        cancelable: true,
+        detail: {
+          originalEvent: ev
+        }
+      }));
+      timer = null;
+    }, LONGPRESS_DELAY);
+  };
+  var move = function move(ev) {
+    // if (!timer) return;
+
+    var pos = _Mouse["default"].getViewportPosition(ev);
+    if (Math.hypot(pos.x - startX, pos.y - startY) > MOVE_TOLERANCE) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  var end = function end() {
+    clearTimeout(timer);
+    timer = null;
+  };
+  document.addEventListener('touchstart', start, {
+    passive: true
+  });
+  document.addEventListener('touchmove', move, {
+    passive: true
+  });
+  document.addEventListener('touchend', end);
+  document.addEventListener('touchcancel', end);
+  _teardownLongTap = function teardownLongTap() {
+    document.removeEventListener('touchstart', start, {
+      passive: true
+    });
+    document.removeEventListener('touchmove', move, {
+      passive: true
+    });
+    document.removeEventListener('touchend', end);
+    document.removeEventListener('touchcancel', end);
+    _teardownLongTap = null;
+  };
+};
+var enableDblTap = function enableDblTap() {
+  var DBLTAP_DELAY = 300;
+  var MOVE_TOLERANCE = 40;
+  var lastTapTime = 0;
+  var lastPos = null;
+  if ((0, _is.isTouchDevice)()) {
+    document.addEventListener('dblclick', function (ev) {
+      ev.preventDefault();
+      ev.stopPropagation();
+      ev.stopImmediatePropagation();
+    }, {
+      capture: true
+    });
+  }
+  var start = function start(ev) {
+    var target = ev.target;
+    if (Date.now() - lastTapTime > DBLTAP_DELAY) {
+      lastTapTime = Date.now();
+      lastPos = _Mouse["default"].getViewportPosition(ev);
+    } else {
+      var pos = _Mouse["default"].getViewportPosition(ev);
+      if (Math.hypot(pos.x - lastPos.x, pos.y - lastPos.y) <= MOVE_TOLERANCE) {
+        target.dispatchEvent(new CustomEvent('dbltap', {
+          bubbles: true,
+          cancelable: true,
+          detail: {
+            originalEvent: ev
+          }
+        }));
+      }
+      lastTapTime = Date.now();
+      lastPos = pos;
+    }
+  };
+  document.addEventListener('touchstart', start, {
+    passive: true
+  });
+  _teardownDblTap = function teardownDblTap() {
+    document.removeEventListener('touchstart', start, {
+      passive: true
+    });
+    _teardownDblTap = null;
+  };
+};
+
+/**
+ * @param {Element} target
+ * @param {Element} el
+ * @returns {Element[]}
+ */
+function buildTree(target, el) {
+  var path = [];
+  var node = target.nodeType === 3 ? target.parentElement : target;
+  while (node) {
+    path.push(node);
+    if (node === el) break;
+    node = node.parentElement;
+  }
+  return path;
+}
+function createWrappedEvent(ev, currentTarget) {
+  var wrappedEv = {
+    _immediateStopped: false,
+    _propagationStopped: false,
+    originalEvent: ev,
+    currentTarget: currentTarget,
+    stopPropagation: function stopPropagation() {
+      wrappedEv._propagationStopped = true;
+      ev.stopPropagation.apply(ev, arguments);
+    },
+    stopImmediatePropagation: function stopImmediatePropagation() {
+      wrappedEv._immediateStopped = true;
+      wrappedEv._propagationStopped = true;
+      ev.stopImmediatePropagation.apply(ev, arguments);
+    }
+  };
+  return new Proxy(wrappedEv, {
+    get: function get(target, prop, receiver) {
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      var value = ev[prop];
+      return (0, _is.isFunction)(value) ? value.bind(ev) : value;
+    }
+  });
+}
+
+/**
+ * @param {Element|Document|Window} el
+ * @param {string} events
+ * @param {string|Element|function} selector
+ * @param {function|AddEventListenerOptions|boolean} [handler]
+ * @param {AddEventListenerOptions|boolean} [options]
+ * @returns {Element}
+ */
+function on(el, events, selector, handler, options) {
+  if ((0, _is.isFunction)(selector)) {
+    options = handler;
+    handler = selector;
+    selector = null;
+  }
+  (0, _traversal.foreach)(events.split(' '), function (rawEvent) {
+    var _rawEvent$split = rawEvent.split('.'),
+      _rawEvent$split2 = _slicedToArray(_rawEvent$split, 2),
+      event = _rawEvent$split2[0],
+      namespace = _rawEvent$split2[1];
+    var listener = function listener(ev) {
+      if (ev.cancelBubble) return;
+      var tree = buildTree(ev.target, el);
+      var binds = _toConsumableArray(LISTENERS.get(el));
+      var _iterator = _createForOfIteratorHelper(tree),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var node = _step.value;
+          var propagationStoppedOnThisNode = false;
+          var _iterator2 = _createForOfIteratorHelper(binds),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var bind = _step2.value;
+              if (bind.event !== ev.type) continue;
+              if (bind.selector) {
+                if (!node.matches(bind.selector)) continue;
+              } else {
+                if (node !== el) continue;
+              }
+              var wrappedEv = createWrappedEvent(ev, node);
+              bind.handler.call(node, wrappedEv);
+              if (wrappedEv._immediateStopped) return;
+              if (wrappedEv._propagationStopped) {
+                propagationStoppedOnThisNode = true;
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+          if (propagationStoppedOnThisNode) return;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    };
+    var store = LISTENERS.get(el);
+    if (!store) {
+      store = [];
+      LISTENERS.set(el, store);
+    }
+    if ((0, _array.inArray)(event, CUSTOM_EVENTS)) {
+      supplyEvent(event);
+    }
+    var events = (0, _traversal.map)(store, function (_, entry) {
+      return entry.event;
+    });
+    if (!(0, _array.inArray)(event, events)) {
+      el.addEventListener(event, listener, options);
+    }
+    store.push({
+      event: event,
+      handler: handler,
+      selector: selector,
+      listener: listener,
+      namespace: namespace,
+      options: options
+    });
+  });
+  return el;
+}
+
+/**
+ * @param {Element|Document|Window} el
+ * @param {string} [events]
+ * @param {string|Element|function} [selector]
+ * @param {function|AddEventListenerOptions|boolean} [handler]
+ * @param {AddEventListenerOptions|boolean} [options]
+ * @returns {Element}
+ */
+function off(el, events, selector, handler, options) {
+  if ((0, _is.isFunction)(selector)) {
+    options = handler;
+    handler = selector;
+    selector = null;
+  }
+  var store = LISTENERS.get(el);
+  if (!store) return el;
+  var evts = events ? events.split(' ') : [undefined];
+  (0, _traversal.foreach)(evts, function (rawEvent) {
+    var _ref = undefined === rawEvent ? [undefined, undefined] : rawEvent.split('.'),
+      _ref2 = _slicedToArray(_ref, 2),
+      event = _ref2[0],
+      namespace = _ref2[1];
+    event = !event ? undefined : event;
+    var hasEvent = undefined !== event;
+    var hasNs = undefined !== namespace;
+    (0, _traversal.foreach)(_toConsumableArray(store).reverse(), function (l) {
+      var match = !hasEvent && !hasNs || hasEvent && !hasNs && l.event === event || !hasEvent && hasNs && l.namespace === namespace || hasEvent && hasNs && l.event === event && l.namespace === namespace;
+      if (match && (undefined === event || l.event === event) && (undefined === handler || l.handler === handler) && (undefined === selector || l.selector === selector) && (undefined === namespace || l.namespace === namespace) && (undefined === options || l.options === options)) {
+        var index = store.indexOf(l);
+        index !== -1 && store.splice(index, 1);
+        if (!(0, _traversal.map)(store, function (_, entry) {
+          return entry.event === event ? entry : null;
+        })[0]) el.removeEventListener(l.event, l.listener, l.options);
+      }
+    });
+  });
+  return el;
+}
+function __resetCustomEventsForTests() {
+  var _teardownLongTap2, _teardownDblTap2;
+  ENABLED_EVENTS.clear();
+  (_teardownLongTap2 = _teardownLongTap) === null || _teardownLongTap2 === void 0 || _teardownLongTap2();
+  (_teardownDblTap2 = _teardownDblTap) === null || _teardownDblTap2 === void 0 || _teardownDblTap2();
+}

package/dist/esm/Mouse.js

@@ -12,7 +12,13 @@ var Mouse = /*#__PURE__*/function () {
   }
   return _createClass(Mouse, null, [{
     key: "getPosition",
-    value: function getPosition(ev, element) {
+    value:
+    /**
+     * @param {Event} ev
+     * @param {Element} element
+     * @returns {{x: number, y: number}}
+     */
+    function getPosition(ev, element) {
       ev = _assertClassBrand(Mouse, this, _getEvent).call(this, ev);
       var rect = {
         left: 0,
@@ -26,10 +32,15 @@ var Mouse = /*#__PURE__*/function () {
         };
       }
       return {
-        x: ev.pageX !== undefined ? ev.pageX - rect.left : rect.left,
-        y: ev.pageY !== undefined ? ev.pageY - rect.top : rect.top
+        x: ev.pageX - rect.left,
+        y: ev.pageY - rect.top
       };
     }
+
+    /**
+     * @param {Event} ev
+     * @returns {{x: number, y: number}}
+     */
   }, {
     key: "getViewportPosition",
     value: function getViewportPosition(ev) {
@@ -45,18 +56,24 @@ var Mouse = /*#__PURE__*/function () {
       ev = _assertClassBrand(Mouse, this, _getEvent).call(this, ev);
       return window.document.elementFromPoint(ev.clientX, ev.clientY);
     }
+
+    /**
+     * @param {Event|{originalEvent?: Event}} ev
+     * @returns {Event}
+     */
   }]);
 }();
 function _getEvent(ev) {
   var _ev$originalEvent;
+  ev = (_ev$originalEvent = ev.originalEvent) !== null && _ev$originalEvent !== void 0 ? _ev$originalEvent : ev;
   if (isTouchDevice()) {
-    var orgEvent = ev.originalEvent ? ev.originalEvent : ev;
-    if (orgEvent.changedTouches && orgEvent.changedTouches.length) {
-      ev = orgEvent.changedTouches[0];
-    } else if (orgEvent.touches) {
-      ev = orgEvent.touches[0];
-    }
+    var _ev$changedTouches, _ev$touches;
+    var touch = ((_ev$changedTouches = ev.changedTouches) === null || _ev$changedTouches === void 0 ? void 0 : _ev$changedTouches[0]) || ((_ev$touches = ev.touches) === null || _ev$touches === void 0 ? void 0 : _ev$touches[0]);
+    ev.clientX = touch.clientX;
+    ev.clientY = touch.clientY;
+    ev.pageX = touch.pageX;
+    ev.pageY = touch.pageY;
   }
-  return (_ev$originalEvent = ev.originalEvent) !== null && _ev$originalEvent !== void 0 ? _ev$originalEvent : ev;
+  return ev;
 }
 export default Mouse;

package/dist/esm/Translator.js

@@ -14,15 +14,15 @@ import { isFunction, isPlainObject } from "./is.js";
 import { each, extend } from "./traversal.js";
 
 /**
- * @typedef {string | (() => string)} TranslatorValue
+ * @typedef {string|(()=>string)} TranslatorValue
  */
 
 /**
- * @typedef {Record<string, Record<string, Record<string, TranslatorValue>>>} TranslatorNsMapping
+ * @typedef {Record<string,Record<string,Record<string,TranslatorValue>>>} TranslatorNsMapping
  */
 
 /**
- * @typedef {Record<string, Record<string, TranslatorValue>>} TranslatorCoreMapping
+ * @typedef {Record<string,Record<string,TranslatorValue>>} TranslatorCoreMapping
  */
 
 /**
@@ -63,7 +63,7 @@ var Translator = /*#__PURE__*/function () {
         var entry = _classPrivateFieldGet(_mapping, this)[namespace][lang][label];
         return _assertClassBrand(_Translator_brand, this, _resolve).call(this, entry);
       }
-      return 'en' !== lang ? this.translate(label, namespace, 'en') : label;
+      return 'en' !== lang ? this.translate(label, 'en', namespace) : label;
     }
 
     /**
@@ -140,11 +140,7 @@ function _findKeyByValue(entries, label) {
 }
 function _resolve(entry) {
   if (isFunction(entry)) {
-    try {
-      return entry();
-    } catch (e) {
-      return null;
-    }
+    return entry();
   }
   return entry;
 }