theprogrammablemind 7.10.0 → 7.10.1

package/src/digraph.js

@@ -14,7 +14,7 @@ class Digraph {
   }
 
   // BFS
-  path(from, to) {
+  path (from, to) {
     debugger
     const frontier = { [from]: [[]] }
     const done = new Set()
@@ -29,12 +29,12 @@ class Digraph {
         continue
       }
       done.add(n)
-      for (let edge of this._edges) {
+      for (const edge of this._edges) {
         if (edge.child == n) {
           if (!frontier[edge.parent]) {
             frontier[edge.parent] = []
           }
-          for (let path of ps) {
+          for (const path of ps) {
             if (edge.parent == to) {
               return [...path, edge]
             }
@@ -45,26 +45,26 @@ class Digraph {
     }
   }
 
-  addEdges(edges) {
-    for (let edge of edges) {
+  addEdges (edges) {
+    for (const edge of edges) {
       this.addEdge(edge)
     }
   }
 
-  addEdge(edge) {
+  addEdge (edge) {
     edge = toA(edge)
     this._edges.push(edge)
   }
 
-  get edges() {
+  get edges () {
     return this._edges
   }
 
-  set edges(edges) {
+  set edges (edges) {
     this._edges = edges
   }
 
-/*
+  /*
   set edges(edges) {
     this._edges = edges.map( toA )
   }

package/src/digraph_internal.js

@@ -13,26 +13,26 @@ class DigraphInternal {
     this._edges = edges
   }
 
-  addEdges(edges) {
-    for (let edge of edges) {
+  addEdges (edges) {
+    for (const edge of edges) {
       this.addEdge(edge)
     }
   }
 
-  addEdge(edge) {
+  addEdge (edge) {
     edge = toA(edge)
     this._edges.push(edge)
   }
 
-  get edges() {
+  get edges () {
     return this._edges
   }
 
-  set edges(edges) {
+  set edges (edges) {
     this._edges = edges
   }
 
-/*
+  /*
   set edges(edges) {
     this._edges = edges.map( toA )
   }

package/src/flatten.js

@@ -93,7 +93,7 @@ const flatten = (markers, value) => {
   if (split) {
     if ('value' in properties) {
       flattenedValues = []
-      for (let v of properties.value) {
+      for (const v of properties.value) {
         if (v.flatten) {
           flattenedValues = flattenedValues.concat(flatten(markers, v)[0])
         } else {

package/src/generators.js

@@ -50,24 +50,23 @@ class Generator {
     }
     // return this.match({ ...args, args: contextArgs(context, hierarchy), objects, global: objects, hierarchy, context, api: this.getAPI(config) })
     const callId = baseArgs.calls.current()
-    const moreArgs = { 
-            uuid: this.uuid, 
-            args: contextArgs(context, hierarchy), 
-            objects, 
-            global: objects, 
-            // hierarchy, 
-            context, 
-            callId,
-            api: this.getAPI(config),
-            apis: this.getAPIs(config) 
-          }
+    const moreArgs = {
+      uuid: this.uuid,
+      args: contextArgs(context, hierarchy),
+      objects,
+      global: objects,
+      // hierarchy,
+      context,
+      callId,
+      api: this.getAPI(config),
+      apis: this.getAPIs(config)
+    }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     // return this.match(args)
     const matches = this.match(args)
-    if ((matches && (options.debug || {}).match)
-        ||
+    if ((matches && (options.debug || {}).match) ||
         callId == this.callId) {
-      debugger; // next line is the matcher
+      debugger // next line is the matcher
       this.match(args)
     }
     return matches
@@ -83,7 +82,7 @@ class Generator {
     }
 
     if (config && config.debugLoops) {
-      console.log("apply", this.toLabel())
+      console.log('apply', this.toLabel())
     }
     // this.getAPI(config)
     let n = (id) => id
@@ -95,26 +94,26 @@ class Generator {
     }
     const km = (name) => config.getConfig(name)
     const callId = baseArgs.calls.current()
-    const moreArgs = { 
-            callId, 
-            uuid: this.uuid, 
-            // km, 
-            args: contextArgs(context, hierarchy), 
-            objects, 
-            log, 
-            global: 
-            objects, 
-            // g, 
-            n, 
-            hierarchy, 
-            context, 
-            uuid: this.uuid, 
-            // gs, 
-            config, 
-            response, 
-            api: this.getAPI(config), 
-            apis: this.getAPIs(config) 
-          }
+    const moreArgs = {
+      callId,
+      uuid: this.uuid,
+      // km,
+      args: contextArgs(context, hierarchy),
+      objects,
+      log,
+      global:
+            objects,
+      // g,
+      n,
+      hierarchy,
+      context,
+      uuid: this.uuid,
+      // gs,
+      config,
+      response,
+      api: this.getAPI(config),
+      apis: this.getAPIs(config)
+    }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     if (this.property == 'generatorp') {
       args.g = args.gp
@@ -126,8 +125,7 @@ class Generator {
       debugger;
     }
     */
-    if ((options.debug || {}).apply
-        ||
+    if ((options.debug || {}).apply ||
         callId == this.callId) {
       debugger
     }
@@ -169,7 +167,7 @@ class Generators {
   // assumed - properties added to context before the generators are called. For setting paraphrase property
   apply (args, context, assumed = {}, options = {}) {
     if (Array.isArray(context)) {
-      throw new Error("Expected a context not an array")
+      throw new Error('Expected a context not an array')
     }
     if (typeof context !== 'object') {
       return String(context)
@@ -179,9 +177,9 @@ class Generators {
     const objects = args.objects
     const hierarchy = args.hierarchy
     const response = args.response
-    
+
     // args = { ...args, ...args.getAssumedScoped(assumed) }
-    args.addAssumedScoped(args, assumed) 
+    args.addAssumedScoped(args, assumed)
     context = Object.assign({}, context, args.assumed)
     let generated = ''
     let applied = false
@@ -193,8 +191,8 @@ class Generators {
         // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
         let errorMessage = 'The apply function did not return a value'
         try {
-          generated= generator.apply(args, objects, context, hierarchy, config, response, log)
-        } catch( e ) {
+          generated = generator.apply(args, objects, context, hierarchy, config, response, log)
+        } catch (e) {
           // the next if handle this
           generated = null
           e.retryCall = () => generator.apply(args, objects, context, hierarchy, config, response, log)
@@ -283,7 +281,7 @@ class Generators {
       lines.setElement(0, 2, JSON.stringify(context, null, 2))
       this.logs.push(lines.toString())
     }
-    return ((config || {}).parenthesized ? "(" + generated + ")" : generated)
+    return ((config || {}).parenthesized ? '(' + generated + ')' : generated)
   }
 }
 

package/src/helpers.js

@@ -69,7 +69,7 @@ const safeEquals = (v1, v2) => {
     if (v1.length != v2.length) {
       return false
     }
-    for (let key in v1) {
+    for (const key in v1) {
       if (!safeEquals(v1[key], v2[key])) {
         return false
       }
@@ -183,72 +183,71 @@ const isCompound = (value) => {
 }
 
 class InitCalls {
-
-  constructor(name) {
+  constructor (name) {
     this.nextCallId = 0
     this.nextContextId = 0
     this.stack = []
     this.name = name
   }
 
-  start() {
+  start () {
     return this.nextCallId
   }
 
-  next() {
+  next () {
     // this.nextContextId += 1
     this.nextContextId += 1
   }
 
-  push() {
+  push () {
     this.nextCallId += 1
     // this.nextCallId += 1
     // this.stack.push(this.nextCallId)
     this.stack.push(this.nextCallId)
     // TODO put the nextContextId in the context for debugging
-    const calls = this.stack.map( (call) => `${this.name}#call${call}` )
+    const calls = this.stack.map((call) => `${this.name}#call${call}`)
     // return `Context#${this.nextContextId}: ${calls}`
     return `Context#${this.nextContextId}: ${calls}`
   }
 
-  current() {
-    return `${this.name}#call${this.stack[this.stack.length-1]}`
+  current () {
+    return `${this.name}#call${this.stack[this.stack.length - 1]}`
   }
 
-  touch(context) {
+  touch (context) {
     if (!context.touchedBy) {
       context.touchedBy = []
     }
-    if (!context.touchedBy.includes( this.current() )) {
-      context.touchedBy.push( this.current() )
+    if (!context.touchedBy.includes(this.current())) {
+      context.touchedBy.push(this.current())
     }
   }
 
-  pop() {
+  pop () {
     this.stack.pop()
   }
 }
 
 const hashCode = (str) => {
-  var hash = 0, i, ch;
-  if (str.length === 0) return hash;
+  let hash = 0; let i; let ch
+  if (str.length === 0) return hash
   for (i = 0; i < str.length; i++) {
-    ch   = str.charCodeAt(i);
-    hash  = ((hash << 5) - hash) + ch;
-    hash |= 0; // Convert to 32bit integer
+    ch = str.charCodeAt(i)
+    hash = ((hash << 5) - hash) + ch
+    hash |= 0 // Convert to 32bit integer
   }
-  return hash;
-};
+  return hash
+}
 
 const sortJson = (json) => {
   return json
 }
 
 const validProps = (valids, object, type) => {
-  for (let prop of Object.keys(object)) {
+  for (const prop of Object.keys(object)) {
     let okay = false
     for (valid of valids) {
-      if (typeof valid == 'string') {
+      if (typeof valid === 'string') {
         okay = prop == valid
       } else {
         okay = prop.match(valid)
@@ -265,14 +264,14 @@ const validProps = (valids, object, type) => {
 
 const mapInPlace = (list, fn) => {
   for (let i = 0; i < list.length; ++i) {
-    list[i] =fn(list[i])
+    list[i] = fn(list[i])
   }
 }
 
 const updateQueries = (queryOrConfig) => {
-  if (typeof queryOrConfig == 'string' || queryOrConfig.query) {
+  if (typeof queryOrConfig === 'string' || queryOrConfig.query) {
     return queryOrConfig
-  } else if (typeof queryOrConfig == 'function') {
+  } else if (typeof queryOrConfig === 'function') {
     return { apply: queryOrConfig.toString() }
   } else {
     const config = queryOrConfig
@@ -281,34 +280,34 @@ const updateQueries = (queryOrConfig) => {
 }
 
 const functionsToStrings = (config) => {
-  config = {...config}
+  config = { ...config }
   const mapGenerator = (generator) => {
-      if (generator.apply) {
-        return { ...generator, match: generator.match.toString(), apply: generator.apply.toString() }
-      } else {
-        return [ generator[0].toString(), generator[1].toString() ]
-      }
+    if (generator.apply) {
+      return { ...generator, match: generator.match.toString(), apply: generator.apply.toString() }
+    } else {
+      return [generator[0].toString(), generator[1].toString()]
     }
+  }
   if (config.generators) {
-    config.generators = config.generators.map( mapGenerator )
+    config.generators = config.generators.map(mapGenerator)
   }
   if (config.semantics) {
-    config.semantics = config.semantics.map( (semantic) => {
+    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() ]
+        return [semantic[0].toString(), semantic[1].toString()]
       }
     })
   }
   if (config.bridges) {
-    config.bridges = config.bridges.map( (bridge) => {
-      bridge = {...bridge}
+    config.bridges = config.bridges.map((bridge) => {
+      bridge = { ...bridge }
       if (bridge.generator) {
         bridge.generator = bridge.generator.toString()
       }
       if (bridge.generators) {
-        bridge.generators = bridge.generators.map( mapGenerator )
+        bridge.generators = bridge.generators.map(mapGenerator)
       }
       if (bridge.generatorp) {
         bridge.generatorp = bridge.generatorp.toString()
@@ -331,7 +330,7 @@ const functionsToStrings = (config) => {
 const ecatch = (where, call) => {
   try {
     return call()
-  } catch( e ) {
+  } catch (e) {
     throw new Error(`${where} ${e.stack}`)
   }
 }
@@ -346,9 +345,9 @@ const subPriority = (sub, sup) => {
   if (Array.isArray(sub)) {
     const subChoosen = sub[0]
     const subOther = sub[1]
-    const hasChoosen = sup.choose.find( (index) => equalKey(sup.context[index], subChoosen)) != undefined
-    const hasOtherChosen = sup.choose.find( (index) => equalKey(sup.context[index], subOther)) != undefined
-    const hasOther = sup.context.find( (other) => equalKey(other, subOther) ) !== undefined
+    const hasChoosen = sup.choose.find((index) => equalKey(sup.context[index], subChoosen)) != undefined
+    const hasOtherChosen = sup.choose.find((index) => equalKey(sup.context[index], subOther)) != undefined
+    const hasOther = sup.context.find((other) => equalKey(other, subOther)) !== undefined
     return !!(hasChoosen && hasOther) && !hasOtherChosen
   }
 
@@ -367,7 +366,7 @@ const subPriority = (sub, sup) => {
   const chosen2 = choose(sup)
   const sameId = (id1, id2) => id1[0] == id2[0] && id1[1] == id2[1]
   // same length so only need one way
-  const missing1 = chosen1.find( (id1) => !chosen2.find( (id2) => sameId(id1, id2)) )
+  const missing1 = chosen1.find((id1) => !chosen2.find((id2) => sameId(id1, id2)))
   if (missing1) {
     return false
   }
@@ -375,26 +374,26 @@ const subPriority = (sub, sup) => {
   return true
 }
 
-module.exports = { 
+module.exports = {
   ecatch,
   functionsToStrings,
   updateQueries,
   mapInPlace,
-  validProps, 
-  args, 
+  validProps,
+  args,
   safeNoDups,
-  safeEquals, 
-  appendNoDups, 
-  hashIndexesGet, 
-  hashIndexesSet, 
-  translationMapping, 
-  normalizeGenerator, 
-  normalizeSemantic, 
-  isArray, 
-  isObject, 
-  isCompound, 
-  InitCalls, 
-  hashCode, 
+  safeEquals,
+  appendNoDups,
+  hashIndexesGet,
+  hashIndexesSet,
+  translationMapping,
+  normalizeGenerator,
+  normalizeSemantic,
+  isArray,
+  isObject,
+  isCompound,
+  InitCalls,
+  hashCode,
   sortJson,
-  subPriority,
+  subPriority
 }

package/src/project.js

@@ -4,7 +4,7 @@ const project = (object, filter) => {
     return
   }
 
-  let projection = {}
+  const projection = {}
   const set = (property, value) => {
     if (value === null || value === undefined) {
       return
@@ -13,13 +13,13 @@ const project = (object, filter) => {
   }
   if (Array.isArray(filter)) {
     if (Array.isArray(object)) {
-      return object.map( element => project(element, filter) )
+      return object.map(element => project(element, filter))
     } else {
       for (let properties of filter) {
-        if (typeof properties == 'function') {
+        if (typeof properties === 'function') {
           properties = properties(object)
         }
-        if (typeof properties == 'object') {
+        if (typeof properties === 'object') {
           if (properties.propertyLists) {
             for (const propertyList in properties.propertyLists) {
               if (object[propertyList]) {
@@ -28,7 +28,7 @@ const project = (object, filter) => {
                 }
               }
             }
-          } 
+          }
           if (properties.valueLists) {
             for (const listProperty in properties.valueLists) {
               const old = object[listProperty]
@@ -70,7 +70,7 @@ const project = (object, filter) => {
         }
       }
     }
-  } else if (typeof filter == 'object') {
+  } else if (typeof filter === 'object') {
     for (const property of Object.keys(filter)) {
       set(property, project(object[property], filter[property]))
     }
@@ -79,5 +79,3 @@ const project = (object, filter) => {
 }
 
 module.exports = { project }
-
-

package/src/semantics.js

@@ -25,7 +25,7 @@ class Semantic {
   toLabel () {
     const where = (this.where) ? `where: "${this.where}"` : ''
     if (!this.km) {
-      return where;
+      return where
     }
     return `KM '${this.km}' ordinal: ${this.index} ${where}`
   }
@@ -55,24 +55,23 @@ class Semantic {
 
     // return this.matcher(Object.assign({}, argsBase, {args: contextArgs(context, hierarchy), objects: objects, global: objects, context: context, hierarchy: hierarchy, api: this.getAPI(config)})
     const callId = baseArgs.calls.current()
-    const moreArgs = { 
-            uuid: this.uuid, 
-            args: contextArgs(context, hierarchy), 
-            objects,
-            global: objects, 
-            context: context, 
-            // hierarchy: hierarchy, 
-            callId,
-            api: this.getAPI(config),
-            apis: this.getAPIs(config)
-          }
+    const moreArgs = {
+      uuid: this.uuid,
+      args: contextArgs(context, hierarchy),
+      objects,
+      global: objects,
+      context: context,
+      // hierarchy: hierarchy,
+      callId,
+      api: this.getAPI(config),
+      apis: this.getAPIs(config)
+    }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
 
     const matches = this.matcher(args)
-    if (matches && (options.debug || {}).match
-        ||
+    if (matches && (options.debug || {}).match ||
         callId == this.callId) {
-      debugger; // next line is the matcher
+      debugger // next line is the matcher
       this.matcher(args)
     }
     return matches
@@ -82,7 +81,7 @@ class Semantic {
     const { hierarchy, config, response } = baseArgs
     const objects = baseArgs.getObjects(this.uuid)
     if (config && config.debugLoops) {
-      console.log("apply", this.toLabel())
+      console.log('apply', this.toLabel())
     }
     if (baseArgs.calls && config && baseArgs.calls.stack.length > config.maxDepth) {
       throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
@@ -99,26 +98,25 @@ class Semantic {
       n = (id) => config.nsToString(id)
     }
     const callId = baseArgs.calls.current()
-    const moreArgs = { 
-            uuid: this.uuid, 
-            callId, 
-            args: contextArgs(context, hierarchy), 
-            objects, 
-            log, 
-            global: objects, 
-            n, 
-            context: contextPrime, 
-            uuid: this.uuid, 
-            // config, 
-            response, 
-            api: this.getAPI(config),
-            apis: this.getAPIs(config)
+    const moreArgs = {
+      uuid: this.uuid,
+      callId,
+      args: contextArgs(context, hierarchy),
+      objects,
+      log,
+      global: objects,
+      n,
+      context: contextPrime,
+      uuid: this.uuid,
+      // config,
+      response,
+      api: this.getAPI(config),
+      apis: this.getAPIs(config)
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
-    if ((options.debug || {}).apply
-        ||
+    if ((options.debug || {}).apply ||
         callId == this.callId) {
-      debugger;
+      debugger
     }
     if (args.breakOnSemantics) {
       debugger
@@ -161,10 +159,10 @@ class Semantics {
     this.calls = {}
   };
 
-  getMostCalled() {
+  getMostCalled () {
     let maxOrdinal = 0
     let maxCounter = 0
-    for (let ordinal in this.calls) {
+    for (const ordinal in this.calls) {
       const counter = this.calls[ordinal]
       if (counter > maxCounter) {
         maxOrdinal = ordinal
@@ -185,24 +183,24 @@ class Semantics {
     const s = (context, options) => this.apply(args, context, options)
     let applied = false
     const stack = args.calls.push()
-    let counter = 0;
+    let counter = 0
     for (const isemantic in this.semantics) {
       const semantic = this.semantics[isemantic]
       if (!semantic) {
-        debugger;
+        debugger
       }
       if (semantic.matches(args, context, options)) {
         if (!this.calls[counter]) {
-          this.calls[counter] = 0;
+          this.calls[counter] = 0
         }
-        this.calls[counter] += 1;
+        this.calls[counter] += 1
         const log = (message) => { this.logs.push(message) }
         try {
           contextPrime = semantic.apply(args, context, s, log, options)
           if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
             args.config.removeSemantic(semantic)
           }
-        } catch( e ) {
+        } catch (e) {
           contextPrime = null
           let errorMessage
           e.retryCall = () => semantic.apply(args, context, s, log, options)
@@ -214,8 +212,8 @@ class Semantics {
             const info = `${semantic.notes ? semantic.notes : ''}${semantic.where ? semantic.where : ''}`
             errorMessage = `Error applying semantics '${info}'. Error is ${e.error.join()}. Semantic is ${semantic.toString()}. ${help}`
           } else {
- 						errorMessage = e.toString();
-					}
+ 						errorMessage = e.toString()
+          }
 
           const widths = [10, 10, 90]
           const lines = new Lines(widths)