Some additional style touch ups and eliminate an unused feature in the compiler that is kind of redundant.

Author: TotalTechGeek

asyncLogic.js

@@ -72,30 +72,20 @@ class AsyncLogicEngine {
     const data = logic[func]
 
     if (this.isData(logic, func)) return logic
-
     if (!this.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
 
     if (typeof this.methods[func] === 'function') {
       const input = await this.run(data, context, { above })
-
       const result = await this.methods[func](input, context, above, this)
       return Array.isArray(result) ? Promise.all(result) : result
     }
 
     if (typeof this.methods[func] === 'object') {
       const { asyncMethod, method, traverse } = this.methods[func]
-      const shouldTraverse =
-          typeof traverse === 'undefined' ? true : traverse
-      const parsedData = shouldTraverse
-        ? await this.run(data, context, { above })
-        : data
-
-      const result = await (asyncMethod || method)(
-        parsedData,
-        context,
-        above,
-        this
-      )
+      const shouldTraverse = typeof traverse === 'undefined' ? true : traverse
+      const parsedData = shouldTraverse ? await this.run(data, context, { above }) : data
+
+      const result = await (asyncMethod || method)(parsedData, context, above, this)
       return Array.isArray(result) ? Promise.all(result) : result
     }
 
@@ -118,14 +108,9 @@ class AsyncLogicEngine {
     if (typeof async !== 'undefined') sync = !async
 
     if (typeof method === 'function') {
-      if (async) {
-        method = { asyncMethod: method, traverse: true }
-      } else {
-        method = { method, traverse: true }
-      }
-    } else {
-      method = { ...method }
-    }
+      if (async) method = { asyncMethod: method, traverse: true }
+      else method = { method, traverse: true }
+    } else method = { ...method }
 
     Object.assign(method, omitUndefined({ deterministic, useContext }))
     // @ts-ignore
@@ -141,13 +126,7 @@ class AsyncLogicEngine {
    */
   addModule (name, obj, annotations = {}) {
     Object.getOwnPropertyNames(obj).forEach((key) => {
-      if (typeof obj[key] === 'function' || typeof obj[key] === 'object') {
-        this.addMethod(
-          `${name}${name ? '.' : ''}${key}`,
-          obj[key],
-          annotations
-        )
-      }
+      if (typeof obj[key] === 'function' || typeof obj[key] === 'object') this.addMethod(`${name}${name ? '.' : ''}${key}`, obj[key], annotations)
     })
   }
 
@@ -210,39 +189,22 @@ class AsyncLogicEngine {
     const { above = [], top = true } = options
     this.fallback.truthy = this.truthy
     if (top) {
-      const constructedFunction = await buildAsync(logic, {
-        engine: this,
-        above,
-        async: true,
-        state: {}
-      })
+      const constructedFunction = await buildAsync(logic, { engine: this, above, async: true, state: {} })
 
       const result = declareSync((...args) => {
         if (top === true) {
           try {
-            const result =
-              typeof constructedFunction === 'function'
-                ? constructedFunction(...args)
-                : constructedFunction
+            const result = typeof constructedFunction === 'function' ? constructedFunction(...args) : constructedFunction
             return Promise.resolve(result)
           } catch (err) {
             return Promise.reject(err)
           }
         }
 
-        const result =
-          typeof constructedFunction === 'function'
-            ? constructedFunction(...args)
-            : constructedFunction
-
-        return result
+        return typeof constructedFunction === 'function' ? constructedFunction(...args) : constructedFunction
       }, top !== true && isSync(constructedFunction))
-
-      return typeof constructedFunction === 'function' || top === true
-        ? result
-        : constructedFunction
+      return typeof constructedFunction === 'function' || top === true ? result : constructedFunction
     }
-
     return logic
   }
 }

compiler.js

@@ -89,9 +89,7 @@ export function isDeterministic (method, engine, buildState) {
 function isDeepSync (method, engine) {
   if (!engine.async) return true
 
-  if (Array.isArray(method)) {
-    return method.every(i => isDeepSync(i, engine))
-  }
+  if (Array.isArray(method)) return method.every(i => isDeepSync(i, engine))
 
   if (typeof method === 'object') {
     const func = Object.keys(method)[0]
@@ -120,10 +118,10 @@ function buildString (method, buildState = {}) {
   const {
     notTraversed = [],
     functions = {},
-    methods = [],
-    state,
+    // methods = [],
+    // state,
     async,
-    above = [],
+    // above = [],
     processing = [],
     values = [],
     engine
@@ -147,16 +145,12 @@ function buildString (method, buildState = {}) {
 
   function makeAsync (result) {
     buildState.asyncDetected = buildState.asyncDetected || asyncDetected
-
-    if (async && asyncDetected) {
-      return `await ${result}`
-    }
+    if (async && asyncDetected) return `await ${result}`
     return result
   }
 
   const func = method && Object.keys(method)[0]
-  buildState.useContext =
-    buildState.useContext || (engine.methods[func] || {}).useContext
+  buildState.useContext = buildState.useContext || (engine.methods[func] || {}).useContext
 
   if (method && typeof method === 'object') {
     if (!func) return pushValue(method)
@@ -192,62 +186,20 @@ function buildString (method, buildState = {}) {
       functions[func] = 1
       asyncDetected = !isSync(engine.methods[func])
 
-      return makeAsync(
-        `gen["${func}"](` + buildString(method[func], buildState) + ')'
-      )
+      return makeAsync(`gen["${func}"](` + buildString(method[func], buildState) + ')')
     } else {
       if (engine.methods[func] && (typeof engine.methods[func].traverse === 'undefined' ? true : engine.methods[func].traverse)) {
         functions[func] = 1
-        asyncDetected = Boolean(
-          async && engine.methods[func] && engine.methods[func].asyncMethod
-        )
+        asyncDetected = Boolean(async && engine.methods[func] && engine.methods[func].asyncMethod)
 
-        return makeAsync(
-          `gen["${func}"](` + buildString(method[func], buildState) + ')'
-        )
+        return makeAsync(`gen["${func}"](` + buildString(method[func], buildState) + ')')
       } else {
-        if (engine.methods[func]) {
-          if (async) {
-            if (engine.methods[func].asyncBuild || engine.methods[func].build) {
-              const builder =
-                engine.methods[func].asyncBuild || engine.methods[func].build
-              const result = builder(
-                method[func],
-                state,
-                above,
-                engine,
-                buildState
-              )
-              methods.push(result)
-              asyncDetected = !isSync(result)
-              return makeAsync(`methods[${methods.length - 1}]()`)
-            }
-          } else {
-            if (engine.methods[func].build) {
-              methods.push(
-                engine.methods[func].build(
-                  method[func],
-                  state,
-                  above,
-                  engine,
-                  buildState
-                )
-              )
-              return makeAsync(`methods[${methods.length - 1}]()`)
-            }
-          }
-        }
-
-        asyncDetected = Boolean(
-          async && engine.methods[func] && engine.methods[func].asyncMethod
-        )
+        asyncDetected = Boolean(async && engine.methods[func] && engine.methods[func].asyncMethod)
 
         functions[func] = 1
         notTraversed.push(method[func])
 
-        return makeAsync(
-          `gen["${func}"](` + `notTraversed[${notTraversed.length - 1}]` + ')'
-        )
+        return makeAsync(`gen["${func}"](` + `notTraversed[${notTraversed.length - 1}]` + ')')
       }
     }
   }
@@ -354,18 +306,14 @@ function processBuiltString (method, str, buildState) {
     }
   })
 
-  if (!Object.keys(functions).length) {
-    return method
-  }
+  if (!Object.keys(functions).length) return method
 
   let copyStateCall = 'state[Override] = context;'
   // console.log(buildState.useContext)
 
   if (!buildState.useContext) {
     copyStateCall = ''
-    while (str.includes('state[Override]')) {
-      str = str.replace('state[Override]', 'context')
-    }
+    str = str.replace(/state\[Override\]/g, 'context')
   }
 
   methods.truthy = engine.truthy

logic.js

@@ -41,9 +41,7 @@ class LogicEngine {
     this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization }
     if (!this.isData) {
       if (!options.permissive) this.isData = () => false
-      else {
-        this.isData = (data, key) => !(key in this.methods)
-      }
+      else this.isData = (data, key) => !(key in this.methods)
     }
   }
 
@@ -80,10 +78,7 @@ class LogicEngine {
     if (typeof this.methods[func] === 'object') {
       const { method, traverse } = this.methods[func]
       const shouldTraverse = typeof traverse === 'undefined' ? true : traverse
-      const parsedData = shouldTraverse
-        ? this.run(data, context, { above })
-        : data
-
+      const parsedData = shouldTraverse ? this.run(data, context, { above }) : data
       return method(parsedData, context, above, this)
     }
 
@@ -97,11 +92,8 @@ class LogicEngine {
    * @param {{ deterministic?: Boolean, useContext?: Boolean }} annotations This is used by the compiler to help determine if it can optimize the function being generated.
    */
   addMethod (name, method, { deterministic, useContext } = {}) {
-    if (typeof method === 'function') {
-      method = { method, traverse: true }
-    } else {
-      method = { ...method }
-    }
+    if (typeof method === 'function') method = { method, traverse: true }
+    else method = { ...method }
 
     Object.assign(method, omitUndefined({ useContext, deterministic }))
     this.methods[name] = declareSync(method)
@@ -115,13 +107,7 @@ class LogicEngine {
    */
   addModule (name, obj, annotations) {
     Object.getOwnPropertyNames(obj).forEach((key) => {
-      if (typeof obj[key] === 'function' || typeof obj[key] === 'object') {
-        this.addMethod(
-          `${name}${name ? '.' : ''}${key}`,
-          obj[key],
-          annotations
-        )
-      }
+      if (typeof obj[key] === 'function' || typeof obj[key] === 'object') this.addMethod(`${name}${name ? '.' : ''}${key}`, obj[key], annotations)
     })
   }
 
@@ -181,18 +167,8 @@ class LogicEngine {
   build (logic, options = {}) {
     const { above = [], top = true } = options
     if (top) {
-      const constructedFunction = build(logic, {
-        state: {},
-        engine: this,
-        above
-      })
-      if (typeof constructedFunction === 'function' || top === true) {
-        return (...args) => {
-          return typeof constructedFunction === 'function'
-            ? constructedFunction(...args)
-            : constructedFunction
-        }
-      }
+      const constructedFunction = build(logic, { state: {}, engine: this, above })
+      if (typeof constructedFunction === 'function' || top === true) return (...args) => typeof constructedFunction === 'function' ? constructedFunction(...args) : constructedFunction
       return constructedFunction
     }
     return logic

package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-logic-engine",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "description": "Construct complex rules with JSON & process them.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",