theprogrammablemind_4wp 7.5.8-beta.76 → 7.5.8-beta.78

package/package.json

@@ -64,6 +64,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.8-beta.76",
+  "version": "7.5.8-beta.78",
   "license": "ISC"
 }

package/src/config.js

@@ -23,13 +23,6 @@ const indent = (string, indent) => {
 }
 
 const config_toServer = (config) => {
-  /*
-  if (config.contextual_priorities) {
-    config.contextual_priorities = config.contextual_priorities.map((cp) => {
-      return [cp.context, cp.choose]
-    })
-  }
-  */
 }
 
 const debugPriority = (priority) => {
@@ -48,14 +41,6 @@ const debugAssociation = (association) => {
   }
 }
 
-const debugContextualPriority = (contextual_priority) => {
-  if (global.entodictonDebugContextualPriority) {
-    if (helpers.safeEquals(entodictonDebugContextualPriority, contextual_priority)) {
-      debugger; // debug hierarchy hit
-    }
-  }
-}
-
 const debugHierarchy = (pair) => {
   if (global.entodictonDebugHierarchy) {
     if (helpers.safeEquals(global.entodictonDebugHierarchy, pair)) {
@@ -87,7 +72,6 @@ const debugConfigProps = (config) => {
   const checkProps = [
     { property: 'priorities', check: (v) => debugPriority(v) },
     { property: 'association', check: (v) => debugAssociation(v) },
-    { property: 'contextual_priorities', check: (v) => debugContextualPriority(v) },
     { property: 'hierarchy', check: (v) => debugHierarchy(v) },
     { property: 'operators', check: (v) => debugOperator(v) },
     { property: 'bridges', check: (v) => debugBridge(v) },
@@ -109,7 +93,6 @@ const validConfigProps = (config) => {
     'operators', 
     'words', 
     'priorities', 
-    'contextual_priorities', 
     'associations', 
     'name', 
     'version', 
@@ -188,20 +171,20 @@ const elist = (list, check, prefix) => {
     }
   }
 }
-const contextual_priorities_valid = (cps) => {
-  elist(cps, (cp) => contextual_priority_valid(cp),  (index, e) => `contextual_priorities has an invalid contextual priority at position ${index}. ${e}`)
+const priorities_valid = (cps) => {
+  elist(cps, (cp) => priority_valid(cp),  (index, e) => `priorities has an invalid priority at position ${index}. ${e}`)
 }
 
-const contextual_priority_valid = (cp) => {
+const priority_valid = (cp) => {
   if (!cp.context) {
-    throw new Error(`The contextual priority ${JSON.stringify(cp)} is missing the "context" property. That is a list of the operator keys that are to be prioritized differently.`)
+    throw new Error(`The priority ${JSON.stringify(cp)} is missing the "context" property. That is a list of the operator keys that are to be prioritized differently.`)
   }
   if (!_.isArray(cp.context)) {
-    throw new Error(`The contextual priority ${JSON.stringify(cp)} has an invalid "context" value. That is a list of the operator keys that are to be prioritized differently.`)
+    throw new Error(`The priority ${JSON.stringify(cp)} has an invalid "context" value. That is a list of the operator keys that are to be prioritized differently.`)
   }
-  elist(cp.context, (element) => operatorKey_valid(element), (index, e) => `The contextual priority ${JSON.stringify(cp)} has an invalid operator key at position ${index}. ${e}`)
+  elist(cp.context, (element) => operatorKey_valid(element), (index, e) => `The priority ${JSON.stringify(cp)} has an invalid operator key at position ${index}. ${e}`)
   if (!_.isArray(cp.choose)) {
-    throw new Error(`The contextual priority ${JSON.stringify(cp)} has an invalid "choose" value. The value should be a list of the operators in the context to consider for prioritization.`)
+    throw new Error(`The priority ${JSON.stringify(cp)} has an invalid "choose" value. The value should be a list of the operators in the context to consider for prioritization.`)
   }
   elist(cp.choose, 
       (element) => {
@@ -212,7 +195,7 @@ const contextual_priority_valid = (cp) => {
           throw new Error(`The value should be an index into the "context" property of the operator that is to be considered for prioritization. Valid values are between 0 and ${cp.context.length-1}.`)
         }
       }, 
-      (index, e) => `The choose property in the contextual priority ${JSON.stringify(cp)} has an invalid index at position ${index}. ${e}`
+      (index, e) => `The choose property in the priority ${JSON.stringify(cp)} has an invalid index at position ${index}. ${e}`
   )
 }
 
@@ -245,7 +228,7 @@ const handleBridgeProps = (config, bridge, addFirst) => {
           if (typeof after == 'string') {
             after = [after, 0]
           }
-          config.addPriorities({ "context": [[bridge.id, bridge.level], after], "choose": [0] })
+          config.addPriorities({ context: [[bridge.id, bridge.level], after], choose: [0] })
         }
       }
       if (bridge.after) {
@@ -253,7 +236,7 @@ const handleBridgeProps = (config, bridge, addFirst) => {
           if (typeof before == 'string') {
             before = [before, 0]
           }
-          config.addPriorities({ "context": [before, [bridge.id, bridge.level]], "choose": [0] })
+          config.addPriorities({ context: [before, [bridge.id, bridge.level]], choose: [0] })
         }
       }
       if (bridge.words) {
@@ -739,7 +722,6 @@ class Config {
       addAssociation: (...args) => this.addAssociation(...args),
       addAssociations: (...args) => this.addAssociations(...args),
       addBridge: (...args) => this.addBridge(...args, uuid),
-      addContextualPriority: (...args) => this.addContextualPriority(...args),
       addGenerator: (...args) => this.addGenerator(...args, uuid, config.name),
       addHierarchy: (...args) => this.addHierarchy(...args),
       addOperator: (...args) => this.addOperator(...args, uuid),
@@ -815,7 +797,6 @@ class Config {
       },
       eqClasses: [],
       priorities: [], // Done
-      contextual_priorities: [],
       version: '3',
       debug: false,
       associations: { // Done
@@ -854,7 +835,6 @@ class Config {
           'namespaces',
           'eqClasses',
           'priorities',
-          'contextual_priorities',
           'associations',
           'words',
           'floaters',
@@ -1053,16 +1033,6 @@ class Config {
     this.validifyTemplate(template)
     instance.template = template
     this.logs.push(`loading template for ${this.name}`)
-    /*
-    if (instance && (instance.associations || instance.learned_contextual_priorities) && !options.rebuild) {
-      if (instance.associations) {
-        this.addAssociations(instance.associations)
-      }
-      if (instance.learned_contextual_priorities && instance.learned_contextual_priorities.length > 0) {
-        this.addContextualPriorities(instance.learned_contextual_priorities)
-      }
-    }
-    */
     if (options.rebuild) {
       // TODO fix beforeQuery
       template = { fragments: [], queries: [], ...template }
@@ -1111,12 +1081,6 @@ class Config {
     }
   }
 
-  addContextualPriorities (cps) {
-    for (let cp of cps) {
-      this.addContextualPriority(cp)
-    }
-  }
-
   debugConfig() {
   }
 
@@ -1134,26 +1098,17 @@ class Config {
 
   // TODO add more error checking to these like addHierarchy has
   // TODO change name from priorities to priority
+  // [ context: <list of [id, level]>, choose: [<indexes of prioritized operator>], [ordered: [true|false]] ]
   addPriorities (priorities) {
     if (!this.config.priorities) {
       this.config.priorities = []
     }
     debugPriority(priorities)
+    priority_valid(priorities)
     this.config.priorities.push(priorities)
     this._delta.json.priorities.push({ action: 'add', priorities })
   }
 
-  // [ operators: <list of [id, level]>, select: <index of prioritized operator> ]
-  addContextualPriority(contextual_priority) {
-    if (!this.config.contextual_priorities) {
-      this.config.contextual_priorities = []
-    }
-    debugContextualPriority(contextual_priority)
-    contextual_priority_valid(contextual_priority)
-    this.config.contextual_priorities.push(contextual_priority)
-    this._delta.json.contextual_priorities.push({ action: 'add', contextual_priority: contextual_priority })
-  }
-
   addHierarchy (child, parent) {
     if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
       this.addHierarchyChildParent(child, parent)
@@ -1549,7 +1504,6 @@ class Config {
       config.hierarchy = config.hierarchy || []
       config.associations = config.associations || { negative: [], positive: [] }
       config.priorities = config.priorities || []
-      config.contextual_priorities = config.contextual_priorities || []
     }
 
     this.maxDepth = 20 // for generators and semantics
@@ -1603,8 +1557,8 @@ class Config {
       }
     }
 
-    if (config && config.contextual_priorities) {
-      contextual_priorities_valid(config.contextual_priorities)
+    if (config && config.priorities) {
+      priorities_valid(config.priorities)
     }
 
     normalizeConfig(config)
@@ -1692,7 +1646,6 @@ class Config {
         bridges: [],
         associations: [],
         priorities: [],
-        contextual_priorities: [],
         hierarchy: [],
       }
     }
@@ -2322,7 +2275,6 @@ class Config {
         bridges: this.config.bridges,
         hierarchy: this.config.hierarchy,
         priorities: this.config.priorities,
-        contextual_priorities: this.config.contextual_priorities,
         associations: this.config.associations,
         words: this.config.words
       }
@@ -2331,7 +2283,6 @@ class Config {
       this.config.bridges = []
       this.config.hierarchy = []
       this.config.priorities = []
-      this.config.contextual_priorities = []
       this.config.associations = { positive: [], negative: [] }
       this.config.words = {}
 
@@ -2540,25 +2491,20 @@ class Config {
 
     if (config.priorities) {
       let priorities = config.priorities
-      priorities = priorities.map((p) => {
-        return { ...p, context: p.context.map( (id) => [toNS(id[0]), id[1]] )}
-      })
-      config.priorities = priorities
-    }
-
-    if (config.contextual_priorities) {
-      let contextual_priorities = config.contextual_priorities
-      contextual_priorities = contextual_priorities.map((cp) => {
+      priorities = priorities.map((cp) => {
         const { context, choose, ordered } = cp
-        return {
+        const priority = {
           context: context.map((id) => {
             return [toNS(id[0]), id[1]]
           }),
           choose,
-          ordered
         }
+        if (ordered) {
+          priority.ordered = ordered
+        }
+        return priority
       })
-      config.contextual_priorities = contextual_priorities
+      config.priorities = priorities
     }
 
     for (const bag of bags) {