tpmkms_4wp 9.5.1 → 9.6.0-beta.0

package/common/helpers/conjunction.js

@@ -1,7 +1,13 @@
 const { propertyToArray } = require('../helpers.js')
 
-const asList = (context) => {
-  if (context.marker === 'list') {
+function asList(context) {
+  if (Array.isArray(context)) {
+    return {
+      marker: 'list',
+      // types: [context.marker],
+      value: context
+    }
+  } else if (context.marker === 'list') {
     return context
   }
   return {
@@ -11,60 +17,64 @@ const asList = (context) => {
   }
 }
 
-const listable = (hierarchy) => (c, type) => {
-  if (!c) {
-    return false
-  }
-  if (hierarchy.isA(c.marker, type)) {
-    return true
-  }
-  if (c.marker === 'list') {
-    for (const t of c.types) {
-      if (hierarchy.isA(t, type)) {
-        return true
+function listable(hierarchy) {
+  return (c, type) => {
+    if (!c) {
+      return false
+    }
+    if (hierarchy.isA(c.marker, type)) {
+      return true
+    }
+    if (c.marker === 'list') {
+      for (const t of c.types) {
+        if (hierarchy.isA(t, type)) {
+          return true
+        }
       }
     }
-  }
-  return false
-}
-
-const isA = (hierarchy) => (child, parent, { strict=false } = {}) => {
-  if (!child || !parent) {
     return false
   }
+}
 
-  if (strict) {
-    if (child.marker) {
-      child = child.marker
-    }
-    if (parent.marker) {
-      parent = parent.marker
+function isA(hierarchy) {
+  return (child, parent, { strict=false } = {}) => {
+    if (!child || !parent) {
+      return false
     }
-    return hierarchy.isA(child, parent)
-  } else {
-    const children = propertyToArray(child)
-    for (const child of children) {
-      let okay = false
-      if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
-        okay = true
-      } else {
-        for (const childT of child.types || [child]) {
-          if (okay) {
-            break
-          }
-          for (const parentT of parent.types || [parent]) {
-            if (hierarchy.isA(childT, parentT)) {
-              okay = true
+
+    if (strict) {
+      if (child.marker) {
+        child = child.marker
+      }
+      if (parent.marker) {
+        parent = parent.marker
+      }
+      return hierarchy.isA(child, parent)
+    } else {
+      const children = propertyToArray(child)
+      for (const child of children) {
+        let okay = false
+        if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
+          okay = true
+        } else {
+          for (const childT of child.types || [child]) {
+            if (okay) {
               break
             }
+            for (const parentT of parent.types || [parent]) {
+              if (hierarchy.isA(childT, parentT)) {
+                okay = true
+                break
+              }
+            }
           }
         }
+        if (!okay) {
+          return false
+        }
       }
-      if (!okay) {
-        return false
-      }
+      return true
     }
-    return true
   }
 }
 

package/common/helpers/dateTimeSelectors.js

@@ -86,8 +86,8 @@ function getTime(time) {
   return { hour, minute, second }
 }
 
-instantiate = (isA, now, context) => {
-  const getType = (context, type) => {
+function instantiate(isA, now, context) {
+  function getType(context, type) {
     if (context.marker == 'onDate_dates' && context.date?.marker == type) {
       return context.date
     } if (context.marker == type) {

package/common/helpers/dialogues.js

@@ -83,16 +83,24 @@ class API {
     }
     const { word, value, number } = context;
     if (!value) {
+      if (config.exists(context.marker)) {
+        return context.marker
+      }
       return
     }
     // const concept = pluralize.singular(value)
-    const concept = this.toScopedId(context)
+    let concept = this.toScopedId(context)
+    const extraTypes = []
+    if (concept == 'unit' && context.objects) {
+      concept = context.objects.map((c) => this.toScopedId(c)).join("_")
+      types.push(this.toScopedId(context.objects[0]))
+    }
     if (config.exists(concept)) {
       return concept
     }
 
     // TODO handle the general case
-    const fixUps = (concept) => {
+    function fixUps(concept) {
       if (concept == '*') {
         return '\\*'
       }

package/common/helpers/formulas.js

@@ -13,7 +13,7 @@ function getVariables(expression, isVariable = (expression) => typeof expression
   return []
 }
 
-const match = (values, head, value) => {
+function match(values, head, value) {
   for (const prop in head) {
     if (head[prop] instanceof Function) {
       if (!head[prop](value[prop])) {
@@ -33,22 +33,24 @@ const match = (values, head, value) => {
   return true
 }
 
-const unify = (rule, value) => {
+function unify(rule, value) {
   const values = { ...rule.values }
   if (match(values, rule.head(values), value)) {
     return rule.body(values)
   }
 }
 
-const f = (values, variable) => (value) => {
-  if (!value) {
-    throw new Error("Value not present")
-  }
-  if (values[variable] && values[variable] != value) {
-    throw new Error("Variable already set to different value")
+function f(values, variable) {
+  return (value) => {
+    if (!value) {
+      throw new Error("Value not present")
+    }
+    if (values[variable] && values[variable] != value) {
+      throw new Error("Variable already set to different value")
+    }
+    values[variable] = value
+    return true
   }
-  values[variable] = value
-  return true
 }
 
 const rules = [
@@ -74,7 +76,7 @@ const rules = [
 ]
 
 function solveFor(expression, variable, isVariable = (expression) => typeof expression.value != 'number') {
-  const sameVar = (c1, c2) => {
+  function sameVar(c1, c2) {
     return c1.value == c2.value
   }
 

package/common/helpers/menus.js

@@ -1,10 +1,10 @@
-const calculateLefts = (defs) => {
+function calculateLefts(defs) {
   const lefts = {}
   calculateLeftsHelper(defs, lefts)
   return lefts
 }
 
-const calculateLeftsHelper = (defs, lefts) => {
+function calculateLeftsHelper(defs, lefts) {
   if (Array.isArray(defs)) {
     let previous
     for (const def of defs) {
@@ -19,13 +19,13 @@ const calculateLeftsHelper = (defs, lefts) => {
   return lefts
 }
 
-const calculateRights = (defs) => {
+function calculateRights(defs) {
   const rights = {}
   calculateRightsHelper(defs, rights)
   return rights
 }
 
-const calculateRightsHelper = (defs, rights) => {
+function calculateRightsHelper(defs, rights) {
   if (Array.isArray(defs)) {
     let previous
     for (const def of defs) {
@@ -40,13 +40,13 @@ const calculateRightsHelper = (defs, rights) => {
   return rights
 }
 
-const calculateDowns = (defs) => {
+function calculateDowns(defs) {
   const downs = {}
   calculateDownsHelper(defs, downs)
   return downs
 }
 
-const calculateDownsHelper = (defs, downs) => {
+function calculateDownsHelper(defs, downs) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       calculateDownsHelper(def, downs)
@@ -72,13 +72,13 @@ const calculateDownsHelper = (defs, downs) => {
   return downs
 }
 
-const calculateUps = (defs) => {
+function calculateUps(defs) {
   const ups = {}
   calculateUpsHelper(defs, ups)
   return ups
 }
 
-const calculateUpsHelper = (defs, ups) => {
+function calculateUpsHelper(defs, ups) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       calculateUpsHelper(def, ups)
@@ -100,13 +100,13 @@ const calculateUpsHelper = (defs, ups) => {
   return ups
 }
 
-const calculateParents = (defs) => {
+function calculateParents(defs) {
   const parents = {}
   calculateParentsHelper(defs, parents)
   return parents
 }
 
-const calculateParentsHelper = (defs, parents) => {
+function calculateParentsHelper(defs, parents) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       parents[def.key] = def.key
@@ -123,13 +123,13 @@ const calculateParentsHelper = (defs, parents) => {
   return parents
 }
 
-const calculatePaths = (defs) => {
+function calculatePaths(defs) {
   const paths = {}
   calculatePathsHelper(defs, paths)
   return paths
 }
 
-const calculatePathsHelper = (defs, paths) => {
+function calculatePathsHelper(defs, paths) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       calculatePathsHelper(def, paths)

package/common/helpers/meta.js

@@ -1,6 +1,6 @@
 const _ = require('lodash')
 
-const hashIndexesGet = (hash, indexes) => {
+function hashIndexesGet(hash, indexes) {
   let value = hash
   for (const i of indexes) {
     value = value[i]
@@ -8,7 +8,7 @@ const hashIndexesGet = (hash, indexes) => {
   return value
 }
 
-const hashIndexesSet = (hash, indexes, value) => {
+function hashIndexesSet(hash, indexes, value) {
   let currentValue = hash
   for (const i of indexes.slice(0, -1)) {
     if (!currentValue[i]) {
@@ -19,7 +19,7 @@ const hashIndexesSet = (hash, indexes, value) => {
   currentValue[indexes[indexes.length-1]] = value
 }
 
-const isPrefix = (prefix, fix) => {
+function isPrefix(prefix, fix) {
   return prefix.every((element, index) => {
     return prefix[index] === fix[index]
   })
@@ -27,11 +27,11 @@ const isPrefix = (prefix, fix) => {
 }
 
 // assumes isPrefix is true
-const replacePrefix = (prefix, prefixPrime, fix) => {
+function replacePrefix(prefix, prefixPrime, fix) {
   return prefixPrime.concat(fix.slice(prefix.length))
 }
 
-const compose = (m1s, m2s) => {
+function compose(m1s, m2s) {
   return m2s.map( (m2) => { 
     m1 = m1s.find( (m1) => isPrefix(m1.from, m2.from) )
     if (m1) {
@@ -48,7 +48,7 @@ const compose = (m1s, m2s) => {
           '[{"from":["two"],"to":["owner"]},{"from":["one"],"to":["ownee"]},{"from":["number"],"to":["number"]}]'
 */
 
-const translationMapping = (from, to) => {
+function translationMapping(from, to) {
   const mappings = []
   if (from.atomic) {
     return mappings
@@ -65,7 +65,7 @@ const translationMapping = (from, to) => {
     if (matchField) {
       let found = false
       const todo = Object.keys(to).map( (key) => [key] )
-      while (!found) {
+      while (!found && todo.length > 0) {
         const tkey = todo.shift()
         const tvalue = hashIndexesGet(to, tkey);
         const fvalue = hashIndexesGet(from, [fkey]);
@@ -89,7 +89,7 @@ const translationMapping = (from, to) => {
   return mappings
 }
 
-const translationMappings = (froms, to) => {
+function translationMappings(froms, to) {
   const mappingss = []
   for (const from of froms) {
     mappingss.push(translationMapping(from, to))
@@ -97,7 +97,7 @@ const translationMappings = (froms, to) => {
   return mappingss
 }
 
-const translationMappingToInstantiatorMappings  = (translationMapping, from , to) => {
+function translationMappingToInstantiatorMappings(translationMapping, from , to) {
   return translationMapping.map( (tm) => {
     return {
       // match: ({context}) => context.value == to[tm.to].value,