tpmkms 9.5.0 → 9.5.1-beta.10

package/common/meta.js

@@ -26,13 +26,13 @@ const config = {
     "(([orAble|]) [orList|or] ([orAble|]))",
     // "cats is the plural of cat"
     // "is cat the plural of cats"
-    { pattern: "([x])", development: true },
+    { pattern: "([x])", scope: "testing" },
     // if f x then g x
-    { pattern: "([e])", development: true },
-    { pattern: "([f])", development: true },
-    { pattern: "([g])", development: true },
-    { pattern: "([undefined])", development: true },
-    { pattern: "([defined])", development: true },
+    { pattern: "([e])", scope: "testing" },
+    { pattern: "([f])", scope: "testing" },
+    { pattern: "([g])", scope: "testing" },
+    { pattern: "([undefined])", scope: "testing" },
+    { pattern: "([defined])", scope: "testing" },
 
     /*
     if creating a new word make a motivation to ask if word is plura or singlar of anohter wordA
@@ -61,9 +61,9 @@ const config = {
   //  [['means', 0], ['is', 0]],
   ],
   hierarchy: [
-    { child: 'e', parent: 'orAble', development: true },
-    { child: 'f', parent: 'orAble', development: true },
-    { child: 'g', parent: 'ifAble', development: true },
+    { child: 'e', parent: 'orAble', scope: "testing" },
+    { child: 'f', parent: 'orAble', scope: "testing" },
+    { child: 'g', parent: 'ifAble', scope: "testing" },
     { child: 'orAble', parent: 'ifAble' },
   ],
   bridges: [
@@ -94,12 +94,12 @@ const config = {
     { id: "then", level: 0, bridge: "{ ...next(operator), consequence: after[0] }" },
     { id: "ifAble" },
     { id: "orAble" },
-    { id: "x", development: true },
-    { id: "e", development: true },
-    { id: "f", development: true },
-    { id: "g", development: true },
-    { id: "undefined", development: true },
-    { id: "defined", development: true },
+    { id: "x", scope: "testing" },
+    { id: "e", scope: "testing" },
+    { id: "f", scope: "testing" },
+    { id: "g", scope: "testing" },
+    { id: "undefined", scope: "testing" },
+    { id: "defined", scope: "testing" },
 //    { id: "testWord2", level: 0, bridge: "{ ...next(operator) }" },
   ],
   version: '3',
@@ -107,12 +107,12 @@ const config = {
     "literals": {
       //  'testWord2': [{"id": "testWord2", "initial": "{ value: 'testWord2Value' }" }],
       // TODO make this development and select out for module
-      // 'x': [{id: "x", initial: "{ value: 'x' }", development: true }],
-      // 'f': [{id: "ifAble", initial: "{ word: 'f' }", development: true }],
-      // 'g': [{id: "ifAble", initial: "{ word: 'g' }", development: true }],
-      'f': [{id: "f", initial: "{ value: 'f', word: 'f' }", development: true }],
-      'x': [{id: "x", initial: "{ value: 'x', word: 'x' }", development: true }],
-      'gq': [{id: "g", initial: "{ word: 'gq', query: true }", development: true }],
+      // 'x': [{id: "x", initial: "{ value: 'x' }", scope: "testing" }],
+      // 'f': [{id: "ifAble", initial: "{ word: 'f' }", scope: "testing" }],
+      // 'g': [{id: "ifAble", initial: "{ word: 'g' }", scope: "testing" }],
+      'f': [{id: "f", initial: "{ value: 'f', word: 'f' }", scope: "testing" }],
+      'x': [{id: "x", initial: "{ value: 'x', word: 'x' }", scope: "testing" }],
+      'gq': [{id: "g", initial: "{ word: 'gq', query: true }", scope: "testing" }],
     }
   },
   generators: [
@@ -120,19 +120,19 @@ const config = {
       where: where(),
       match: ({context}) => context.marker == 'undefined',
       apply: ({context}) => 'undefined',
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'defined',
       apply: ({context}) => 'defined',
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
       match: ({context}) => context.evalue && !context.paraphrase,
       apply: ({context}) => context.evalue.verbatim,
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
@@ -154,13 +154,13 @@ const config = {
       where: where(),
       match: ({context}) => context.marker === 'ifAble',
       apply: ({context}) => context.value,
-      development: true,
+      scope: "testing",
     },
     { 
       where: where(),
       match: ({context}) => ['x', 'g', 'f', 'e', 'ifAble'].includes(context.marker),
       apply: ({context}) => `${context.word}`,
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
@@ -182,7 +182,7 @@ const config = {
         }
         context.isResponse = true
       },
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
@@ -206,10 +206,14 @@ const config = {
         // setup the read semantic
        
           // !topLevel or maybe !value??!?! 
-          const match = (defContext) => ({context}) => context.marker == (defContext.consequence || {}).marker && context.query // && !context.value
-          const apply = (DEFINITIONs, DERIVED) => {
+          function match(defContext) {
+            return ({context}) => context.marker == (defContext.consequence || {}).marker && context.query // && !context.value
+          }
+          function apply(DEFINITIONs, DERIVED) {
             const mappingss = translationMappings(DEFINITIONs, DERIVED)
-            const invertMappings = (mappings) => mappings.map( ({ from, to }) => { return { to: from, from: to } } )
+            function invertMappings(mappings) {
+              return mappings.map( ({ from, to }) => { return { to: from, from: to } } )
+            }
             return async ({context, s, config}) => { 
               DEFINITIONs = _.cloneDeep(DEFINITIONs)
               //const mappings = mappingss[0]
@@ -306,15 +310,21 @@ const config = {
       apply: async ({config, context, g}) => {
         // setup the write semantic
         {
-          const matchByMarker = (defContext) => ({context}) => context.marker == defContext.from.marker && !context.query && !context.objects
-          const matchByValue = (defContext) => ({context}) => context.evalue == defContext.from.value && !context.query && !context.objects
-          const apply = (mappings, TO) => async ({context, s}) => {
-            TO = _.cloneDeep(TO)
-            for (const { from, to } of mappings) {
-              hashIndexesSet(TO, to, hashIndexesGet(context, from))
+          function matchByMarker(defContext) {
+            return ({context}) => context.marker == defContext.from.marker && !context.query && !context.objects
+          }
+          function matchByValue(defContext) {
+            return ({context}) => context.evalue == defContext.from.value && !context.query && !context.objects
+          }
+          function apply(mappings, TO) {
+            return async ({context, s}) => {
+              TO = _.cloneDeep(TO)
+              for (const { from, to } of mappings) {
+                hashIndexesSet(TO, to, hashIndexesGet(context, from))
+              }
+              toPrime = await s(TO)
+              context.result = toPrime.result
             }
-            toPrime = await s(TO)
-            context.result = toPrime.result
           }
           const mappings = translationMapping(context.from, context.to)
           let match = matchByMarker(context)
@@ -333,30 +343,36 @@ const config = {
 
         // setup the read semantic
         {
-          const matchByMarker = (defContext) => ({context, uuid}) => context.marker == defContext.from.marker && (context.query || context.evaluate) && !context[`disable${uuid}`]
-          const matchByValue = (defContext) => ({context, uuid}) => context.value == defContext.from.value && (context.query || context.evaluate) && !context[`disable${uuid}`]
-          const apply = (mappings, TO) => async ({uuid, context, s, g, config}) => {
-            TO = _.cloneDeep(TO)
-            for (const { from, to } of mappings) {
-              hashIndexesSet(TO, to, hashIndexesGet(context, from))
-            }
-            // next move add debug arg to s and g
-            // TODO why is there query and evaluate?
-            if (context.query) {
-              TO.query = context.query
-            } else {
-              TO.evaluate = context.evaluate
-            }
-            TO[`disable${uuid}`] = true
-            toPrime = await s(TO)
-            if (context.query) {
-              if (toPrime.evalue) {
-                context.evalue = toPrime.evalue
+          function matchByMarker(defContext) {
+            return ({context, uuid}) => context.marker == defContext.from.marker && (context.query || context.evaluate) && !context[`disable${uuid}`]
+          }
+          function matchByValue(defContext) {
+            return ({context, uuid}) => context.value == defContext.from.value && (context.query || context.evaluate) && !context[`disable${uuid}`]
+          }
+          function apply(mappings, TO) {
+            return async ({uuid, context, s, g, config}) => {
+              TO = _.cloneDeep(TO)
+              for (const { from, to } of mappings) {
+                hashIndexesSet(TO, to, hashIndexesGet(context, from))
+              }
+              // next move add debug arg to s and g
+              // TODO why is there query and evaluate?
+              if (context.query) {
+                TO.query = context.query
+              } else {
+                TO.evaluate = context.evaluate
+              }
+              TO[`disable${uuid}`] = true
+              toPrime = await s(TO)
+              if (context.query) {
+                if (toPrime.evalue) {
+                  context.evalue = toPrime.evalue
+                } else {
+                  context.evalue = toPrime
+                }
               } else {
-                context.evalue = toPrime
+                context.evalue = toPrime.evalue
               }
-            } else {
-              context.evalue = toPrime.evalue
             }
           }
           const mappings = translationMapping(context.from, context.to)

package/common/nameable.js

@@ -77,25 +77,25 @@ const config = {
   operators: [
     // "([call] ([nameable]) (name))",
     "([call] ([nameable]) (!@<=endOfSentence)*)",
-    { pattern: "([getNamesByType] (type))", development: true },
-    { pattern: "([m1])", development: true },
-//    { pattern: "([testPullFromContext] ([memorable]))", development: true }
+    { pattern: "([getNamesByType] (type))", scope: "testing" },
+    { pattern: "([m1])", scope: "testing" },
+//    { pattern: "([testPullFromContext] ([memorable]))", scope: "testing" }
   ],
   words: {
     literals: {
-//      "m1": [{"id": "memorable", development: true, "initial": "{ value: 'm1' }" }],
-//      "m2": [{"id": "memorable", development: true, "initial": "{ value: 'm2' }" }],
+//      "m1": [{"id": "memorable", scope: "testing", "initial": "{ value: 'm1' }" }],
+//      "m2": [{"id": "memorable", scope: "testing", "initial": "{ value: 'm2' }" }],
     },
   },
   bridges: [
     {
       id: 'm1',
       isA: ['memorable', 'nameable'],
-      development: true,
+      scope: "testing",
     },
     {
       id: 'getNamesByType',
-      development: true,
+      scope: "testing",
       isA: ['verb'],
       bridge: "{ ...next(operator), type: after[0] }",
       semantic: async ({context, api}) => {

package/common/ordering.instance.json

@@ -594,7 +594,7 @@
             "word": "wants",
             "range": {
               "start": 0,
-              "end": 37
+              "end": 4
             },
             "dead": true,
             "types": [
@@ -2207,12 +2207,7 @@
                 },
                 "do": {
                   "left": "liker",
-                  "right": "likee",
-                  "range": {
-                    "start": 3,
-                    "end": 11
-                  },
-                  "text": "ikes y"
+                  "right": "likee"
                 },
                 "liker": {
                   "value": "x",
@@ -2246,6 +2241,21 @@
                   ],
                   "level": 0
                 },
+                "operator": {
+                  "value": "like",
+                  "number": "one",
+                  "text": "likes",
+                  "marker": "like",
+                  "word": "likes",
+                  "range": {
+                    "start": 5,
+                    "end": 9
+                  },
+                  "evaluateWord": true,
+                  "imperative": false,
+                  "isVerb": true,
+                  "level": 0
+                },
                 "unflatten": [
                   "liker",
                   "likee"
@@ -2254,6 +2264,18 @@
                   "liker",
                   "likee"
                 ],
+                "interpolate": [
+                  {
+                    "property": "liker"
+                  },
+                  {
+                    "property": "operator",
+                    "number": "liker"
+                  },
+                  {
+                    "property": "likee"
+                  }
+                ],
                 "dead": true,
                 "types": [
                   "like"
@@ -2272,12 +2294,7 @@
                 },
                 "do": {
                   "left": "lover",
-                  "right": "lovee",
-                  "range": {
-                    "start": 16,
-                    "end": 24
-                  },
-                  "text": ""
+                  "right": "lovee"
                 },
                 "lover": {
                   "value": "x",
@@ -2311,6 +2328,21 @@
                   ],
                   "level": 0
                 },
+                "operator": {
+                  "value": "love",
+                  "number": "one",
+                  "text": "loves",
+                  "marker": "love",
+                  "word": "loves",
+                  "range": {
+                    "start": 18,
+                    "end": 22
+                  },
+                  "evaluateWord": true,
+                  "imperative": false,
+                  "isVerb": true,
+                  "level": 0
+                },
                 "unflatten": [
                   "lover",
                   "lovee"
@@ -2319,6 +2351,18 @@
                   "lover",
                   "lovee"
                 ],
+                "interpolate": [
+                  {
+                    "property": "lover"
+                  },
+                  {
+                    "property": "operator",
+                    "number": "lover"
+                  },
+                  {
+                    "property": "lovee"
+                  }
+                ],
                 "types": [
                   "love"
                 ],
@@ -2343,12 +2387,7 @@
             },
             "do": {
               "left": "wanter",
-              "right": "wantee",
-              "range": {
-                "start": 31,
-                "end": 39
-              },
-              "text": ""
+              "right": "wantee"
             },
             "wanter": {
               "value": "x",
@@ -2382,6 +2421,21 @@
               ],
               "level": 0
             },
+            "operator": {
+              "value": "want",
+              "text": "wants",
+              "marker": "want",
+              "word": "wants",
+              "range": {
+                "start": 33,
+                "end": 37
+              },
+              "evaluateWord": true,
+              "imperative": false,
+              "isVerb": true,
+              "number": "one",
+              "level": 0
+            },
             "unflatten": [
               "wanter",
               "wantee"
@@ -2390,6 +2444,18 @@
               "wanter",
               "wantee"
             ],
+            "interpolate": [
+              {
+                "property": "wanter"
+              },
+              {
+                "property": "operator",
+                "number": "wanter"
+              },
+              {
+                "property": "wantee"
+              }
+            ],
             "types": [
               "want"
             ],

package/common/ordering.js

@@ -32,7 +32,7 @@ const api = new API();
 
   if a likes b then a wants b
 */
-const initializer = ({config, km}) => {
+function initializer({config, km}) {
   const oapi = km('ordering').api
   oapi.createOrdering({ name: 'preference', categories: [ ['love', 'like'], ['hate', 'dislike'] ], ordering: [ ['love', 'like'], ['like', 'dislike'], ['dislike', 'hate'] ] })
   const papi = km('properties').api