FWeinb · December 22, 2016 16:51
diff --git a/index.html b/index.html
 <!DOCTYPE html>
 <html>
 <head>
 	<meta charset="utf-8"/>
 	<title>Proxy path reader</title>
 	<script src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/1.0.0/benchmark.min.js"></script>
 	<script src="./suite.js"></script>
 </head>
 <body>
 	<h1>Open the console to view the results</h1>
 	<h2><code>cmd + alt + j</code> or <code>ctrl + alt + j</code></h2>
 </body>
 </html>
diff --git a/suite.js b/suite.js
 "use strict";

 (function (factory) {
 	if (typeof Benchmark !== "undefined") {
 		factory(Benchmark);
 	} else {
 		factory(require("benchmark"));
 	}
 })(function (Benchmark) {
 	var suite = new Benchmark.Suite;

 	Benchmark.prototype.setup = function () {
 		// Path resolver factory 
 		// Creates a resolver based on the target, path and resolveValue function
 		const createPathResolver = (target, path, resolveValue) => (context) => {
 		  const resolvedPath = [];
 		  // resolvePath will contain the actual path by resolving recursively
 		  for (let i = 0; i < path.length; i++) {
 		    const curr = path[i]    
 		    resolvedPath.push(
 		      typeof curr === 'function'
 		      ? curr(context).value
 		      : curr
 		    );
 		  }
 		  return {
 		    target,
 		    path: resolvedPath.join('.'),
 		    value: resolveValue(resolvedPath, context)
 		  }
 		}
 		
 		// Used to transfere a function from toPrimitive to the "parent" object 
 		let fnTransfer;
 		function PathRecorder (target, resolveValue) {
 		  // Create the root function the proxy is wrapping for the main object
 		  const rootFunction = () => {
 		    const  f = () => {};
 		    f.path = [];
 		    f.root = true;
 		    return f;
 		  }
 		
 		  // Create a child function the proxy is wrapping for all supsequent objects
 		  const childFunction = (path) => {
 		    const f = () => {};
 		    f.path = path;
 		    return f;
 		  }
 		  
 		  const toPrimitive = () => '';
 		  
 		  // Handler of all Proxy object
 		  const Handler = {
 		    
 		    apply(obj, thisArg, values) {
 		      // Root is called like a tagged template use old behaviour
 		      if (obj.root) return operators[target].apply(null, values);
 		      // Cache the function
 		      obj.cachedFn = obj.cachedFn || createPathResolver(target, obj.path, resolveValue);
 		      // context is the first parameter
 		      const context = values[0];
 		      // Resolve the value and return it. 
 		      return obj.cachedFn(context);
 		    },
 		    
 		    get(obj, name, proxy) {
 		      // TODO: This needs to be changed in string`` in cerebral 
 		      // because this could possible go wrong
 		      if (name === 'getValue') return undefined;
 		      // cache busting
 		      obj.cachedFn == undefined;
 		      // Always start a new path for a root obj
 		      obj.path = obj.root ? obj.path = [] : obj.path;
 		      if (name === Symbol.toPrimitive) {
 		        // create a resolver that will be transfered to the "parent" object
 		        fnTransfer = createPathResolver(target, obj.path, resolveValue);
 		        return toPrimitive;
 		      } else if (fnTransfer !== undefined) { 
 		        // There is a fnTransfere function add it.
 		        obj.path.push(fnTransfer);
 		        fnTransfer = undefined;
 		      } else {
 		        // input.a.b normal property access just append
 		        obj.path.push(name);
 		      }
 		      // Only create a new function when we are on the root object, otherwise just reuse it.
 		      return new Proxy(obj.root ? childFunction(obj.path) : obj, Handler);
 		    }
 		  };
 		  return new Proxy(rootFunction(), Handler);
 		}
 		  
 		const state = PathRecorder('state', (path, context) => {
 		  return path.reduce((currentState, key) => {
 		    return currentState ? currentState[key] : undefined
 		  }, context.state)
 		});
 		
 		const input = PathRecorder('input', (path, context) => {
 		  return path.reduce((currentState, key) => {
 		    return currentState ? currentState[key] : undefined
 		  }, context.input)
 		});
 		
 		const signal = PathRecorder('signal', (path, context) => {
 		  return context.controller.getSignal(path);
 		});
 		
 		const context = {
 		  input: {
 		    awesome: {
 		      hello: "World"
 		    }
 		  },
 		  state: {
 		    hello: {
 		      a: 'hello',
 		      world: {
 		        'World' : "Awesome!!!!"
 		      }
 		    }
 		  }
 		}
 	};


 	suite.add("state.hello.world[input.awesome[state.hello.a]](context);", function () {
 		state.hello.world[input.awesome[state.hello.a]](context);
 	});

 	suite.on("cycle", function (evt) {
 		console.log(" - " + evt.target);
 	});

 	suite.on("complete", function (evt) {
 		console.log(new Array(30).join("-"));

 		var results = evt.currentTarget.sort(function (a, b) {
 			return b.hz - a.hz;
 		});

 		results.forEach(function (item) {
 			console.log((idx + 1) + ". " + item);
 		});
 	});

 	console.log("Proxy path reader");
 	console.log(new Array(30).join("-"));
 	suite.run();
 });
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8"/>
	<title>Proxy path reader</title>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/1.0.0/benchmark.min.js"></script>
	<script src="./suite.js"></script>
	</head>
	<body>
	<h1>Open the console to view the results</h1>
	<h2><code>cmd + alt + j</code> or <code>ctrl + alt + j</code></h2>
	</body>
	</html>
	"use strict";

	(function (factory) {
	if (typeof Benchmark !== "undefined") {
	factory(Benchmark);
	} else {
	factory(require("benchmark"));
	}
	})(function (Benchmark) {
	var suite = new Benchmark.Suite;

	Benchmark.prototype.setup = function () {
	// Path resolver factory
	// Creates a resolver based on the target, path and resolveValue function
	const createPathResolver = (target, path, resolveValue) => (context) => {
	const resolvedPath = [];
	// resolvePath will contain the actual path by resolving recursively
	for (let i = 0; i < path.length; i++) {
	const curr = path[i]
	resolvedPath.push(
	typeof curr === 'function'
	? curr(context).value
	: curr
	);
	}
	return {
	target,
	path: resolvedPath.join('.'),
	value: resolveValue(resolvedPath, context)
	}
	}

	// Used to transfere a function from toPrimitive to the "parent" object
	let fnTransfer;
	function PathRecorder (target, resolveValue) {
	// Create the root function the proxy is wrapping for the main object
	const rootFunction = () => {
	const f = () => {};
	f.path = [];
	f.root = true;
	return f;
	}

	// Create a child function the proxy is wrapping for all supsequent objects
	const childFunction = (path) => {
	const f = () => {};
	f.path = path;
	return f;
	}

	const toPrimitive = () => '';

	// Handler of all Proxy object
	const Handler = {

	apply(obj, thisArg, values) {
	// Root is called like a tagged template use old behaviour
	if (obj.root) return operators[target].apply(null, values);
	// Cache the function
	obj.cachedFn = obj.cachedFn \|\| createPathResolver(target, obj.path, resolveValue);
	// context is the first parameter
	const context = values[0];
	// Resolve the value and return it.
	return obj.cachedFn(context);
	},

	get(obj, name, proxy) {
	// TODO: This needs to be changed in string`` in cerebral
	// because this could possible go wrong
	if (name === 'getValue') return undefined;
	// cache busting
	obj.cachedFn == undefined;
	// Always start a new path for a root obj
	obj.path = obj.root ? obj.path = [] : obj.path;
	if (name === Symbol.toPrimitive) {
	// create a resolver that will be transfered to the "parent" object
	fnTransfer = createPathResolver(target, obj.path, resolveValue);
	return toPrimitive;
	} else if (fnTransfer !== undefined) {
	// There is a fnTransfere function add it.
	obj.path.push(fnTransfer);
	fnTransfer = undefined;
	} else {
	// input.a.b normal property access just append
	obj.path.push(name);
	}
	// Only create a new function when we are on the root object, otherwise just reuse it.
	return new Proxy(obj.root ? childFunction(obj.path) : obj, Handler);
	}
	};
	return new Proxy(rootFunction(), Handler);
	}

	const state = PathRecorder('state', (path, context) => {
	return path.reduce((currentState, key) => {
	return currentState ? currentState[key] : undefined
	}, context.state)
	});

	const input = PathRecorder('input', (path, context) => {
	return path.reduce((currentState, key) => {
	return currentState ? currentState[key] : undefined
	}, context.input)
	});

	const signal = PathRecorder('signal', (path, context) => {
	return context.controller.getSignal(path);
	});

	const context = {
	input: {
	awesome: {
	hello: "World"
	}
	},
	state: {
	hello: {
	a: 'hello',
	world: {
	'World' : "Awesome!!!!"
	}
	}
	}
	}
	};


	suite.add("state.hello.world[input.awesome[state.hello.a]](context);", function () {
	state.hello.world[input.awesome[state.hello.a]](context);
	});

	suite.on("cycle", function (evt) {
	console.log(" - " + evt.target);
	});

	suite.on("complete", function (evt) {
	console.log(new Array(30).join("-"));

	var results = evt.currentTarget.sort(function (a, b) {
	return b.hz - a.hz;
	});

	results.forEach(function (item) {
	console.log((idx + 1) + ". " + item);
	});
	});

	console.log("Proxy path reader");
	console.log(new Array(30).join("-"));
	suite.run();
	});