Implement miscellaneous fixes and test a handful of setups for precision implementation

Author: TotalTechGeek

compatibility.js

@@ -1,7 +1,9 @@
 import defaultMethods from './defaultMethods.js'
+import { Sync } from './constants.js'
 const oldAll = defaultMethods.all
 
 const all = {
+  [Sync]: defaultMethods.all[Sync],
   method: (args, context, above, engine) => {
     if (Array.isArray(args)) {
       const first = engine.run(args[0], context, above)

defaultMethods.js

@@ -224,6 +224,7 @@ const defaultMethods = {
   // Why "executeInLoop"? Because if it needs to execute to get an array, I do not want to execute the arguments,
   // Both for performance and safety reasons.
   or: {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, _1, _2, engine) => {
       // See "executeInLoop" above
       const executeInLoop = Array.isArray(arr)
@@ -262,6 +263,7 @@ const defaultMethods = {
     traverse: false
   },
   and: {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, _1, _2, engine) => {
       // See "executeInLoop" above
       const executeInLoop = Array.isArray(arr)
@@ -310,6 +312,7 @@ const defaultMethods = {
     return 0
   },
   get: {
+    [Sync]: true,
     method: ([data, key, defaultValue], context, above, engine) => {
       const notFound = defaultValue === undefined ? null : defaultValue
 
@@ -391,6 +394,7 @@ const defaultMethods = {
   some: createArrayIterativeMethod('some', true),
   all: createArrayIterativeMethod('every', true),
   none: {
+    [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     traverse: false,
     // todo: add async build & build
     method: (val, context, above, engine) => {
@@ -411,7 +415,7 @@ const defaultMethods = {
   },
   merge: (arrays) => (Array.isArray(arrays) ? [].concat(...arrays) : [arrays]),
   every: createArrayIterativeMethod('every'),
-  filter: createArrayIterativeMethod('filter'),
+  filter: createArrayIterativeMethod('filter', true),
   reduce: {
     deterministic: (data, buildState) => {
       return (
@@ -521,6 +525,7 @@ const defaultMethods = {
   '!': (value, _1, _2, engine) => Array.isArray(value) ? !engine.truthy(value[0]) : !engine.truthy(value),
   '!!': (value, _1, _2, engine) => Boolean(Array.isArray(value) ? engine.truthy(value[0]) : engine.truthy(value)),
   cat: {
+    [Sync]: true,
     method: (arr) => {
       if (typeof arr === 'string') return arr
       if (!Array.isArray(arr)) return arr.toString()
@@ -659,8 +664,8 @@ function createArrayIterativeMethod (name, useTruthy = false) {
         (await engine.run(selector, context, {
           above
         })) || []
-      return asyncIterators[name](selector, (i, index) => {
-        const result = engine.run(mapper, i, {
+      return asyncIterators[name](selector, async (i, index) => {
+        const result = await engine.run(mapper, i, {
           above: [{ iterator: selector, index }, context, above]
         })
         return useTruthy ? engine.truthy(result) : result
@@ -680,15 +685,16 @@ function createArrayIterativeMethod (name, useTruthy = false) {
 
       const method = build(mapper, mapState)
       const aboveArray = method.aboveDetected ? buildState.compile`[{ iterator: z, index: x }, context, above]` : buildState.compile`null`
+      const useTruthyMethod = useTruthy ? buildState.compile`engine.truthy` : buildState.compile``
 
       if (async) {
         if (!isSyncDeep(mapper, buildState.engine, buildState)) {
           buildState.detectAsync = true
-          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x, z) => ${method}(i, x, ${aboveArray}))`
+          return buildState.compile`await asyncIterators[${name}](${selector} || [], async (i, x, z) => ${useTruthyMethod}(${method}(i, x, ${aboveArray})))`
         }
       }
 
-      return buildState.compile`(${selector} || [])[${name}]((i, x, z) => ${method}(i, x, ${aboveArray}))`
+      return buildState.compile`(${selector} || [])[${name}]((i, x, z) => ${useTruthyMethod}(${method}(i, x, ${aboveArray})))`
     },
     traverse: false
   }

package.json

@@ -37,7 +37,8 @@
   },
   "jest": {
     "testPathIgnorePatterns": [
-      "./bench"
+      "./bench",
+      "./precision"
     ]
   },
   "exports": {

precision/index.js

@@ -1,5 +1,15 @@
-export function configurePrecision (engine, constructor) {
+
+export function configurePrecision (engine, constructor, compatible = true) {
   engine.precision = constructor
+
+  engine.truthy = (data) => {
+    if ((data || false).toNumber) return Number(data)
+    if (compatible && Array.isArray(data) && data.length === 0) return false
+    return data
+  }
+
+  if (engine.fallback) engine.fallback.truthy = engine.truthy
+
   engine.addMethod('+', {
     method: (data) => {
       if (typeof data === 'string') return constructor(data)
@@ -15,30 +25,28 @@ export function configurePrecision (engine, constructor) {
         return res
       }
       return false
-    },
-    optimizeUnary: true,
-    deterministic: true
-  })
+    }
+  }, { optimizeUnary: true, sync: true, deterministic: true })
 
   engine.addMethod('-', {
     method: (data) => {
       if (typeof data === 'string') return constructor(data).mul(-1)
       if (typeof data === 'number') return constructor(data).mul(-1)
       let res = constructor(data[0])
+      if (data.length === 1) return res.mul(-1)
       for (let i = 1; i < data.length; i++) res = res.minus(data[i])
       return res
     },
     compile: (args, buildState) => {
       if (Array.isArray(args)) {
         let res = buildState.compile`(engine.precision(${args[0]}))`
+        if (args.length === 1) return buildState.compile`(${res}.mul(-1))`
         for (let i = 1; i < args.length; i++) res = buildState.compile`(${res}.minus(${args[i]}))`
         return res
       }
       return false
-    },
-    optimizeUnary: true,
-    deterministic: true
-  })
+    }
+  }, { optimizeUnary: true, sync: true, deterministic: true })
 
   engine.addMethod('*', {
     method: (data) => {
@@ -53,10 +61,8 @@ export function configurePrecision (engine, constructor) {
         return res
       }
       return false
-    },
-    deterministic: true,
-    precise: true
-  })
+    }
+  }, { sync: true, deterministic: true })
 
   engine.addMethod('/', {
     method: (data) => {
@@ -71,9 +77,8 @@ export function configurePrecision (engine, constructor) {
         return res
       }
       return false
-    },
-    deterministic: true
-  })
+    }
+  }, { sync: true, deterministic: true })
 
   engine.addMethod('%', {
     method: (data) => {
@@ -88,7 +93,39 @@ export function configurePrecision (engine, constructor) {
         return res
       }
       return false
+    }
+  }, { sync: true, deterministic: true })
+
+  engine.addMethod('===', {
+    method: (args) => {
+      if (args.length === 2) {
+        if (args[0].eq) return args[0].eq(args[1])
+        if (args[1].eq) return args[1].eq(args[0])
+        return args[0] === args[1]
+      }
+      for (let i = 1; i < args.length; i++) {
+        if (args[i - 1].eq && !args[i - 1].eq(args[i])) return false
+        if (args[i].eq && !args[i].eq(args[i - 1])) return false
+        if (args[i - 1] !== args[i]) return false
+      }
+      return true
+    }
+  }, { sync: true, deterministic: true })
+
+  engine.addMethod('!==', {
+    method: (args) => {
+      if (args.length === 2) {
+        if (args[0].eq) return !args[0].eq(args[1])
+        if (args[1].eq) return !args[1].eq(args[0])
+        return args[0] !== args[1]
+      }
+      for (let i = 1; i < args.length; i++) {
+        if (args[i - 1].eq && args[i - 1].eq(args[i])) return false
+        if (args[i].eq && args[i].eq(args[i - 1])) return false
+        if (args[i - 1] !== args[i]) return true
+      }
+      return false
     },
     deterministic: true
-  })
+  }, { sync: true, deterministic: true })
 }

precision/test.js

@@ -0,0 +1,34 @@
+import { AsyncLogicEngine } from '../index.js'
+import { Decimal } from 'decimal.js'
+import { configurePrecision } from './index.js'
+import { isDeepStrictEqual } from 'util'
+
+import fs from 'fs'
+
+const tests = JSON.parse(fs.readFileSync('../bench/tests.json').toString())
+
+Decimal.prototype.toString = function () {
+  return this.toFixed()
+}
+
+Decimal.prototype.valueOf = function () {
+  return this.toFixed()
+}
+
+const decimalEngine = new AsyncLogicEngine(undefined, { compatible: true })
+configurePrecision(decimalEngine, Decimal.clone({ precision: 100 }))
+
+let count = 0
+for (const test of tests) {
+  if (typeof test !== 'string') {
+    let result = await decimalEngine.run(test[0], test[1])
+    if (result && result.toNumber) result = Number(result)
+    if (Array.isArray(result)) result = result.map((x) => (x && x.toNumber ? Number(x) : x))
+    if (!isDeepStrictEqual(result, test[2])) {
+      count++
+      console.log(test[0], test[2], result)
+    }
+  }
+}
+
+console.log(count, 'Wrong')