feat(temp vars): allow temp vars in expressions and rework them internally

Author: solkimicreb

index.js

@@ -5,14 +5,12 @@ const modifiers = require('./src/modifiers')
 const compiler = require('./src/compiler')
 const rawCompiler = require('./src/rawCompiler')
 
-module.exports = {
-  compileExpression: compiler.compileExpression,
-  compileCode: compiler.compileCode,
-  compileRawExpression: rawCompiler.compileExpression,
-  compileRawCode: rawCompiler.compileCode,
-  expose: context.expose,
-  hide: context.hide,
-  hideAll: context.hideAll,
-  filter: modifiers.filter,
-  limiter: modifiers.limiter
-}
+exports.compileExpression = compiler.compileExpression
+exports.compileCode = compiler.compileCode
+exports.compileRawExpression = rawCompiler.compileExpression
+exports.compileRawCode = rawCompiler.compileCode
+exports.expose = context.expose
+exports.hide = context.hide
+exports.hideAll = context.hideAll
+exports.filter = modifiers.filter
+exports.limiter = modifiers.limiter

src/compiler.js

@@ -24,8 +24,8 @@ function compileExpression (src) {
     return expression
   }
 
-  return function evaluateExpression (context) {
-    let value = expression.exec(context)
+  return function evaluateExpression (context, tempVars) {
+    let value = expression.exec(context, tempVars)
     for (let filter of expression.filters) {
       const args = filter.argExpressions.map(evaluateArgExpression, context)
       value = filter.effect(value, ...args)

src/context.js

@@ -2,14 +2,15 @@
 
 const globals = new Set()
 const proxies = new WeakMap()
-const handlers = {has}
+const tempVarStore = new WeakMap()
+const handlers = {has, get}
 
 let globalObj
 if (typeof window !== 'undefined') globalObj = window // eslint-disable-line
 else if (typeof global !== 'undefined') globalObj = global // eslint-disable-line
 else if (typeof self !== 'undefined') globalObj = self // eslint-disable-line
 globalObj.$nxCompileToSandbox = toSandbox
-globalObj.$nxCompileCreateBackup = createBackup
+globalObj.$nxClearSandbox = clearSandbox
 
 module.exports = {
   expose,
@@ -40,10 +41,16 @@ function has (target, key) {
   return globals.has(key) ? Reflect.has(target, key) : true
 }
 
-function toSandbox (obj) {
-  if (typeof obj !== 'object') {
-    throw new TypeError(`First argument must be an object, instead it is a ${typeof obj}.`)
+function get (target, key, receiver) {
+  const tempVars = tempVarStore.get(target)
+  if (tempVars && (key in tempVars)) {
+    return tempVars[key]
   }
+  return Reflect.get(target, key, receiver)
+}
+
+function toSandbox (obj, tempVars) {
+  tempVarStore.set(obj, tempVars)
   let sandbox = proxies.get(obj)
   if (!sandbox) {
     sandbox = new Proxy(obj, handlers)
@@ -52,12 +59,6 @@ function toSandbox (obj) {
   return sandbox
 }
 
-function createBackup (context, tempVars) {
-  if (typeof tempVars === 'object') {
-    const backup = {}
-    for (let key of Object.keys(tempVars)) {
-      backup[key] = context[key]
-    }
-    return backup
-  }
+function clearSandbox (obj) {
+  tempVarStore.delete(obj)
 }

src/rawCompiler.js

@@ -6,21 +6,17 @@ module.exports = {
 }
 
 function compileExpression (src) {
-  return new Function('context', // eslint-disable-line
-    `const sandbox = $nxCompileToSandbox(context)
+  return new Function('context', 'tempVars', // eslint-disable-line
+    `const sandbox = $nxCompileToSandbox(context, tempVars)
     try { with (sandbox) { return ${src} } } catch (err) {
       if (!(err instanceof TypeError)) throw err
-    }`)
+    }
+    $nxClearSandbox(context)`)
 }
 
 function compileCode (src) {
   return new Function('context', 'tempVars', // eslint-disable-line
-    `const backup = $nxCompileCreateBackup(context, tempVars)
-    Object.assign(context, tempVars)
-    const sandbox = $nxCompileToSandbox(context)
-    try {
-      with (sandbox) { ${src} }
-    } finally {
-      Object.assign(context, backup)
-    }`)
+    `const sandbox = $nxCompileToSandbox(context, tempVars)
+    with (sandbox) { ${src} }
+    $nxClearSandbox(context)`)
 }