Stupid Jelly - a bean compatible event system that proxies everything to native dom events

Registry.js

class Registry {
  static split(string) {
    return string.split(' ');
  }

  constructor() {
    Object.defineProperties(this, {
      map: {value: new WeakMap()}
    });
  }

  get(el, events) {
    if (!this.map.has(el)) {
      this.map.set(el, new Map());
    }

    const entry = this.map.get(el);

    if (!events) { return entry; }

    return Registry.split(events).map(event => {
      if (!entry.has(event)) {
        entry.set(event, new Set());
      }

      return entry.get(event);
    });
  }

  delete(el, events) {
    if (!events) {
      this.map.delete(el);

      return;
    }

    const entry = this.map.get(el);

    if (!entry) { return; }

    Registry.split(events).forEach(event => entry.delete(event));
  }
}

StupidJelly.js

class StupidJelly {

  static isSupported(el, event) {
    const eventName = `on${event}`;
    const isSupported = (eventName in el);

    if (isSupported) { return true; }

    const oldAttribute = el.getAttribute(eventName);
    el.setAttribute(eventName, 'return;');

    const isFunction = typeof el[eventName] === 'function';

    if (oldAttribute) {
      el.setAttribute(eventName, oldAttribute);
    } else {
      el.removeAttribute(eventName);
    }

    return isFunction;
  }

  on(el, events, fn) {
    if (typeof el.addEventListener === 'function' && typeof events === 'string') {
      events.split(' ').filter(s => s && s.length).map(
        s => s.toLowerCase()
      ).filter(
        s => StupidJelly.isSupported(el, s)
      ).forEach(
        event => el.addEventListener(event, fn)
      );
    }
  }

  once(el, events, fn) {
    const self = this;
    const handler = function(...args) {
      fn.apply(this, args);
      self.off(el, events, handler);
    };

    this.on(el, events, handler);
  }

  off(el, events, fn) {
    if (typeof el.removeEventListener === 'function' && typeof events === 'string') {
      console.debug('off', events);
      events.split(' ').filter(s => s && s.length).map(
        s => s.toLowerCase()
      ).filter(
        s => StupidJelly.isSupported(el, s)
      ).forEach(event => el.removeEventListener(event, fn));
    }
  }
}

export default new StupidJelly();