@pluginjs/events - npm Package Compare versions

Comparing version 0.0.5 to 0.5.0

dist/events.esm.js

 import { parent } from '@pluginjs/dom';
 import { curry } from '@pluginjs/utils';
 
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+
 const outputIdentity = identity => {
   if (!identity) {
-    return { type: 'self', value: '' };
+    return {
+      type: 'self',
+      value: ''
+    };
   }
+
   if (typeof identity === 'string') {
-    return { type: 'selector', value: identity };
+    return {
+      type: 'selector',
+      value: identity
+    };
   }
@@ -19,2 +64,3 @@
   }
+
   return Object.entries(tuple).map(kv => `[${prefix}${kv.join('=')}]`).join('');
@@ -24,6 +70,6 @@ };
 const dispatch = event => {
-  const { target, currentTarget } = event;
+  const target = event.target,
+        currentTarget = event.currentTarget;
   const eventStorage = EventStorage.getEventStorage(currentTarget);
   const eventName = event.type;
-
   const attrVerify = {
@@ -45,20 +91,30 @@ self: node => node === currentTarget,
     }
+
     if (currentTarget !== window && !currentTarget.contains(node)) {
       return result;
     }
-    const matchEventList = eventStorage.listeners[eventName].filter(({ identity }) => {
-      const { type, value } = identity;
+
+    const matchEventList = eventStorage.listeners[eventName].filter(({
+      identity
+    }) => {
+      const type = identity.type,
+            value = identity.value;
       const identityMapper = attrVerify[type];
+
       if (identityMapper && identityMapper(node, value)) {
         return true;
       }
+
       return false;
     });
     return nodeTreeCheck(parent(node), result.concat(matchEventList));
-  };
-  // nodeTreeCheck(target).map(e => console.log(e.handler.toString()))
-  nodeTreeCheck(target).reduce((result, { handler }) => result !== false && handler(event), true);
+  }; // nodeTreeCheck(target).map(e => console.log(e.handler.toString()))
+
+
+  nodeTreeCheck(target).reduce((result, {
+    handler
+  }) => result !== false && handler(event), true);
 };
 
-let EventStorage = class EventStorage {
+class EventStorage {
   constructor(element) {
@@ -69,3 +125,8 @@ this.element = element;
 
-  on({ identity, handler, eventName, namespace }) {
+  on({
+    identity,
+    handler,
+    eventName,
+    namespace
+  }) {
     this.ensureHandler(handler);
@@ -81,6 +142,15 @@
 
-    this.listeners[eventName].push({ identity, handler, namespace });
+    this.listeners[eventName].push({
+      identity,
+      handler,
+      namespace
+    });
   }
 
-  once({ identity, handler, eventName, namespace }) {
+  once({
+    identity,
+    handler,
+    eventName,
+    namespace
+  }) {
     this.ensureHandler(handler);
@@ -94,7 +164,10 @@
       this.removeListener(eventName, callback);
-
       return handler(event);
     };
 
-    this.listeners[eventName].push({ identity, handler: callback, namespace });
+    this.listeners[eventName].push({
+      identity,
+      handler: callback,
+      namespace
+    });
   }
@@ -106,2 +179,3 @@
     }
+
     return this.removeListener(_eventName, handler);
@@ -121,3 +195,2 @@ }
     });
-
     this.listener = {};
@@ -127,4 +200,8 @@ }
   removeListener(_eventName, handler) {
-    const [eventName, namespace] = _eventName.split('.');
-    //   .example  || click  || click.example
+    const _eventName$split = _eventName.split('.'),
+          _eventName$split2 = _slicedToArray(_eventName$split, 2),
+          eventName = _eventName$split2[0],
+          namespace = _eventName$split2[1]; //   .example  || click  || click.example
+
+
     if (!eventName && namespace) {
@@ -155,4 +232,8 @@ Object.entries(this.listeners).map(([key, value]) => {
   removeAllListeners(_eventName) {
-    const [eventName, namespace] = _eventName.split('.');
-    //   .example  || click  || click.example
+    const _eventName$split3 = _eventName.split('.'),
+          _eventName$split4 = _slicedToArray(_eventName$split3, 2),
+          eventName = _eventName$split4[0],
+          namespace = _eventName$split4[1]; //   .example  || click  || click.example
+
+
     if (!eventName && namespace) {
@@ -203,9 +284,15 @@ Object.entries(this.listeners).map(([key, value]) => {
     const type = typeof handler;
+
     if (type === 'function') {
       return handler;
     }
+
     throw new TypeError(`Listeners should be function or closure. Received type: ${type}`);
   }
 
-  static of({ type: _eventName, identity, handler }, element) {
+  static of({
+    type: _eventName,
+    identity,
+    handler
+  }, element) {
     if (!element.__eventStorage) {
@@ -215,6 +302,8 @@ element.__eventStorage = new this(element);
 
-    const [eventName, namespace] = _eventName.split('.');
+    const _eventName$split5 = _eventName.split('.'),
+          _eventName$split6 = _slicedToArray(_eventName$split5, 2),
+          eventName = _eventName$split6[0],
+          namespace = _eventName$split6[1];
 
     const eventStorage = this.getEventStorage(element);
-
     eventStorage.on({
@@ -228,3 +317,7 @@ identity: outputIdentity(identity),
 
-  static once({ type: _eventName, identity, handler }, element) {
+  static once({
+    type: _eventName,
+    identity,
+    handler
+  }, element) {
     if (!element.__eventStorage) {
@@ -234,6 +327,8 @@ element.__eventStorage = new this(element);
 
-    const [eventName, namespace] = _eventName.split('.');
+    const _eventName$split7 = _eventName.split('.'),
+          _eventName$split8 = _slicedToArray(_eventName$split7, 2),
+          eventName = _eventName$split8[0],
+          namespace = _eventName$split8[1];
 
     const eventStorage = this.getEventStorage(element);
-
     eventStorage.once({
@@ -249,2 +344,3 @@ identity: outputIdentity(identity),
     const eventStorage = this.getEventStorage(element);
+
     if (!eventStorage) {
@@ -254,3 +350,6 @@ return;
 
-    const { type: _eventName = options, handler } = options;
+    const _options$type = options.type,
+          _eventName = _options$type === void 0 ? options : _options$type,
+          handler = options.handler;
+
     eventStorage.off(_eventName, handler);
@@ -262,4 +361,5 @@ }
   }
-};
 
+}
+
 const trigger = curry((options, el) => {
@@ -270,11 +370,15 @@ if (options instanceof window.Event) {
   }
-  const { type = options, data } = options;
-  const eventName = type;
 
-  const eventStorage = EventStorage.getEventStorage(el);
+  const _options$type = options.type,
+        type = _options$type === void 0 ? options : _options$type,
+        data = options.data;
+  const eventName = type; // const eventStorage = EVENTSTORAGE.getEventStorage(el)
+  // if (eventStorage && eventStorage.hasListeners(eventName)) {
+  //   eventStorage.trigger(eventName, data)
+  // }
 
-  if (eventStorage && eventStorage.hasListeners(eventName)) {
-    eventStorage.trigger(eventName, data);
-  }
-
+  const event = new CustomEvent(eventName, {
+    detail: data
+  });
+  el.dispatchEvent(event);
   return el;
@@ -329,2 +433,3 @@ });
  */
+
 const removeEvent = curry((options, element) => {
@@ -342,2 +447,3 @@ EventStorage.delete(options, element);
  */
+
 const bindEventOnce = curry((options, element) => {
@@ -347,5 +453,4 @@ EventStorage.once(options, element);
 });
-
 const getEventStorage = element => EventStorage.getEventStorage(element);
 
 export { trigger, bindEvent, removeEvent, bindEventOnce, getEventStorage };

dist/events.js

@@ -1,534 +0,441 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@pluginjs/dom'), require('@pluginjs/utils')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@pluginjs/dom', '@pluginjs/utils'], factory) :
-  (factory((global['@pluginjs/events'] = {}),global['@pluginjs/dom'],global['@pluginjs/utils']));
-}(this, (function (exports,dom,utils) { 'use strict';
+'use strict';
 
-  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  };
+Object.defineProperty(exports, '__esModule', { value: true });
 
-  var classCallCheck = function (instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  };
+var dom = require('@pluginjs/dom');
+var utils = require('@pluginjs/utils');
 
-  var createClass = 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 _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+}
 
-    return function (Constructor, protoProps, staticProps) {
-      if (protoProps) defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) defineProperties(Constructor, staticProps);
-      return Constructor;
-    };
-  }();
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
 
-  var slicedToArray = function () {
-    function sliceIterator(arr, i) {
-      var _arr = [];
-      var _n = true;
-      var _d = false;
-      var _e = undefined;
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
 
-      try {
-        for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-          _arr.push(_s.value);
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
 
-          if (i && _arr.length === i) break;
-        }
-      } catch (err) {
-        _d = true;
-        _e = err;
-      } finally {
-        try {
-          if (!_n && _i["return"]) _i["return"]();
-        } finally {
-          if (_d) throw _e;
-        }
-      }
-
-      return _arr;
+      if (i && _arr.length === i) break;
     }
-
-    return function (arr, i) {
-      if (Array.isArray(arr)) {
-        return arr;
-      } else if (Symbol.iterator in Object(arr)) {
-        return sliceIterator(arr, i);
-      } else {
-        throw new TypeError("Invalid attempt to destructure non-iterable instance");
-      }
-    };
-  }();
-
-  var outputIdentity = function outputIdentity(identity) {
-    if (!identity) {
-      return { type: 'self', value: '' };
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
     }
-    if (typeof identity === 'string') {
-      return { type: 'selector', value: identity };
-    }
+  }
 
-    return identity;
-  };
+  return _arr;
+}
 
-  var tupleToStyleSelector = function tupleToStyleSelector(tuple, prefix) {
-    if (typeof tuple === 'string') {
-      return tuple;
-    }
-    return Object.entries(tuple).map(function (kv) {
-      return '[' + prefix + kv.join('=') + ']';
-    }).join('');
-  };
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
 
-  var dispatch = function dispatch(event) {
-    var target = event.target,
-        currentTarget = event.currentTarget;
+const outputIdentity = identity => {
+  if (!identity) {
+    return {
+      type: 'self',
+      value: ''
+    };
+  }
 
-    var eventStorage = EventStorage.getEventStorage(currentTarget);
-    var eventName = event.type;
-
-    var attrVerify = {
-      self: function self(node) {
-        return node === currentTarget;
-      },
-      class: function _class(node, value) {
-        return node.matches('.' + value);
-      },
-      selector: function selector(node, value) {
-        return node.matches(value);
-      },
-      id: function id(node, value) {
-        return node.matches('#' + value);
-      },
-      tagName: function tagName(node, value) {
-        return node.matches(value);
-      },
-      dom: function dom$$1(node, value) {
-        return node === value;
-      },
-      dataset: function dataset(node, value) {
-        return node.matches(tupleToStyleSelector(value, 'data-'));
-      },
-      attribute: function attribute(node, value) {
-        return node.matches(tupleToStyleSelector(value));
-      },
-      func: function func(node, value) {
-        return Boolean(value(node));
-      }
+  if (typeof identity === 'string') {
+    return {
+      type: 'selector',
+      value: identity
     };
+  }
 
-    var nodeTreeCheck = function nodeTreeCheck(node) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return identity;
+};
 
-      if (!node) {
-        return result;
-      }
-      if (currentTarget !== window && !currentTarget.contains(node)) {
-        return result;
-      }
-      var matchEventList = eventStorage.listeners[eventName].filter(function (_ref) {
-        var identity = _ref.identity;
-        var type = identity.type,
-            value = identity.value;
+const tupleToStyleSelector = (tuple, prefix) => {
+  if (typeof tuple === 'string') {
+    return tuple;
+  }
 
-        var identityMapper = attrVerify[type];
-        if (identityMapper && identityMapper(node, value)) {
-          return true;
-        }
-        return false;
-      });
-      return nodeTreeCheck(dom.parent(node), result.concat(matchEventList));
-    };
-    // nodeTreeCheck(target).map(e => console.log(e.handler.toString()))
-    nodeTreeCheck(target).reduce(function (result, _ref2) {
-      var handler = _ref2.handler;
-      return result !== false && handler(event);
-    }, true);
+  return Object.entries(tuple).map(kv => `[${prefix}${kv.join('=')}]`).join('');
+};
+
+const dispatch = event => {
+  const target = event.target,
+        currentTarget = event.currentTarget;
+  const eventStorage = EventStorage.getEventStorage(currentTarget);
+  const eventName = event.type;
+  const attrVerify = {
+    self: node => node === currentTarget,
+    class: (node, value) => node.matches(`.${value}`),
+    selector: (node, value) => node.matches(value),
+    id: (node, value) => node.matches(`#${value}`),
+    tagName: (node, value) => node.matches(value),
+    dom: (node, value) => node === value,
+    dataset: (node, value) => node.matches(tupleToStyleSelector(value, 'data-')),
+    attribute: (node, value) => node.matches(tupleToStyleSelector(value)),
+    func: (node, value) => Boolean(value(node))
   };
 
-  var EventStorage = function () {
-    function EventStorage(element) {
-      classCallCheck(this, EventStorage);
+  const nodeTreeCheck = (node, result = []) => {
+    if (!node) {
+      return result;
+    }
 
-      this.element = element;
-      this.listeners = {};
+    if (currentTarget !== window && !currentTarget.contains(node)) {
+      return result;
     }
 
-    createClass(EventStorage, [{
-      key: 'on',
-      value: function on(_ref3) {
-        var identity = _ref3.identity,
-            handler = _ref3.handler,
-            eventName = _ref3.eventName,
-            namespace = _ref3.namespace;
+    const matchEventList = eventStorage.listeners[eventName].filter(({
+      identity
+    }) => {
+      const type = identity.type,
+            value = identity.value;
+      const identityMapper = attrVerify[type];
 
-        this.ensureHandler(handler);
+      if (identityMapper && identityMapper(node, value)) {
+        return true;
+      }
 
-        if (!this.hasListeners(eventName)) {
-          this.createEventListener(eventName);
-        }
+      return false;
+    });
+    return nodeTreeCheck(dom.parent(node), result.concat(matchEventList));
+  }; // nodeTreeCheck(target).map(e => console.log(e.handler.toString()))
 
-        if (this.checkRepeats(eventName, handler)) {
-          return;
-        }
 
-        this.listeners[eventName].push({ identity: identity, handler: handler, namespace: namespace });
-      }
-    }, {
-      key: 'once',
-      value: function once(_ref4) {
-        var _this = this;
+  nodeTreeCheck(target).reduce((result, {
+    handler
+  }) => result !== false && handler(event), true);
+};
 
-        var identity = _ref4.identity,
-            handler = _ref4.handler,
-            eventName = _ref4.eventName,
-            namespace = _ref4.namespace;
+class EventStorage {
+  constructor(element) {
+    this.element = element;
+    this.listeners = {};
+  }
 
-        this.ensureHandler(handler);
+  on({
+    identity,
+    handler,
+    eventName,
+    namespace
+  }) {
+    this.ensureHandler(handler);
 
-        if (!this.hasListeners(eventName)) {
-          this.createEventListener(eventName);
-        }
+    if (!this.hasListeners(eventName)) {
+      this.createEventListener(eventName);
+    }
 
-        var callback = function callback(event) {
-          _this.removeListener(eventName, callback);
+    if (this.checkRepeats(eventName, handler)) {
+      return;
+    }
 
-          return handler(event);
-        };
+    this.listeners[eventName].push({
+      identity,
+      handler,
+      namespace
+    });
+  }
 
-        this.listeners[eventName].push({ identity: identity, handler: callback, namespace: namespace });
-      }
-    }, {
-      key: 'off',
-      value: function off(_eventName, handler) {
-        if (typeof handler === 'undefined') {
-          return this.removeAllListeners(_eventName);
-        }
-        return this.removeListener(_eventName, handler);
-      }
-    }, {
-      key: 'trigger',
-      value: function trigger(eventName, data) {
-        var event = new CustomEvent(eventName, {
-          detail: data
-        });
-        this.element.dispatchEvent(event);
-      }
-    }, {
-      key: 'clear',
-      value: function clear() {
-        var _this2 = this;
+  once({
+    identity,
+    handler,
+    eventName,
+    namespace
+  }) {
+    this.ensureHandler(handler);
 
-        Object.entries(this.listeners).map(function (_ref5) {
-          var _ref6 = slicedToArray(_ref5, 2),
-              key = _ref6[0],
-              value = _ref6[1];
+    if (!this.hasListeners(eventName)) {
+      this.createEventListener(eventName);
+    }
 
-          _this2.deleteEventListener(key);
-        });
+    const callback = event => {
+      this.removeListener(eventName, callback);
+      return handler(event);
+    };
 
-        this.listener = {};
-      }
-    }, {
-      key: 'removeListener',
-      value: function removeListener(_eventName, handler) {
-        var _this3 = this;
+    this.listeners[eventName].push({
+      identity,
+      handler: callback,
+      namespace
+    });
+  }
 
-        var _eventName$split = _eventName.split('.'),
-            _eventName$split2 = slicedToArray(_eventName$split, 2),
-            eventName = _eventName$split2[0],
-            namespace = _eventName$split2[1];
-        //   .example  || click  || click.example
+  off(_eventName, handler) {
+    if (typeof handler === 'undefined') {
+      return this.removeAllListeners(_eventName);
+    }
 
+    return this.removeListener(_eventName, handler);
+  }
 
-        if (!eventName && namespace) {
-          Object.entries(this.listeners).map(function (_ref7) {
-            var _ref8 = slicedToArray(_ref7, 2),
-                key = _ref8[0],
-                value = _ref8[1];
+  trigger(eventName, data) {
+    const event = new CustomEvent(eventName, {
+      detail: data
+    });
+    this.element.dispatchEvent(event);
+  }
 
-            _this3.listeners[key] = _this3.listeners[key].filter(function (eventTuple) {
-              return eventTuple.handler !== handler || eventTuple.namespace !== namespace;
-            });
+  clear() {
+    Object.entries(this.listeners).map(([key, value]) => {
+      this.deleteEventListener(key);
+    });
+    this.listener = {};
+  }
 
-            if (_this3.listeners[key].length === 0) {
-              _this3.deleteEventListener(key);
-            }
-          });
-        } else if (eventName && !namespace) {
-          // console.log('eventName')
-          this.listeners[eventName] = this.listeners[eventName].filter(function (eventTuple) {
-            return eventTuple.handler !== handler;
-          });
+  removeListener(_eventName, handler) {
+    const _eventName$split = _eventName.split('.'),
+          _eventName$split2 = _slicedToArray(_eventName$split, 2),
+          eventName = _eventName$split2[0],
+          namespace = _eventName$split2[1]; //   .example  || click  || click.example
 
-          if (this.listeners[eventName].length === 0) {
-            this.deleteEventListener(eventName);
-          }
-        } else if (eventName && namespace) {
-          this.listeners[eventName] = this.listeners[eventName].filter(function (eventTuple) {
-            return eventTuple.handler !== handler || eventTuple.namespace !== namespace;
-          });
 
-          if (this.listeners[eventName].length === 0) {
-            this.deleteEventListener(eventName);
-          }
+    if (!eventName && namespace) {
+      Object.entries(this.listeners).map(([key, value]) => {
+        this.listeners[key] = this.listeners[key].filter(eventTuple => eventTuple.handler !== handler || eventTuple.namespace !== namespace);
+
+        if (this.listeners[key].length === 0) {
+          this.deleteEventListener(key);
         }
+      });
+    } else if (eventName && !namespace) {
+      // console.log('eventName')
+      this.listeners[eventName] = this.listeners[eventName].filter(eventTuple => eventTuple.handler !== handler);
+
+      if (this.listeners[eventName].length === 0) {
+        this.deleteEventListener(eventName);
       }
-    }, {
-      key: 'removeAllListeners',
-      value: function removeAllListeners(_eventName) {
-        var _this4 = this;
+    } else if (eventName && namespace) {
+      this.listeners[eventName] = this.listeners[eventName].filter(eventTuple => eventTuple.handler !== handler || eventTuple.namespace !== namespace);
 
-        var _eventName$split3 = _eventName.split('.'),
-            _eventName$split4 = slicedToArray(_eventName$split3, 2),
-            eventName = _eventName$split4[0],
-            namespace = _eventName$split4[1];
-        //   .example  || click  || click.example
+      if (this.listeners[eventName].length === 0) {
+        this.deleteEventListener(eventName);
+      }
+    }
+  }
 
+  removeAllListeners(_eventName) {
+    const _eventName$split3 = _eventName.split('.'),
+          _eventName$split4 = _slicedToArray(_eventName$split3, 2),
+          eventName = _eventName$split4[0],
+          namespace = _eventName$split4[1]; //   .example  || click  || click.example
 
-        if (!eventName && namespace) {
-          Object.entries(this.listeners).map(function (_ref9) {
-            var _ref10 = slicedToArray(_ref9, 2),
-                key = _ref10[0],
-                value = _ref10[1];
 
-            _this4.listeners[key] = _this4.listeners[key].filter(function (eventTuple) {
-              return eventTuple.namespace !== namespace;
-            });
+    if (!eventName && namespace) {
+      Object.entries(this.listeners).map(([key, value]) => {
+        this.listeners[key] = this.listeners[key].filter(eventTuple => eventTuple.namespace !== namespace);
 
-            if (_this4.listeners[key].length === 0) {
-              _this4.deleteEventListener(key);
-            }
-          });
-        } else if (eventName && !namespace) {
-          this.deleteEventListener(eventName);
-        } else if (eventName && namespace && this.listeners[eventName]) {
-          this.listeners[eventName] = this.listeners[eventName].filter(function (eventTuple) {
-            return eventTuple.namespace !== namespace;
-          });
-
-          if (this.listeners[eventName].length === 0) {
-            this.deleteEventListener(eventName);
-          }
+        if (this.listeners[key].length === 0) {
+          this.deleteEventListener(key);
         }
+      });
+    } else if (eventName && !namespace) {
+      this.deleteEventListener(eventName);
+    } else if (eventName && namespace && this.listeners[eventName]) {
+      this.listeners[eventName] = this.listeners[eventName].filter(eventTuple => eventTuple.namespace !== namespace);
 
-        return this;
+      if (this.listeners[eventName].length === 0) {
+        this.deleteEventListener(eventName);
       }
-    }, {
-      key: 'createEventListener',
-      value: function createEventListener(eventName) {
-        this.listeners[eventName] = [];
-        this.element.addEventListener(eventName, dispatch, false);
-      }
-    }, {
-      key: 'deleteEventListener',
-      value: function deleteEventListener(eventName) {
-        this.element.removeEventListener(eventName, dispatch);
-        delete this.listeners[eventName];
-      }
-    }, {
-      key: 'checkRepeats',
-      value: function checkRepeats(eventName, handler) {
-        return this.listeners[eventName].filter(function (value) {
-          return value.handler === handler;
-        }).length !== 0;
-      }
-    }, {
-      key: 'hasListeners',
-      value: function hasListeners(eventName) {
-        if (!this.listeners[eventName] || Object.keys(this.listeners[eventName]).length === 0) {
-          return false;
-        }
+    }
 
-        return true;
-      }
-    }, {
-      key: 'ensureHandler',
-      value: function ensureHandler(handler) {
-        var type = typeof handler === 'undefined' ? 'undefined' : _typeof(handler);
-        if (type === 'function') {
-          return handler;
-        }
-        throw new TypeError('Listeners should be function or closure. Received type: ' + type);
-      }
-    }], [{
-      key: 'of',
-      value: function of(_ref11, element) {
-        var _eventName = _ref11.type,
-            identity = _ref11.identity,
-            handler = _ref11.handler;
+    return this;
+  }
 
-        if (!element.__eventStorage) {
-          element.__eventStorage = new this(element);
-        }
+  createEventListener(eventName) {
+    this.listeners[eventName] = [];
+    this.element.addEventListener(eventName, dispatch, false);
+  }
 
-        var _eventName$split5 = _eventName.split('.'),
-            _eventName$split6 = slicedToArray(_eventName$split5, 2),
-            eventName = _eventName$split6[0],
-            namespace = _eventName$split6[1];
+  deleteEventListener(eventName) {
+    this.element.removeEventListener(eventName, dispatch);
+    delete this.listeners[eventName];
+  }
 
-        var eventStorage = this.getEventStorage(element);
+  checkRepeats(eventName, handler) {
+    return this.listeners[eventName].filter(value => value.handler === handler).length !== 0;
+  }
 
-        eventStorage.on({
-          identity: outputIdentity(identity),
-          handler: handler,
-          eventName: eventName,
-          namespace: namespace
-        });
-      }
-    }, {
-      key: 'once',
-      value: function once(_ref12, element) {
-        var _eventName = _ref12.type,
-            identity = _ref12.identity,
-            handler = _ref12.handler;
+  hasListeners(eventName) {
+    if (!this.listeners[eventName] || Object.keys(this.listeners[eventName]).length === 0) {
+      return false;
+    }
 
-        if (!element.__eventStorage) {
-          element.__eventStorage = new this(element);
-        }
+    return true;
+  }
 
-        var _eventName$split7 = _eventName.split('.'),
-            _eventName$split8 = slicedToArray(_eventName$split7, 2),
-            eventName = _eventName$split8[0],
-            namespace = _eventName$split8[1];
+  ensureHandler(handler) {
+    const type = typeof handler;
 
-        var eventStorage = this.getEventStorage(element);
+    if (type === 'function') {
+      return handler;
+    }
 
-        eventStorage.once({
-          identity: outputIdentity(identity),
-          handler: handler,
-          eventName: eventName,
-          namespace: namespace
-        });
-      }
-    }, {
-      key: 'delete',
-      value: function _delete(options, element) {
-        var eventStorage = this.getEventStorage(element);
-        if (!eventStorage) {
-          return;
-        }
+    throw new TypeError(`Listeners should be function or closure. Received type: ${type}`);
+  }
 
-        var _options$type = options.type,
-            _eventName = _options$type === undefined ? options : _options$type,
-            handler = options.handler;
+  static of({
+    type: _eventName,
+    identity,
+    handler
+  }, element) {
+    if (!element.__eventStorage) {
+      element.__eventStorage = new this(element);
+    }
 
-        eventStorage.off(_eventName, handler);
-      }
-    }, {
-      key: 'getEventStorage',
-      value: function getEventStorage(element) {
-        return element.__eventStorage;
-      }
-    }]);
-    return EventStorage;
-  }();
+    const _eventName$split5 = _eventName.split('.'),
+          _eventName$split6 = _slicedToArray(_eventName$split5, 2),
+          eventName = _eventName$split6[0],
+          namespace = _eventName$split6[1];
 
-  var trigger = utils.curry(function (options, el) {
-    if (options instanceof window.Event) {
-      el.dispatchEvent(options);
-      return el;
+    const eventStorage = this.getEventStorage(element);
+    eventStorage.on({
+      identity: outputIdentity(identity),
+      handler,
+      eventName,
+      namespace
+    });
+  }
+
+  static once({
+    type: _eventName,
+    identity,
+    handler
+  }, element) {
+    if (!element.__eventStorage) {
+      element.__eventStorage = new this(element);
     }
-    var _options$type = options.type,
-        type = _options$type === undefined ? options : _options$type,
-        data = options.data;
 
-    var eventName = type;
+    const _eventName$split7 = _eventName.split('.'),
+          _eventName$split8 = _slicedToArray(_eventName$split7, 2),
+          eventName = _eventName$split8[0],
+          namespace = _eventName$split8[1];
 
-    var eventStorage = EventStorage.getEventStorage(el);
+    const eventStorage = this.getEventStorage(element);
+    eventStorage.once({
+      identity: outputIdentity(identity),
+      handler,
+      eventName,
+      namespace
+    });
+  }
 
-    if (eventStorage && eventStorage.hasListeners(eventName)) {
-      eventStorage.trigger(eventName, data);
+  static delete(options, element) {
+    const eventStorage = this.getEventStorage(element);
+
+    if (!eventStorage) {
+      return;
     }
 
+    const _options$type = options.type,
+          _eventName = _options$type === void 0 ? options : _options$type,
+          handler = options.handler;
+
+    eventStorage.off(_eventName, handler);
+  }
+
+  static getEventStorage(element) {
+    return element.__eventStorage;
+  }
+
+}
+
+const trigger = utils.curry((options, el) => {
+  if (options instanceof window.Event) {
+    el.dispatchEvent(options);
     return el;
-  });
-  /**
-   * bindEvent ({
-   *   type: 'example:CustomEvent',
-   *   handler: event => {
-   *     let { instance } = event.detail
-   *   }
-   * }, elemment)
-   *
-   * trigger({
-   *   type: 'example:CustomEvent',
-   *   data: {instance: this}
-   * }, elemment)
-   */
+  }
 
-  var bindEvent = utils.curry(function (options, element) {
-    EventStorage.of(options, element);
-    return element;
-  });
-  /**
-   * bindEvent ({
-   *   type: eventName,
-   *   handler
-   * }, el)
-   * bindEvent ({
-   *   type: eventName,
-   *   identity: '.className',
-   *   handler
-   * }, el)
-   * bindEvent ({
-   *   type,
-   *   identity: {
-   *     type: '[selector |class | id | attr | dataset]',
-   *     value
-   *   },
-   *   handler
-   * }, el)
-   * example:
-   * <li><a href="#" data-test="example">test</a></li>
-   * bindEvent ({
-   *   type,
-   *   identity: {
-   *     type: 'dataset',
-   *     value: {test: 'example'}
-   *   },
-   *   handler
-   * }, el)
-   */
-  var removeEvent = utils.curry(function (options, element) {
-    EventStorage.delete(options, element);
-    return element;
-  });
-  /**
-   * removeEvent (this.eventName(), el)
-   * removeEvent (eventName, el)
-   * removeEvent ({
-   *   type: [this.eventName() || eventName],
-   *   handler
-   * }, el)
-   */
-  var bindEventOnce = utils.curry(function (options, element) {
-    EventStorage.once(options, element);
-    return element;
-  });
+  const _options$type = options.type,
+        type = _options$type === void 0 ? options : _options$type,
+        data = options.data;
+  const eventName = type;
+  const eventStorage = EventStorage.getEventStorage(el);
 
-  var getEventStorage = function getEventStorage(element) {
-    return EventStorage.getEventStorage(element);
-  };
+  if (eventStorage && eventStorage.hasListeners(eventName)) {
+    eventStorage.trigger(eventName, data);
+  }
 
-  exports.trigger = trigger;
-  exports.bindEvent = bindEvent;
-  exports.removeEvent = removeEvent;
-  exports.bindEventOnce = bindEventOnce;
-  exports.getEventStorage = getEventStorage;
+  return el;
+});
+/**
+ * bindEvent ({
+ *   type: 'example:CustomEvent',
+ *   handler: event => {
+ *     let { instance } = event.detail
+ *   }
+ * }, elemment)
+ *
+ * trigger({
+ *   type: 'example:CustomEvent',
+ *   data: {instance: this}
+ * }, elemment)
+ */
 
-  Object.defineProperty(exports, '__esModule', { value: true });
+const bindEvent = utils.curry((options, element) => {
+  EventStorage.of(options, element);
+  return element;
+});
+/**
+ * bindEvent ({
+ *   type: eventName,
+ *   handler
+ * }, el)
+ * bindEvent ({
+ *   type: eventName,
+ *   identity: '.className',
+ *   handler
+ * }, el)
+ * bindEvent ({
+ *   type,
+ *   identity: {
+ *     type: '[selector |class | id | attr | dataset]',
+ *     value
+ *   },
+ *   handler
+ * }, el)
+ * example:
+ * <li><a href="#" data-test="example">test</a></li>
+ * bindEvent ({
+ *   type,
+ *   identity: {
+ *     type: 'dataset',
+ *     value: {test: 'example'}
+ *   },
+ *   handler
+ * }, el)
+ */
 
-})));
+const removeEvent = utils.curry((options, element) => {
+  EventStorage.delete(options, element);
+  return element;
+});
+/**
+ * removeEvent (this.eventName(), el)
+ * removeEvent (eventName, el)
+ * removeEvent ({
+ *   type: [this.eventName() || eventName],
+ *   handler
+ * }, el)
+ */
+
+const bindEventOnce = utils.curry((options, element) => {
+  EventStorage.once(options, element);
+  return element;
+});
+const getEventStorage = element => EventStorage.getEventStorage(element);
+
+exports.trigger = trigger;
+exports.bindEvent = bindEvent;
+exports.removeEvent = removeEvent;
+exports.bindEventOnce = bindEventOnce;
+exports.getEventStorage = getEventStorage;

package.json

 {
 	"name": "@pluginjs/events",
-	"main": "dist/events.js",
-	"dev-main": "src/main.js",
+	"main": "dist/events.umd.js",
+	"source": "src/main.js",
 	"module": "dist/events.esm.js",
@@ -10,7 +10,7 @@ "dependencies": {
 	},
-	"version": "0.0.5",
+	"version": "0.5.0",
 	"description": "A flexible modern events js plugin.",
 	"author": "Creation Studio Limited",
 	"homepage": "https://github.com/pluginjs/plugin.js",
-	"license": "GPL-v3",
+	"license": "GPL-3.0",
 	"files": [
@@ -31,3 +31,28 @@ "dist",
 	},
-	"category": "utils"
+	"category": "utils",
+	"scripts": {
+		"build": "plugin build",
+		"build:js": "plugin script build-js",
+		"build:scss": "plugin script build-scss",
+		"test": "jest",
+		"build:md": "plugin script build-md"
+	},
+	"cjs": "dist/events.cjs.js",
+	"jest": {
+		"setupTestFrameworkScriptFile": "jest-extended",
+		"verbose": true,
+		"testPathIgnorePatterns": [
+			"fixtures"
+		]
+	},
+	"devDependencies": {
+		"@pluginjs/cli": "^0.5.18",
+		"babel-jest": "^23.0.1",
+		"jest": "^23.1.0",
+		"jest-extended": "^0.7.2",
+		"rollup": "^0.59.2",
+		"rollup-plugin-babel": "^4.0.0-beta.4",
+		"rollup-plugin-commonjs": "^9.1.3",
+		"rollup-plugin-node-resolve": "^3.3.0"
+	}
 }

src/eventStorage.js

@@ -118,3 +118,3 @@ import { parent } from '@pluginjs/dom'
   clear() {
-    Object.entries(this.listeners).map(([key, value]) => {
+    Object.entries(this.listeners).forEach(([key]) => {
       this.deleteEventListener(key)
@@ -130,3 +130,3 @@ })
     if (!eventName && namespace) {
-      Object.entries(this.listeners).map(([key, value]) => {
+      Object.entries(this.listeners).forEach(([key]) => {
         this.listeners[key] = this.listeners[key].filter(
@@ -166,3 +166,3 @@ eventTuple =>
     if (!eventName && namespace) {
-      Object.entries(this.listeners).map(([key, value]) => {
+      Object.entries(this.listeners).forEach(([key]) => {
         this.listeners[key] = this.listeners[key].filter(
@@ -169,0 +169,0 @@ eventTuple => eventTuple.namespace !== namespace

src/main.js

@@ -12,8 +12,11 @@ import { curry } from '@pluginjs/utils'
 
-  const eventStorage = EVENTSTORAGE.getEventStorage(el)
+  // const eventStorage = EVENTSTORAGE.getEventStorage(el)
 
-  if (eventStorage && eventStorage.hasListeners(eventName)) {
-    eventStorage.trigger(eventName, data)
-  }
-
+  // if (eventStorage && eventStorage.hasListeners(eventName)) {
+  //   eventStorage.trigger(eventName, data)
+  // }
+  const event = new CustomEvent(eventName, {
+    detail: data
+  })
+  el.dispatchEvent(event)
   return el
@@ -20,0 +23,0 @@ })

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

No README

Quality

Package does not have a README. This may indicate a failed publish or a low quality package.

Found 1 instance in 1 package

Minified code

Quality

This package contains minified code. This may be harmless in some cases where minified code is included in packaged libraries, however packages on npm should not minify code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

60633

increased by3.78%

Number of package files

8

increased by14.29%

Lines of code

1893

increased by18.39%

Number of low quality alerts

1

decreased by-50%

Number of medium quality alerts

1

decreased by-50%

Number of lines in readme file

35

increased byInfinity%

Worsened metrics

Dev dependency count

8

increased byInfinity%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes