Socket
Socket
Sign inDemoInstall

function-overloader

Package Overview
Dependencies
Maintainers
1
Versions
42
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

function-overloader - npm Package Compare versions

Comparing version 1.13.1 to 2.0.0

src/actions/createExecuteAction.js

394

dist/index.js

@@ -10,3 +10,3 @@ (function webpackUniversalModuleDefinition(root, factory) {

}
})(typeof self !== 'undefined' ? self : this, function() {
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap

@@ -74,3 +74,3 @@ /******/ // The module cache

/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 5);
/******/ return __webpack_require__(__webpack_require__.s = 2);
/******/ })

@@ -88,98 +88,32 @@ /************************************************************************/

});
exports.default = createDoneAction;
function createDoneAction(_ref) {
var result = _ref.result,
debug = _ref.debug;
exports.default = createExecuteAction;
return function () {
debug("call done with result", result);
return result;
};
}
var _checkCondition = __webpack_require__(7);
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
var _checkCondition2 = _interopRequireDefault(_checkCondition);
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createElseAction;
var _createDoneAction = __webpack_require__(0);
var _createDoneAction2 = _interopRequireDefault(_createDoneAction);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function createExecuteAction(actions) {
return function () {
for (var _len = arguments.length, testedArguments = Array(_len), _key = 0; _key < _len; _key++) {
testedArguments[_key] = arguments[_key];
}
function createElseAction(_ref) {
var testedArguments = _ref.testedArguments,
result = _ref.result,
isEnabled = _ref.isEnabled,
debug = _ref.debug;
return function (callback) {
debug("call else");
if (isEnabled) {
debug("execute function");
isEnabled = false;
result = callback.apply(undefined, _toConsumableArray(testedArguments));
debug("function sync result", result);
var chosenCondition = actions.filter(function (condition) {
return condition.conditionArguments;
}).find(function (condition) {
return (0, _checkCondition2.default)(condition.conditionArguments, testedArguments);
});
if (!chosenCondition) {
chosenCondition = actions.find(function (condition) {
return !condition.conditionArguments;
});
}
return {
done: (0, _createDoneAction2.default)({ result: result, debug: debug })
};
};
}
if (chosenCondition) {
var _chosenCondition;
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createWhenAction;
var _checkCondition = __webpack_require__(10);
var _checkCondition2 = _interopRequireDefault(_checkCondition);
var _createDoAction = __webpack_require__(11);
var _createDoAction2 = _interopRequireDefault(_createDoAction);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function createWhenAction(_ref) {
var testedArguments = _ref.testedArguments,
result = _ref.result,
isEnabled = _ref.isEnabled,
debug = _ref.debug;
return function () {
for (var _len = arguments.length, conditionArguments = Array(_len), _key = 0; _key < _len; _key++) {
conditionArguments[_key] = arguments[_key];
return (_chosenCondition = chosenCondition).callback.apply(_chosenCondition, testedArguments);
}
debug("call when", conditionArguments);
var conditionResult = (0, _checkCondition2.default)(conditionArguments, testedArguments);
debug("conditionResult", conditionResult);
return {
do: (0, _createDoAction2.default)({
conditionResult: conditionResult,
testedArguments: testedArguments,
isEnabled: isEnabled,
result: result,
debug: debug
})
};
return null;
};

@@ -189,3 +123,3 @@ }

/***/ }),
/* 3 */
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

@@ -245,48 +179,12 @@

/***/ }),
/* 4 */
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = __webpack_require__(3);
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createElseThrowAction;
var _createDoneAction = __webpack_require__(0);
var _createDoneAction2 = _interopRequireDefault(_createDoneAction);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function createElseThrowAction(_ref) {
var testedArguments = _ref.testedArguments,
result = _ref.result,
isEnabled = _ref.isEnabled,
debug = _ref.debug;
return function () {
debug("call elseThrow");
if (isEnabled) {
isEnabled = false;
throw TypeError("Wrong parameters", testedArguments);
}
return {
done: (0, _createDoneAction2.default)({ result: result, debug: debug })
};
};
}
/***/ }),
/* 5 */
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(6);
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";

@@ -300,3 +198,3 @@

var _Overload = __webpack_require__(7);
var _Overload = __webpack_require__(4);

@@ -310,3 +208,3 @@ var _Overload2 = _interopRequireDefault(_Overload);

/***/ }),
/* 7 */
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

@@ -323,59 +221,55 @@

var _debug = __webpack_require__(8);
var _createWhenAction = __webpack_require__(5);
var _debug2 = _interopRequireDefault(_debug);
var _createWhenAction2 = _interopRequireDefault(_createWhenAction);
var _createSetAction = __webpack_require__(9);
var _createTypeFactory = __webpack_require__(9);
var _createSetAction2 = _interopRequireDefault(_createSetAction);
var _createTypeFactory = __webpack_require__(12);
var _createTypeFactory2 = _interopRequireDefault(_createTypeFactory);
var _number = __webpack_require__(13);
var _number = __webpack_require__(10);
var _number2 = _interopRequireDefault(_number);
var _string = __webpack_require__(14);
var _string = __webpack_require__(11);
var _string2 = _interopRequireDefault(_string);
var _object = __webpack_require__(15);
var _object = __webpack_require__(12);
var _object2 = _interopRequireDefault(_object);
var _array = __webpack_require__(16);
var _array = __webpack_require__(13);
var _array2 = _interopRequireDefault(_array);
var _boolean = __webpack_require__(17);
var _boolean = __webpack_require__(14);
var _boolean2 = _interopRequireDefault(_boolean);
var _function = __webpack_require__(18);
var _function = __webpack_require__(15);
var _function2 = _interopRequireDefault(_function);
var _symbol = __webpack_require__(19);
var _symbol = __webpack_require__(16);
var _symbol2 = _interopRequireDefault(_symbol);
var _undefined = __webpack_require__(20);
var _undefined = __webpack_require__(17);
var _undefined2 = _interopRequireDefault(_undefined);
var _instance = __webpack_require__(21);
var _instance = __webpack_require__(18);
var _instance2 = _interopRequireDefault(_instance);
var _interface = __webpack_require__(22);
var _interface = __webpack_require__(19);
var _interface2 = _interopRequireDefault(_interface);
var _null = __webpack_require__(24);
var _null = __webpack_require__(21);
var _null2 = _interopRequireDefault(_null);
var _any = __webpack_require__(25);
var _any = __webpack_require__(22);

@@ -394,18 +288,7 @@ var _any2 = _interopRequireDefault(_any);

_createClass(Overload, null, [{
key: "set",
value: function set() {
for (var _len = arguments.length, testedArguments = Array(_len), _key = 0; _key < _len; _key++) {
testedArguments[_key] = arguments[_key];
}
var isEnabled = true;
var result = null;
var debug = (0, _debug2.default)("Overloader");
var setAction = (0, _createSetAction2.default)({
testedArguments: testedArguments,
isEnabled: isEnabled,
result: result,
debug: debug
});
return setAction();
key: "when",
value: function when() {
var actions = [];
var whenAction = (0, _createWhenAction2.default)(actions);
return whenAction.apply(undefined, arguments);
}

@@ -432,9 +315,3 @@ }]);

/***/ }),
/* 8 */
/***/ (function(module, exports) {
module.exports = require("debug");
/***/ }),
/* 9 */
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

@@ -448,41 +325,68 @@

});
exports.default = createSetAction;
exports.default = createWhenAction;
var _createElseAction = __webpack_require__(1);
var _createElseAction = __webpack_require__(6);
var _createElseAction2 = _interopRequireDefault(_createElseAction);
var _createWhenAction = __webpack_require__(2);
var _createElseThrowAction = __webpack_require__(8);
var _createWhenAction2 = _interopRequireDefault(_createWhenAction);
var _createElseThrowAction = __webpack_require__(4);
var _createElseThrowAction2 = _interopRequireDefault(_createElseThrowAction);
var _createDoneAction = __webpack_require__(0);
var _createExecuteAction = __webpack_require__(0);
var _createDoneAction2 = _interopRequireDefault(_createDoneAction);
var _createExecuteAction2 = _interopRequireDefault(_createExecuteAction);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function createSetAction(_ref) {
var testedArguments = _ref.testedArguments,
result = _ref.result,
isEnabled = _ref.isEnabled,
debug = _ref.debug;
function createWhenAction(actions) {
var newActions = actions.slice();
return function () {
for (var _len = arguments.length, conditionArguments = Array(_len), _key = 0; _key < _len; _key++) {
conditionArguments[_key] = arguments[_key];
}
return function () {
debug("call set");
var options = {
testedArguments: testedArguments,
isEnabled: isEnabled,
result: result,
debug: debug
return {
do: function _do(callback) {
newActions.push({
conditionArguments: conditionArguments,
callback: callback
});
return {
when: createWhenAction(newActions),
else: (0, _createElseAction2.default)(newActions),
elseThrow: (0, _createElseThrowAction2.default)(newActions),
execute: (0, _createExecuteAction2.default)(newActions)
};
}
};
};
}
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = createElseAction;
var _createExecuteAction = __webpack_require__(0);
var _createExecuteAction2 = _interopRequireDefault(_createExecuteAction);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function createElseAction(actions) {
var newActions = actions.slice();
return function (callback) {
newActions.push({
callback: callback
});
return {
when: (0, _createWhenAction2.default)(options),
else: (0, _createElseAction2.default)(options),
elseThrow: (0, _createElseThrowAction2.default)(options),
done: (0, _createDoneAction2.default)(options)
execute: (0, _createExecuteAction2.default)(newActions)
};

@@ -493,3 +397,3 @@ };

/***/ }),
/* 10 */
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

@@ -505,3 +409,3 @@

var _checkTypeCondition = __webpack_require__(3);
var _checkTypeCondition = __webpack_require__(1);

@@ -523,3 +427,3 @@ var _checkTypeCondition2 = _interopRequireDefault(_checkTypeCondition);

/***/ }),
/* 11 */
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

@@ -533,50 +437,24 @@

});
exports.default = createDoAction;
exports.default = createElseThrowAction;
var _createElseAction = __webpack_require__(1);
var _createExecuteAction = __webpack_require__(0);
var _createElseAction2 = _interopRequireDefault(_createElseAction);
var _createExecuteAction2 = _interopRequireDefault(_createExecuteAction);
var _createWhenAction = __webpack_require__(2);
var _createWhenAction2 = _interopRequireDefault(_createWhenAction);
var _createElseThrowAction = __webpack_require__(4);
var _createElseThrowAction2 = _interopRequireDefault(_createElseThrowAction);
var _createDoneAction = __webpack_require__(0);
var _createDoneAction2 = _interopRequireDefault(_createDoneAction);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function createElseThrowAction(actions) {
var newActions = actions.slice();
return function () {
newActions.push({
callback: function callback() {
for (var _len = arguments.length, testedArguments = Array(_len), _key = 0; _key < _len; _key++) {
testedArguments[_key] = arguments[_key];
}
function createDoAction(_ref) {
var testedArguments = _ref.testedArguments,
result = _ref.result,
conditionResult = _ref.conditionResult,
isEnabled = _ref.isEnabled,
debug = _ref.debug;
return function (callback) {
debug("call do");
if (conditionResult && isEnabled) {
debug("execute function");
isEnabled = false;
result = callback.apply(undefined, _toConsumableArray(testedArguments));
debug("function sync result", result);
}
var options = {
testedArguments: testedArguments,
isEnabled: isEnabled,
result: result,
debug: debug
};
throw TypeError("Wrong parameters", testedArguments);
}
});
return {
when: (0, _createWhenAction2.default)(options),
else: (0, _createElseAction2.default)(options),
elseThrow: (0, _createElseThrowAction2.default)(options),
done: (0, _createDoneAction2.default)(options)
execute: (0, _createExecuteAction2.default)(newActions)
};

@@ -587,3 +465,3 @@ };

/***/ }),
/* 12 */
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

@@ -609,3 +487,3 @@

/***/ }),
/* 13 */
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

@@ -625,3 +503,3 @@

/***/ }),
/* 14 */
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

@@ -641,3 +519,3 @@

/***/ }),
/* 15 */
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

@@ -659,3 +537,3 @@

/***/ }),
/* 16 */
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

@@ -677,3 +555,3 @@

/***/ }),
/* 17 */
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

@@ -693,3 +571,3 @@

/***/ }),
/* 18 */
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

@@ -709,3 +587,3 @@

/***/ }),
/* 19 */
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

@@ -727,3 +605,3 @@

/***/ }),
/* 20 */
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

@@ -743,3 +621,3 @@

/***/ }),
/* 21 */
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

@@ -759,3 +637,3 @@

/***/ }),
/* 22 */
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

@@ -772,3 +650,3 @@

var _checkSingleCondition = __webpack_require__(23);
var _checkSingleCondition = __webpack_require__(20);

@@ -787,3 +665,3 @@ var _checkSingleCondition2 = _interopRequireDefault(_checkSingleCondition);

/***/ }),
/* 23 */
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

@@ -799,3 +677,3 @@

var _checkTypeCondition = __webpack_require__(3);
var _checkTypeCondition = __webpack_require__(1);

@@ -811,3 +689,3 @@ var _checkTypeCondition2 = _interopRequireDefault(_checkTypeCondition);

/***/ }),
/* 24 */
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

@@ -827,3 +705,3 @@

/***/ }),
/* 25 */
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

@@ -830,0 +708,0 @@

6

package.json
{
"name": "function-overloader",
"version": "1.13.1",
"version": "2.0.0",
"description": "improve overloading functions and methods in js",

@@ -62,5 +62,3 @@ "main": "dist/index.js",

},
"dependencies": {
"debug": "^3.0.1"
},
"dependencies": {},
"lint-staged": {

@@ -67,0 +65,0 @@ "*.js": [

42

README.md

@@ -28,3 +28,3 @@ # FUNCTION OVERLOADER

constructor() {
Overload.set(...arguments)
Overload
.when(Overload.STRING, Overload.NUMBER)

@@ -40,3 +40,3 @@ .do((monsterName, level) => {

})
.done();
.execute(...arguments);
console.log(`Monster ${this.name} level ${this.level} created`);

@@ -46,3 +46,3 @@ }

addAttribute() {
return Overload.set(...arguments)
return Overload
.when(Overload.INSTANCE(Attribute))

@@ -52,3 +52,3 @@ .do(this.addExisitingAttribute)

.do(this.addNewAttribute)
.done();
.execute(...arguments);
}

@@ -115,3 +115,3 @@

function someOverloadedFunction() {
return Overload.set(...arguments)
return Overload
.when(<list of types>)

@@ -121,3 +121,3 @@ .do(someFunctionHandlingFirstCase)

.do(someFunctionHandlingSecondCase)
.done();
.execute(...arguments);
}

@@ -128,15 +128,2 @@ ```

### init
```javascript
Overload.set(...arguments)
```
accept function arguments. It is possible by passing them one by one, but preffered why is to just pass spread `...arguments`.
It will return `Condition Response`
Another possibility is to :
```javascript
new Overload(...arguments);
```
And it will also return `Condition Response`
### .when()

@@ -195,10 +182,9 @@

### .done()
### .execute()
```javascript
.done()
.execute()
```
should be called at the end to mark that now we should get chosen function response
No arguments. Will return funtion response
accept function arguments. It is possible by passing them one by one, but preferred why is to just pass spread `...arguments`.
Will return funtion response

@@ -216,12 +202,4 @@ ### .do()

## Debugger
For easy debug this library run your script with
```
DEBUG=Overloader <command to run>
```
## License
MIT

17

src/actions/createElseAction.js

@@ -1,15 +0,12 @@

import createDoneAction from "./createDoneAction";
export default function createElseAction({ testedArguments, result, isEnabled, debug }) {
import createExecuteAction from "./createExecuteAction";
export default function createElseAction(actions) {
const newActions = actions.slice();
return callback => {
debug("call else");
if (isEnabled) {
debug("execute function");
isEnabled = false;
result = callback(...testedArguments);
debug("function sync result", result);
}
newActions.push({
callback
});
return {
done: createDoneAction({ result, debug })
execute: createExecuteAction(newActions)
};
};
}

17

src/actions/createElseThrowAction.js

@@ -1,13 +0,14 @@

import createDoneAction from "./createDoneAction";
export default function createElseThrowAction({ testedArguments, result, isEnabled, debug }) {
import createExecuteAction from "./createExecuteAction";
export default function createElseThrowAction(actions) {
const newActions = actions.slice();
return () => {
debug("call elseThrow");
if (isEnabled) {
isEnabled = false;
throw TypeError("Wrong parameters", testedArguments);
}
newActions.push({
callback(...testedArguments) {
throw TypeError("Wrong parameters", testedArguments);
}
});
return {
done: createDoneAction({ result, debug })
execute: createExecuteAction(newActions)
};
};
}

30

src/actions/createWhenAction.js

@@ -1,18 +0,22 @@

import checkCondition from "../checkCondition/checkCondition";
import createDoAction from "./createDoAction";
export default function createWhenAction({ testedArguments, result, isEnabled, debug }) {
import createElseAction from "./createElseAction";
import createElseThrowAction from "./createElseThrowAction";
import createExecuteAction from "./createExecuteAction";
export default function createWhenAction(actions) {
const newActions = actions.slice();
return (...conditionArguments) => {
debug("call when", conditionArguments);
let conditionResult = checkCondition(conditionArguments, testedArguments);
debug("conditionResult", conditionResult);
return {
do: createDoAction({
conditionResult,
testedArguments,
isEnabled,
result,
debug
})
do(callback) {
newActions.push({
conditionArguments,
callback
});
return {
when: createWhenAction(newActions),
else: createElseAction(newActions),
elseThrow: createElseThrowAction(newActions),
execute: createExecuteAction(newActions)
};
}
};
};
}

19

src/Overload.js

@@ -1,5 +0,3 @@

import createDebug from "debug";
import createWhenAction from "./actions/createWhenAction";
import createSetAction from "./actions/createSetAction";
import createTypeFactory from "./createTypeFactory";

@@ -33,14 +31,7 @@ import numberCondition from "./types/number";

static set(...testedArguments) {
let isEnabled = true;
let result = null;
let debug = createDebug("Overloader");
let setAction = createSetAction({
testedArguments,
isEnabled,
result,
debug
});
return setAction();
static when(...conditionArguments) {
let actions = [];
let whenAction = createWhenAction(actions);
return whenAction(...conditionArguments);
}
}

182

src/Overload.spec.js

@@ -6,3 +6,3 @@ /* eslint-disable no-new-wrappers */

it("ensure that 'when' method return only object with 'do' method", () => {
let whenMethodResult = Overload.set().when();
let whenMethodResult = Overload.when();
expect(whenMethodResult).to.have.property("do");

@@ -12,19 +12,19 @@ expect(whenMethodResult).to.not.have.property("when");

expect(whenMethodResult).to.not.have.property("elseThrow");
expect(whenMethodResult).to.not.have.property("done");
expect(whenMethodResult).to.not.have.property("execute");
});
it("ensure that 'do' method return object with 'when' & 'else' & 'elseThrow' & 'done' methods", () => {
let doMethodResult = Overload.set()
.when()
.do(() => {});
it("ensure that 'do' method return object with 'when' & 'else' & 'elseThrow' & 'execute' methods", () => {
let doMethodResult = Overload.when().do(() => {});
expect(doMethodResult).to.have.property("when");
expect(doMethodResult).to.have.property("else");
expect(doMethodResult).to.have.property("elseThrow");
expect(doMethodResult).to.have.property("done");
expect(doMethodResult).to.have.property("execute");
expect(doMethodResult).to.not.have.property("do");
});
it("ensure that 'else' method return only object with 'done' method", () => {
let elseMethodResult = Overload.set().else(() => {});
expect(elseMethodResult).to.have.property("done");
it("ensure that 'else' method return only object with 'execute' method", () => {
let elseMethodResult = Overload.when()
.do(() => {})
.else(() => {});
expect(elseMethodResult).to.have.property("execute");
expect(elseMethodResult).to.not.have.property("when");

@@ -36,5 +36,7 @@ expect(elseMethodResult).to.not.have.property("else");

it("ensure that 'elseThrow' method return only object with 'done' method", () => {
let elseMethodResult = Overload.set().else(() => {});
expect(elseMethodResult).to.have.property("done");
it("ensure that 'elseThrow' method return only object with 'execute' method", () => {
let elseMethodResult = Overload.when()
.do(() => {})
.else(() => {});
expect(elseMethodResult).to.have.property("execute");
expect(elseMethodResult).to.not.have.property("when");

@@ -46,10 +48,11 @@ expect(elseMethodResult).to.not.have.property("else");

it("ensure that 'done' method return response", () => {
let doneMethodResult = Overload.set().done();
expect(doneMethodResult).to.be.null();
it("ensure that 'execute' method return response", () => {
let executeMethodResult = Overload.when()
.do(() => null)
.execute();
expect(executeMethodResult).to.be.null();
});
it("return sync result for typeof tests", () => {
let result = Overload.set("someString", 12345)
.when(Overload.NUMBER, Overload.STRING)
let result = Overload.when(Overload.NUMBER, Overload.STRING)
.do(() => "wrong result")

@@ -60,3 +63,3 @@ .when(Overload.STRING, Overload.NUMBER)

.do(() => "wrong result")
.done();
.execute("someString", 12345);
expect(result).to.be.equal("correct result");

@@ -66,60 +69,50 @@ });

it("resolved to correct types", () => {
let result = Overload.set("someString")
.when(Overload.STRING)
let result = Overload.when(Overload.STRING)
.do(() => "correct string")
.done();
.execute("someString");
expect(result).to.be.equal("correct string");
result = Overload.set(1234)
.when(Overload.NUMBER)
result = Overload.when(Overload.NUMBER)
.do(() => "correct number")
.done();
.execute(1234);
expect(result).to.be.equal("correct number");
result = Overload.set(true)
.when(Overload.BOOLEAN)
result = Overload.when(Overload.BOOLEAN)
.do(() => "correct bool")
.done();
.execute(true);
expect(result).to.be.equal("correct bool");
result = Overload.set(() => {})
.when(Overload.FUNCTION)
result = Overload.when(Overload.FUNCTION)
.do(() => "correct function")
.done();
.execute(() => {});
expect(result).to.be.equal("correct function");
result = Overload.set({})
.when(Overload.OBJECT)
result = Overload.when(Overload.OBJECT)
.do(() => "correct object")
.done();
.execute({});
expect(result).to.be.equal("correct object");
result = Overload.set([])
.when(Overload.ARRAY)
result = Overload.when(Overload.ARRAY)
.do(() => "correct object")
.done();
.execute([]);
expect(result).to.be.equal("correct object");
result = Overload.set(null)
.when(Overload.NULL)
result = Overload.when(Overload.NULL)
.do(() => "correct object")
.done();
.execute(null);
expect(result).to.be.equal("correct object");
result = Overload.set(Symbol("test"))
.when(Overload.SYMBOL)
result = Overload.when(Overload.SYMBOL)
.do(() => "correct symbol")
.done();
.execute(Symbol("test"));
expect(result).to.be.equal("correct symbol");
result = Overload.set(undefined)
.when(Overload.UNDEFINED)
result = Overload.when(Overload.UNDEFINED)
.do(() => "correct undefined")
.done();
.execute(undefined);
expect(result).to.be.equal("correct undefined");
result = Overload.set("test")
.when(Overload.ANY)
result = Overload.when(Overload.ANY)
.do(() => "correct undefined")
.done();
.execute("test");
expect(result).to.be.equal("correct undefined");

@@ -129,4 +122,3 @@ });

it("return correct response when expected undefined as argument", () => {
let result = Overload.set(undefined, 12345)
.when(Overload.NUMBER, Overload.STRING)
let result = Overload.when(Overload.NUMBER, Overload.STRING)
.do(() => "wrong result")

@@ -137,3 +129,3 @@ .when(Overload.UNDEFINED, Overload.NUMBER)

.do(() => "wrong result")
.done();
.execute(undefined, 12345);
expect(result).to.be.equal("correct result");

@@ -143,4 +135,3 @@ });

it("return correct response when expected no arguments", () => {
let result = Overload.set()
.when(Overload.NUMBER, Overload.STRING)
let result = Overload.when(Overload.NUMBER, Overload.STRING)
.do(() => "wrong result")

@@ -151,7 +142,6 @@ .when()

.do(() => "wrong result")
.done();
.execute();
expect(result).to.be.equal("correct result");
result = Overload.set()
.when(Overload.UNDEFINED, Overload.UNDEFINED)
result = Overload.when(Overload.UNDEFINED, Overload.UNDEFINED)
.do(() => "wrong resultAA")

@@ -162,3 +152,3 @@ .when()

.do(() => "wrong result")
.done();
.execute();
expect(result).to.be.equal("correct result");

@@ -168,4 +158,3 @@ });

it("invoke else and correct response when no condition met", () => {
let result = Overload.set(10, 10)
.when(Overload.NUMBER, Overload.STRING)
let result = Overload.when(Overload.NUMBER, Overload.STRING)
.do(() => "wrong result")

@@ -177,3 +166,3 @@ .when()

.else(() => "correct result")
.done();
.execute(10, 10);
expect(result).to.be.equal("correct result");

@@ -184,4 +173,3 @@ });

expect(() => {
Overload.set(10, 10)
.when(Overload.NUMBER, Overload.STRING)
Overload.when(Overload.NUMBER, Overload.STRING)
.do(() => "wrong result")

@@ -193,3 +181,3 @@ .when()

.elseThrow()
.done();
.execute(10, 10);
}).to.throw(TypeError);

@@ -203,4 +191,3 @@ });

const test1 = new Test1();
let result = Overload.set("someString", test1)
.when(Overload.NUMBER, Overload.INSTANCE(Test2))
let result = Overload.when(Overload.NUMBER, Overload.INSTANCE(Test2))
.do(() => "wrong result")

@@ -211,3 +198,3 @@ .when(Overload.STRING, Overload.INSTANCE(Test1))

.do(() => "wrong result")
.done();
.execute("someString", test1);
expect(result).to.be.equal("correct result");

@@ -217,4 +204,3 @@ });

it("return async result for typeof tests", () => {
return Overload.set("someString", 12345)
.when(Overload.NUMBER, Overload.STRING)
return Overload.when(Overload.NUMBER, Overload.STRING)
.do(() => Promise.resolve("wrong result"))

@@ -225,3 +211,3 @@ .when(Overload.STRING, Overload.NUMBER)

.do(() => Promise.resolve("wrong result"))
.done()
.execute("someString", 12345)
.then(result => {

@@ -233,14 +219,9 @@ expect(result).to.be.equal("correct result");

it("return correct response when expected interface", () => {
let result = Overload.set({
propertyString: "someString",
propertyNumber: 1234,
propertyFunction: () => {}
})
.when(
Overload.INTERFACE({
propertyString: Overload.NUMBER,
propertyNumber: Overload.NUMBER,
propertyFunction: Overload.FUNCTION
})
)
let result = Overload.when(
Overload.INTERFACE({
propertyString: Overload.NUMBER,
propertyNumber: Overload.NUMBER,
propertyFunction: Overload.FUNCTION
})
)
.do(() => "wrong result")

@@ -255,3 +236,7 @@ .when(

.do(() => "correct result")
.done();
.execute({
propertyString: "someString",
propertyNumber: 1234,
propertyFunction: () => {}
});
expect(result).to.be.equal("correct result");

@@ -261,17 +246,9 @@ });

it("return correct response when expected interface with deep interface", () => {
let result = Overload.set({
propertyString: "someString",
propertyNumber: 1234,
propertyFunction: () => {},
propertyObject: {
name: "someName"
}
})
.when(
Overload.INTERFACE({
propertyString: Overload.NUMBER,
propertyNumber: Overload.NUMBER,
propertyFunction: Overload.FUNCTION
})
)
let result = Overload.when(
Overload.INTERFACE({
propertyString: Overload.NUMBER,
propertyNumber: Overload.NUMBER,
propertyFunction: Overload.FUNCTION
})
)
.do(() => "wrong result")

@@ -289,5 +266,12 @@ .when(

.do(() => "correct result")
.done();
.execute({
propertyString: "someString",
propertyNumber: 1234,
propertyFunction: () => {},
propertyObject: {
name: "someName"
}
});
expect(result).to.be.equal("correct result");
});
});
.npmignore
package-lock.json
src/actions/createDoAction.js
src/actions/createDoneAction.js
src/actions/createSetAction.js
.idea/workspace.xml

Sorry, the diff of this file is not supported yet

dist/index.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc