async-invoker 1.1.2 → 2.0.0-beta.1

package/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,30 @@
+Note: This is just a template, so feel free to use/remove the unnecessary things
+
+### Description
+- Type: Bug | Enhancement | Question
+- Related Issue: `#abc`
+
+---------------------------------------------------------------
+## Bug
+**Expected Behavior**
+
+**Actual Behavior**
+
+**Steps to Reproduce**
+
+----------------------------------------------------------------
+## Enhancement
+
+**Reason to enhance/problem with existing solution**
+
+**Suggested enhancement**
+
+**Pros**
+
+**Cons**
+
+-----------------------------------------------------------------
+
+## Question
+
+**How to?**

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,3 @@
+[Finishes #ID](https://www.pivotaltracker.com/story/show/ID)
+
+- [ ] App levantada, probada y con los tests corridos! [👌](https://c.tenor.com/joILBoleQeoAAAAC/ricky-fort.gif)

package/.github/workflows/trufflehog-scan.yml

@@ -0,0 +1,14 @@
+name: Trufflehog Scan
+
+on:
+  pull_request:
+    branches:
+      - main
+      - master
+
+jobs:
+  trufflehog-scan:
+    uses: Parsimotion/public-workflows/.github/workflows/trufflehog-scan.yml@main
+    with:
+      pr-number: ${{ github.event.pull_request.number }}
+      base-commit: ${{ github.event.pull_request.base.sha }}

package/babel.config.json

@@ -0,0 +1,5 @@
+{
+  "presets": [
+    ["@babel/preset-env"]
+  ]
+}

package/lib/async.invoker.js

@@ -1,81 +1,69 @@
-(function() {
-  var AsyncInvoker, Promise, _, eval_,
-    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
-    slice = [].slice;
+"use strict";
 
-  Promise = require("bluebird");
-
-  eval_ = require("eval");
-
-  _ = require("lodash");
-
-  module.exports = AsyncInvoker = (function() {
-    function AsyncInvoker(code, options, globals) {
-      this.options = options != null ? options : {};
-      if (globals == null) {
-        globals = {};
+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); }
+function _readOnlyError(r) { throw new TypeError('"' + r + '" is read-only'); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), 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 Promise = require("bluebird");
+var eval_ = require("eval");
+var _ = require("lodash");
+var AsyncInvoker = /*#__PURE__*/function () {
+  function AsyncInvoker(code) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var globals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    _classCallCheck(this, AsyncInvoker);
+    this.options = options;
+    _.defaults(this.options, {
+      logErrors: true
+    });
+    code = "module.exports = ".concat(code);
+    this._invoke = this._doSomething(function () {
+      return eval_(code, globals);
+    });
+    this._assertIsFunction(this._invoke);
+  }
+  return _createClass(AsyncInvoker, [{
+    key: "invoke",
+    value: function invoke() {
+      var _this = this;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
       }
-      this._assertIsFunction = bind(this._assertIsFunction, this);
-      this._doSomething = bind(this._doSomething, this);
-      this.invoke = bind(this.invoke, this);
-      _.defaults(this.options, {
-        logErrors: true
+      var invoke = function invoke(functionArgs) {
+        return _this._doSomething(function () {
+          return _this._invoke.apply(null, functionArgs);
+        });
+      };
+      var tryLog = function tryLog(e) {
+        if (_this.options.logErrors) console.log(e);
+      };
+      return new Promise(function (resolve, reject) {
+        try {
+          var output = invoke(args.concat(resolve));
+          if (!_.isUndefined(output)) {
+            resolve(output);
+          }
+        } catch (e) {
+          tryLog(e);
+          reject(e);
+        }
       });
-      code = "module.exports = " + code;
-      this._invoke = this._doSomething(((function(_this) {
-        return function() {
-          return eval_(code, globals);
-        };
-      })(this)));
-      this._assertIsFunction(this._invoke);
     }
-
-    AsyncInvoker.prototype.invoke = function() {
-      var args, invoke, tryLog;
-      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-      invoke = (function(_this) {
-        return function(functionArgs) {
-          return _this._doSomething((function() {
-            return _this._invoke.apply(null, functionArgs);
-          }));
-        };
-      })(this);
-      tryLog = (function(_this) {
-        return function(e) {
-          if (_this.options.logErrors) {
-            return console.log(e);
-          }
-        };
-      })(this);
-      return new Promise((function(_this) {
-        return function(resolve, reject) {
-          var e, error, output;
-          try {
-            output = invoke(args.concat(resolve));
-            if (!_.isUndefined(output)) {
-              return resolve(output);
-            }
-          } catch (error) {
-            e = error;
-            tryLog(e);
-            return reject(e);
-          }
-        };
-      })(this));
-    };
-
-    AsyncInvoker.prototype._doSomething = function(doSomething) {
+  }, {
+    key: "_doSomething",
+    value: function _doSomething(doSomething) {
       return doSomething();
-    };
-
-    AsyncInvoker.prototype._assertIsFunction = function(func) {
+    }
+  }, {
+    key: "_assertIsFunction",
+    value: function _assertIsFunction(func) {
       if (!_.isFunction(func)) {
         throw new Error("The function is not a function");
       }
-    };
-
-    return AsyncInvoker;
-
-  })();
-
-}).call(this);
+    }
+  }]);
+}();
+module.exports = AsyncInvoker;

package/lib/index.js

@@ -1,4 +1,3 @@
-(function() {
-  module.exports = require("./async.invoker");
+"use strict";
 
-}).call(this);
+module.exports = require("./async.invoker");

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "async-invoker",
-  "version": "1.1.2",
+  "version": "2.0.0-beta.1",
   "description": "Create a runner of code asynchronous",
   "main": "index.js",
   "scripts": {
-    "test": "grunt test",
-    "prepublish": "grunt build"
+    "test": "mocha --require @babel/register --reporter spec 'src/**/*.spec.js'",
+    "build": "rm -rf lib && babel src --out-dir lib --ignore 'src/**/*.spec.js'",
+    "prepublish": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -13,15 +14,14 @@
   },
   "dependencies": {
     "bluebird": "3.4.6",
-    "eval": "0.1.4",
-    "lodash": "4.17.15"
+    "eval": "0.1.6",
+    "lodash": "^4.18.1"
   },
   "devDependencies": {
-    "grunt": "1.0.1",
-    "grunt-bump": "0.8.0",
-    "grunt-contrib-clean": "1.0.0",
-    "grunt-contrib-coffee": "1.0.0",
-    "grunt-mocha-test": "0.12.7",
+    "@babel/cli": "^7.24.0",
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "@babel/register": "^7.24.0",
     "mocha": "3.0.2",
     "should": "11.1.0"
   },