pixi-hammer - npm Package Compare versions

Comparing version 0.1.0 to 0.2.0

example.js

@@ -17,4 +17,11 @@ var PIXI = require('pixi.js');
 rect.drawRect(100, 100, 100, 100);
+rect.priority = 1;
 app.stage.addChild(rect);
 
+var rect2 = new PIXI.Graphics();
+rect2.beginFill(0x0000FF);
+rect2.drawRect(150, 50, 100, 100);
+rect2.priority = 2;
+app.stage.addChild(rect2);
+
 /**
@@ -30,5 +37,9 @@ * connect events
 c.listen(rect, 'tap', function(e) {
-  console.log('tapping on the rect!');
+  console.log('tapping on the rect1!');
 });
 
+c.listen(rect2, 'tap', function(e) {
+  console.log('tapping on the rect2!');
+});
+
 c.start();

index.js

@@ -1,2 +0,1 @@
-var _ = require('lodash');
 var Hammer = require('hammerjs');
@@ -46,30 +45,35 @@
   self._handler = function(e) {
-    e = Connector.normalizePointer(e, self._offset.x, self._offset.y);
+    Connector.normalizePointer(e, self._offset.x, self._offset.y);
     // sugar sub method to ending propagations
     e.end = self._mc.stop.bind(self._mc, true);
-    var y = _.sortBy(
-      self._listeners[e.type],
-      _.partial(_.get, _, 'instance.priority', -1)
-    );
-
+    
+    var y = self._listeners[e.type].sort(function(a, b) {
+      return (a.instance.priority || -1) > (b.instance.priority || -1)
+    });
+    
     // check hitArea or just using native `containsPoint`
-    var target = _.findLast(y, function(listener) {
+    var target;
+    for (var i = y.length - 1; i >= 0; i--) {
+      var listener = y[i];
       if (!self.isHitable(listener.instance)) {
-        return false;
+        continue;
       }
 
       if (listener.instance.hitArea) {
-        listener.instance.worldTransform.applyInverse(
-          e.center,
-          self._tempPoint
-        );
-        return _.invoke(
-          listener.instance.hitArea,
-          'containsPoint',
-          self._tempPoint
-        );
+        listener.instance.worldTransform.applyInverse(e.center, self._tempPoint);
+        if (listener.instance.hitArea.containsPoint(self._tempPoint)) {
+          target = listener;
+          break;
+        } else {
+          continue;
+        }
       } else {
-        return _.invoke(listener.instance, 'containsPoint', e.center);
+        if (listener.instance.containsPoint(e.center)) {
+          target = listener;
+          break;
+        } else {
+          continue;
+        }
       }
-    });
+    }
     target && target.callback.call(target.instance, e);
@@ -94,3 +98,3 @@ };
   var self = this;
-  if (_.isUndefined(callback)) {
+  if (callback === undefined) {
     callback = option;
@@ -101,31 +105,27 @@ option = undefined;
   var l = (self._listeners[event] = self._listeners[event] || []);
-  var keys = ['priority', 'instance', 'callback'];
 
   // set options for recoginzers
   if (option) {
-    var optionKey = _.includes(event, '-')
-      ? _.first(_.split(event, '-'))
-      : self.getRecognizerType(event);
-    _.set(self._options, optionKey, option);
+    var optionKey = event.includes('-') ? event.split('-')[0] : self.getRecognizerType(event);
+    self._options[optionKey] = option;
   }
 
   // set listeners for events
-  var info = _.zipObject(keys, [
-    _.get(instance, 'priority', 0),
-    instance,
-    callback
-  ]);
-  var sortedIndex = _.sortedIndexBy(l, info, 'priority');
-  self._listeners[event] = _.concat(
-    _.slice(l, 0, sortedIndex),
-    info,
-    _.slice(l, sortedIndex, _.size(l))
-  );
+  var info = {
+    priority: instance.priority || 0,
+    instance: instance,
+    callback: callback
+  };
+  
+  var sortedIndex = l.length;
+  for (var i = 0; i < l.length; i++) {
+    if (l[i].priority >= info.priority) {
+      sortedIndex = i;
+      break;
+    }
+  }
+  self._listeners[event] = [].concat(l.slice(0, sortedIndex)).concat(info).concat(l.slice(sortedIndex, l.length));
 
   // for event added after `start` and dint have reusable recognizer
-  if (
-    self._isStart &&
-    !_.isEqual(event, 'hammer.input') &&
-    !self._mc.get(event)
-  ) {
+  if (self._isStart && event !== 'hammer.input' && !self._mc.get(event)) {
     if (self.isCustomEvent(event)) {
@@ -136,9 +136,12 @@ self.createCustomRecognizer(event);
     }
-    if (!_.has(self._mc.handlers, event)) {
+    if (!self._mc.handlers[event]) {
       self._mc.on(event, self._handler);
       // run related dependencies stack again
-      _.chain(self._dependencies)
-        .filter(_.partial(_.includes, _, event))
-        .each(_.bind(_.spread(self.setDependency), self))
-        .value();
+      self._dependencies
+        .filter(function(dep) {
+          return dep.includes(event);
+        })
+        .forEach(function(dep) {
+          self.setDependency.apply(self, dep);
+        });
     }
@@ -165,28 +168,27 @@ }
 
-  // initialize normal recognizers
-  _.chain(self._listeners)
-    .keys()
-    .reject(self.isCustomEvent)
-    // return the valid name of recognizer constructor
-    .map(_.bind(self.getRecognizerType, self))
-    .compact()
-    .uniq()
-    .each(_.bind(self.createRecognizer, self))
-    .value();
+  var temp = [];
+  for (var key in self._listeners) {
+    if (self.isCustomEvent(key)) {
+      // initialize custom recognizers
+      var customName = self.getCustomName(key);
+      if (!temp.includes(customName)) {
+        temp.push(customName);
+        self.createCustomRecognizer(key);
+      }
+    } else {
+      // initialize normal recognizers
+      var type = self.getRecognizerType(key);
+      self.createRecognizer(type);
+    }
+  }
 
-  // initialize custom recognizers
-  _.chain(self._listeners)
-    .keys()
-    .filter(self.isCustomEvent)
-    .groupBy(self.getCustomName)
-    .each(_.bind(self.createCustomRecognizer, self))
-    .value();
-
   // run the dependecies stack
-  _.each(self._dependencies, _.bind(_.spread(self.setDependency), self));
+  self._dependencies.forEach(function(dep) {
+    self.setDependency.apply(self, dep);
+  });
 
-  _.each(self._listeners, function(callbacks, type) {
+  for (var key in self._listeners) {
     // listen to events
-    self._mc.on(type, self._handler);
-  });
+    self._mc.on(key, self._handler);
+  }
 };
@@ -221,12 +223,8 @@
   var self = this;
-  var base = self.isCustomEvent(event)
-    ? _.chain(event)
-        .split('-')
-        .last()
-        .value()
-    : event;
-  return _.find(
-    self.C.recognizers,
-    _.unary(_.partial(_.startsWith, _.upperFirst(base)))
-  );
+  var base = self.isCustomEvent(event) ? event.split('-').pop() : event;
+
+  return self.C.recognizers.find(function(reg) {
+    var name = base[0].toUpperCase() + base.slice(1);
+    return reg.indexOf(name) === 0;
+  });
 };
@@ -240,3 +238,3 @@
 Connector.prototype.isCustomEvent = function(event) {
-  return _.includes(event, '-');
+  return event.includes('-');
 };
@@ -250,3 +248,3 @@
 Connector.prototype.getCustomName = function(event) {
-  return _.first(_.split(event, '-'));
+  return event.split('-').shift();
 };
@@ -261,3 +259,3 @@
   var self = this;
-  var opt = _.get(self._options, recognizerType, {});
+  var opt = self._options[recognizerType] || {};
   self._mc.add(new global.Hammer[recognizerType](opt));
@@ -274,14 +272,12 @@ };
   var self = this;
-  var recognizerType = self.getRecognizerType(_.first(event));
+  var recognizerType = self.getRecognizerType(event);
   var customName = self.getCustomName(event);
 
-  var opt = _.get(self._options, customName, {});
+  var opt = {};
+  for (var key in self._options[customName]) {
+    opt[key] = self._options[customName][key];
+  }
+  opt.event = [customName, recognizerType.toLowerCase()].join('-');
 
-  self._mc.add(
-    new global.Hammer[recognizerType](
-      _.assign(opt, {
-        event: _.join([customName, _.lowerFirst(recognizerType)], '-')
-      })
-    )
-  );
+  self._mc.add(new global.Hammer[recognizerType](opt));
 };
@@ -306,3 +302,3 @@
   }
-  if (_.isEmpty(instance.parent) && !_.isEqual(instance.name, 'stage')) {
+  if (!instance.parent && instance.name !== 'stage') {
     return false;
@@ -325,5 +321,6 @@ }
   var self = this;
-  _.each(self._listeners, function(callbacks, type) {
-    self._mc.off(type, self._handler);
-  });
+  
+  for (var key in self._listeners) {
+    self._mc.off(key, self._handler);
+  }
   self._mc.destroy();
@@ -343,12 +340,6 @@ self._mc = null;
 Connector.normalizePointer = function(e, offsetX, offsetY) {
-  offsetX = offsetX || 0;
-  offsetY = offsetY || 0;
-  var normalized = _.cloneDeep(e);
-
-  normalized.center.x = (e.center.x - offsetX);
-  normalized.center.y = (e.center.y - offsetY);
-
-  return normalized;
+  e.center.x = (e.center.x - offsetX || 0);
+  e.center.y = (e.center.y - offsetY || 0);
 }
 
 module.exports = Connector;

package.json

 {
   "name": "pixi-hammer",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Use Hammerjs with pixi",
@@ -18,4 +18,3 @@ "repository": "thammin/pixi-hammer",
   "dependencies": {
-    "hammerjs": "^2.0.8",
-    "lodash": "^4.17.4"
+    "hammerjs": "^2.0.8"
   },
@@ -22,0 +21,0 @@ "devDependencies": {

README.md

@@ -44,3 +44,2 @@ # pixi-hammer
 
-- [ ] remove lodash dependency
 - [ ] examples for `stopPropagation` etc 
@@ -47,0 +46,0 @@ - [ ] simplify API (adding listener on demand)

No alert changes

Improved metrics

Total package byte prevSize

10963

increased by0.96%

Dependency count

1

decreased by-50%

Worsened metrics

Lines of code

326

decreased by-0.31%

Number of lines in readme file

49

decreased by-2%

Dependency changes

• - Removedlodash@^4.17.4

• - Removedlodash@4.17.21(transitive)