tpmkms_4wp 9.5.1 → 9.6.0

package/common/helpers.js

@@ -1,13 +1,14 @@
 const pluralize = require('pluralize')
+const { flatten } = require('./runtime').theprogrammablemind
 
-const unshiftL = (list, element, max) => {
+function unshiftL(list, element, max) {
   if (list.length >= max) {
     list.pop()
   }
   list.unshift(element)
 }
 
-const pushL = (list, element, max) => {
+function pushL(list, element, max) {
   if (list.length >= max) {
     list.shift()
   }
@@ -15,11 +16,11 @@ const pushL = (list, element, max) => {
 }
 
 // X pm today or tomorrow
-const millisecondsUntilHourOfDay = (newDate, hour) => {
+function millisecondsUntilHourOfDay(newDate, hour) {
   const now = newDate()
   const target = newDate(now)
 
-  const addHours = (date, h) => {
+  function addHours(date, h) {
     date.setTime(date.getTime() + (h*60*60*1000));
   }
   const hours = target.getHours()
@@ -34,11 +35,11 @@ const millisecondsUntilHourOfDay = (newDate, hour) => {
   return diff;
 }
 
-const indent = (string, indent) => {
+function indent(string, indent) {
   return string.replace(/^/gm, ' '.repeat(indent));
 }
 
-const getCount = (context) => {
+function getCount(context) {
   if (context.quantity) {
     return context.quantity.value
   }
@@ -47,13 +48,23 @@ const getCount = (context) => {
   }
 }
 
-const words = (word, additional = {}) => {
+function words(word, additional = {}) {
   return [{ word: pluralize.singular(word), number: 'one', ...additional }, { word: pluralize.plural(word), number: 'many', ...additional }]
 }
 
-const isMany = (context) => {
-  if (((context || {}).value || {}).marker == 'list' && (((context || {}).value || {}).value || []).length > 1) {
-    return true
+function isMany(context) {
+  if (!context) {
+    return
+  }
+  // if (((context || {}).value || {}).marker == 'list' && (((context || {}).value || {}).value || []).length > 1) {
+  const isList = context.marker == 'list' || context.value?.marker == 'list'
+  if (isList) {
+    if (context.value?.length > 1) {
+      return true
+    }
+    if (context.value?.value?.length > 1) {
+      return true
+    }
   }
 
   let number = context.number
@@ -77,13 +88,13 @@ const isMany = (context) => {
   return false
 }
 
-const requiredArgument = (value, name) => {
+function requiredArgument(value, name) {
   if (!value) {
     throw new Error(`${name} is a required argument`)
   }
 }
 
-const chooseNumber = (context, one, many) => {
+function chooseNumber(context, one, many) {
   if (isMany(context)) {
     return many;
   } else {
@@ -91,7 +102,7 @@ const chooseNumber = (context, one, many) => {
   }
 }
 
-const zip = (...arrays) => {
+function zip(...arrays) {
   if (arrays == []) {
     return []
   }
@@ -107,15 +118,21 @@ const zip = (...arrays) => {
 }
 
 
-const focus = (context) => {
-  const helper = (context) => {
+function focus(context) {
+  function helper(context) {
     if (!context || !context.focusable) {
       return null
     }
     for (const property of context.focusable) {
       let focus = helper(context[property])
-      if (!focus && (context[property] || {}).focus) {
-        focus = context[property]
+      if (!focus) {
+        const flat = flatten(['list'], context[property])[0]
+        for (const element of flat) {
+          if (element.focus) {
+            focus = context[property]
+            break
+          }
+        }
       }
       return focus
     }
@@ -126,7 +143,7 @@ const focus = (context) => {
 
 // if property is a list make array of elements of the list, if not return an array with the property value
 // fromList
-const propertyToArray = (value) => {
+function propertyToArray(value) {
   if (Array.isArray(value)) {
     return value
   } else if (value.marker == 'list') {
@@ -136,7 +153,23 @@ const propertyToArray = (value) => {
   }
 }
 
-wordNumber = (word, toPlural) => {
+// values is marker: 'list' or some context
+function concats(values) {
+  combined = []
+  for (const value of values) {
+    if (value.marker == 'list') {
+      combined = combined.concat(value.value)
+    } else {
+      combined.push(value)
+    }
+  }
+  return {
+    marker: 'list',
+    value: combined
+  }
+}
+
+function wordNumber(word, toPlural) {
   if (toPlural) {
     return pluralize.plural(word)
   } else {
@@ -144,17 +177,18 @@ wordNumber = (word, toPlural) => {
   }
 }
 
-const toEValue = (context) => {
+function toEValue(context) {
   while( context.evalue ) {
     context = context.evalue
   }
 	return context;
 }
 
-const defaultObjectCheck = (extra = []) => {
+function defaultObjectCheck(extra = []) {
   return {
     objects: [
       {
+        extra,
         match: ({objects}) => true,
         apply: () => extra
       },
@@ -162,57 +196,62 @@ const defaultObjectCheck = (extra = []) => {
   }
 }
 
-const defaultContextCheckProperties = (extra) => {
+function defaultContextCheckProperties(extra) {
   return ['marker', 'text', 'verbatim', 'value', 'evalue', 'isResponse', { properties: 'modifiers' }, { properties: 'postModifiers' }, ...extra]
 }
 
-const defaultContextCheck = ({marker, extra = [], exported = false} = {}) => {
+function defaultContextCheck({marker, extra = [], exported = false} = {}) {
   let match
   if (marker) {
     match = ({context}) => context.marker == marker
   } else {
-    match = ({context}) => !Array.isArray(context)
   }
   return {
+    marker,
     match,
     exported,
     apply: () => ['marker', 'text', 'verbatim', 'value', 'evalue', 'isResponse', { properties: 'modifiers' }, { properties: 'postModifiers' }, ...extra],
   }
 }
 
-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
-    }
-    return hierarchy.isA(child, parent)
-  } else {
-    if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
-      return true
+function isA(hierarchy) {
+  return (child, parent, { strict=false } = {}) => {
+    if (!child || !parent) {
+      return false
     }
-    for (const childT of child.types || [child]) {
-      for (const parentT of parent.types || [parent]) {
-        if (hierarchy.isA(childT, parentT)) {
-          return true
+
+    if (strict) {
+      if (child.marker) {
+        child = child.marker
+      }
+      if (parent.marker) {
+        parent = parent.marker
+      }
+      return hierarchy.isA(child, parent)
+    } else {
+      if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
+        return true
+      }
+      for (const childT of child.types || [child]) {
+        for (const parentT of parent.types || [parent]) {
+          if (hierarchy.isA(childT, parentT)) {
+            return true
+          }
         }
       }
+      return false
     }
-    return false
   }
 }
 
-const getValue = (propertyPath, object) => {
+function getValue(propertyPath, object) {
   if (!propertyPath) {
     return
   }
-  const path = propertyPath.split('.')
+  let path = propertyPath
+  if (typeof path == 'string') {
+    path = propertyPath.split('.')
+  }
   let value = object
   for (const name of path) {
     if (!value) {
@@ -223,7 +262,30 @@ const getValue = (propertyPath, object) => {
   return value
 }
 
-const processTemplateString = async (template, evaluate) => {
+function setValue(propertyPath, object, newValue) {
+  if (!propertyPath) {
+    return;
+  }
+  let path = propertyPath;
+  if (typeof path === 'string') {
+    path = propertyPath.split('.');
+  }
+  let current = object;
+  for (let i = 0; i < path.length; i++) {
+    const name = path[i];
+    if (i === path.length - 1) {
+      // Set the value at the final step
+      current[name] = newValue;
+      break;
+    }
+    if (current[name] === undefined || current[name] === null) {
+      current[name] = {};  // Create a plain object for nesting
+    }
+    current = current[name];
+  }
+}
+
+async function processTemplateString(template, evaluate) {
   async function resolveWithCallback(strings, ...keys) {
     // const resolvedValues = await Promise.all(keys.map(key => lookupVariable(key)));
     const resolvedValues = await Promise.all(keys.map(async (key) => {
@@ -263,11 +325,66 @@ const processTemplateString = async (template, evaluate) => {
   return await processTemplateString(template)
 }
 
+// removeProp.js
+function removeProp(obj, testFn, { maxDepth = Infinity, seen = new WeakSet() } = {}) {
+  if (!obj || typeof obj !== 'object' || maxDepth <= 0) return obj;
+  if (seen.has(obj)) return obj;
+  seen.add(obj);
+
+  if (Array.isArray(obj)) {
+    // ---- ARRAY: process each element (but don't remove elements unless testFn says so)
+    let writeIdx = 0;
+    for (let i = 0; i < obj.length; i++) {
+      const element = obj[i];
+      const shouldRemoveElement = testFn(element, i, obj);
+
+      if (shouldRemoveElement) {
+        // Remove the whole array element
+        if (element && typeof element === 'object') {
+          // Still walk inside it in case testFn wants side effects
+          removeProp(element, testFn, { maxDepth: maxDepth - 1, seen });
+        }
+        // Skip writing it back
+      } else {
+        // Keep element, but walk into it to remove inner props
+        removeProp(element, testFn, { maxDepth: maxDepth - 1, seen });
+        if (writeIdx !== i) {
+          obj[writeIdx] = element;
+        }
+        writeIdx++;
+      }
+    }
+    obj.length = writeIdx;
+    return obj;
+  }
+
+  // ---- OBJECT: iterate over own keys
+  const keys = Reflect.ownKeys(obj);
+  for (const key of keys) {
+    const val = obj[key];
+    const shouldRemove = testFn(val, key, obj);
+
+    if (shouldRemove) {
+      delete obj[key];
+      if (val && typeof val === 'object') {
+        removeProp(val, testFn, { maxDepth: maxDepth - 1, seen });
+      }
+    } else {
+      removeProp(val, testFn, { maxDepth: maxDepth - 1, seen });
+    }
+  }
+
+  return obj;
+}
+
 module.exports = {
   processTemplateString,
   unshiftL,
   pushL,
+
   getValue,
+  setValue,
+
   defaultContextCheck,
   defaultContextCheckProperties,
   defaultObjectCheck,
@@ -284,4 +401,6 @@ module.exports = {
   wordNumber,
   requiredArgument,
   isA,
+  removeProp,
+  concats
 }

package/common/hierarchy.js

@@ -1,4 +1,4 @@
-const { knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { debug, knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const properties = require('./properties')
 const hierarchy_tests = require('./hierarchy.test.json')
@@ -6,11 +6,11 @@ const pluralize = require('pluralize')
 const _ = require('lodash')
 const { isMany } = require('./helpers')
 
-const getTypes = ( km, concept, instance ) => {
+function getTypes( km, concept, instance ) {
   const propertiesAPI = km('properties').api;
   const conceptAPI = km('concept').api;
   const digraph = propertiesAPI.digraph;
-  const intersect = (set1, set2) => {
+  function intersect(set1, set2) {
     return new Set([...set1].filter(x => set2.has(x)))
   }
   const descendants = digraph.descendants(concept.value)
@@ -253,9 +253,11 @@ 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)
+            api.seenHierarchyWatcher({ childId: oneConceptId, child: oneConcept, parentId: twoConceptId, parent: twoConcept })
             context.sameWasProcessed = true
           }
         }
@@ -286,7 +288,7 @@ const config = {
   ]
 };
 
-const initializer = ({apis, hierarchy}) => {
+function initializer({apis, hierarchy}) {
     apis('stm').addIsA( (child, parent) => {
       return hierarchy.isA(child, parent) 
     })

package/common/kirk.instance.json

@@ -1666,7 +1666,7 @@
             "dead": true,
             "range": {
               "start": 0,
-              "end": 11
+              "end": 2
             },
             "types": [
               "self"