theprogrammablemind 7.5.8-beta.21 → 7.5.8-beta.23

package/package.json

@@ -63,6 +63,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.8-beta.21",
+  "version": "7.5.8-beta.23",
   "license": "ISC"
 }

package/src/config.js

@@ -30,6 +30,23 @@ const config_toServer = (config) => {
   }
 }
 
+const setupInitializerFNArgs = (config, args) => {
+  const aw = (word, def) => config.addWord(word, def, args.uuid)
+  const ag = (generator) => config.addGenerator(generator, args.uuid, config.name)
+  const km = (name) => config.getConfig(name)
+  const apis = (name) => config.getConfig(name).api
+
+  return {
+    ...args,
+    addWord: aw,
+    addGenerator: ag,
+    config: config.getPseudoConfig(args.uuid, args.currentConfig),
+    km,
+    baseConfig: config,
+    apis,
+  }
+}
+
 const contextual_priorities_toServer = (cp) => {
   if (cp.context && cp.choose) {
     return [cp.context, cp.choose]
@@ -581,19 +598,19 @@ class Config {
     return config_toServer(config)
   }
 
-  getPsuedoConfig() {
+  getPseudoConfig(uuid, config) {
     return {
       description: "this is a pseudo config that has limited functionality due to being available in the initializer function context",
       addAssociation: (...args) => this.addAssociation(...args),
       addAssociations: (...args) => this.addAssociations(...args),
-      addBridge: (...args) => this.addBridge(...args),
+      addBridge: (...args) => this.addBridge(...args, uuid),
       addContextualPriority: (...args) => this.addContextualPriority(...args),
-      addGenerator: (...args) => this.addGenerator(...args),
+      addGenerator: (...args) => this.addGenerator(...args, uuid, config.name),
       addHierarchy: (...args) => this.addHierarchy(...args),
-      addOperator: (...args) => this.addOperator(...args),
+      addOperator: (...args) => this.addOperator(...args, uuid),
       addPriorities: (...args) => this.addPriorities(...args),
-      addSemantic: (...args) => this.addSemantic(...args),
-      addWord: (...args) => this.addWord(...args),
+      addSemantic: (...args) => this.addSemantic(...args, uuid, config.name),
+      addWord: (...args) => this.addWord(...args, uuid),
 
       addArgs: (...args) => this.addArgs(...args),
       getBridge: (...args) => this.getBridge(...args),
@@ -1024,12 +1041,12 @@ class Config {
     }
   }
 
-  addBridge (bridge) {
+  addBridge (bridge, uuid) {
     if (!this.config.bridges) {
       this.config.bridges = []
     }
     const bridges = this.config.bridges
-    const def = Object.assign({}, bridge, { uuid: this._uuid })
+    const def = Object.assign({}, bridge, { uuid: uuid || this._uuid })
   
     if (global.entodictonDebugBridge) {
       if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
@@ -1051,12 +1068,7 @@ class Config {
     this._delta.json.bridges.push({ action: 'add', bridge: def })
   }
 
-  addGenerator (match, apply) {
-    let generator = match
-    if ((typeof match === 'function') && (typeof apply === 'function')) {
-      generator = { match, apply }
-    }
-
+  addGenerator (generator, uuid, name) {
     if (!(typeof generator.match === 'function')) {
       throw new Error('addGenerator: Expected matcher to be a function')
     }
@@ -1073,17 +1085,12 @@ class Config {
     }
 
     const generators = this.config.generators
-    Object.assign(generator, { uuid: this._uuid, km: this.name, index: generators.length })
+    Object.assign(generator, { uuid: uuid || this._uuid, km: name || this.name, index: generators.length })
     // used to be unshift
     generators.unshift(generator)
   }
 
-  addSemantic (match, apply) {
-    let semantic = match
-    if ((typeof match === 'function') && (typeof apply === 'function')) {
-      semantic = { match, apply }
-    }
-
+  addSemantic (semantic, uuid, name) {
     if (!(typeof semantic.match === 'function')) {
       throw new Error('addSemantic: Expected match to be a function')
     }
@@ -1100,11 +1107,11 @@ class Config {
     }
 
     const semantics = this.config.semantics
-    Object.assign(semantic, { uuid: this._uuid, km: this.name, index: semantics.length })
+    Object.assign(semantic, { uuid: uuid || this._uuid, km: name || this.name, index: semantics.length })
     semantics.unshift(semantic)
   }
 
-  addOperator (objectOrPattern) {
+  addOperator (objectOrPattern, uuid) {
     if (!this.config.operators) {
       this.config.operators = []
     }
@@ -1113,9 +1120,9 @@ class Config {
 
     let operator;
     if (typeof objectOrPattern === 'string') {
-      operator = { pattern: objectOrPattern, uuid: this._uuid }
+      operator = { pattern: objectOrPattern, uuid: uuid || this._uuid }
     } else {
-      operator = Object.assign({}, objectOrPattern, { uuid: this._uuid })
+      operator = Object.assign({}, objectOrPattern, { uuid: uuid || this._uuid })
     }
 
     if (global.entodictonDebugOperator) {
@@ -1136,16 +1143,16 @@ class Config {
     this._delta.json.operators.push({ action: 'add', operator })
   }
 
-  addWord (word, def) {
-    this.addWordInternal(word, def)
+  addWord (word, def, uuid) {
+    this.addWordInternal(word, def, uuid)
   }
 
-  addWordInternal (word, def) {
+  addWordInternal (word, def, uuid) {
     if (!this.config.words) {
       this.config.words = {}
     }
     const words = this.config.words
-    def = Object.assign({}, def, { uuid: this._uuid })
+    def = Object.assign({}, def, { uuid: uuid || this._uuid })
     if (words[word]) {
       if (!words[word].some((e) => helpers.safeEquals(e, def))) {
         words[word].unshift(def)
@@ -1686,7 +1693,6 @@ class Config {
     cp._uuid = cp.configs[0]._uuid
     // update uuid here set the uuid in the objects and add error checking
     cp.initializerFn = this.initializerFn
-    cp.initAfterApi = this.initAfterApi
     cp._api = _.cloneDeep(this._api)
     cp._namespace = this._namespace
     cp._eqClasses = this._eqClasses
@@ -1836,27 +1842,20 @@ class Config {
       }
       */
       const objects = {}
-      const km = (name) => this.getConfig(name)
       if (config instanceof Config) {
-        // const aw = addWord(this.config, config.uuid)
-        const aw = (word, def) => this.addWord(word, def)
-        const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
         this.get('objects').namespaced[config._uuid] = objects
         if (config._api) {
           config._api.objects = objects
           config._api.config = () => this
         }
-        config.initializerFn({ addWord: aw, addGenerator: ag, km, testConfig: config, config: this.getPsuedoConfig(), baseConfig: this, currentConfig: config, objects, namespace, uuid, api: config.api })
+        config.initializerFn(setupInitializerFNArgs(this, { testConfig: config, currentConfig: config, objects, namespace, uuid }))
       } else {
-        // const aw = addWord(this.config, this.uuid)
-        const aw = (word, def) => this.addWord(word, def)
-        const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
         this.get('objects').namespaced[this._uuid] = objects
         if (config._api) {
           config._api.objects = objects
           config._api.config = () => this
         }
-        this.initializerFn({ addWord: aw, addGenerator: ag, km, testConfig: this, config: this.getPsuedoConfig(), baseConfig: this, currentConfig: this, objects, namespace, uuid, api: this.api })
+        this.initializerFn(setupInitializerFNArgs(this, { testConfig: this, currentConfig: this, objects, namespace, uuid }))
       }
     })
     this.instances.forEach((instance) => client.processInstance(this, instance))
@@ -1864,13 +1863,8 @@ class Config {
 
   initialize ({ force = true } = {}) {
     if (force || !this.wasInitialized) {
-      // const aw = addWord(this.config, this.uuid)
-      const aw = (word, def) => this.addWord(word, def)
-      const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
-      const km = (name) => this.getConfig(name)
-      // this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects: this.get('objects'), uuid: this._uuid, namespace: '', api: this.api })
       const objects = this.config.objects.namespaced[this._uuid]
-      this.initializerFn({ addWord: aw, addGenerator: ag, km, testConfig: this, config: this.getPsuedoConfig(), baseConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '', api: this.api })
+      this.initializerFn(setupInitializerFNArgs(this, { testConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '' }))
       this.wasInitialized = true
     }
   }
@@ -1878,16 +1872,14 @@ class Config {
   initializer (fn, options = {}) {
     if (options) {
       for (let option of Object.keys(options)) {
-        const validOptions = ['initAfterApi']
-        if (!['initAfterApi'].includes(option)) {
+        const validOptions = []
+        if (!validOptions.includes(option)) {
           throw new Error(`For Config.initializer, unrecognized option ${option}. The valid options are ${validOptions}`)
         }
       }
     }
-    const { initAfterApi = false } = options;
     this.wasInitialized = false
-    this.initAfterApi = initAfterApi
-    this.initializerFn = (args) => {
+    this.initializerFn = (args, { dontCallFn } = {}) => {
       const transitoryMode = global.transitoryMode
       global.transitoryMode = false
       // const baseConfig = args.baseConfig
@@ -1900,7 +1892,10 @@ class Config {
         currentConfig.api.uuid = currentConfig._uuid
       }
       // this.instances.forEach( (instance) => client.processInstance(this, instance) )
-      fn(args)
+      // greg55
+      if (args.isAfterApi) {
+        fn(args)
+      }
       currentConfig.wasInitialized = true
       global.transitoryMode = transitoryMode
     }
@@ -2088,15 +2083,13 @@ class Config {
     const initAfterApis = []
     const reverseIt = true
     const interleaved = true
-    let isAfterApi = false
     this.configs.forEach((km) => {
       const namespace = km.namespace
       this.config.objects.namespaced[km._uuid] = {}
       const namespacedObjects = this.config.objects.namespaced[km._uuid]
       this.setupNamespace(km)
-      // const aw = addWord(km.config.config ? km.config.config : km.config, km.config.uuid)
-      const aw = (word, def) => this.addWord(word, def)
-      const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
+      // const aw = (word, def) => this.addWord(word, def)
+      // const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
       let config = km.config
      
       if (config.addedArgss) { 
@@ -2122,37 +2115,31 @@ class Config {
         return config
       }
       // const hierarchy = new DigraphInternal((config.config || {}).hierarchy)
-      const args = new Object({ 
+      const args = new Object(setupInitializerFNArgs(this, { 
         isModule, 
-        addWord: aw, 
-        addGenerator: ag,
-        km: kmFn, 
         hierarchy: this.hierarchy, 
         testConfig: config,
-        config: this.getPsuedoConfig(), 
-        baseConfig: this, 
         currentConfig: config, 
         uuid: config._uuid, 
         objects: namespacedObjects, 
         namespace, 
         motivation: (m) => this.addMotivation(m),
-        get api() {
-          if (!isAfterApi) {
-            throw new Error("APIs should not be accessed in the initializer until after they are all initialized. Call initializer like config.initializer(fn, { initAfterApi: true }). Then the args to the initalizer will include isAfterApi which can be used to determine if the initialize is being run before or after the API's are initialized. The default is before.")
-          }
-          return config.api 
-        }
-      })
-      config.initializerFn(args)
-      if (config.initAfterApi) {
-        // reverse the list
-        initAfterApis.unshift({ config, args })
-      } else {
-        if (interleaved) {
-          initAfterApis.unshift(null)
-        }
+        api: config.api,
+      }))
+
+      const currentConfig = args.currentConfig
+
+      if (args.currentConfig.api) {
+        args.currentConfig.api.objects = args.objects
+        // TODO assign pseudo config?
+        args.currentConfig.api.config = () => args.baseConfig
+        args.currentConfig.api.uuid = args.currentConfig._uuid
+        args.currentConfig.wasInitialized = true
       }
-      // greg
+      // debugger
+      // greg55
+      config.initializerFn(args, { dontCallFn: true })
+        initAfterApis.unshift({ config, args })
       if (config._api) {
         if (config._api.initialize) {
           // reverse the list
@@ -2194,7 +2181,6 @@ class Config {
       this.config.semantics = []
     }
 
-    isAfterApi = true
     if (!interleaved) {
       for (const config of addInternals) {
         if (!reverseIt) {
@@ -2208,8 +2194,7 @@ class Config {
         init()
       }
       for (let init of initAfterApis) {
-        // init.args.isAfterApi = true
-        init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi })
+        init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true })
       }
       this.instances.forEach((instance) => client.processInstance(this, instance))
     } else {
@@ -2242,11 +2227,12 @@ class Config {
         }
         // console.log('name -------------', name)
         if (inits[i]) {
+          // greg55
           inits[i]()
         }
         if (initAfterApis[i]) {
           const init = initAfterApis[i]
-          init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi})
+          init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true})
         }
         const instance = this.instances.find((instance) => instance.name == name)
         if (instance) {
@@ -2377,15 +2363,9 @@ class Config {
         }
         const km = (name) => this.getConfig(name)
         if (config instanceof Config) {
-          // const aw = addWord(this.config, config.uuid)
-          const aw = (word, def) => this.addWord(word, def)
-          const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
-          config.initializerFn({ isModule: this.isModule, addWord: aw, addGenerator: ag, baseConfig: this, km, currentConfig: config, testConfig: config, config: this.getPsuedoConfig(), objects: nsobjects, namespace, uuid, api: config.api })
+          config.initializerFn(setupInitializerFNArgs(this, { isModule: this.isModule, currentConfig: config, testConfig: config, objects: nsobjects, namespace, uuid }))
         } else {
-          // const aw = addWord(this.config, this.uuid)
-          const aw = (word, def) => this.addWord(word, def)
-          const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
-          this.initializerFn({ isModule: this.isModule, addWord: aw, addGenerator: ag, baseConfig: this, km, currentConfig: this, testConfig: this, config: this.getPsuedoConfig(), objects: nsobjects, namespace, uuid, api: this.api })
+          this.initializerFn(setupInitializerFNArgs(this, { isModule: this.isModule, currentConfig: this, testConfig: this, objects: nsobjects, namespace, uuid }))
         }
       })
     }