theprogrammablemind 8.3.0-beta.5 → 8.3.0-beta.7

package/package.json

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

package/src/config.js

@@ -387,32 +387,45 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
           config.config.generators.push(addUUID(generator))
         }
       }
-      if (bridge.evaluator) {
-        const semantic = {
-          where: bridge.evaluator.where || bridge.where || helpers.where(3),
-          match: ({ context }) => bridge.id == context.marker && context.evaluate,
-          apply: (args) => bridge.evaluator(args),
-          applyWrapped: bridge.evaluator,
-          property: 'evaluator'
+
+      const addSemantic = (semantic, evaluate) => {
+        const match = semantic.match || (() => true)
+        let apply = semantic
+        // if I do apply == semantic.apply or semantic there is one function that has apply defined for some reason even though not explicitly set
+        if (semantic.apply && typeof semantic !== 'function') {
+          apply = semantic.apply
+        }
+        const semanticDef = {
+          where: semantic.where || bridge.where || helpers.where(4),
+          match: (args) => bridge.id == args.context.marker && !!args.context.evaluate == evaluate && match(args),
+          apply: (args) => apply(args),
+          applyWrapped: semantic,
+          property: evaluate ? 'evaluator':'semantic',
         }
         if (addFirst) {
-          config.config.semantics.unshift(addUUID(semantic))
+          config.config.semantics.unshift(addUUID(semanticDef))
         } else {
-          config.config.semantics.push(addUUID(semantic))
+          config.config.semantics.push(addUUID(semanticDef))
         }
       }
+
+      if (bridge.evaluator) {
+        addSemantic(bridge.evaluator, true)
+      }
+
       if (bridge.semantic) {
-        const semantic = {
-          where: bridge.semantic.where || bridge.where || helpers.where(3),
-          match: ({ context }) => bridge.id == context.marker && !context.evaluate,
-          apply: (args) => bridge.semantic(args),
-          applyWrapped: bridge.semantic,
-          property: 'semantic'
+        addSemantic(bridge.semantic, false)
+      }
+
+      if (bridge.evaluators) {
+        for (const evaluator of bridge.evaluators) {
+          addSemantic(evaluator, true)
         }
-        if (addFirst) {
-          config.config.semantics.unshift(addUUID(semantic))
-        } else {
-          config.config.semantics.push(addUUID(semantic))
+      }
+
+      if (bridge.semantics) {
+        for (const semantic of bridge.semantics) {
+          addSemantic(semantic, false)
         }
       }
     }
@@ -423,8 +436,8 @@ const handleCalculatedProps = (baseConfig, moreConfig, { addFirst, uuid } = {})
   if (moreConfig.bridges) {
     moreConfig.bridges = moreConfig.bridges.map((bridge) => {
       bridge = { ...bridge }
-      const valid = ['after', 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
-        'level', 'optional', 'selector', 'semantic', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
+      const valid = ['after', 'before', 'bridge', 'development', 'evaluator', 'evaluators', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
+        'level', 'optional', 'selector', 'semantic', 'semantics', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
       helpers.validProps(valid, bridge, 'bridge')
       handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
       return bridge
@@ -1149,13 +1162,16 @@ class Config {
             delete bridge.generatorr
             delete bridge.generatorpr
             delete bridge.evaluator
+            delete bridge.evaluators
             delete bridge.semantic
+            delete bridge.semantics
             if (!bridge.bridge) {
               bridge.bridge = "{ ...next(operator) }"
             }
             return bridge
           })
         } else {
+          /* done in updateQueries now
           config.generators = (config.generators || []).map((generator) => {
             generator = { ...generator }
             delete generator.where
@@ -1190,6 +1206,7 @@ class Config {
             }
             return bridge
           })
+          */
         }
         return config
       }

package/src/configHelpers.js

@@ -321,7 +321,6 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
             const mostCalled = semantics.getMostCalled()
             e.message += `\nThe most called semantic was:\nnotes: ${mostCalled.notes}\nmatch: ${mostCalled.matcher.toString()}\napply: ${mostCalled._apply.toString()}\n`
           }
-          // contextPrime = semantics.apply(args, { marker: 'error', context, error: e })
           if (isInstance) {
             console.log('error', e.error)
           }

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
     })
   }