Improve compiler performance by reducing arguments passed into methods and removing unnecessary array allocations for "above" when it's not used.

Author: TotalTechGeek

compiler.js

@@ -6,11 +6,11 @@ import {
   Sync,
   Compiled
 } from './constants.js'
-import declareSync from './utilities/declareSync.js'
 
 // asyncIterators is required for the compiler to operate as intended.
 import asyncIterators from './async_iterators.js'
 import { coerceArray } from './utilities/coerceArray.js'
+import { countArguments } from './utilities/countArguments.js'
 
 /**
  * Provides a simple way to compile logic into a function that can be run.
@@ -208,17 +208,22 @@ function buildString (method, buildState = {}) {
     if (!coerce && Array.isArray(lower) && lower.length === 1) lower = lower[0]
     else if (coerce && Array.isArray(lower)) coerce = ''
 
+    const argumentsDict = [', context', ', context, above', ', context, above, engine']
+
     if (typeof engine.methods[func] === 'function') {
       asyncDetected = !isSync(engine.methods[func])
-      return makeAsync(`engine.methods["${func}"](${coerce}(` + buildString(lower, buildState) + '), context, above, engine)')
+      const argumentsNeeded = argumentsDict[countArguments(engine.methods[func]) - 1] || argumentsDict[2]
+      return makeAsync(`engine.methods["${func}"](${coerce}(` + buildString(lower, buildState) + ')' + argumentsNeeded + ')')
     } else {
+      asyncDetected = Boolean(async && engine.methods[func] && engine.methods[func].asyncMethod)
+      const argCount = countArguments(asyncDetected ? engine.methods[func].asyncMethod : engine.methods[func].method)
+      const argumentsNeeded = argumentsDict[argCount - 1] || argumentsDict[2]
+
       if (engine.methods[func] && (typeof engine.methods[func].traverse === 'undefined' ? true : engine.methods[func].traverse)) {
-        asyncDetected = Boolean(async && engine.methods[func] && engine.methods[func].asyncMethod)
-        return makeAsync(`engine.methods["${func}"]${asyncDetected ? '.asyncMethod' : '.method'}(${coerce}(` + buildString(lower, buildState) + '), context, above, engine)')
+        return makeAsync(`engine.methods["${func}"]${asyncDetected ? '.asyncMethod' : '.method'}(${coerce}(` + buildString(lower, buildState) + ')' + argumentsNeeded + ')')
       } else {
-        asyncDetected = Boolean(async && engine.methods[func] && engine.methods[func].asyncMethod)
         notTraversed.push(lower)
-        return makeAsync(`engine.methods["${func}"]${asyncDetected ? '.asyncMethod' : '.method'}(` + `notTraversed[${notTraversed.length - 1}]` + ', context, above, engine)')
+        return makeAsync(`engine.methods["${func}"]${asyncDetected ? '.asyncMethod' : '.method'}(` + `notTraversed[${notTraversed.length - 1}]` + argumentsNeeded + ')')
       }
     }
   }
@@ -303,11 +308,14 @@ function processBuiltString (method, str, buildState) {
   })
 
   const final = `(values, methods, notTraversed, asyncIterators, engine, above, coerceArray) => ${buildState.asyncDetected ? 'async' : ''} (context ${buildState.extraArguments ? ',' + buildState.extraArguments : ''}) => { const result = ${str}; return result }`
-
   // console.log(str)
   // console.log(final)
   // eslint-disable-next-line no-eval
-  return declareSync((typeof globalThis !== 'undefined' ? globalThis : global).eval(final)(values, methods, notTraversed, asyncIterators, engine, above, coerceArray), !buildState.asyncDetected)
+  return Object.assign(
+    (typeof globalThis !== 'undefined' ? globalThis : global).eval(final)(values, methods, notTraversed, asyncIterators, engine, above, coerceArray), {
+      [Sync]: !buildState.asyncDetected,
+      aboveDetected: str.includes(', above')
+    })
 }
 
 export { build }

defaultMethods.js

@@ -310,28 +310,30 @@ const defaultMethods = {
         avoidInlineAsync: true
       }
       mapper = build(mapper, mapState)
+      const aboveArray = mapper.aboveDetected ? '[null, context, above]' : 'null'
+
       buildState.methods.push(mapper)
       if (async) {
         if (!isSync(mapper) || selector.includes('await')) {
           buildState.detectAsync = true
           if (typeof defaultValue !== 'undefined') {
             return `await asyncIterators.reduce(${selector} || [], (a,b) => methods[${
               buildState.methods.length - 1
-            }]({ accumulator: a, current: b }, [null, context, above]), ${defaultValue})`
+            }]({ accumulator: a, current: b }, ${aboveArray}), ${defaultValue})`
           }
           return `await asyncIterators.reduce(${selector} || [], (a,b) => methods[${
             buildState.methods.length - 1
-          }]({ accumulator: a, current: b }, [null, context, above]))`
+          }]({ accumulator: a, current: b }, ${aboveArray}))`
         }
       }
       if (typeof defaultValue !== 'undefined') {
         return `(${selector} || []).reduce((a,b) => methods[${
           buildState.methods.length - 1
-        }]({ accumulator: a, current: b }, [null, context, above]), ${defaultValue})`
+        }]({ accumulator: a, current: b }, ${aboveArray}), ${defaultValue})`
       }
       return `(${selector} || []).reduce((a,b) => methods[${
         buildState.methods.length - 1
-      }]({ accumulator: a, current: b }, [null, context, above]))`
+      }]({ accumulator: a, current: b }, ${aboveArray}))`
     },
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw new InvalidControlInput(input)
@@ -536,14 +538,17 @@ function createArrayIterativeMethod (name, useTruthy = false) {
         extraArguments: 'index, above'
       }
 
+      const method = build(mapper, mapState)
+      const aboveArray = method.aboveDetected ? buildState.compile`[{ item: null }, context, above]` : buildState.compile`null`
+
       if (async) {
         if (!isSyncDeep(mapper, buildState.engine, buildState)) {
           buildState.detectAsync = true
-          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x) => ${build(mapper, mapState)}(i, x, [{ item: null }, context, above]))`
+          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x) => ${method}(i, x, ${aboveArray}))`
         }
       }
 
-      return buildState.compile`(${selector} || [])[${name}]((i, x) => ${build(mapper, mapState)}(i, x, [{ item: null }, context, above]))`
+      return buildState.compile`(${selector} || [])[${name}]((i, x) => ${method}(i, x, ${aboveArray}))`
     },
     traverse: false
   }

package.json

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

utilities/countArguments.js

@@ -0,0 +1,32 @@
+const counts = new WeakMap()
+
+/**
+ * Counts the number of arguments a function has; paying attention to the function's signature
+ * to avoid edge cases.
+ * This is used to allow for compiler optimizations.
+ * @param {(...args: any[]) => any} fn
+ * @returns {number}
+ */
+export function countArguments (fn) {
+  if (!fn || typeof fn !== 'function' || !fn.length) return 0
+  if (!counts.has(fn)) counts.set(fn, _countArguments(fn))
+  return counts.get(fn)
+}
+
+/**
+ * Counts the number of arguments a function has; paying attention to the function's signature.
+ * This is the internal implementation that does not use a WeakMap.
+ * @param {(...args: any[]) => any} fn
+ * @returns {number}
+ */
+function _countArguments (fn) {
+  if (!fn || typeof fn !== 'function' || !fn.length) return 0
+  let fnStr = fn.toString()
+  if (fnStr[0] !== '(' && fnStr[0] !== 'f') return 0
+  fnStr = fnStr.substring(fnStr.indexOf('('), fnStr.indexOf('{')).replace(/=>/g, '')
+
+  // regex to check for "..." or "="
+  const regex = /\.{3}|=/
+  if (regex.test(fnStr)) return 0
+  return fn.length
+}