ekms 9.7.1-beta.11 → 9.7.1-beta.13

package/common/fastfood.js

@@ -145,6 +145,7 @@ const template = {
       floaters: ['instance'],
       priorities: [
        // { "context": [['counting', 0], ['strawberry_smoothie', 0], ], "choose": [0] },
+       { "context": [['counting', 0], ['strawberry_smoothie', 0], ], "choose": [1] },
        { "context": [['cheese_potato', 0], ['broccoli_list_cheddar_potato', 0]], "choose": [1] },
        { "context": [['chicken_go_wrap', 0], ['chicken_sandwich', 0], ], "choose": [0] },
        { "context": [['strawberry_banana', 0], ['smoothie', 0], ], "choose": [0] },
@@ -442,6 +443,12 @@ const template = {
         ],
       },
     },
+    {
+      priorities: [
+        { context: [['list', 0], ['integer', 0], ['strawberry', 0], ['smoothie', 0]], choose: [2, 3], ordered: true },
+        { context: [['list', 0], ['integer', 1], ['strawberry', 1], ['smoothie', 0]], choose: [2, 3], ordered: true },
+      ],
+    },
   ],
 }
 

package/common/gdefaults.js

@@ -1,4 +1,5 @@
 const pluralize = require('pluralize')
+const { interpolate } = require('./helpers/gdefaults')
 const { defaultContextCheck, getValue, isMany } = require('./helpers')
 const { debug, knowledgeModule, where, flatten } = require('./runtime').theprogrammablemind
 const tokenize = require('./tokenize.js')
@@ -35,8 +36,9 @@ const config = {
       where: where(),
       // match: ({context}) => context.paraphrase && context.interpolate,
       match: ({context}) => context.interpolate,
-      apply: async ({interpolate, context}) => {
-        return interpolate(context.interpolate, context)
+      apply: async (args) => {
+        const {debug, context} = args
+        return interpolate(args)(context.interpolate, context)
       }
     },
     {
@@ -112,13 +114,16 @@ const config = {
           if (index == context.postModifiers.length - 1) {
             const fn = Array.isArray(context[modifier]) ? gs: g;
             if (Array.isArray(context[modifier])) {
-              text.push(await gs(context[modifier].map((c) => { return {...c , number} })))
+              debug.breakAt('fastfood#call7')
+              text.push(await gs(context[modifier].map((c) => { return {...c , number} }), { isModifier: true }))
             } else {
-              text.push(await g({...context[modifier], number}))
+              debug.breakAt('fastfood#call7')
+              text.push(await g({...context[modifier], number}, { isModifier: true }))
             }
           } else {
             const fn = Array.isArray(context[modifier]) ? gs: g;
-            text.push(await fn(context[modifier]))
+            debug.breakAt('fastfood#call7')
+            text.push(await fn({ ...context[modifier], isModifier: true }))
           }
         }
         return text.join(' ')
@@ -214,7 +219,7 @@ const config = {
 
     {
       where: where(),
-      match: ({context}) => context.paraphrase && context.word && (context.number == 'many' || context.number > 1),
+      match: ({context}) => context.paraphrase && context.word && (context.number == 'many' || context.number > 1) && !context.isModifier,
       apply: ({context}) => {
         // TODO make the sentence that the plural celcius is celcius work
         if (["fahrenheit", "celcius"].includes(context.word)) {
@@ -307,121 +312,7 @@ function initializer({config}) {
         },
         verbatim, 
         say: verbatim,
-        interpolate: async (interpolate, context) => {
-          async function evaluator(key) {
-            if (Array.isArray(context[key])) {
-              return args.gsp(context[key])
-            } else {
-              return args.gp(context[key])
-            }
-          }
-          function getValue(keyOrValue) {
-            if (typeof keyOrValue == 'string' && context[keyOrValue]) {
-              return context[keyOrValue]
-            }
-            return keyOrValue // it's a value
-          }
-
-          if (Array.isArray(interpolate)) {
-            const strings = []
-            let separator = ''
-            const byPosition = []
-            for (const element of interpolate) {
-              // { "word": { "marker": "canPassive" } ie { word: <selectionCriteria> }
-              if (element.word) {
-                const word = args.getWordFromDictionary(element.word)
-                if (word) {
-                  strings.push(separator)
-                  strings.push(await args.gp(word))
-                  separator = ' '
-                }
-              } else if (typeof element == 'string') {
-                separator = element
-              } else if (element.separator && element.values) {
-                let ctr = 0
-                const values = getValue(element.values)
-                const vstrings = []
-                for (const value of values) {
-                  if (ctr == values.length-1) {
-                    vstrings.push(getValue(element.separator))
-                  }
-                  ctr += 1
-                  vstrings.push(getValue(value))
-                }
-                strings.push(await args.gsp(vstrings))
-              } else if (element.semantic) {
-                const wordContext = {}
-                for (const term of element.semantic) {
-                  if (term.property) {
-                    Object.assign(wordContext, context[term.property])
-                  } else if (term.overrides) {
-                    Object.assign(wordContext, term.overrides)
-                  }
-                }
-                const value = await args.gp(wordContext) //, { options: { debug: { apply: true } } })
-                if (value) {
-                  strings.push(separator)
-                  strings.push(await args.gp(value))
-                  separator = ' '
-                }
-              } else if (element.property) {
-                value = context[element.property]
-                if (value) {
-                  if (element.context) {
-                    value = { ...value, ...element.context }
-                  }
-                  async function handleProperty(value) {
-                    strings.push(separator)
-                    if (Array.isArray(value)) {
-                      strings.push(await args.gsp(value))
-                    } else {
-                      strings.push(await args.gp(value))
-                    }
-                    separator = ' '
-                  }
-                  if (element.byPosition) {
-                    const element = { start: value.range.start, insert: ((value) => () => handleProperty(value))(value) }
-                    if (byPosition.length == 0) {
-                      byPosition.push(element)
-                    } else {
-                      const index = byPosition.findIndex((element) => element.start < value.range.start)
-                      if (index == -1) {
-                        byPosition.unshift(element)
-                      } else {
-                        byPosition.splice(index+1, 0, element)
-                      }
-                    }
-                  } else {
-                    await handleProperty(value)
-                  }
-                }
-              } else if (element.context) {
-                let value = element.context
-                if (element.property) {
-                  value = context[element.property]
-                  if (element.context) {
-                    Object.assign(value, element.context)
-                  }
-                }
-                // if (!value?.number && element.number) {
-                if (value?.form !== 'infinitive' && element.number) {
-                  value.number = isMany(context[element.number]) ? "many": "one"
-                }
-                if (value) {
-                  strings.push(separator)
-                  strings.push(await args.gp(value))
-                  separator = ' '
-                }
-              }
-            }
-            for (const { insert } of byPosition) {
-              await insert()
-            }
-            return strings.join('')
-          } else {
-            return await helpers.processTemplateString(interpolate, evaluator)
-          }
-        }
+        interpolate: interpolate(args),
       }
     })
   }

package/common/hierarchy.js

@@ -258,7 +258,6 @@ const config = {
         const twoConcepts = asList(context.same);
         for (const oneConcept of oneConcepts.value) {
           for (const twoConcept of twoConcepts.value) {
-            // debug.counter('greg23', { breakAt: 39 })
             oneConceptId = await api.makeObject({...args, context: oneConcept})
             twoConceptId = await api.makeObject({...args, context: twoConcept})
             api.rememberIsA(oneConceptId, twoConceptId)

package/common/length.instance.json

@@ -4747,6 +4747,33 @@
               "unit"
             ],
             "propertyOf": true,
+            "interpolate": [
+              {
+                "property": "property"
+              },
+              {
+                "word": "of"
+              },
+              {
+                "property": "object"
+              }
+            ],
+            "property": {
+              "value": "unit",
+              "number": "many",
+              "text": "units",
+              "marker": "unit",
+              "dead": true,
+              "word": "units",
+              "range": {
+                "start": 51,
+                "end": 55
+              },
+              "types": [
+                "unit"
+              ],
+              "level": 0
+            },
             "object": {
               "marker": "length",
               "value": "length",

package/common/ordering.instance.json

@@ -676,7 +676,8 @@
               "unknown"
             ],
             "level": 0,
-            "concept": true
+            "concept": true,
+            "evaluate": false
           },
           "two": {
             "marker": "xfx",

package/common/ordinals.js

@@ -17,7 +17,7 @@ const config = {
       id: "ordinal", 
       isA: ["listable"],
       bridge: "{ instance: false, ordinal: true, ...next(operator) }",
-      init: { 'notConjunctableWith':['quantity'] },
+      initial: { 'notConjunctableWith':['quantity', 'number'] },
     },
     { 
       id: "orderable", 
@@ -28,8 +28,14 @@ const config = {
       id: "ordinalOnOrdered", 
       isA: ['adjective'],
       convolution: true,
-      // bridge: "{ ...after[0], ordinal: before[0], modifiers: append(['ordinal'], after[0].modifiers), generate: append(['ordinal'], or(after[0].generate, after)) }" 
-      bridge: "{ ...after[0], ordinal: before[0], modifiers: append(['ordinal'], after[0].modifiers) }" 
+      // bridge: "{ ...after[0], ordinal: before[0], modifiers: append(['ordinal'], after[0].modifiers), interpolate: append(['ordinal'], or(after[0].interpolate, after)) }" 
+      bridge: `{ 
+        ...after[0], 
+        ordinal: before[0], 
+        ordinalObject: after[0],
+        interpolate: [{ property: 'ordinal' }, { property: 'ordinalObject' }],
+        modifiers: append(['ordinal'], after[0].modifiers) 
+      }` 
     },
   ],
   semantics: [

package/common/pipboy.instance.json

@@ -17,7 +17,7 @@
     "medicine and stimpaks are takeable",
     "item modifies property",
     {
-      "apply": "({config}) => {\n      config.updateBridge('item_property', ({ bridge }) => {\n        if (!bridge.init) {\n          bridge.init = {}\n        }\n        bridge.init['typeIsSingular'] = true\n      })\n    }"
+      "apply": "({config}) => {\n      config.updateBridge('item_property', ({ bridge }) => {\n        if (!bridge.initial) {\n          bridge.initial = {}\n        }\n        bridge.initial['typeIsSingular'] = true\n      })\n    }"
     },
     "damage luck hp rads value ap charisma range and accuracy are item properties",
     {
@@ -35896,7 +35896,7 @@
       }
     },
     {
-      "apply": "({config}) => {\n      config.updateBridge('item_property', ({ bridge }) => {\n        if (!bridge.init) {\n          bridge.init = {}\n        }\n        bridge.init['typeIsSingular'] = true\n      })\n    }"
+      "apply": "({config}) => {\n      config.updateBridge('item_property', ({ bridge }) => {\n        if (!bridge.initial) {\n          bridge.initial = {}\n        }\n        bridge.initial['typeIsSingular'] = true\n      })\n    }"
     },
     {
       "hierarchy": [

package/common/pipboy.js

@@ -489,10 +489,10 @@ const template = {
     "item modifies property",
     ({config}) => {
       config.updateBridge('item_property', ({ bridge }) => {
-        if (!bridge.init) {
-          bridge.init = {}
+        if (!bridge.initial) {
+          bridge.initial = {}
         }
-        bridge.init['typeIsSingular'] = true
+        bridge.initial['typeIsSingular'] = true
       })
     },
     "damage luck hp rads value ap charisma range and accuracy are item properties",

package/common/pressure.instance.json

@@ -4420,6 +4420,33 @@
               "unit"
             ],
             "propertyOf": true,
+            "interpolate": [
+              {
+                "property": "property"
+              },
+              {
+                "word": "of"
+              },
+              {
+                "property": "object"
+              }
+            ],
+            "property": {
+              "value": "unit",
+              "number": "many",
+              "text": "units",
+              "marker": "unit",
+              "dead": true,
+              "word": "units",
+              "range": {
+                "start": 28,
+                "end": 32
+              },
+              "types": [
+                "unit"
+              ],
+              "level": 0
+            },
             "object": {
               "value": "pressure",
               "number": "one",