theprogrammablemind 8.3.0-beta.4 → 8.3.0-beta.6

package/package.json

@@ -65,6 +65,6 @@
     "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "8.3.0-beta.4",
+  "version": "8.3.0-beta.6",
   "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,44 +1162,53 @@ 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 {
-          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
-          })
+          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)
           config.bridges = (config.bridges || []).map((bridge) => {
             bridge = { ...bridge }
             delete bridge.where
             if (bridge.generatorp) {
-              bridge.generatorp = bridge.generatorp.toString()
+              bridge.generatorp = toCanonical(bridge.generatorp)
             }
             if (bridge.generatorr) {
-              bridge.generatorr = bridge.generatorr.toString()
+              bridge.generatorr = toCanonical(bridge.generatorr)
             }
             if (bridge.generatorpr) {
-              bridge.generatorpr = bridge.generatorpr.toString()
+              bridge.generatorpr = toCanonical(bridge.generatorpr)
             }
             if (bridge.evaluator) {
-              bridge.evaluator = bridge.evaluator.toString()
+              bridge.evaluator = toCanonical(bridge.evaluator)
             }
             if (bridge.semantic) {
-              bridge.semantic = bridge.semantic.toString()
+              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()
             }
             return bridge
           })

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