theprogrammablemind 8.3.0-beta.6 → 8.3.0-beta.8

package/package.json

@@ -65,6 +65,6 @@
     "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "8.3.0-beta.6",
+  "version": "8.3.0-beta.8",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -418,14 +418,22 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       }
 
       if (bridge.evaluators) {
-        for (const evaluator of bridge.evaluators) {
-          addSemantic(evaluator, true)
+        const evaluators = [...bridge.evaluators]
+        evaluators.reverse()
+        if (evaluators) {
+          for (const evaluator of evaluators) {
+            addSemantic(evaluator, true)
+          }
         }
       }
 
       if (bridge.semantics) {
-        for (const semantic of bridge.semantics) {
-          addSemantic(semantic, false)
+        const semantics = [...bridge.semantics]
+        semantics.reverse()
+        if (semantics) {
+          for (const semantic of semantics) {
+            addSemantic(semantic, false)
+          }
         }
       }
     }
@@ -1171,47 +1179,42 @@ class Config {
             return bridge
           })
         } else {
-          const toCanonical = (def) => {
-            if (typeof def == 'function') {
-              return def.toString()
-            } else if (typeof def == 'string') {
-              return def
-            }
-            def = { ...def }
-            delete def.where
-            def.match = def.match ? def.match.toString() : ""
-            def.apply = def.apply ? def.apply.toString() : ""
-            return def
-          }
-
-          config.generators = (config.generators || []).map(toCanonical)
-          config.semantics = (config.semantics || []).map(toCanonical)
+          /* done in updateQueries now
+          config.generators = (config.generators || []).map((generator) => {
+            generator = { ...generator }
+            delete generator.where
+            generator.match = generator.match.toString()
+            generator.apply = generator.apply.toString()
+            return generator
+          })
+          config.semantics = (config.semantics || []).map((semantic) => {
+            semantic = { ...semantic }
+            delete semantic.where
+            semantic.match = semantic.match.toString()
+            semantic.apply = semantic.apply.toString()
+            return semantic
+          })
           config.bridges = (config.bridges || []).map((bridge) => {
             bridge = { ...bridge }
             delete bridge.where
             if (bridge.generatorp) {
-              bridge.generatorp = toCanonical(bridge.generatorp)
+              bridge.generatorp = bridge.generatorp.toString()
             }
             if (bridge.generatorr) {
-              bridge.generatorr = toCanonical(bridge.generatorr)
+              bridge.generatorr = bridge.generatorr.toString()
             }
             if (bridge.generatorpr) {
-              bridge.generatorpr = toCanonical(bridge.generatorpr)
+              bridge.generatorpr = bridge.generatorpr.toString()
             }
             if (bridge.evaluator) {
-              bridge.evaluator = toCanonical(bridge.evaluator)
+              bridge.evaluator = bridge.evaluator.toString()
             }
             if (bridge.semantic) {
-              bridge.semantic = toCanonical(bridge.semantic)
-            }
-            if (bridge.evaluators) {
-              bridge.evaluators = bridge.evaluators.map(toCanonical).toString()
-            }
-            if (bridge.semantics) {
-              bridge.semantics = bridge.semantics.map(toCanonical).toString()
+              bridge.semantic = bridge.semantic.toString()
             }
             return bridge
           })
+          */
         }
         return config
       }

package/src/helpers.js

@@ -312,24 +312,18 @@ const updateQueries = (queryOrConfig) => {
 
 const functionsToStrings = (config) => {
   config = { ...config }
-  const mapGenerator = (generator) => {
-    if (generator.apply) {
-      return { ...generator, match: generator.match.toString(), apply: generator.apply.toString() }
+  defToStrings = (def) => {
+    if (def.apply) {
+      return { ...def, match: def.match.toString(), apply: def.apply.toString() }
     } else {
-      return [generator[0].toString(), generator[1].toString()]
+      return [def[0].toString(), def[1].toString()]
     }
   }
   if (config.generators) {
-    config.generators = config.generators.map(mapGenerator)
+    config.generators = config.generators.map(defToStrings)
   }
   if (config.semantics) {
-    config.semantics = config.semantics.map((semantic) => {
-      if (semantic.apply) {
-        return { ...semantic, match: semantic.match.toString(), apply: semantic.apply.toString() }
-      } else {
-        return [semantic[0].toString(), semantic[1].toString()]
-      }
-    })
+    config.semantics = config.semantics.map(defToStrings)
   }
   if (config.bridges) {
     config.bridges = config.bridges.map((bridge) => {
@@ -338,7 +332,7 @@ const functionsToStrings = (config) => {
         bridge.generator = bridge.generator.toString()
       }
       if (bridge.generators) {
-        bridge.generators = bridge.generators.map(mapGenerator)
+        bridge.generators = bridge.generators.map(defToStrings)
       }
       if (bridge.generatorp) {
         bridge.generatorp = bridge.generatorp.toString()
@@ -349,9 +343,15 @@ const functionsToStrings = (config) => {
       if (bridge.semantic) {
         bridge.semantic = bridge.semantic.toString()
       }
+      if (bridge.semantics) {
+        bridge.semantics = bridge.semantics.toString()
+      }
       if (bridge.evaluator) {
         bridge.evaluator = bridge.evaluator.toString()
       }
+      if (bridge.evaluators) {
+        bridge.evaluators = bridge.evaluators.toString()
+      }
       return bridge
     })
   }