ppipe 2.6.3 → 2.6.6

package/package.json

@@ -1,32 +1,36 @@
-{
-	"name": "ppipe",
-	"version": "2.6.3",
-	"description": "piping without the operator support",
-	"main": "src/index.js",
-	"scripts": {
-		"test": "nyc --reporter=text --reporter=html mocha test",
-		"coverage": "nyc report --reporter=text-lcov | coveralls"
-	},
-	"keywords": [
-		"piping",
-		"promise",
-		"chain",
-		"async",
-		"pipe",
-		"pipe-operator",
-		"pipes-values"
-	],
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/egeozcan/ppipe.git"
-	},
-	"author": "Yavuz Ege Özcan",
-	"license": "ISC",
-	"devDependencies": {
-		"chai": "^4.2.0",
-		"coveralls": "^3.0.6",
-		"eslint": "^6.5.0",
-		"mocha": "^6.2.1",
-		"nyc": "^14.1.1"
-	}
-}
+{
+	"name": "ppipe",
+	"version": "2.6.6",
+	"description": "piping without the operator support",
+	"main": "src/index.js",
+	"scripts": {
+		"test": "nyc --reporter=text --reporter=html mocha test",
+		"coverage": "nyc report --reporter=text-lcov | coveralls",
+		"lint": "eslint --fix src/"
+	},
+	"keywords": [
+		"piping",
+		"promise",
+		"chain",
+		"async",
+		"pipe",
+		"pipe-operator",
+		"pipes-values"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/egeozcan/ppipe.git"
+	},
+	"author": "Yavuz Ege Özcan",
+	"license": "ISC",
+	"devDependencies": {
+		"chai": "^4.2.0",
+		"coveralls": "^3.1.0",
+		"eslint": "^8.12.0",
+		"eslint-config-prettier": "^8.5.0",
+		"eslint-plugin-prettier": "^4.0.0",
+		"mocha": "^9.2.2",
+		"nyc": "^15.1.0",
+		"prettier": "^2.6.1"
+	}
+}

package/prettier.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+	trailingComma: "es5",
+	tabWidth: 4,
+	useTabs: true,
+	semi: true,
+	singleQuote: false,
+	printWidth: 120,
+};

package/src/getPropertyByPath.js

@@ -1,4 +1,4 @@
-//Mostly taken from https://stackoverflow.com/a/6491621/300011
+// Mostly taken from https://stackoverflow.com/a/6491621/300011
 const isPromise = require("./lib/isPromise");
 
 module.exports = function getPropertyByPath(object, accessString) {
@@ -6,13 +6,15 @@ module.exports = function getPropertyByPath(object, accessString) {
 	accessString = accessString.replace(/\[(\w+)\]/g, ".$1");
 	// strip a leading dot
 	accessString = accessString.replace(/^\./, "");
+
 	const properties = accessString.split(".");
+
 	for (let i = 0, n = properties.length; i < n; ++i) {
 		const property = properties[i];
-		object = isPromise(object)
-			? object.then(x => getProperty(property, x))
-			: getProperty(property, object);
+
+		object = isPromise(object) ? object.then((x) => getProperty(property, x)) : getProperty(property, object);
 	}
+
 	return object;
 };
 
@@ -20,14 +22,14 @@ function getProperty(property, object) {
 	if (object === undefined) {
 		return;
 	}
+
 	let call = false;
+
 	if (property.endsWith("()")) {
 		call = true;
 		property = property.substr(0, property.length - 2);
 	}
 	if (property in object) {
 		return call ? object[property]() : object[property];
-	} else {
-		return;
 	}
 }

package/src/index.js

@@ -1,40 +1,45 @@
 const isFn = require("./lib/isFunction");
 const getPropertyByPath = require("./getPropertyByPath");
 const isPromise = require("./lib/isPromise");
-const unitFn = x => x;
-const isUndef = val => typeof val === "undefined";
-const truthy = val => !isUndef(val) && val !== null;
+
+const unitFn = (x) => x;
+const isUndef = (val) => typeof val === "undefined";
+const truthy = (val) => !isUndef(val) && val !== null;
 
 function createPpipe(extensions = {}) {
-	const ppipe = (val, thisVal, err) => {
-		const pipe = function(fn, ...params) {
+	function ppipe(val, thisVal, err) {
+		function pipe(fn, ...params) {
 			if (isUndef(fn)) {
 				if (truthy(err)) {
 					throw err;
 				}
+
 				return val;
 			}
+
 			if (!isFn(fn)) {
 				if (fn instanceof Placeholder && params.length === 0) {
 					params = [fn];
 					fn = unitFn;
 				} else {
-					throw new Error(
-						"first parameter to a pipe should be a function or a single placeholder"
-					);
+					throw new Error("first parameter to a pipe should be a function or a single placeholder");
 				}
 			}
-			const callResultFn = value => {
+
+			const callResultFn = (value) => {
 				let replacedPlaceHolder = false;
+
 				for (let i = params.length; i >= 0; i--) {
 					const pholdr = params[i];
+
 					if (!(pholdr instanceof Placeholder)) {
 						continue;
 					}
+
 					replacedPlaceHolder = true;
-					const replacedParam = !pholdr.prop
-						? value
-						: getPropertyByPath(value, pholdr.prop);
+
+					const replacedParam = !pholdr.prop ? value : getPropertyByPath(value, pholdr.prop);
+
 					pholdr.expandTarget === true
 						? params.splice(i, 1, ...replacedParam)
 						: params.splice(i, 1, replacedParam);
@@ -42,9 +47,11 @@ function createPpipe(extensions = {}) {
 				if (!replacedPlaceHolder) {
 					params.splice(params.length, 0, value);
 				}
+
 				return fn.call(thisVal, ...params);
 			};
 			let res;
+
 			if (isPromise(val)) {
 				res = val.then(callResultFn);
 			} else {
@@ -54,27 +61,29 @@ function createPpipe(extensions = {}) {
 					err = e;
 				}
 			}
+
 			return ppipe(res, undefined, err);
-		};
+		}
+
 		const piped = new Proxy(pipe, {
 			get(target, name) {
 				switch (name) {
 					case "then":
 					case "catch": {
-						const res = truthy(err)
-							? Promise.reject(err)
-							: Promise.resolve(val);
-						return (...params) =>
-							name === "then" ? res.then(...params) : res.catch(...params);
+						const res = truthy(err) ? Promise.reject(err) : Promise.resolve(val);
+
+						return (...params) => (name === "then" ? res.then(...params) : res.catch(...params));
 					}
 					case "val":
 						if (truthy(err)) {
 							throw err;
 						}
+
 						return val;
 					case "with":
-						return ctx => {
+						return (ctx) => {
 							thisVal = ctx;
+
 							return piped;
 						};
 					case "pipe":
@@ -82,43 +91,45 @@ function createPpipe(extensions = {}) {
 					case "bind":
 					case "call":
 					case "apply":
-						return (...params) => {
-							return pipe[name](...params);
-						};
+						return (...params) => pipe[name](...params);
 				}
+
 				if (isPromise(val)) {
 					return (...params) =>
-						piped(x => {
+						piped((x) => {
 							if (isUndef(x[name])) {
 								throw new TypeError(`${name} is not defined on ${x}`);
 							}
+
 							return isFn(x[name]) ? x[name](...params) : x[name];
 						});
 				}
+
 				const fnExistsInCtx = truthy(thisVal) && isFn(thisVal[name]);
 				const valHasProp = !fnExistsInCtx && !isUndef(val[name]);
-				const extensionWithNameExists =
-					!fnExistsInCtx && !valHasProp && isFn(extensions[name]);
+				const extensionWithNameExists = !fnExistsInCtx && !valHasProp && isFn(extensions[name]);
+
 				if (fnExistsInCtx || valHasProp || extensionWithNameExists) {
 					const ctx = fnExistsInCtx ? thisVal : valHasProp ? val : extensions;
+
 					return (...params) =>
 						piped((...replacedParams) => {
-							const newParams =
-								fnExistsInCtx || extensionWithNameExists
-									? replacedParams
-									: params;
+							const newParams = fnExistsInCtx || extensionWithNameExists ? replacedParams : params;
+
 							return !isFn(ctx[name]) ? ctx[name] : ctx[name](...newParams);
 						}, ...params);
 				}
-			}
+			},
 		});
+
 		return piped;
-	};
+	}
+
 	return Object.assign(ppipe, {
 		extend(newExtensions) {
 			return createPpipe(Object.assign(newExtensions, extensions));
 		},
-		_
+		_,
 	});
 }
 class Placeholder {
@@ -132,19 +143,16 @@ class Placeholder {
 	}
 }
 
-const placeholderProxy = (prop = undefined, expandTarget = false) => {
-	return new Proxy(new Placeholder(prop, expandTarget), {
+const placeholderProxy = (prop = undefined, expandTarget = false) =>
+	new Proxy(new Placeholder(prop, expandTarget), {
 		get(target, name) {
-			if (
-				name === Symbol.iterator ||
-				Object.getOwnPropertyNames(target).includes(name)
-			) {
+			if (name === Symbol.iterator || Object.getOwnPropertyNames(target).includes(name)) {
 				return target[name];
 			}
-			return placeholderProxy([prop, name].filter(x => !!x).join("."));
-		}
+
+			return placeholderProxy([prop, name].filter((x) => !!x).join("."));
+		},
 	});
-};
 
 const _ = placeholderProxy();
 

package/src/lib/isFunction.js

@@ -1 +1 @@
-module.exports = val => typeof val === "function";
+module.exports = (val) => typeof val === "function";

package/src/lib/isPromise.js

@@ -1,3 +1,3 @@
 const isFn = require("./isFunction");
 
-module.exports = val => val && isFn(val.then);
+module.exports = (val) => val && isFn(val.then);

package/test/examples.js

@@ -1,175 +1,175 @@
-let assert = require("chai").assert;
-let ppipe = require("../src/index.js");
-
-const add = (x, y) => x + y;
-const square = x => x * x;
-const divide = (x, y) => x / y;
-const double = x => x * 2;
-
-let _ = ppipe._;
-
-const delay = fn => (...args) =>
-	new Promise(resolve => setTimeout(() => resolve(fn.apply(null, args)), 10));
-const someAPICall = delay(x => x);
-
-describe("check readme", function() {
-	it("first example", function() {
-		const res = ppipe(1)(add, 1)(double)(square)(divide, ppipe._, 8)(add, 1)();
-		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
-	});
-
-	it("second example", function() {
-		const res = ppipe(1)
-			.pipe(add, 1)
-			.pipe(double)
-			.pipe(square)
-			.pipe(divide, _, 8)
-			.pipe(add, 1)();
-		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
-	});
-
-	it("third example", async function() {
-		async function asyncDouble(x) {
-			const result = x * 2;
-			await someAPICall(result);
-			return result;
-		}
-		const res = await ppipe(1)
-			.pipe(add, 1)
-			.pipe(asyncDouble)
-			.pipe(square)
-			.pipe(divide, _, 8)
-			.pipe(add, 1);
-		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
-	});
-
-	it("fourth example", async function() {
-		async function asyncComplexDouble(x) {
-			const result = x * 2;
-			const someInfo = await someAPICall(result);
-			return {
-				result,
-				someInfo,
-				getResultPlus: y => result + y
-			};
-		}
-		const res = await ppipe(1)
-			.pipe(add, 1)
-			.pipe(asyncComplexDouble)
-			.pipe(square, _.result)
-			.pipe(divide, _, 8)
-			.pipe(add, 1);
-		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
-		const res2 = await ppipe(1)
-			.pipe(add, 1)
-			.pipe(asyncComplexDouble)
-			.result()
-			.pipe(asyncComplexDouble)
-			.getResultPlus(2)
-			.pipe(square)
-			.pipe(divide, _, 8)
-			.pipe(add, 1)
-			.pipe(add, -2.5);
-		assert.equal(11, res2);
-		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
-	});
-
-	it("fourth example async result", async function() {
-		async function asyncComplexDouble(x) {
-			const result = x * 2;
-			const someInfo = await someAPICall(result);
-			//go wild with deferring
-			return Promise.resolve({
-				result,
-				someInfo,
-				//go wilder with deferring
-				getResultPlusAsync: y =>
-					new Promise(resolve => setTimeout(() => resolve(result + y), 10))
-			});
-		}
-		const res3 = await ppipe(1)
-			.pipe(add, 1)
-			.pipe(asyncComplexDouble)
-			.result()
-			.pipe(asyncComplexDouble)
-			.getResultPlusAsync(2)
-			.pipe(square)
-			.pipe(divide, _, 8)
-			.pipe(add, 1)
-			.pipe(add, -2.5);
-		assert.equal(11, res3);
-	});
-
-	it("fifth example", async function() {
-		async function advancedDouble(x) {
-			const result = x * 2;
-			const someInfo = await someAPICall(result);
-			return {
-				getResult() {
-					return result;
-				},
-				someInfo
-			};
-		}
-		const res = await ppipe(1)
-			.pipe(add, 1)
-			.pipe(advancedDouble)
-			.getResult()
-			.pipe(square)
-			.pipe(divide, _, 8)
-			.pipe(add, 1);
-		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
-		const res2 = await ppipe(1)
-			.pipe(add, 1)
-			.pipe(x => Promise.resolve(x))
-			//.pipe((...params) => (console.log(params), params[0]))
-			.pipe(advancedDouble)
-			.getResult()
-			.toFixed(2)
-			.pipe(parseInt)
-			.pipe(square)
-			.pipe(divide, _, 8)
-			.pipe(add, 1);
-		assert.equal(res2, 3);
-	});
-
-	it("sixth example", async function() {
-		class Example {
-			constructor(myInt) {
-				this.foo = Promise.resolve(myInt);
-			}
-			addToFoo(x) {
-				return this.foo.then(foo => foo + x);
-			}
-		}
-		const res = await ppipe(10)
-			.with(new Example(5))
-			.addToFoo(_);
-		assert.equal(res, 15);
-		const res2 = await ppipe(10)
-			.with(new Example(5))
-			.addToFoo();
-		assert.equal(res2, 15);
-	});
-
-	it("seventh example", async function() {
-		let logged = false;
-		const newPipe = ppipe.extend({
-			divide(x, y) {
-				return x / y;
-			},
-			log(...params) {
-				logged = true;
-				assert.equal(params[params.length - 1], 1);
-				return params[params.length - 1];
-			}
-		});
-		const res = await newPipe(10)
-			.pipe(x => x + 1)
-			.divide(_, 11)
-			.log("here is our x: ")
-			.pipe(x => x + 1);
-		assert.equal(res, 2);
-		assert.equal(logged, true);
-	});
-});
+let assert = require("chai").assert;
+let ppipe = require("../src/index.js");
+
+const add = (x, y) => x + y;
+const square = x => x * x;
+const divide = (x, y) => x / y;
+const double = x => x * 2;
+
+let _ = ppipe._;
+
+const delay = fn => (...args) =>
+	new Promise(resolve => setTimeout(() => resolve(fn.apply(null, args)), 10));
+const someAPICall = delay(x => x);
+
+describe("check readme", function() {
+	it("first example", function() {
+		const res = ppipe(1)(add, 1)(double)(square)(divide, ppipe._, 8)(add, 1)();
+		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
+	});
+
+	it("second example", function() {
+		const res = ppipe(1)
+			.pipe(add, 1)
+			.pipe(double)
+			.pipe(square)
+			.pipe(divide, _, 8)
+			.pipe(add, 1)();
+		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
+	});
+
+	it("third example", async function() {
+		async function asyncDouble(x) {
+			const result = x * 2;
+			await someAPICall(result);
+			return result;
+		}
+		const res = await ppipe(1)
+			.pipe(add, 1)
+			.pipe(asyncDouble)
+			.pipe(square)
+			.pipe(divide, _, 8)
+			.pipe(add, 1);
+		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
+	});
+
+	it("fourth example", async function() {
+		async function asyncComplexDouble(x) {
+			const result = x * 2;
+			const someInfo = await someAPICall(result);
+			return {
+				result,
+				someInfo,
+				getResultPlus: y => result + y
+			};
+		}
+		const res = await ppipe(1)
+			.pipe(add, 1)
+			.pipe(asyncComplexDouble)
+			.pipe(square, _.result)
+			.pipe(divide, _, 8)
+			.pipe(add, 1);
+		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
+		const res2 = await ppipe(1)
+			.pipe(add, 1)
+			.pipe(asyncComplexDouble)
+			.result()
+			.pipe(asyncComplexDouble)
+			.getResultPlus(2)
+			.pipe(square)
+			.pipe(divide, _, 8)
+			.pipe(add, 1)
+			.pipe(add, -2.5);
+		assert.equal(11, res2);
+		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
+	});
+
+	it("fourth example async result", async function() {
+		async function asyncComplexDouble(x) {
+			const result = x * 2;
+			const someInfo = await someAPICall(result);
+			//go wild with deferring
+			return Promise.resolve({
+				result,
+				someInfo,
+				//go wilder with deferring
+				getResultPlusAsync: y =>
+					new Promise(resolve => setTimeout(() => resolve(result + y), 10))
+			});
+		}
+		const res3 = await ppipe(1)
+			.pipe(add, 1)
+			.pipe(asyncComplexDouble)
+			.result()
+			.pipe(asyncComplexDouble)
+			.getResultPlusAsync(2)
+			.pipe(square)
+			.pipe(divide, _, 8)
+			.pipe(add, 1)
+			.pipe(add, -2.5);
+		assert.equal(11, res3);
+	});
+
+	it("fifth example", async function() {
+		async function advancedDouble(x) {
+			const result = x * 2;
+			const someInfo = await someAPICall(result);
+			return {
+				getResult() {
+					return result;
+				},
+				someInfo
+			};
+		}
+		const res = await ppipe(1)
+			.pipe(add, 1)
+			.pipe(advancedDouble)
+			.getResult()
+			.pipe(square)
+			.pipe(divide, _, 8)
+			.pipe(add, 1);
+		assert.equal(res, add(divide(square(double(add(1, 1))), 8), 1));
+		const res2 = await ppipe(1)
+			.pipe(add, 1)
+			.pipe(x => Promise.resolve(x))
+			//.pipe((...params) => (console.log(params), params[0]))
+			.pipe(advancedDouble)
+			.getResult()
+			.toFixed(2)
+			.pipe(parseInt)
+			.pipe(square)
+			.pipe(divide, _, 8)
+			.pipe(add, 1);
+		assert.equal(res2, 3);
+	});
+
+	it("sixth example", async function() {
+		class Example {
+			constructor(myInt) {
+				this.foo = Promise.resolve(myInt);
+			}
+			addToFoo(x) {
+				return this.foo.then(foo => foo + x);
+			}
+		}
+		const res = await ppipe(10)
+			.with(new Example(5))
+			.addToFoo(_);
+		assert.equal(res, 15);
+		const res2 = await ppipe(10)
+			.with(new Example(5))
+			.addToFoo();
+		assert.equal(res2, 15);
+	});
+
+	it("seventh example", async function() {
+		let logged = false;
+		const newPipe = ppipe.extend({
+			divide(x, y) {
+				return x / y;
+			},
+			log(...params) {
+				logged = true;
+				assert.equal(params[params.length - 1], 1);
+				return params[params.length - 1];
+			}
+		});
+		const res = await newPipe(10)
+			.pipe(x => x + 1)
+			.divide(_, 11)
+			.log("here is our x: ")
+			.pipe(x => x + 1);
+		assert.equal(res, 2);
+		assert.equal(logged, true);
+	});
+});