@knowlearning/agents 0.9.16 → 0.9.18

package/agents/generic.js

@@ -56,6 +56,8 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   const environmentPromise = new Promise(r => resolveEnvironment = r)
   let lastSentSI = -1
   let lastHeartbeat
+  let lastSynchronousScopePatched = null
+  let lastSynchronousScopePatchPromise = null
   const syncedPromiseResolutions = []
 
   const patches = state('patches')
@@ -77,12 +79,20 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     if (watcherIndex > -1) watchers[key].splice(watcherIndex, 1)
     else console.warn('TRIED TO REMOVE WATCHER THAT DOES NOT EXIST')
   }
-  function flushMessageQueue() {
-    //  TODO: probably want to make this loop async so we don't try and push more to
-    //        a closed connection
+
+  // TODO: clear acknowledged messages
+  async function flushMessageQueue() {
+    // this makes flushing async, giving time for queue message to combine synchronous updates
+    await new Promise(resolve => resolve())
+    lastSynchronousScopePatched = null
+
     while (authed && ws.readyState === WebSocket.OPEN && lastSentSI+1 < messageQueue.length) {
+      lastSynchronousScopePatched = null
       lastSentSI += 1
       ws.send(JSON.stringify(messageQueue[lastSentSI]))
+
+      //  async so we don't try and push more to a closed connection
+      await new Promise(resolve => resolve())
     }
   }
 
@@ -90,13 +100,21 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     return new Promise((resolve, reject) => responses[si].push([resolve, reject]))
   }
 
-  function queueMessage(message) {
+  function queueMessage({ scope, patch }) {
     isSynced = false
-    si += 1
-    const promise = new Promise((resolve, reject) => responses[si] = [[resolve, reject]])
-    messageQueue.push({...message, si, ts: Date.now()})
-    flushMessageQueue()
-    return promise
+    if (lastSynchronousScopePatched === scope) {
+      const i = messageQueue.length - 1
+      messageQueue[i].patch = [...messageQueue[i].patch, ...patch]
+    }
+    else {
+      si += 1
+      lastSynchronousScopePatchPromise = new Promise((resolve, reject) => responses[si] = [[resolve, reject]])
+      messageQueue.push({ scope, patch, si, ts: Date.now()})
+      lastSynchronousScopePatched = scope
+      flushMessageQueue()
+    }
+
+    return lastSynchronousScopePatchPromise
   }
 
   function checkHeartbeat() {
@@ -114,11 +132,11 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   async function restartConnection() {
     if (restarting) return
 
-    restarting = true
     authed = false
-    ws.onmessage = () => {} // needs to be a no-op since a closing ws can still get messages
     if (!disconnected) {
       await new Promise(r => setTimeout(r, Math.min(1000, failedConnections * 100)))
+      ws.onmessage = () => {} // needs to be a no-op since a closing ws can still get messages
+      restarting = true
       failedConnections += 1
       initWS() // TODO: don't do this if we are purposefully unloading...
       restarting = false
@@ -231,8 +249,12 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
 
   function create({ id=uuid(), active_type, active, name }) {
     //  TODO: collapse into 1 patch and 1 interact call
-    interact(id, [{ op: 'add', path: ['active_type'], value: active_type }], false)
-    interact(id, [{ op: 'add', path: ['active'], value: active }], false)
+    //        (requires updating side effects)
+    const patch = [
+      { op: 'add', path: ['active_type'], value: active_type },
+      { op: 'add', path: ['active'], value: active }
+    ]
+    interact(id, patch, false)
     return id
   }
 
@@ -300,7 +322,45 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     })
   }
 
+  function watchResolution(path, callback) {
+    const id = path[0]
+    const references = path.slice(1)
+    let unwatchDeeper = () => {}
+
+    const unwatch = watch(id, ({ state }) => {
+      if (references.length === 0) {
+        callback(value)
+        return
+      }
+
+      //  TODO: check if value we care about actually changed
+      //        and ignore this update if it has not.
+      unwatchDeeper()
+
+      let value = state
+      for (let index = 0; index < references.length; index += 1) {
+        value = value[references[index]]
+        if (
+          value === null ||
+          value === undefined ||
+          index === references.length - 1
+        ) callback(value)
+        else if (isUUID(value)) {
+          unwatchDeeper = watchResolution([value, ...references.slice(index + 1)], callback)
+          return
+        }
+      }
+    })
+
+    return () => {
+      unwatch()
+      unwatchDeeper()
+    }
+  }
+
   function watch(scope=DEFAULT_SCOPE_NAME, fn) {
+    if (Array.isArray(scope)) return watchResolution(scope, fn)
+
     let initialSent = false
     const queue = []
     function cb(update) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowlearning/agents",
-  "version": "0.9.16",
+  "version": "0.9.18",
   "description": "API for embedding applications in KnowLearning systems.",
   "main": "node.js",
   "browser": "browser.js",

package/vue/3/components/scope.vue

@@ -1,5 +1,5 @@
 <template>
-  <span v-if="state">{{value ? value : placeholder }}</span>
+  <span v-if="value">{{ value === null && placeholder ? placeholder : value }}</span>
   <span v-else>loading...</span>
 </template>
 
@@ -8,46 +8,29 @@
   export default {
   	props: {
   	  id: String,
-      path: {
-        type: Array,
-        default: []
-      },
-      placeholder: {
-        type: String,
-        default: ''
-      }
+      path: { type: Array, default: [] },
+      placeholder: { type: String, default: '' }
   	},
   	data() {
   	  return {
-  	  	state: null
+  	  	value: undefined
   	  }
   	},
     watch: {
-      id() {
-        this.stopWatching()
-        this.startWatching()
+      id() { this.startWatching() },
+      path: { 
+        deep: true,
+        handler() { this.startWatching() }
       }
     },
-    mounted() {
-      this.startWatching()
-  	},
+    created() { this.startWatching() },
     unmounted() {
-      this.stopWatching()
-    },
-    computed: {
-      value() {
-        if (this.path.length === 0) return this.state
-
-        return (
-          this
-            .path
-            .reduce((acc, field) => acc?.[field], this.state)
-        )
-      }
+      if (this.startWatching) this.stopWatching()
     },
     methods: {
       startWatching() {
-        this.stopWatching = Agent.watch(this.id, ({ state }) => this.state = state)
+        if (this.startWatching) this.stopWatching()
+        this.stopWatching = Agent.watch([this.id, ...path], value => this.value = value)
       }
     }
   }