tpmkms 9.7.1-beta.13 → 9.7.1-beta.14

package/common/helpers/gdefaults.js

@@ -0,0 +1,143 @@
+const helpers = require('../helpers')
+
+function interpolate(args) {
+  return 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 = []
+      let number;
+      for (const [elementIndex, element] of interpolate.entries()) {
+        const isLastElement = elementIndex == interpolate.length - 1
+        // { "word": { "marker": "canPassive" } ie { word: <selectionCriteria> }
+        async function handleElement(context, element) {
+          if (element.context?.invisible) {
+            return
+          }
+          if (element.word) {
+            const word = args.getWordFromDictionary(element.word) || 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 (element.isQuantified && number && isLastElement) {
+                  value.number = number
+                }
+                if (Array.isArray(value)) {
+                  strings.push(await args.gsp(value))
+                } else {
+                  strings.push(await args.gp(value))
+                }
+                separator = ' '
+              }
+              if (element.isQuantifier) {
+                number = helpers.isMany({ quantity: value }) ? "many": "one"
+              }
+              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?.form !== 'infinitive' && element.number) {
+              value.number = helpers.isMany(context[element.number]) ? "many": "one"
+            }
+            if (value) {
+              strings.push(separator)
+              strings.push(await args.gp(value))
+              separator = ' '
+            }
+          }
+        }
+
+        let currentContext = context
+        let currentElement = element
+        while (currentElement.inside) {
+          currentContext = currentContext[currentElement.inside]
+          currentElement = currentElement.value
+        }
+        await handleElement(currentContext, currentElement)
+      }
+      for (const { insert } of byPosition) {
+        await insert()
+      }
+      return strings.join('')
+    } else {
+      return await helpers.processTemplateString(interpolate, evaluator)
+    }
+  }
+}
+
+module.exports = {
+  interpolate
+}

package/package.json

@@ -254,6 +254,7 @@
     "common/helpers/drone.js",
     "common/helpers/formulas.js",
     "common/helpers/frankenhash.js",
+    "common/helpers/gdefaults.js",
     "common/helpers/menus.js",
     "common/helpers/meta.js",
     "common/helpers/ordering.js",
@@ -392,8 +393,8 @@
     "scriptjs": "^2.5.9",
     "table": "^6.7.1",
     "uuid": "^9.0.0",
-    "theprogrammablemind": "9.7.1-beta.13"
+    "theprogrammablemind": "9.7.1-beta.14"
   },
-  "version": "9.7.1-beta.13",
+  "version": "9.7.1-beta.14",
   "license": "UNLICENSED"
 }