@knowlearning/agents 0.9.15 → 0.9.17

package/agents/browser/embedded.js

@@ -209,7 +209,7 @@ export default function EmbeddedAgent() {
   function disconnect() { return send({ type: 'disconnect' }) }
   function reconnect() { return send({ type: 'reconnect' }) }
   function synced() { return send({ type: 'synced' }) }
-  function close() { return send({ type: 'close' }) }
+  function close(info) { return send({ type: 'close', info }) }
 
   return {
     embedded: true,

package/agents/browser/initialize.js

@@ -54,8 +54,7 @@ function embed(environment, iframe) {
       sendDown({})
     }
     else if (type === 'close') {
-      console.log('closing?', listeners)
-      if (listeners.close) listeners.close()
+      if (listeners.close) listeners.close(message.info)
     }
     else if (type === 'environment') {
       const env = await Agent.environment()

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.15",
+  "version": "0.9.17",
   "description": "API for embedding applications in KnowLearning systems.",
   "main": "node.js",
   "browser": "browser.js",

package/vue/3/persist/component.js

@@ -28,29 +28,7 @@ export default function (module, scope) {
         }
       }
       else if (component.setup) {
-        const origSetupFn = component.setup
-        const isReactiveRef = r => r && r.__v_isRef
-        component.setup = function setupProxy(a, b) { // need to specifically add this here, otherwise second argument not passed in arguments array (probably because of webpack optimization...)
-          let refs = origSetupFn.call(this, a, b)
-
-          Object
-            .entries(state)
-            .filter(([k]) => isReactiveRef(refs[k]))
-            .forEach(([k, v]) => refs[k].value = v)
-
-          Object
-            .entries(refs)
-            .filter(([_,r]) => isReactiveRef(r) && isScopeSerializable(r.value))
-            .forEach(([key, ref]) => {
-              watchEffect(() => {
-                if (state[key] !== ref.value) {
-                  state[key] = ref.value
-                }
-              })
-            })
-
-          return refs
-        }
+        throw new Error('vuePersistantCompoent is for components using the Options API. To use the composition API see https://docs.knowlearning.systems/frameworks/vue/')
       }
     }