eventproxy - npm Package Compare versions

Comparing version 0.1.4 to 0.2.0

index.js

@@ -1,1 +0,1 @@
-module.exports = require('./lib/eventproxy.js');
+module.exports = process.env.EVENTPROXY_COV ? require('./lib-cov/eventproxy') : require('./lib/eventproxy');

lib/eventproxy.js

 /*global exports */
-/**
- * @fileoverview This file is used for define the EventProxy library.
+/*!
+ * This file is used for define the EventProxy library.
  * @author <a href="mailto:[e-mail]">Jackson Tian</a>
  * @version 0.1.0
  */
-
 ;(function (name, definition) {
@@ -22,10 +21,10 @@ // this is considered "safe":
 })('EventProxy', function () {
+
   /**
-   * @description EventProxy. A module that can be mixed in to *any object* in order to provide it with
-   * custom events. You may `bind` or `unbind` a callback function to an event;
+   * EventProxy. An implementation of task/event based asynchronous pattern.
+   * A module that can be mixed in to *any object* in order to provide it with custom events.
+   * You may `bind` or `unbind` a callback function to an event;
    * `trigger`-ing an event fires all callbacks in succession.
-   * @constructor
-   * @name EventProxy
-   * @class EventProxy. An implementation of task/event based asynchronous pattern.
-   * @example
+   * Examples:
+   * ```
    * var render = function (template, resources) {};
@@ -36,2 +35,3 @@ * var proxy = new EventProxy();
    * proxy.trigger("l10n", resources);
+   * ```
    */
@@ -47,7 +47,6 @@ var EventProxy = function () {
   /**
-   * @description Bind an event, specified by a string name, `ev`, to a `callback` function.
-   * Passing `"all"` will bind the callback to all events fired.
-   * @memberOf EventProxy#
-   * @param {string} eventName Event name.
-   * @param {function} callback Callback.
+   * Bind an event, specified by a string name, `ev`, to a `callback` function.
+   * Passing `all` will bind the callback to all events fired.
+   * @param {String} eventName Event name.
+   * @param {Function} callback Callback.
    */
@@ -60,13 +59,21 @@ EventProxy.prototype.addListener = function (ev, callback) {
   };
+  /**
+   * `addListener` alias
+   */
   EventProxy.prototype.bind = EventProxy.prototype.addListener;
+  /**
+   * `addListener` alias
+   */
   EventProxy.prototype.on = EventProxy.prototype.addListener;
+  /**
+   * `addListener` alias
+   */
   EventProxy.prototype.await = EventProxy.prototype.addListener;
 
   /**
-   * @description Remove one or many callbacks. If `callback` is null, removes all
-   * callbacks for the event. If `ev` is null, removes all bound callbacks
+   * Remove one or many callbacks. If `callback` is null, removes all callbacks for the event.
+   * If `ev` is null, removes all bound callbacks
    * for all events.
-   * @memberOf EventProxy#
-   * @param {string} eventName Event name.
-   * @param {function} callback Callback.
+   * @param {String} eventName Event name.
+   * @param {Function} callback Callback.
    */
@@ -96,9 +103,11 @@ EventProxy.prototype.removeListener = function (ev, callback) {
   };
+  /**
+   * `removeListener` alias
+   */
   EventProxy.prototype.unbind = EventProxy.prototype.removeListener;
 
   /**
-   * @description Remove all listeners.
-   * It equals unbind(); Just add this API for as same as Event.Emitter.
-   * @memberOf EventProxy#
-   * @param {string} event Event name.
+   * Remove all listeners. It equals unbind()
+   * Just add this API for as same as Event.Emitter.
+   * @param {String} event Event name.
    */
@@ -110,7 +119,7 @@ EventProxy.prototype.removeAllListeners = function (event) {
   /**
-   * @description Trigger an event, firing all bound callbacks. Callbacks are passed the
+   * Trigger an event, firing all bound callbacks. Callbacks are passed the
    * same arguments as `trigger` is, apart from the event name.
    * Listening for `"all"` passes the true event name as the first argument.
-   * @param {string} eventName Event name
-   * @param {mix} data Pass in data
+   * @param {String} eventName Event name
+   * @param {Mix} data Pass in data
    */
@@ -139,25 +148,31 @@ EventProxy.prototype.trigger = function (eventName, data) {
   };
+  /**
+   * `trigger` alias
+   */
   EventProxy.prototype.emit = EventProxy.prototype.trigger;
+  /**
+   * `trigger` alias
+   */
   EventProxy.prototype.fire = EventProxy.prototype.trigger;
 
   /**
-   * @description Bind an event like the bind method, but will remove the listener after it was fired.
-   * @param {string} ev Event name
-   * @param {function} callback Callback
+   * Bind an event like the bind method, but will remove the listener after it was fired.
+   * @param {String} ev Event name
+   * @param {Function} callback Callback
    */
   EventProxy.prototype.once = function (ev, callback) {
-    var self = this,
-      wrapper = function () {
-        callback.apply(self, arguments);
-        self.unbind(ev, wrapper);
-      };
+    var self = this;
+    var wrapper = function () {
+      callback.apply(self, arguments);
+      self.unbind(ev, wrapper);
+    };
     this.bind(ev, wrapper);
     return this;
   };
-  
+
   /**
-   * @description Bind an event, and trigger it immediately.
-   * @param {string} ev Event name.
-   * @param {function} callback Callback.
-   * @param {mix} data The data that will be passed to calback as arguments.
+   * Bind an event, and trigger it immediately.
+   * @param {String} ev Event name.
+   * @param {Function} callback Callback.
+   * @param {Mix} data The data that will be passed to calback as arguments.
    */
@@ -169,2 +184,6 @@ EventProxy.prototype.immediate = function (ev, callback, data) {
   };
+  /**
+   * `immediate` alias
+   */
+  EventProxy.prototype.asap = EventProxy.prototype.immediate;
 
@@ -227,12 +246,14 @@ var _assign = function (eventname1, eventname2, cb, once) {
   /**
-   * @description Assign some events, after all events were fired, the callback will be executed once.
-   * @example
+   * Assign some events, after all events were fired, the callback will be executed once.
+   * Examples:
+   * ```
    * proxy.all(ev1, ev2, callback);
    * proxy.all([ev1, ev2], callback);
    * proxy.all(ev1, [ev2, ev3], callback);
-   * @param {string} eventName1 First event name.
-   * @param {string} eventName2 Second event name.
-   * @param {function} callback Callback, that will be called after predefined events were fired.
+   * ```
+   * @param {String} eventName1 First event name.
+   * @param {String} eventName2 Second event name.
+   * @param {Function} callback Callback, that will be called after predefined events were fired.
    */
-  EventProxy.prototype.all = function (eventname1, eventname2, cb) {
+  EventProxy.prototype.all = function (eventname1, eventname2, callback) {
     var args = Array.prototype.concat.apply([], arguments);
@@ -243,15 +264,32 @@ args.push(true);
   };
+  /**
+   * `all` alias
+   */
   EventProxy.prototype.assign = EventProxy.prototype.all;
 
   /**
-   * @description Assign some events, after all events were fired, the callback will be executed first time.
-   * then any event that predefined be fired again, the callback will executed with the newest data.
-   * @example
+   * Assign the only one 'error' event handler.
+   * @param {Function(err)} callback
+   */
+  EventProxy.prototype.fail = function (callback) {
+    var that = this;
+    that.once('error', function (err) {
+      that.unbind();
+      callback(err);
+    });
+    return this;
+  };
+
+  /**
+   * Assign some events, after all events were fired, the callback will be executed first time.
+   * Then any event that predefined be fired again, the callback will executed with the newest data.
+   * Examples:
+   * ```
    * proxy.tail(ev1, ev2, callback);
    * proxy.tail([ev1, ev2], callback);
    * proxy.tail(ev1, [ev2, ev3], callback);
-   * @memberOf EventProxy#
-   * @param {string} eventName1 First event name.
-   * @param {string} eventName2 Second event name.
-   * @param {function} callback Callback, that will be called after predefined events were fired.
+   * ```
+   * @param {String} eventName1 First event name.
+   * @param {String} eventName2 Second event name.
+   * @param {Function} callback Callback, that will be called after predefined events were fired.
    */
@@ -264,11 +302,16 @@ EventProxy.prototype.tail = function () {
   };
+  /**
+   * `tail` alias
+   */
   EventProxy.prototype.assignAll = EventProxy.prototype.tail;
+  /**
+   * `tail` alias
+   */
   EventProxy.prototype.assignAlways = EventProxy.prototype.tail;
 
   /**
-   * @description The callback will be executed after the event be fired N times.
-   * @memberOf EventProxy#
-   * @param {string} eventName Event name.
-   * @param {number} times N times.
-   * @param {function} callback Callback, that will be called after event was fired N times.
+   * The callback will be executed after the event be fired N times.
+   * @param {String} eventName Event name.
+   * @param {Mumber} times N times.
+   * @param {Function} callback Callback, that will be called after event was fired N times.
    */
@@ -298,4 +341,3 @@ EventProxy.prototype.after = function (eventName, times, callback) {
   /**
-   * @description The callback will be executed after any registered event was fired. It only executed once.
-   * @memberOf EventProxy#
+   * The callback will be executed after any registered event was fired. It only executed once.
    * @param {string} eventName1 Event name.
@@ -329,4 +371,3 @@ * @param {string} eventName2 Event name.
   /**
-   * @description The callback will be executed when the evnet name not equals with assigned evnet.
-   * @memberOf EventProxy#
+   * The callback will be executed when the evnet name not equals with assigned evnet.
    * @param {string} eventName Event name.
@@ -343,23 +384,63 @@ * @param {function} callback Callback.
   };
-  
+
   /**
-   * Create a new EventProxy
-   * @example
-   *     var ep = EventProxy.create();
-   *     ep.assign('user', 'articles', function(user, articles) {
-   *       // do something...
-   *     });
+   * Success callback wraper, will handler err for you.
    *
-   *     // or one line ways: Create EventProxy and Assign
+   * ```js
+   * fs.readFile('foo.txt', ep.done('content'));
    *
-   *     var ep = EventProxy.create('user', 'articles', function(user, articles) {
-   *       // do something...
-   *     });
+   * // equal to =>
    *
-   * @returns {EventProxy}
+   * fs.readFile('foo.txt', function (err, content) {
+   *   if (err) {
+   *     return ep.emit('error', err);
+   *   }
+   *   ep.emit('content', content);
+   * });
+   * ```
+   *
+   * @param {Function|String} handler, success callback or event name will be emit after callback.
+   * @return {Function}
    */
+  EventProxy.prototype.done = function (handler) {
+    var that = this;
+    return function (err, data) {
+      if (err) {
+        return that.emit('error', err);
+      }
+      if (typeof handler === 'function') {
+        return handler(data);
+      }
+      var eventname = handler;
+      that.emit(eventname, data);
+    };
+  };
+
+  /**
+   * Create a new EventProxy
+   * Examples:
+   * ```
+   * var ep = EventProxy.create();
+   * ep.assign('user', 'articles', function(user, articles) {
+   *   // do something...
+   * });
+   * // or one line ways: Create EventProxy and Assign
+   * var ep = EventProxy.create('user', 'articles', function(user, articles) {
+   *   // do something...
+   * });
+   *
+   * @returns {EventProxy} EventProxy instance
+   */
+
   EventProxy.create = function () {
     var ep = new EventProxy();
-    if (arguments.length) {
-      ep.assign.apply(ep, Array.prototype.slice.call(arguments));
+    var args = Array.prototype.concat.apply([], arguments);
+    if (args.length) {
+      var errorHandler = args[args.length - 1];
+      var callback = args[args.length - 2];
+      if (typeof errorHandler === 'function' && typeof callback === 'function') {
+        args.pop();
+        ep.fail(errorHandler);
+      }
+      ep.assign.apply(ep, Array.prototype.slice.call(args));
     }
@@ -366,0 +447,0 @@ return ep;

package.json

 {
-  "name"          : "eventproxy",
-  "description"   : "An implementation of task/event based asynchronous pattern.",
-  "homepage"      : "https://github.com/JacksonTian/eventproxy",
-  "keywords"      : ["event", "task-base", "event machine", "nested callback terminator"],
-  "author"        : "Jackson Tian <[e-mail]>",
-  "contributors"  : [
-    { "name": "Jackson Tian", "email": "[e-mail]" },
-    { "name": "fengmk2", "email": "[e-mail]" }
+  "name": "eventproxy",
+  "description": "An implementation of task/event based asynchronous pattern.",
+  "homepage": "https://github.com/JacksonTian/eventproxy",
+  "keywords": [
+    "event",
+    "task-base",
+    "event machine",
+    "nested callback terminator"
   ],
-  "dependencies"  : {},
+  "author": "Jackson Tian <[e-mail]>",
+  "contributors": [
+    "Jackson Tian <[e-mail]>",
+    "fengmk2 <[e-mail]>"
+  ],
+  "dependencies": {},
   "devDependencies": {
     "mocha": "*",
+    "jscover": "*",
+    "pedding": "*",
     "chai": "*"
@@ -19,7 +26,13 @@ },
   },
-  "repository"    : {
-    "type": "git", 
+  "repository": {
+    "type": "git",
     "url": "git://github.com/JacksonTian/eventproxy.git"
   },
-  "version"       : "0.1.4"
+  "version": "0.2.0",
+  "main": "index.js",
+  "directories": {
+    "doc": "doc",
+    "test": "test"
+  },
+  "license": "MIT"
 }

README.md

@@ -1,132 +0,240 @@
-这个世界上不存在所谓回调函数深度嵌套的问题。 —— [Jackson Tian](http://weibo.com/shyvo)
----
+EventProxy [![Build Status](https://secure.travis-ci.org/JacksonTian/eventproxy.png)](http://travis-ci.org/JacksonTian/eventproxy)
+======
 
-[![Build Status](https://secure.travis-ci.org/JacksonTian/eventproxy.png)](http://travis-ci.org/JacksonTian/eventproxy)
+> 这个世界上不存在所谓回调函数深度嵌套的问题。 —— [Jackson Tian](http://weibo.com/shyvo)
 
----
+> 世界上本没有嵌套回调，写得人多了，也便有了`}}}}}}}}}}}}`。 -- [fengmk2](http://fengmk2.github.com)
 
-[EventProxy API Documentation](http://eventproxy.html5ify.com/jsdoc/symbols/EventProxy.html)  
+* API文档: [EventProxy API Documentation](http://eventproxy.html5ify.com/jsdoc/symbols/EventProxy.html)
+* jscoverage: [95%](http://fengmk2.github.com/coverage/eventproxy.html)
 
-    npm install eventproxy
+EventProxy 仅仅是一个很轻量的工具，但是能够带来一种事件式编程的思维变化。有几个特点：
 
----
-EventProxy.js仅仅是一个很轻量的工具，但是能够带来一种事件式编程的思维变化。有几个特点：
+1. 利用事件机制解耦复杂业务逻辑
+2. 移除被广为诟病的深度callback嵌套问题
+3. 将串行等待变成并行等待，提升多异步场景下的执行效率
+4. 无平台依赖，适合前后端，能用于浏览器和Node.js
 
-   1. 利用事件机制解耦复杂业务逻辑
-   2. 移除被广为诟病的深度callback嵌套问题
-   3. 将串行等待变成并行等待，提升多异步场景下的执行效率
-   4. 无平台依赖，适合前后端，能用于浏览器和Node.js
-
 现在的，无深度嵌套的，并行的
 
-    var proxy = new EventProxy();
-    var render = function (template, data, l10n){
-        _.template(template, data);
-    };
-    proxy.assign("template", "data", "l10n", render);
-    $.get("template", function (template) {
-        // something
-        proxy.trigger("template", template);
-    });
-    $.get("data", function (data) {
-        // something
-        proxy.trigger("data", data);
-    });
-    $.get("l10n", function (l10n) {
-        // something
-        proxy.trigger("l10n", l10n);
-    });
+```js
+var ep = EventProxy.create("template", "data", "l10n", function (template, data, l10n) {
+  _.template(template, data, l10n);
+});
 
+$.get("template", function (template) {
+  // something
+  ep.emit("template", template);
+});
+$.get("data", function (data) {
+  // something
+  ep.emit("data", data);
+});
+$.get("l10n", function (l10n) {
+  // something
+  ep.emit("l10n", l10n);
+});
+```
+
 过去的，深度嵌套的，串行的。
 
-    var render = function (template, data){
-        _.template(template, data);
-    };
-    $.get("template", function (template) {
-        // something
-        $.get("data", function (data) {
-            // something
-            $.get("l10n", function (l10n) {
-                // something
-                render(template, data);
-            });
-        });
+```js
+var render = function (template, data) {
+  _.template(template, data);
+};
+$.get("template", function (template) {
+  // something
+  $.get("data", function (data) {
+    // something
+    $.get("l10n", function (l10n) {
+      // something
+      render(template, data, l10n);
     });
+  });
+});
+```
 
-For Frontend user:
+## For Frontend user:
 
-Assign once. The callback will be executed once when all event were fired.
+### Assign once. 
 
-    <script src="eventproxy.js"></script>
-    <script>
-        var proxy = new EventProxy();
-        var render = function (template, data, l10n){
-            _.template(template, data);
-        };
-        proxy.assign("template", "data", "l10n", render);
-        $.get("template", function (template) {
-            // something
-            proxy.trigger("template", template);
-        });
-        $.get("data", function (data) {
-            // something
-            proxy.trigger("data", data);
-        });
-        $.get("l10n", function (l10n) {
-            // something
-            proxy.trigger("l10n", l10n);
-        });
-    </script>
+The callback will be executed once when all event were fired.
 
-Assign always. The callback will be executed first time when all event were fired. And after that, any event was fired will trigger callback. It's useful when you need refresh UI with newest data, e.g. stock app.
+```js
+<script src="https://raw.github.com/JacksonTian/eventproxy/master/lib/eventproxy.js"></script>
+<script>
+  var render = function (template, data, l10n) {
+    _.template(template, data, l10n);
+  };
+  var ep = EventProxy.create("template", "data", "l10n", render);
+  $.get("template", function (template) {
+    // something
+    ep.emit("template", template);
+  });
+  $.get("data", function (data) {
+    // something
+    ep.emit("data", data);
+  });
+  $.get("l10n", function (l10n) {
+    // something
+    ep.emit("l10n", l10n);
+});
+</script>
+```
 
-    <script src="eventproxy.js"></script>
-    <script>
-        var proxy = new EventProxy();
-        var render = function (template, data, l10n){
-            _.template(template, data);
-        };
-        proxy.assignAll("template", "dataUpdate", "l10n", render);
-        $.get("template", function (template) {
-            // something
-            proxy.trigger("template", template);
-        });
+### Assign always. 
 
-        $.get("l10n", function (l10n) {
-            // something
-            proxy.trigger("l10n", l10n);
-        });
+The callback will be executed first time when all event were fired. And after that, 
+any event was fired will trigger callback. It's useful when you need refresh UI with newest data, e.g. stock app.
 
-        // Need refresh data and UI for some realtime application.
-        setInterval(function () {
-            $.get("data", function (data) {
-                // something
-                proxy.trigger("dataUpdate", data);
-            });
-        }, 1000);
-    </script>
+```js
+<script src="https://raw.github.com/JacksonTian/eventproxy/master/lib/eventproxy.js"></script>
+<script>
+  var render = function (template, data, l10n) {
+    _.template(template, data, l10n);
+  };
+  var ep = EventProxy.create();
 
-For Node.js:
+  ep.assignAll("template", "dataUpdate", "l10n", render);
+  $.get("template", function (template) {
+    // something
+    proxy.emit("template", template);
+  });
 
-    var EventProxy = require("eventproxy");
+  $.get("l10n", function (l10n) {
+    // something
+    proxy.emit("l10n", l10n);
+  });
 
-    var proxy = new EventProxy();
-    var render = function (template, data, l10n){
-        return _.template(template, data);
-    };
-    proxy.assign("template", "data", "l10n", render);
-    $.get("template", function (template) {
-        // something
-        proxy.trigger("template", template);
-    });
+  // Need refresh data and UI for some realtime application.
+  setInterval(function () {
     $.get("data", function (data) {
-        // something
-        proxy.trigger("data", data);
+      // something
+      proxy.emit("dataUpdate", data);
     });
-    $.get("l10n", function (l10n) {
-        // something
-        proxy.trigger("l10n", l10n);
+  }, 1000);
+</script>
+```
+
+## For Node.js:
+
+```bash
+$ npm install eventproxy
+```
+
+Sample code:
+
+```js
+var eventproxy = require("eventproxy");
+
+var ep = eventproxy.create("template", "data", "l10n", function (template, data, l10n) {
+  return _.template(template, data);
+});
+
+$.get("template", function (template) {
+  // something
+  proxy.emit("template", template);
+});
+$.get("data", function (data) {
+  // something
+  proxy.emit("data", data);
+});
+$.get("l10n", function (l10n) {
+  // something
+  proxy.emit("l10n", l10n);
+});
+```
+
+## 统一处理error返回
+
+这是来自我们实践代码总结，通过 `error` 事件统一处理所有异步请求的异常。
+
+```js
+var eventproxy = require('eventproxy');
+
+exports.getTweet = function (userId, tweetId, callback) {
+  // eventproxy.create(events, handler, errorHandler);
+  var ep = eventproxy.create('user', 'tweet', 'retweets', 'friends', 'messages', 
+  function (user, tweet, retweets, friends, messages) {
+    user.friends = friends;
+    user.messages = messages;
+    tweet.user = user;
+    tweet.retweets = retweets;
+    callback(null, tweet);
+  }, function (err) {
+    callback(err);
+  });
+
+  // or you can use `ep.fail(errorHandler)` to listen 'error' event.
+
+  twitter.get(tweetId, ep.done('tweet'));
+  twitter.getRetweets(tweetId, ep.done('retweets'));
+  twitter.getUser(userId, ep.done(function (user) {
+    ep.emit('user', user);
+    twitter.getUserFriends(user.id, ep.done('friends'));
+  }));
+  twitter.getUserMessages(userId, ep.done('message'));
+};
+```
+
+在没使用上述方法前，我们会这样写代码:
+
+```js
+var eventproxy = require('eventproxy');
+
+exports.getTweet = function (userId, tweetId, callback) {
+  // eventproxy.create(events, handler);
+  var ep = eventproxy.create('user', 'tweet', 'retweets', 'friends', 'messages', 
+  function (user, tweet, retweets, friends, messages) {
+    user.friends = friends;
+    user.messages = messages;
+    tweet.user = user;
+    tweet.retweets = retweets;
+    callback(null, tweet);
+  });
+
+  ep.once('error', function (err) {
+    ep.unbind();
+    callback(err);
+  });
+
+  twitter.get(tweetId, function (err, tweet) {
+    if (err) {
+      return ep.emit('error', err);
+    }
+    ep.emit('tweet', tweet);
+  });
+  twitter.getRetweets(tweetId, function (err, retweets) {
+    if (err) {
+      return ep.emit('error', err);
+    }
+    ep.emit('retweets', retweets);
+  });
+  twitter.getUser(userId, function (err, user) {
+    if (err) {
+      return ep.emit('error', err);
+    }
+    ep.emit('user', user);
+    twitter.getUserFriends(user.id, function (err, friends) {
+      if (err) {
+        return ep.emit('error', err);
+      }
+      ep.emit('friends', friends);
     });
+  });
+  twitter.getUserMessages(userId, function (err, messages) {
+    if (err) {
+      return ep.emit('error', err);
+    }
+    ep.emit('messages', messages);
+  });
+};
+```
 
-# 注意事项
-请勿使用`all`作为业务中的事件名。该事件名为保留事件。
+## 注意事项
+
+请勿使用`all`作为业务中的事件名。该事件名为保留事件。
+
+## License 
+
+(The MIT License)

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

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Fixed alerts

Non-existent author

Supply chain risk

The package was published by an npm account that no longer exists.

Found 1 instance in 1 package

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

Uses eval

Supply chain risk

Package uses dynamic code execution (e.g., eval()), which is a dangerous practice. This can prevent the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Improved metrics

Number of lines in readme file

241

increased by82.58%

Number of high supply chain risk alerts

0

decreased by-100%

Number of low supply chain risk alerts

1

decreased by-90.91%

Number of medium supply chain risk alerts

1

decreased by-66.67%

Worsened metrics

Total package byte prevSize

20763

decreased by-95.6%

Dev dependency count

4

increased by100%

Number of package files

8

decreased by-61.9%

Lines of code

412

decreased by-95.48%

No dependency changes