tpmkms_4wp 9.3.0 → 9.4.0

package/common/formulas.instance.json

@@ -278,11 +278,6 @@
           "article",
           false
         ],
-        [
-          "evaluate",
-          "verb",
-          false
-        ],
         [
           "every",
           "article",

package/common/formulas.js

@@ -207,7 +207,9 @@ knowledgeModule({
       objects: [
         'formulas',
       ],
-      context: defaultContextCheck(),
+      context: [
+        defaultContextCheck(),
+      ]
     }
   },
 })

package/common/gdefaults.js

@@ -242,7 +242,11 @@ const initializer = ({config}) => {
         },
         interpolate: async (interpolate, context) => {
           const evaluator = async (key) => {
-            return args.gp(context[key])
+            if (Array.isArray(context[key])) {
+              return args.gsp(context[key])
+            } else {
+              return args.gp(context[key])
+            }
           }
           return await helpers.processTemplateString(interpolate, evaluator)
         }
@@ -261,8 +265,7 @@ knowledgeModule({
     name: './gdefaults.test.json',
     contents: gdefaults_tests,
     checks: {
-            context: defaultContextCheck(),
-          },
-
+      context: [defaultContextCheck()],
+    },
   },
 })

package/common/help.js

@@ -103,7 +103,7 @@ knowledgeModule({
     name: './help.test.json',
     contents: help_tests,
     checks: {
-            context: defaultContextCheck(),
-          },
+      context: [defaultContextCheck()],
+    }
   },
 })

package/common/helpers/dateTimeSelectors.js

@@ -0,0 +1,198 @@
+const pluralize = require('pluralize')
+const deepEqual = require('deep-equal')
+const { chooseNumber, zip } = require('../helpers.js')
+const { compose, translationMapping, translationMappingToInstantiatorMappings } = require('./meta.js')
+
+const dayMap = {
+  'sunday_dates': 0,
+  'monday_dates': 1,
+  'tuesday_dates': 2,
+  'wednesday_dates': 3,
+  'thursday_dates': 4,
+  'friday_dates': 5,
+  'saturday_dates': 6
+};
+
+function getNextDayOfWeek(date, targetDay) {
+
+  const targetDayNum = dayMap[targetDay.toLowerCase()]
+  if (!targetDayNum) {
+    return
+  }
+  const currentDay = date.getDay();
+
+  let daysUntilNext = targetDayNum - currentDay;
+  if (daysUntilNext <= 0) {
+    daysUntilNext += 7; // If target day is today or past, get next week's occurrence
+  }
+
+  const nextDate = new Date(date);
+  nextDate.setDate(date.getDate() + daysUntilNext);
+  return nextDate;
+}
+
+function toMonthNumber(value) {
+  const map = {
+    "jan_dates": 1,
+    "feb_dates": 2,
+    "mar_dates": 3,
+    "apr_dates": 4,
+    "may_dates": 5,
+    "jun_dates": 6,
+    "jul_dates": 7,
+    "aug_dates": 8,
+    "sept_dates": 9,
+    "oct_dates": 10,
+    "nov_dates": 11,
+    "dec_dates": 12,
+    "january_dates": 1,
+    "february_dates": 2,
+    "march_dates": 3,
+    "april_dates": 4,
+    "june_dates": 6,
+    "july_dates": 7,
+    "august_dates": 8,
+    "september_dates": 9,
+    "october_dates": 10,
+    "november_dates": 11,
+    "december_dates": 12,
+  }
+  return map[value]
+}
+
+function getTime(time) {
+  let hour = 0
+  const minute = 0
+  const second = 0
+  let hour_offset = 0
+  if (time.time?.ampm?.ampm == 'pm') {
+    hour_offset = 12
+  }
+  if (time.marker == 'integer') {
+    hour = time.value
+  } else if (time.marker == 'atTime') {
+    hour = time.time.value
+  }
+  hour += hour_offset
+  if (time.hour) {
+    hour = time.hour
+  }
+  if (time.second) {
+    second = time.second
+  }
+  if (time.minute) {
+    minute = time.minute
+  }
+  return { hour, minute, second }
+}
+
+instantiate = (isA, now, context) => {
+  const getType = (context, type) => {
+    if (context.marker == 'onDate_dates' && context.date?.marker == type) {
+      return context.date
+    } if (context.marker == type) {
+      return context
+    }
+  }
+  let value
+  if (value = getType(context, 'monthDay_dates')) {
+    const day = value.day.value;
+    // const month = toMonthNumber(value.month.value);
+    const month = value.month.month_ordinal
+    const currentMonth = now.getMonth() + 1; // 1-based (January = 1)
+    const currentYear = now.getFullYear();
+    const year = currentMonth >= month ? currentYear + 1 : currentYear;
+    const date = new Date(year, month-1, day)
+    return date.toISOString()
+  } else if (value = getType(context, 'monthDayYear_dates')) {
+    const day = value.day.value;
+    // const month = toMonthNumber(value.month.value);
+    const month = value.month.month_ordinal
+    const year = value.year.value;
+    const date = new Date(year, month-1, day)
+    return date.toISOString()
+  } else if (isA(context?.marker, 'dateTimeSelector')) {
+    // (on date) OR (date)
+    const date = context.date?.date || context.date
+    const dateTimeSelector = getNextDayOfWeek(now, date.value)
+    const time = context.time || context.defaultTime
+    if (time) {
+      const hms = getTime(time)
+      dateTimeSelector.setHours(hms.hour)
+      dateTimeSelector.setMinutes(hms.minute)
+      dateTimeSelector.setSeconds(hms.second)
+      dateTimeSelector.setMilliseconds(0)
+    }
+    return dateTimeSelector.toISOString()
+  } else if (context.dateTimeSelector) {
+    const dateTimeSelector = getNextDayOfWeek(now, context.dateTimeSelector?.value)
+    if (dateTimeSelector) {
+      return dateTimeSelector.toISOString()
+    }
+  } else if (context.value) {
+    const dateTimeSelector = getNextDayOfWeek(now, context.value)
+    if (dateTimeSelector) {
+      return dateTimeSelector.toISOString()
+    }
+  }
+}
+
+// function getNthDayOfMonth(dayName, ordinal, monthName, year = new Date().getFullYear()) {
+function getNthDayOfMonth(dayName, ordinal, monthName, now) {
+  // Validate inputs
+  const days = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+  const months = [ 'january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december' ];
+
+  let year = now.getFullYear()
+
+  dayName = dayName.toLowerCase();
+  monthName = monthName.toLowerCase();
+
+  if (!days.includes(dayName)) throw new Error('Invalid day name');
+  if (!months.includes(monthName)) throw new Error('Invalid month name');
+  if (!Number.isInteger(ordinal) || ordinal < 1 || ordinal > 5) throw new Error('Ordinal must be an integer between 1 and 5');
+
+  const monthIndex = months.indexOf(monthName);
+  if (monthIndex <= now.getMonth()) {
+    year += 1
+  }
+  const targetDayIndex = days.indexOf(dayName);
+
+  const date = new Date(year, monthIndex, 1);
+
+  while (date.getDay() !== targetDayIndex) {
+    date.setDate(date.getDate() + 1);
+  }
+
+  date.setDate(date.getDate() + (ordinal - 1) * 7);
+
+  if (date.getMonth() !== monthIndex) {
+    throw new Error(`The ${ordinal}th ${dayName} does not exist in ${monthName} ${year}`);
+  }
+
+  return date.toISOString();
+}
+
+function getNthWeekdayAfterDate(startDate, weekday_ordinal, n) {
+  // Ensure startDate is a Date object
+  const date = new Date(startDate);
+  let weekday_index = weekday_ordinal - 1
+  // Normalize weekday_index (0 = Sunday, 1 = Monday, ..., 6 = Saturday)
+  weekday_index = (weekday_index % 7 + 7) % 7;
+  // Get current day of the week
+  const currentDay = date.getDay();
+  // Calculate days until the next desired weekday_index
+  let daysUntilNext = (weekday_index - currentDay + 7) % 7;
+  if (daysUntilNext === 0) daysUntilNext = 7; // Move to next occurrence if already on the desired weekday_index
+  // Calculate total days to add: days until next weekday_index + 7 days for each additional occurrence
+  const daysToAdd = daysUntilNext + (n - 1) * 7;
+  // Add days to the start date
+  date.setDate(date.getDate() + daysToAdd);
+  return date.toISOString();
+}
+
+module.exports = {
+  instantiate,
+  getNthDayOfMonth,
+  getNthWeekdayAfterDate,
+}

package/common/helpers/dialogues.js

@@ -77,12 +77,7 @@ class API {
   }
 
   // word is for one or many
-  makeObject({config, context, types=[], source_value=undefined, doPluralize=true} = {}) {
-    /*
-    if (!context.unknown) {
-      return context.value
-    }
-    */
+  async makeObject({config, context, types=[], source_value=undefined, doPluralize=true, initial={}} = {}) {
     if (typeof context == 'string') {
       context = { word: context, value: context }
     }
@@ -103,11 +98,18 @@ class API {
       }
       return concept
     }
+
+    initial.value = source_value || concept
+    await this.args.s({ value, makeObject: true, initial })
     // config.addOperator({ pattern: `(["${fixUps(concept)}"])`, allowDups: true })
-    config.addOperator({ pattern: `(["${concept}"])`, allowDups: true })
+    config.addOperator({ pattern: `(["${concept}"|])`, allowDups: true })
     config.addBridge({ id: concept, level: 0, bridge: `{ ...next(operator), value: or(operator.value, '${source_value || concept}') }` , allowDups: true })
+
     const addConcept = (word, number) => {
-      config.addWord(word, { id: concept, initial: `{ value: "${source_value || concept}", number: "${number}" }` } )
+      if (number) {
+        initial.number = number
+      }
+      config.addWord(word, { id: concept, initial: JSON.stringify(initial) } )
       const baseTypes = [
         'theAble',
         'queryable',
@@ -119,6 +121,7 @@ class API {
       this.setupObjectHierarchy(config, concept, {types: allTypes});
     }
 
+    pluralize.isSingular(word)
     if (pluralize.isSingular(word)) {
       addConcept(word, 'one')
       doPluralize && addConcept(pluralize.plural(word), 'many')

package/common/helpers/properties.js

@@ -546,9 +546,9 @@ class API {
     }
   }
 
-  makeObject(args) {
+  async makeObject(args) {
 		const types = [ 'hierarchyAble', 'object', 'property' ];
-    return args.km("dialogues").api.makeObject({ ...args, types: (args.types || []).concat(types) });
+    return await args.km("dialogues").api.makeObject({ ...args, types: (args.types || []).concat(types) });
   }
 
   relation_add (relations) {

package/common/helpers.js

@@ -151,58 +151,33 @@ const toEValue = (context) => {
 	return context;
 }
 
-const defaultContextCheckValidify = (properties) => {
-  for (const value of properties) {
-    if (typeof value == 'string') {
-      continue
-    }
-    if (typeof value.property == 'string' && value.filter) {
-      continue
-    }
-    throw new Error("Expected the <checks> argument to defaultContextCheck to be a list of <property> or { property: <property>, filter: <checks> }. Where <property> is a string.")
+const defaultObjectCheck = (extra = []) => {
+  return {
+    objects: [
+      {
+        match: ({objects}) => true,
+        apply: () => extra
+      },
+    ],
   }
 }
 
-const defaultContextCheckProperties = ['marker', 'text', 'verbatim', 'isResponse', { property: 'response', filter: ['marker', 'text', 'verbatim'] }] 
-
-const expand_checks = (properties) => {
-  const expanded = []
-  for (const property of properties) {
-    defaultContextCheckValidify(properties)
-    if (typeof property == 'string') {
-      expanded.push({ property, filter: defaultContextCheckProperties })
-    } else {
-      expanded.push({ property: property.property, filter: [...defaultContextCheckProperties, ...expand_checks(property.filter)] })
-    }
-  }
-  return expanded
+const defaultContextCheckProperties = (extra) => {
+  return ['marker', 'text', 'verbatim', 'value', 'evalue', 'isResponse', { properties: 'modifiers' }, { properties: 'postModifiers' }, ...extra]
 }
 
-const defaultContextCheck = (properties = []) => {
-  defaultContextCheckValidify(properties)
-  return [
-    ...defaultContextCheckProperties,
-    // ...properties.map((property) => { return { property, filter: defaultContextCheckProperties } }),
-    ...expand_checks(properties),
-    (object) => {
-      if (typeof object.value == 'object') {
-        return { property: 'value', filter: defaultContextCheckProperties }
-      } else {
-        return 'value'
-      }
-    },
-    (object) => {
-      if (!Array.isArray(object.modifiers)) {
-        return
-      }
-      if (typeof object.modifiers[0] == 'object') {
-        return { property: 'modifiers', filter: defaultContextCheckProperties }
-      } else {
-        return 'modifiers'
-      }
-    },
-    { property: 'modifiers', isPropertyList: true, filter: defaultContextCheckProperties }
-  ]
+const defaultContextCheck = ({marker, extra = [], exported = false} = {}) => {
+  let match
+  if (marker) {
+    match = ({context}) => context.marker == marker
+  } else {
+    match = ({context}) => !Array.isArray(context)
+  }
+  return {
+    match,
+    exported,
+    apply: () => ['marker', 'text', 'verbatim', 'value', 'evalue', 'isResponse', { properties: 'modifiers' }, { properties: 'postModifiers' }, ...extra],
+  }
 }
 
 const isA = (hierarchy) => (child, parent, { strict=false } = {}) => {
@@ -295,6 +270,7 @@ module.exports = {
   getValue,
   defaultContextCheck,
   defaultContextCheckProperties,
+  defaultObjectCheck,
 	toEValue,
   millisecondsUntilHourOfDay,
   indent,

package/common/hierarchy.js

@@ -164,15 +164,15 @@ const config = {
       notes: 'c is a y',
       where: where(),
       match: ({context, listable}) => listable(context.marker, 'hierarchyAble') && !context.pullFromContext && !context.wantsValue && context.same && !context.same.pullFromContext && context.same.wantsValue,
-      apply: ({context, km, objects, asList, baseConfig : config}) => {
+      apply: async ({context, km, objects, asList, baseConfig : config}) => {
         const api = km('properties').api
         // mark c as an instance?
         const oneConcepts = asList(context);
         const twoConcepts = asList(context.same);
         for (let oneConcept of oneConcepts.value) {
           for (let twoConcept of twoConcepts.value) {
-            oneConcept = api.makeObject({config, context})
-            twoConcept = api.makeObject({config, context: context.same})
+            oneConcept = await api.makeObject({config, context})
+            twoConcept = await api.makeObject({config, context: context.same})
             api.rememberIsA(oneConcept, twoConcept)
           }
         }
@@ -183,14 +183,14 @@ const config = {
       notes: 'an x is a y',
       where: where(),
       match: ({context, listable}) => listable(context.marker, 'hierarchyAble') && !context.pullFromContext && context.wantsValue && context.same,
-      apply: ({context, km, objects, baseConfig : config, asList}) => {
+      apply: async ({context, km, objects, baseConfig : config, asList}) => {
         const api = km('properties').api
         const oneConcepts = asList(context);
         const twoConcepts = asList(context.same);
         for (let oneConcept of oneConcepts.value) {
           for (let twoConcept of twoConcepts.value) {
-            oneConcept = api.makeObject({config, context})
-            twoConcept = api.makeObject({config, context: context.same})
+            oneConcept = await api.makeObject({config, context})
+            twoConcept = await api.makeObject({config, context: context.same})
             api.rememberIsA(oneConcept, twoConcept) 
             context.sameWasProcessed = true
           }
@@ -246,15 +246,15 @@ const config = {
        
         return listable(context, 'hierarchyAble') && context.same && context.same.concept && !context.query
       },
-      apply: (args) => {
+      apply: async (args) => {
         const {callId, config, objects, km, context, asList, listable} = args
         const api = km('properties').api
         const oneConcepts = asList(context);
         const twoConcepts = asList(context.same);
         for (const oneConcept of oneConcepts.value) {
           for (const twoConcept of twoConcepts.value) {
-            oneConceptId = api.makeObject({...args, context: oneConcept})
-            twoConceptId = api.makeObject({...args, context: twoConcept})
+            oneConceptId = await api.makeObject({...args, context: oneConcept})
+            twoConceptId = await api.makeObject({...args, context: twoConcept})
             api.rememberIsA(oneConceptId, twoConceptId)
             context.sameWasProcessed = true
           }
@@ -305,10 +305,9 @@ knowledgeModule( {
     // TODO doesnt this need the KM
     checks: {
       objects: ['children', 'concept', 'parents', 'properties'],
-      checks: {
-        context: defaultContextCheck(),
-      },
-
+      context: [
+        defaultContextCheck(),
+      ],
     },
     includes: {
       words: true,

package/common/javascript.js

@@ -73,8 +73,7 @@ knowledgeModule( {
     name: './javascript.test.json',
     contents: javascript_tests,
     checks: {
-            context: defaultContextCheck(),
-          },
-
+      context: [defaultContextCheck()],
+    }
   },
 })