Switch to compatibility by default.

Author: TotalTechGeek

asyncLogic.js

@@ -8,7 +8,6 @@ import declareSync from './utilities/declareSync.js'
 import { buildAsync } from './compiler.js'
 import omitUndefined from './utilities/omitUndefined.js'
 import { optimize } from './async_optimizer.js'
-import { applyPatches } from './compatibility.js'
 import { coerceArray } from './utilities/coerceArray.js'
 
 /**
@@ -24,7 +23,7 @@ class AsyncLogicEngine {
    * - In mainline: empty arrays are falsey; in our implementation, they are truthy.
    *
    * @param {Object} methods An object that stores key-value pairs between the names of the commands & the functions they execute.
-   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: boolean, permissive?: boolean, compatible?: boolean }} options
+   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: boolean, permissive?: boolean }} options
    */
   constructor (
     methods = defaultMethods,
@@ -38,8 +37,6 @@ class AsyncLogicEngine {
     this.async = true
     this.fallback = new LogicEngine(methods, options)
 
-    if (options.compatible) applyPatches(this)
-
     this.optimizedMap = new WeakMap()
     this.missesSinceSeen = 0
 
@@ -58,6 +55,8 @@ class AsyncLogicEngine {
    * @returns
    */
   truthy (value) {
+    if (Array.isArray(value) && value.length === 0) return false
+    if (Number.isNaN(value)) return true
     return value
   }
 
@@ -216,5 +215,4 @@ class AsyncLogicEngine {
     return logic
   }
 }
-Object.assign(AsyncLogicEngine.prototype.truthy, { [OriginalImpl]: true })
 export default AsyncLogicEngine

compatibility.js

@@ -52,6 +52,7 @@ function isSyncDeep (method, engine, buildState) {
   return true
 }
 
+const oldAll = createArrayIterativeMethod('every', true)
 const defaultMethods = {
   '+': (data) => {
     if (!data) return 0
@@ -278,17 +279,13 @@ const defaultMethods = {
     },
     deterministic: (data, buildState) => isDeterministic(data, buildState.engine, buildState),
     compile: (data, buildState) => {
-      if (!buildState.engine.truthy[OriginalImpl]) {
-        let res = buildState.compile``
-        if (Array.isArray(data) && data.length) {
-          for (let i = 0; i < data.length; i++) res = buildState.compile`${res} engine.truthy(prev = ${data[i]}) ? prev : `
-          res = buildState.compile`${res} prev`
-          return res
-        }
-        return false
+      let res = buildState.compile``
+      if (Array.isArray(data) && data.length) {
+        for (let i = 0; i < data.length; i++) res = buildState.compile`${res} engine.truthy(prev = ${data[i]}) ? prev : `
+        res = buildState.compile`${res} prev`
+        return res
       }
-      if (Array.isArray(data) && data.length) return `(${data.map((i) => buildString(i, buildState)).join(' || ')})`
-      return `(${buildString(data, buildState)}).reduce((a,b) => a||b, false)`
+      return false
     },
     lazy: true
   },
@@ -323,17 +320,13 @@ const defaultMethods = {
     lazy: true,
     deterministic: (data, buildState) => isDeterministic(data, buildState.engine, buildState),
     compile: (data, buildState) => {
-      if (!buildState.engine.truthy[OriginalImpl]) {
-        let res = buildState.compile``
-        if (Array.isArray(data) && data.length) {
-          for (let i = 0; i < data.length; i++) res = buildState.compile`${res} !engine.truthy(prev = ${data[i]}) ? prev : `
-          res = buildState.compile`${res} prev`
-          return res
-        }
-        return false
+      let res = buildState.compile``
+      if (Array.isArray(data) && data.length) {
+        for (let i = 0; i < data.length; i++) res = buildState.compile`${res} !engine.truthy(prev = ${data[i]}) ? prev : `
+        res = buildState.compile`${res} prev`
+        return res
       }
-      if (Array.isArray(data) && data.length) return `(${data.map((i) => buildString(i, buildState)).join(' && ')})`
-      return `(${buildString(data, buildState)}).reduce((a,b) => a&&b, true)`
+      return false
     }
   },
   substr: ([string, from, end]) => {
@@ -441,7 +434,25 @@ const defaultMethods = {
   },
   map: createArrayIterativeMethod('map'),
   some: createArrayIterativeMethod('some', true),
-  all: createArrayIterativeMethod('every', true),
+  all: {
+    [Sync]: oldAll[Sync],
+    method: (args, context, above, engine) => {
+      if (Array.isArray(args)) {
+        const first = engine.run(args[0], context, above)
+        if (Array.isArray(first) && first.length === 0) return false
+      }
+      return oldAll.method(args, context, above, engine)
+    },
+    asyncMethod: async (args, context, above, engine) => {
+      if (Array.isArray(args)) {
+        const first = await engine.run(args[0], context, above)
+        if (Array.isArray(first) && first.length === 0) return false
+      }
+      return oldAll.asyncMethod(args, context, above, engine)
+    },
+    deterministic: oldAll.deterministic,
+    lazy: oldAll.lazy
+  },
   none: {
     [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     lazy: true,
@@ -450,12 +461,7 @@ const defaultMethods = {
       return !defaultMethods.some.method(val, context, above, engine)
     },
     asyncMethod: async (val, context, above, engine) => {
-      return !(await defaultMethods.some.asyncMethod(
-        val,
-        context,
-        above,
-        engine
-      ))
+      return !(await defaultMethods.some.asyncMethod(val, context, above, engine))
     },
     compile: (data, buildState) => {
       const result = defaultMethods.some.compile(data, buildState)

defaultMethods.js

@@ -7,7 +7,6 @@ import { build } from './compiler.js'
 import declareSync from './utilities/declareSync.js'
 import omitUndefined from './utilities/omitUndefined.js'
 import { optimize } from './optimizer.js'
-import { applyPatches } from './compatibility.js'
 import { coerceArray } from './utilities/coerceArray.js'
 import { OriginalImpl } from './constants.js'
 
@@ -17,14 +16,9 @@ import { OriginalImpl } from './constants.js'
 class LogicEngine {
   /**
    * Creates a new instance of the Logic Engine.
-   *
-   * "compatible" applies a few patches to make it compatible with the preferences of mainline JSON Logic.
-   * The main changes are:
-   * - In mainline: "all" will return false if the array is empty; by default, we return true.
-   * - In mainline: empty arrays are falsey; in our implementation, they are truthy.
-   *
+  *
    * @param {Object} methods An object that stores key-value pairs between the names of the commands & the functions they execute.
-   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean, permissive?: boolean, compatible?: boolean }} options
+   * @param {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean, permissive?: boolean }} options
    */
   constructor (
     methods = defaultMethods,
@@ -37,8 +31,6 @@ class LogicEngine {
     this.optimizedMap = new WeakMap()
     this.missesSinceSeen = 0
 
-    if (options.compatible) applyPatches(this)
-
     /** @type {{ disableInline?: Boolean, disableInterpretedOptimization?: Boolean }} */
     this.options = { disableInline: options.disableInline, disableInterpretedOptimization: options.disableInterpretedOptimization }
     if (!this.isData) {
@@ -54,6 +46,8 @@ class LogicEngine {
    * @returns
    */
   truthy (value) {
+    if (Array.isArray(value) && value.length === 0) return false
+    if (Number.isNaN(value)) return true
     return value
   }
 
@@ -186,5 +180,4 @@ class LogicEngine {
     return logic
   }
 }
-Object.assign(LogicEngine.prototype.truthy, { [OriginalImpl]: true })
 export default LogicEngine