tpmkms_4wp 8.0.0-beta.21 → 8.0.0-beta.23

package/common/reports.js

@@ -100,7 +100,7 @@ const apiTemplate = (marker, testData) => {
     },
     productGenerator: {
       match: ({context}) => context.marker == marker && context.isInstance, 
-      apply: ({g, context}) => `${context.name}`,
+      apply: ({context}) => `${context.name}`,
     }
   }
 }
@@ -190,9 +190,9 @@ let configStruct = {
         bridge: "{ ...next(operator), on: { marker: 'report', pullFromContext: true }, from: after[0], to: after[1] }",
         directionBridge: "{ ...next(operator), on: { marker: 'report', pullFromContext: true }, directionBridge: true, from: after[0], to: after[1] }",
 
-        generatorp: ({context, gp}) => `move ${gp(context.from)} ${gp(context.to)}`,
-        semantic: ({context, e, objects, kms, insert}) => {
-          const report = e(context.on)
+        generatorp: async ({context, gp}) => `move ${await gp(context.from)} ${await gp(context.to)}`,
+        semantic: async ({context, e, objects, kms, insert}) => {
+          const report = await e(context.on)
           const id = report.value.value
           const listing = objects.listings[id]
 
@@ -218,9 +218,9 @@ let configStruct = {
         where: where(),
         id: "remove", level: 0, 
         bridge: "{ ...next(operator), on: { marker: 'report', pullFromContext: true }, removee: after[0] }",
-        generatorp: ({context, gp}) => `remove ${gp(context.removee)}`,
-        semantic: ({context, e, kms, insert, objects}) => {
-          const report = e(context.on)
+        generatorp: async ({context, gp}) => `remove ${await gp(context.removee)}`,
+        semantic: async ({context, e, kms, insert, objects}) => {
+          const report = await e(context.on)
           const id = report.value.value
           const listing = objects.listings[id]
           const column = context.removee.index.value
@@ -232,7 +232,7 @@ let configStruct = {
         where: where(),
         id: "column", level: 0, 
         bridge: "{ ...next(operator), index: after[0] }",
-        generatorp: ({context, gp}) => `column ${gp(context.index)}`,
+        generatorp: async ({context, gp}) => `column ${await gp(context.index)}`,
     },
     { id: "ordering", level: 0, bridge: "{ ...next(operator) }" },
     { id: "direction", level: 0, bridge: "{ ...next(operator) }" },
@@ -248,10 +248,10 @@ let configStruct = {
           {
             where: where(),
             match: ({context}) => context.marker == 'report' && context.describe,
-            apply: ({context, apis, gp, gs, objects}) => {
+            apply: async ({context, apis, gs, objects}) => {
               const listings = objects.listings[context.value]
               // {"type":"tables","columns":["name"],"ordering":[]}
-              return `for ${listings.api}, showing the ${wordNumber('property', listings.columns.length > 1)} ${gs(listings.columns, ' ', ' and ')} as ${listings.type}`
+              return `for ${listings.api}, showing the ${wordNumber('property', listings.columns.length > 1)} ${await gs(listings.columns, ' ', ' and ')} as ${listings.type}`
             }
           },
           {
@@ -297,8 +297,8 @@ let configStruct = {
       level: 0,
       isA: ['verby'],
       bridge: "{ ...next(operator), report: after[0] }",
-      "generatorp": ({g, context}) => `describe ${g(context.report)}`,
-      "generatorr": ({gp, context, apis, objects, config}) => {
+      "generatorp": async ({g, context}) => `describe ${await g(context.report)}`,
+      "generatorr": async ({gp, context, apis, objects, config}) => {
                     const reports = propertyToArray(context.report)
                     let response = ''
                     for (let report of reports) {
@@ -308,11 +308,11 @@ let configStruct = {
                             continue
                           }
                           const description = {describe: true, word: reportId, types:["report"], value: reportId, text: reportId, marker: "report"}
-                          response += `${reportId}: ${gp(description)}\n`
+                          response += `${reportId}: ${await gp(description)}\n`
                         }
                       } else {
                         // response += `${gp(report)}: ${describe(report.value)}\n`
-                        response += `${gp(report)}: ${gp({ ...report, describe: true })}\n`
+                        response += `${await gp(report)}: ${await gp({ ...report, describe: true })}\n`
                       }
                     }
                     return response
@@ -327,9 +327,9 @@ let configStruct = {
       id: "call", 
       level: 0, 
       bridge: "{ ...next(operator), namee: after[0], name: after[1] }",
-      generatorp: ({g, context}) => `call ${g(context.namee)} ${g(context.name)}`,
-      semantic: ({g, context, objects, e, config, km}) => {
-        const namee = e(context.namee).evalue
+      generatorp: async ({g, context}) => `call ${await g(context.namee)} ${await g(context.name)}`,
+      semantic: async ({context, objects, e, config, km}) => {
+        const namee = (await e(context.namee)).evalue
         const id = namee.value
         const listing = objects.listings[id]
         const name = context.name.text
@@ -383,41 +383,23 @@ let configStruct = {
 
   priorities: [
     { "context": [['ordering', 0], ['articlePOS', 0], ], "choose": [0] },
-  /*
-    [['the', 0], ['ordering', 0]],
-    [['listAction', 0], ['cost', 1]],
-    [['answer', 0], ['listAction', 0], ['the', 0]],
-    [['answer', 0], ['listAction', 0], ['the', 0], ['with', 0]],
-  */
   ],
   generators: [
     { 
       notes: 'paraphrase show',
       where: where(),
       match: ({context, objects}) => context.marker == 'show' && context.paraphrase,
-      apply: ({gs, gsp, gp, e, apis, objects, context}) => {
+      apply: async ({gs, gp, e, apis, objects, context}) => {
         if (context.report) {
-          return `show ${gp(context.report)}`
+          return `show ${await gp(context.report)}`
         } else {
-          const report = e(context.on)
+          const report = await e(context.on)
           const id = report.value.value
           const listing = objects.listings[id]
-          return `the properties being shown are ${gs(listing.columns, ', ', ' and ')}`
+          return `the properties being shown are ${await gs(listing.columns, ', ', ' and ')}`
         }
       }
     },
-    /*
-    { 
-      where: where(),
-      match: ({context, isA}) => isA(context.marker, 'reportAction') && context.on && context.isResponse, 
-      apply: ({context, g}) => `${g({...context, on: undefined})} on ${g(context.on)}` 
-    },
-    { 
-      where: where(),
-      match: ({context, isA}) => isA(context.marker, 'reportAction') && context.on && context.paraphrase, 
-      apply: ({context, g}) => `${g({...context, on: undefined})} on ${g(context.on)}` 
-    },
-    */
     { 
       where: where(),
       match: ({context}) => context.marker == 'product' && !context.isInstance, 
@@ -426,12 +408,12 @@ let configStruct = {
     { 
       where: where(),
       match: ({context}) => context.marker == 'listAction' && context.paraphrase, 
-      apply: ({g, context}) => `list ${g(context.what)}` 
+      apply: async ({g, context}) => `list ${await g(context.what)}` 
     },
     { 
       notes: 'show the results as a sentence',
       where: where(),
-      match: ({context, objects, apis}) => {
+      match: ({context, objects}) => {
         if (!(context.marker == 'listAction' && context.isResponse)) {
           return false
         }
@@ -439,15 +421,15 @@ let configStruct = {
           return true
         }
       },
-      apply: ({g, gs, context, objects}) => {
+      apply: async ({g, gs, context, objects}) => {
         const listing = objects.listings[context.id]
-        return `the ${g(listing.api)} are ${gs(context.listing, ' ', ' and ')}` 
+        return `the ${await g(listing.api)} are ${await gs(context.listing, ' ', ' and ')}` 
       }
     },
     { 
       notes: 'show the results as a table',
       where: where(),
-      match: ({context, objects, apis}) => {
+      match: ({context, objects}) => {
         if (!(context.marker == 'listAction' && context.isResponse && !context.paraphrase)) {
           return false
         }
@@ -455,7 +437,7 @@ let configStruct = {
           return true
         }
       }, 
-      apply: ({g, gs, objects, context, e, kms, apis}) => {
+      apply: async ({objects, context, e, kms}) => {
         let report = '';
         const products = context.listing
         const columns = objects.listings[context.id].columns
@@ -463,20 +445,21 @@ let configStruct = {
           kms.stm.api.setVariable('price', { marker: 'price', value: 23 })
           kms.stm.api.setVariable('quantity', { marker: 'quantity', value: 3 })
           const c1 = { marker: 'worth', value: 'worth' }
-          r1 = toEValue(e(c1));
-          r2 = e({ marker: 'supplier', value: 'supplier' })
+          r1 = toEValue(await e(c1));
+          r2 = await e({ marker: 'supplier', value: 'supplier' })
         }
-        const data = products.map( (product) => {
+        const data = []
+        for (const product of products) {
           const row = []
           for (let p of Object.keys(product)) {
             kms.stm.api.setVariable(p, { marker: p, value: product[p] })
           }
           for (let property of columns) {
-            const value = toEValue(e({ marker: property, value: property }));
+            const value = toEValue(await e({ marker: property, value: property }));
             row.push(value)
           }
-          return row
-        });
+          data.push(row)
+        };
         report += table([columns].concat(data))
         return report
       }
@@ -484,12 +467,12 @@ let configStruct = {
     { 
       where: where(),
       match: ({context}) => context.marker == 'answer' && context.paraphrase, 
-      apply: ({g, context}) => `answer with ${context.type}` 
+      apply: ({context}) => `answer with ${context.type}` 
     },
     { 
       where: where(),
       match: ({context}) => context.marker == 'answer' && !context.paraphrase, 
-      apply: ({g, context}) => `answering with ${context.type}` 
+      apply: ({context}) => `answering with ${context.type}` 
     },
   ],
 
@@ -498,13 +481,13 @@ let configStruct = {
       where: where(),
       notes: 'handle show semantic',
       match: ({context}) => context.marker == 'show',
-      apply: ({context, e, km, kms, apis, insert, config, objects}) => {
+      apply: async ({context, e, km, kms, apis, insert, config, objects}) => {
         if (context.report) {
           const values = propertyToArray(context.report)
           const responses = []
           for (let value of values) {
             if (!value.value || value.pullFromContext) {
-              value = e(value)
+              value = await e(value)
             }
             let id = value.value
             if (value.evalue) {
@@ -527,7 +510,7 @@ let configStruct = {
           }
           context.isResponse = true
         } else {
-          const report = e(context.on)
+          const report = await e(context.on)
           const id = report.value.value
           const listing = objects.listings[id]
           const values = propertyToArray(context.properties)
@@ -550,11 +533,11 @@ let configStruct = {
       notes: 'get the report data',
       where: where(),
       match: ({context}) => context.marker == 'listAction', 
-      apply: ({context, e, objects, apis, km, config}) => {
+      apply: async ({context, e, objects, apis, km, config}) => {
         //const name = '***current***'
         if (context.api) {
           // id = newReport({km, objects})
-          const report = e({ marker: 'report', pullFromContext: true })
+          const report = await e({ marker: 'report', pullFromContext: true })
           const id = report.value.value
           const listing = objects.listings[id]
           listing.api = context.api
@@ -562,7 +545,7 @@ let configStruct = {
           context.id = id
           context.listing = apis[listing.api].getAllProducts(listing)
         } else {
-          const report = e({ marker: 'report', pullFromContext: true })
+          const report = await e({ marker: 'report', pullFromContext: true })
           const id = report.evalue.value
           const listing = objects.listings[id]
           const api = apis[listing.api]
@@ -572,16 +555,16 @@ let configStruct = {
         context.isResponse = true
       },
     },
-    [
-      ({context}) => context.marker == 'answer', 
-      ({e, context, objects, kms, insert}) => {
-        const report = e({ marker: 'report', pullFromContext: true })
+    {
+      match: ({context}) => context.marker == 'answer', 
+      apply: async ({e, context, objects, kms, insert}) => {
+        const report = await e({ marker: 'report', pullFromContext: true })
         const id = report.value.value
         const listing = objects.listings[id]
         listing.type = context.type
         kms.events.api.happens(insert, { marker: "changes", level: 1, changeable: { marker: 'report', pullFromContext: true } })
       }
-    ],
+    },
   ],
 };
 
@@ -616,7 +599,7 @@ const createConfig = async () => {
     // config.addAPI(api1)
     // config.addAPI(api2)
   }
-  config.initializer(({config, objects, km, isModule}) => {
+  await config.initializer(({config, objects, km, isModule}) => {
     objects.tempReportId = 0
     objects.listings = {
     }

package/common/scorekeeper.js

@@ -122,36 +122,29 @@ let configStruct = {
     {
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.isResponse && context.two && context.two.marker == 'next',
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
                 const response = context.evalue;
                 const concept = response.two;
                 concept.paraphrase = true
                 concept.isSelf = true
-                const instance = g(concept.evalue)
+                const instance = await g(concept.evalue)
                 return instance
              }
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'point' && context.isResponse && context.amount,
-      apply: ({context, g}) => `${g(context.amount)} points` 
+      apply: async ({context, g}) => `${await g(context.amount)} points` 
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'scored' && context.paraphrase,
-      apply: ({context, g}) => `${g(context.player)} got ${g(context.points)}`
+      apply: async ({context, g}) => `${await g(context.player)} got ${await g(context.points)}`
     },
-    /*
-    {
-      where: where(),
-      match: ({context}) => context.marker == 'enumeration' && context.paraphrase,
-      apply: ({context, g}) => `${g(context.concept)} are ${g(context.items)}`
-    },
-    */
     {
       where: where(),
       match: ({context}) => context.marker == 'start' && context.paraphrase,
-      apply: ({context, g}) => `start ${g(context.arg)}`
+      apply: async ({context, g}) => `start ${await g(context.arg)}`
     },
 
   ],
@@ -161,7 +154,6 @@ let configStruct = {
       where: where(),
       match: ({context}) => context.marker == 'player' && context.same,
       apply: ({context, objects, config, km}) => {
-        //objects.players = context.same.value.map( (props) => props.value )
         const players = context.same.value.map( (props) => props.value )
         setPlayers(objects, config, players)
         for (let player of objects.players) {
@@ -205,11 +197,11 @@ let configStruct = {
               matchq: ({objects}) => objects.players.length == 0,
               applyq: () => 'who are the players?',
               matchr: ({context}) => context.marker == 'list',
-              applyr: ({context, gs, objects, config}) => {
+              applyr: async ({context, gs, objects, config}) => {
                         const players = context.value.map( (player) => player.value )
                         setPlayers(objects, config, players)
                         objects.allPlayersAreKnown = true;
-                        context.verbatim = `The players are ${gs(objects.players, ' ', ' and ')}`
+                        context.verbatim = `The players are ${await gs(objects.players, ' ', ' and ')}`
                         context.isResponse = true;
                       }
             }
@@ -242,12 +234,12 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'player' && context.evaluate && context.pullFromContext,
-      apply: ({context, objects, gs}) => {
+      apply: async ({context, objects, gs}) => {
         const players = objects.players
         if (players.length == 0) {
           context.evalue = 'no one'
         } else {
-          context.evalue = gs(players, ' ', ' and ')
+          context.evalue = await gs(players, ' ', ' and ')
         }
       }
     },
@@ -354,7 +346,7 @@ const createConfig = async () => {
   const config = new Config(configStruct, module)
   config.stop_auto_rebuild()
   await config.add(dialogues, numbers, properties)
-  config.initializer( ({objects, km, isModule}) => {
+  await config.initializer( ({objects, km, isModule}) => {
     objects.players = []
     objects.nextPlayer = undefined;
     setNextPlayer(km, objects);

package/common/sdefaults.js

@@ -12,10 +12,10 @@ let configStruct = {
       // match: ({context}) => context.flatten || context.listable && context.value[0].flatten,
       match: ({context}) => context.flatten || context.listable && context.value.some((value) => value.flatten),
       // match: ({context}) => context.flatten || context.listable || (Array.isArray(context.value) && context.value.some((value) => value.flatten)),
-      apply: ({config, km, context, s}) => {
+      apply: async ({config, km, context, s}) => {
         const [flats, wf] = flatten(['list'], context)
         for (let flat of flats) {
-          s({ ...flat, flatten: false })
+          await s({ ...flat, flatten: false })
         }
       }
     },
@@ -24,8 +24,8 @@ let configStruct = {
       where: where(),
       priority: -1,
       match: ({context}) => context.semanticIsEvaluate,
-      apply: ({context, e}) => {
-        context.value = e({ ...context, semanticIsEvaluate: false })
+      apply: async ({context, e}) => {
+        context.value = await e({ ...context, semanticIsEvaluate: false })
         context.isResponse
       }
     },

package/common/stm.js

@@ -103,7 +103,7 @@ let createConfig = async () => {
   const config = new Config({ name: 'stm' }, module)
   config.stop_auto_rebuild()
 
-  config.initializer( ({config}) => {
+  await config.initializer( ({config}) => {
     config.addArgs(({kms}) => ({
       mentioned: (context) => {
         kms.stm.api.mentioned(context)

package/common/tell.js

@@ -66,25 +66,25 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'tell',
-      apply: ({context, g}) => `tell ${g(context.target)} ${g(context.info.info)} ${g(context.event)}`
+      apply: async ({context, g}) => `tell ${await g(context.target)} ${await g(context.info.info)} ${await g(context.event)}`
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'info',
-      apply: ({context, g}) => context.info
+      apply: ({context}) => context.info
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'event' && context.paraphrase,
-      apply: ({context, g}) => 'event'
+      apply: ({context}) => 'event'
     },
   ],
   semantics: [
     {
       where: where(),
       match: ({context, hierarchy}) => !context.happening && hierarchy.isA(context.marker, 'tell'),
-      apply: ({context, api, s, config}) => {
-        const result = config.processContext({ ...context.event, happening: true })
+      apply: async ({context, api, config}) => {
+        const result = await config.processContext({ ...context.event, happening: true })
         const event = result.context.event
         if (event) {
           event.then( (result) => {
@@ -103,7 +103,7 @@ const createConfig = async () => {
   config.stop_auto_rebuild() 
   await config.setApi(api)
   await config.add(dialogues)
-  config.initializer( ({config, isModule}) => {
+  await config.initializer( ({config, isModule}) => {
       if (!isModule) {
         config.addSemantic({
           match: ({context, hierarchy}) => context.happening && hierarchy.isA(context.marker, 'event'),

package/common/temperature.instance.json

@@ -5239,48 +5239,6 @@
             0
           ]
         ],
-        [
-          [
-            "celcius",
-            0
-          ],
-          [
-            "divideByOperator",
-            0
-          ],
-          [
-            "equals",
-            0
-          ],
-          [
-            "fahrenheit",
-            0
-          ],
-          [
-            "leftParenthesis",
-            0
-          ],
-          [
-            "minusOperator",
-            0
-          ],
-          [
-            "number",
-            0
-          ],
-          [
-            "plusOperator",
-            0
-          ],
-          [
-            "rightParenthesis",
-            0
-          ],
-          [
-            "timesOperator",
-            0
-          ]
-        ],
         [
           [
             "celcius",
@@ -5576,48 +5534,6 @@
         0
       ]
     ],
-    [
-      [
-        "celcius",
-        0
-      ],
-      [
-        "divideByOperator",
-        0
-      ],
-      [
-        "equals",
-        0
-      ],
-      [
-        "fahrenheit",
-        0
-      ],
-      [
-        "leftParenthesis",
-        0
-      ],
-      [
-        "minusOperator",
-        0
-      ],
-      [
-        "number",
-        0
-      ],
-      [
-        "plusOperator",
-        0
-      ],
-      [
-        "rightParenthesis",
-        0
-      ],
-      [
-        "timesOperator",
-        0
-      ]
-    ],
     [
       [
         "celcius",

package/common/testing.js

@@ -13,9 +13,9 @@ let configStruct = {
     {
       where: where(),
       id: 'testingEvaluate',
-      generatorp: ({context, g}) => `${context.word} ${g(context.value)}`,
-      semantic: ({context, e}) => {
-        context.evalue = e(context.value)
+      generatorp: async ({context, g}) => `${context.word} ${await g(context.value)}`,
+      semantic: async ({context, e}) => {
+        context.evalue = await e(context.value)
         context.isResponse = true
       },
       bridge: "{ ...next(operator), value: after[0] }",

package/common/time.js

@@ -103,12 +103,12 @@ const configStruct = {
     { 
       where: where(),
       match: ({context}) => context.marker == 'ampm' && context.paraphrase, 
-      apply: ({g, context, gp}) => `${gp(context.hour)} ${context.ampm}` 
+      apply: async ({g, context, gp}) => `${await gp(context.hour)} ${context.ampm}` 
     },
     { 
       where: where(),
       match: ({context}) => context.marker == 'time' && context.evalue && context.format == 12, 
-      apply: ({g, context}) => {
+      apply: ({context}) => {
         let hh = context.evalue.getHours();
         let ampm = 'am'
         if (hh > 12) {
@@ -175,7 +175,7 @@ const createConfig = async () => {
   config.stop_auto_rebuild()
   await config.add(tell, numbers, countable)
   await config.setApi(api)
-  config.initializer( ({config, objects, kms, isModule}) => {
+  await config.initializer( ({config, objects, kms, isModule}) => {
     if (!isModule) {
       kms.time.api.newDate = () => new Date("December 25, 1995 1:59:58 pm" )
     }

package/common/ui.js

@@ -58,7 +58,7 @@ const configStruct = {
     {
       where: where(),
       match: ({context, isA}) => isA(context, 'direction'),
-      apply: ({context, insert, s, fragments}) => {
+      apply: async ({context, insert, s, fragments}) => {
         const direction = context
         const fragment = fragments("move direction")
         const mappings = [{
@@ -66,8 +66,8 @@ const configStruct = {
           match: ({context}) => context.value == 'direction',
           apply: ({context}) => Object.assign(context, direction),
         }]
-        const instantiation = fragment.instantiate(mappings)
-        s(instantiation)
+        const instantiation = await fragment.instantiate(mappings)
+        await s(instantiation)
       }
     },
   ],
@@ -117,7 +117,7 @@ const configStruct = {
        isA: ['verby'],
        level: 0, 
        bridge: "{ ...next(operator), action: after[0] }",
-       generatorp: ({context, g}) => `stop ${g(context.action)}`,
+       generatorp: async ({context, g}) => `stop ${await g(context.action)}`,
        semantic: ({api, context}) => {
          api.stop(context.action.value)
        }
@@ -128,7 +128,7 @@ const configStruct = {
        isA: ['verby'],
        level: 0, 
        bridge: "{ ...next(operator), direction: after[0] }",
-       generatorp: ({context, g}) => `move ${g(context.direction)}`,
+       generatorp: async ({context, g}) => `move ${await g(context.direction)}`,
        semantic: ({api, context}) => {
          api.move(context.direction.value, context.direction.steps ? context.direction.steps.value : 1)
        }

package/package.json

@@ -280,8 +280,8 @@
     "table": "^6.7.1",
     "base-64": "^1.0.0",
     "argparse": "^2.0.1",
-    "theprogrammablemind_4wp": "8.0.0-beta.21"
+    "theprogrammablemind_4wp": "8.0.0-beta.23"
   },
-  "version": "8.0.0-beta.21",
+  "version": "8.0.0-beta.23",
   "license": "UNLICENSED"
 }