Further improve interpreted mode performance when the optimizer is disabled. This should make interpreted mode in JLE within 3% of JLJS, and optimized interpreted mode about 2.3x faster

Author: TotalTechGeek

asyncLogic.js

@@ -46,21 +46,21 @@ class AsyncLogicEngine {
    * @param {*} logic The logic being executed.
    * @param {*} context The context of the logic being run (input to the function.)
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
-   * @returns {Promise<{ func: string, result: * }>}
+   * @returns {Promise<*>}
    */
   async _parse (logic, context, above) {
     const [func] = Object.keys(logic)
     const data = logic[func]
 
-    if (this.isData(logic, func)) return { result: 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 { result: Array.isArray(result) ? Promise.all(result) : result, func }
+      return Array.isArray(result) ? Promise.all(result) : result
     }
 
     if (typeof this.methods[func] === 'object') {
@@ -77,7 +77,7 @@ class AsyncLogicEngine {
         above,
         this
       )
-      return { result: Array.isArray(result) ? Promise.all(result) : result, func }
+      return Array.isArray(result) ? Promise.all(result) : result
     }
 
     throw new Error(`Method '${func}' is not set up properly.`)
@@ -176,10 +176,7 @@ class AsyncLogicEngine {
       return result
     }
 
-    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) {
-      const { result } = await this._parse(logic, data, above)
-      return result
-    }
+    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) return this._parse(logic, data, above)
 
     return logic
   }

defaultMethods.js

@@ -7,7 +7,7 @@ import declareSync from './utilities/declareSync.js'
 import { build, buildString } from './compiler.js'
 import chainingSupported from './utilities/chainingSupported.js'
 import InvalidControlInput from './errors/InvalidControlInput.js'
-import { splitPath } from './utilities/splitPath.js'
+import { splitPathMemoized } from './utilities/splitPath.js'
 
 function isDeterministic (method, engine, buildState) {
   if (Array.isArray(method)) {
@@ -34,17 +34,36 @@ function isDeterministic (method, engine, buildState) {
 }
 
 const defaultMethods = {
-  '+': (data) => [].concat(data).reduce((a, b) => +a + +b, 0),
-  '*': (data) => data.reduce((a, b) => +a * +b),
-  '/': (data) => data.reduce((a, b) => +a / +b),
-
-  '-': (data) =>
-  // @ts-ignore Type checking is incorrect on the following line.
-    ((a) => (a.length === 1 ? (a[0] = -a[0]) : a) & 0 || a)(
-      [].concat(data)
-      // @ts-ignore Type checking is incorrect on the following line.
-    ).reduce((a, b) => +a - +b),
-  '%': (data) => data.reduce((a, b) => +a % +b),
+  '+': (data) => {
+    if (typeof data === 'string') return +data
+    if (typeof data === 'number') return +data
+    let res = 0
+    for (let i = 0; i < data.length; i++) res += +data[i]
+    return res
+  },
+  '*': (data) => {
+    let res = 1
+    for (let i = 0; i < data.length; i++) res *= +data[i]
+    return res
+  },
+  '/': (data) => {
+    let res = data[0]
+    for (let i = 1; i < data.length; i++) res /= +data[i]
+    return res
+  },
+  '-': (data) => {
+    if (typeof data === 'string') return -data
+    if (typeof data === 'number') return -data
+    if (data.length === 1) return -data[0]
+    let res = data[0]
+    for (let i = 1; i < data.length; i++) res -= +data[i]
+    return res
+  },
+  '%': (data) => {
+    let res = data[0]
+    for (let i = 1; i < data.length; i++) res %= +data[i]
+    return res
+  },
   max: (data) => Math.max(...data),
   min: (data) => Math.min(...data),
   in: ([item, array]) => (array || []).includes(item),
@@ -145,8 +164,18 @@ const defaultMethods = {
   '!=': ([a, b]) => a != b,
   '!==': ([a, b]) => a !== b,
   xor: ([a, b]) => a ^ b,
-  or: (arr) => arr.reduce((a, b) => a || b, false),
-  and: (arr) => arr.reduce((a, b) => a && b),
+  or: (arr) => {
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i]) return arr[i]
+    }
+    return arr[arr.length - 1]
+  },
+  and: (arr) => {
+    for (let i = 0; i < arr.length; i++) {
+      if (!arr[i]) return arr[i]
+    }
+    return arr[arr.length - 1]
+  },
   substr: ([string, from, end]) => {
     if (end < 0) {
       const result = string.substr(from)
@@ -163,7 +192,7 @@ const defaultMethods = {
     method: ([data, key, defaultValue], context, above, engine) => {
       const notFound = defaultValue === undefined ? null : defaultValue
 
-      const subProps = splitPath(String(key))
+      const subProps = splitPathMemoized(String(key))
       for (let i = 0; i < subProps.length; i++) {
         if (data === null || data === undefined) {
           return notFound
@@ -205,7 +234,7 @@ const defaultMethods = {
       }
       return null
     }
-    const subProps = splitPath(String(key))
+    const subProps = splitPathMemoized(String(key))
     for (let i = 0; i < subProps.length; i++) {
       if (context === null || context === undefined) {
         return notFound
@@ -815,7 +844,7 @@ defaultMethods.get.compile = function (data, buildState) {
     if (key && typeof key === 'object') return false
 
     key = key.toString()
-    const pieces = splitPath(key)
+    const pieces = splitPathMemoized(key)
     if (!chainingSupported) {
       return `(((a,b) => (typeof a === 'undefined' || a === null) ? b : a)(${pieces.reduce(
         (text, i) => {
@@ -864,7 +893,7 @@ defaultMethods.var.compile = function (data, buildState) {
       buildState.useContext = true
       return false
     }
-    const pieces = splitPath(key)
+    const pieces = splitPathMemoized(key)
     const [top] = pieces
     buildState.varTop.add(top)
 

index.js

@@ -7,9 +7,9 @@ import Compiler from './compiler.js'
 import Constants from './constants.js'
 import defaultMethods from './defaultMethods.js'
 import { asLogicSync, asLogicAsync } from './asLogic.js'
-import { splitPath } from './utilities/splitPath.js'
+import { splitPath, splitPathMemoized } from './utilities/splitPath.js'
 
-export { splitPath }
+export { splitPath, splitPathMemoized }
 export { LogicEngine }
 export { AsyncLogicEngine }
 export { Compiler }
@@ -18,4 +18,4 @@ export { defaultMethods }
 export { asLogicSync }
 export { asLogicAsync }
 
-export default { LogicEngine, AsyncLogicEngine, Compiler, Constants, defaultMethods, asLogicSync, asLogicAsync, splitPath }
+export default { LogicEngine, AsyncLogicEngine, Compiler, Constants, defaultMethods, asLogicSync, asLogicAsync, splitPath, splitPathMemoized }

logic.js

@@ -49,13 +49,13 @@ class LogicEngine {
     const [func] = Object.keys(logic)
     const data = logic[func]
 
-    if (this.isData(logic, func)) return { result: 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 = this.run(data, context, { above })
-      return { result: this.methods[func](input, context, above, this), func }
+      return this.methods[func](input, context, above, this)
     }
 
     if (typeof this.methods[func] === 'object') {
@@ -65,7 +65,7 @@ class LogicEngine {
         ? this.run(data, context, { above })
         : data
 
-      return { result: method(parsedData, context, above, this), func }
+      return method(parsedData, context, above, this)
     }
 
     throw new Error(`Method '${func}' is not set up properly.`)
@@ -144,10 +144,7 @@ class LogicEngine {
 
     if (Array.isArray(logic)) return logic.map((i) => this.run(i, data, { above }))
 
-    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) {
-      const { result } = this._parse(logic, data, above)
-      return result
-    }
+    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) return this._parse(logic, data, above)
 
     return logic
   }

package.json

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

utilities/splitPath.js

@@ -1,3 +1,24 @@
+const parsedPaths = new Map()
+
+/**
+ * Splits a path string into an array of parts; lightly memoized.
+ * It will reset the entire cache after 2048 paths, this could be improved
+ * by implementing an LRU cache or something, but I'm trying to keep
+ * this library fairly dep free, and the code not too cumbersome.
+ *
+ * Memoizing the splitPath function can be seen as cheating, but I think it's likely
+ * that a lot of the same paths will be used for logic, so it's a good optimization.
+ *
+ * @param {string} str
+ * @returns {string[]}
+ */
+export function splitPathMemoized (str) {
+  if (parsedPaths.has(str)) return parsedPaths.get(str)
+  if (parsedPaths.size > 2048) parsedPaths.clear()
+  const parts = splitPath(str)
+  parsedPaths.set(str, parts)
+  return parts
+}
 
 /**
  * Splits a path string into an array of parts.
@@ -34,6 +55,5 @@ export function splitPath (str, separator = '.', escape = '\\') {
     } else current += char
   }
   parts.push(current)
-
   return parts
 }