u8-mqtt 0.0.22 → 0.0.27

package/code/base.jsy

@@ -2,7 +2,6 @@ import {_mqtt_conn} from './_conn.jsy'
 import {_mqtt_topic_router} from './_router.jsy'
 import {_mqtt_dispatch} from './_dispatch.jsy'
 
-export default MQTTBaseClient
 export class MQTTBaseClient ::
   constructor(opt={}) ::
     this._conn_ = _mqtt_conn @ this,
@@ -21,15 +20,15 @@ export class MQTTBaseClient ::
     if null == pkt.keep_alive ::
       pkt.keep_alive = 60
 
-    const res = await this._conn_
-      .send_connect @ 'connect', pkt, 'connack'
+    let res = await this._conn_
+      .send_connect('connect', pkt, 'connack')
 
     // TODO: merge with server's keep_alive frequency
     this._conn_.ping(pkt.keep_alive)
     return res
 
   async disconnect(pkt={}) ::
-    const res = await this._send('disconnect', pkt)
+    let res = await this._send('disconnect', pkt)
     this._conn_.reset()
     return res
 
@@ -49,20 +48,38 @@ export class MQTTBaseClient ::
     pkt = _as_topics(pkt, ex)
     return this._send('unsubscribe', pkt, pkt)
 
-  // alias: sub_route
+  get on_topic() :: return this.router.add
+
+  // alias: sub_topic
   subscribe_topic(topic_route, ...args) ::
-    let topic = topic_route.replace(/[:*].*$/, '#')
-    this.on_topic @ topic_route, true, args.pop() // handler
+    let topic = this.topic_for(topic_route)
+    this.router.add @ topic_route, true, args.pop() // handler
     this.subscribe @ [[ topic ]], args.pop() // ex
     return this
 
+  // alias: unsub_topic
+  unsubscribe_topic(topic_route) ::
+    let topic = this.topic_for(topic_route)
+    this.router.remove @ topic_route, true
+    return this.unsubscribe @ [[ topic ]]
+
+  topic_for(topic_route) ::
+    return topic_route.replace(/[:*].*$/, '#')
+
 
   // alias: pub
-  publish(pkt) :: return _pub(this, pkt)
-  post(topic, payload) :: return _pub(this, {qos:0, topic, payload})
-  send(topic, payload) :: return _pub(this, {qos:1, topic, payload})
-  json_post(topic, msg) :: return _pub(this, {qos:0, topic, msg, arg:'msg'})
-  json_send(topic, msg) :: return _pub(this, {qos:1, topic, msg, arg:'msg'})
+  publish(pkt, fn_encode) :: return _pub(this, pkt, fn_encode)
+  post(topic, payload) :: return _pub.m(this, topic, payload)
+  send(topic, payload) :: return _pub.mq(this, topic, payload)
+  store(topic, payload) :: return _pub.mqr(this, topic, payload)
+
+  json_post(topic, msg) :: return _pub.o(this, topic, msg)
+  json_send(topic, msg) :: return _pub.oq(this, topic, msg)
+  json_store(topic, msg) :: return _pub.oqr(this, topic, msg)
+
+  obj_post(topic, msg, fn_encode) :: return _pub.o(this, topic, msg, fn_encode)
+  obj_send(topic, msg, fn_encode) :: return _pub.oq(this, topic, msg, fn_encode)
+  obj_store(topic, msg, fn_encode) :: return _pub.oqr(this, topic, msg, fn_encode)
 
 
 
@@ -99,27 +116,29 @@ export class MQTTBaseClient ::
   /* async _send(type, pkt) -- provided by _conn_ and transport */
 
   _init_router(opt) ::
-    const router = _mqtt_topic_router(this)
-    this.on_topic = router.add
-    return this.router = router
+    return this.router = _mqtt_topic_router(this)
 
   _init_dispatch(opt) ::
-    const router = this._init_router(opt, this)
+    let router = this._init_router(opt, this)
 
-    const tgt = @{}
+    let tgt = @{}
       __proto__: opt.on_mqtt_type || {}
-      mqtt_publish: router.invoke
+      router
+
+    if ! tgt.mqtt_publish ::
+      tgt.mqtt_publish = router.invoke
 
-    return _mqtt_dispatch @ this, tgt
+    return _mqtt_dispatch(this, tgt)
 
 
 ::
-  const p = MQTTBaseClient.prototype
+  let p = MQTTBaseClient.prototype
   Object.assign @ p, @{}
     pub: p.publish
     sub: p.subscribe
     unsub: p.unsubscribe
     sub_topic: p.subscribe_topic
+    unsub_topic: p.unsubscribe_topic
 
   /*
     p.on_mqtt_type = {
@@ -128,6 +147,7 @@ export class MQTTBaseClient ::
       mqtt_connack(pkt, ctx) ::
       mqtt_disconnect(pkt, ctx) ::
 
+      mqtt_publish(pkt, ctx)
       mqtt_subscribe(pkt, ctx) ::
       mqtt_unsubscribe(pkt, ctx) ::
 
@@ -137,18 +157,6 @@ export class MQTTBaseClient ::
   */
 
 
-function _pub(self, pkt) ::
-  let key, {qos, msg, payload} = pkt
-  if undefined === payload ::
-    if undefined === msg ::
-      const arg = pkt.arg || 'payload'
-      return v => _pub @ self, {...pkt, [arg]: v}
-
-    pkt.payload = JSON.stringify(msg)
-
-  if (1 === qos) key = pkt
-  return self._send('publish', pkt, key)
-
 function _as_topics(pkt, ex) ::
   if 'string' === typeof pkt ::
     return {topics:[pkt], ... ex}
@@ -156,3 +164,40 @@ function _as_topics(pkt, ex) ::
     return {topics:[... pkt], ... ex}
   return ex ? {...pkt, ...ex} : pkt
 
+
+function _pub(self, pkt, fn_encode) ::
+  if undefined === pkt.payload ::
+    let {msg} = pkt
+    switch typeof msg ::
+      case 'function':
+        fn_encode = msg
+        msg = undefined
+
+      case 'undefined':
+        let arg = pkt.arg || 'payload'
+        return v => _pub(self, {...pkt, [arg]: v}, fn_encode)
+
+      default:
+        pkt.payload = fn_encode
+          ? fn_encode(msg)
+          : JSON.stringify(msg)
+
+  return self._send @ 'publish', pkt,
+    pkt.qos ? pkt : void 0 // key
+
+::
+  Object.assign @ _pub, @{}
+    m: (self, topic, payload) =>
+      _pub(self, {topic, payload, qos:0})
+    mq: (self, topic, payload) =>
+      _pub(self, {topic, payload, qos:1})
+    mqr: (self, topic, payload) =>
+      _pub(self, {topic, payload, qos:1, retain: 1})
+
+    o: (self, topic, msg, fn_encode) =>
+      _pub(self, {topic, msg, arg: 'msg', qos:0}, fn_encode)
+    oq: (self, topic, msg, fn_encode) =>
+      _pub(self, {topic, msg, arg: 'msg', qos:1}, fn_encode)
+    oqr: (self, topic, msg, fn_encode) =>
+      _pub(self, {topic, msg, arg: 'msg', qos:1, retain: 1}, fn_encode)
+

package/code/core.jsy

@@ -1,10 +1,9 @@
-import MQTTBaseClient from './base.jsy'
+import {MQTTBaseClient} from './base.jsy'
 
 #IF PLAT_NODEJS
   import {connect as tcp_connect} from 'net'
 
 
-export default MQTTCoreClient
 export class MQTTCoreClient extends MQTTBaseClient ::
   static _with_session(mqtt_session) ::
     this.prototype._mqtt_session = mqtt_session
@@ -12,7 +11,7 @@ export class MQTTCoreClient extends MQTTBaseClient ::
   constructor(opt={}) ::
     super(opt)
     this.with_live(opt.on_live)
-    this.with_reconnnect(opt.on_reconnect)
+    this.with_reconnect(opt.on_reconnect)
 
 
   // on_live(client) ::
@@ -23,24 +22,24 @@ export class MQTTCoreClient extends MQTTBaseClient ::
     return this
 
   // on_reconnect(client) ::
-  with_reconnnect(on_reconnnect) ::
-    if on_reconnnect ::
-      this.on_reconnnect = on_reconnnect
+  with_reconnect(on_reconnect) ::
+    if on_reconnect ::
+      this.on_reconnect = on_reconnect
 
       if ! this._conn_.is_set ::
-        on_reconnnect(this)
+        on_reconnect(this)
 
     return this
 
 
   with_async_iter(async_iter, write_u8_pkt) ::
-    const on_mqtt_chunk = this._conn_.set @
+    let on_mqtt_chunk = this._conn_.set @
       this._mqtt_session(),
       write_u8_pkt
 
     this._msg_loop = @!>
       async_iter = await async_iter
-      for await (const chunk of async_iter)
+      for await (let chunk of async_iter)
         on_mqtt_chunk(chunk)
 
       this._conn_.reset()
@@ -68,7 +67,7 @@ export class MQTTCoreClient extends MQTTBaseClient ::
       if !Number.isFinite(port) ::
         ({port, host: hostname} = port)
 
-      const sock = tcp_connect(port, hostname)
+      let sock = tcp_connect(port, hostname)
       return this.with_stream(sock)
 
 
@@ -77,7 +76,6 @@ export class MQTTCoreClient extends MQTTBaseClient ::
       if undefined === write_stream ::
         write_stream = read_stream
 
-      read_stream.once @ 'end', this._conn_.reset
       return this.with_async_iter @ read_stream,
         u8_pkt => write_stream.write(u8_pkt)
 
@@ -102,8 +100,8 @@ export class MQTTCoreClient extends MQTTBaseClient ::
         websock.addEventListener('open', y, {once: true}))
 
 
-    const {_conn_} = this
-    const on_mqtt_chunk = _conn_.set @
+    let {_conn_} = this
+    let on_mqtt_chunk = _conn_.set @
       this._mqtt_session(),
       async u8_pkt => @
         await ready

package/code/session.mjs

@@ -2,6 +2,7 @@ import {
   _bind_mqtt_session_ctx,
 
   mqtt_decode_connack,
+  mqtt_decode_disconnect,
   mqtt_decode_publish,
   mqtt_decode_puback,
   mqtt_decode_pubxxx,
@@ -21,22 +22,22 @@ import {
 } from 'u8-mqtt-packet'
 
 
-export default mqtt_session_ctx
 export function mqtt_session_ctx(mqtt_level) {
   let {ctx} = mqtt_session_ctx
   if (undefined === ctx ) {
-    const as_utf8 = u8 =>
+    let as_utf8 = u8 =>
       new TextDecoder('utf-8').decode(u8)
 
-    const std_pkt_api = {
+    let std_pkt_api = {
       utf8(u8) { return as_utf8( u8 || this.payload ) },
-      json(u8) { return JSON.parse( as_utf8( u8 || this.payload )) },
+      json(u8) { return JSON.parse( as_utf8( u8 || this.payload ) || null ) },
     }
 
     mqtt_session_ctx.ctx = ctx =
       _bind_mqtt_session_ctx(
         [ // lst_decode_ops
           mqtt_decode_connack,
+          mqtt_decode_disconnect,
           mqtt_decode_publish,
           mqtt_decode_puback,
           mqtt_decode_pubxxx,

package/code/v4.mjs

@@ -1,7 +1,7 @@
-import mqtt_session_ctx from './session.mjs'
-import MQTTCore from './core.jsy'
+import {mqtt_session_ctx} from './session.mjs'
+import {MQTTCoreClient} from './core.jsy'
 
-class MQTTClient_v4 extends MQTTCore {
+class MQTTClient_v4 extends MQTTCoreClient {
   _mqtt_session() { return mqtt_session_ctx(4)() }
 }
 

package/code/v5.mjs

@@ -1,7 +1,7 @@
-import mqtt_session_ctx from './session.mjs'
-import MQTTCore from './core.jsy'
+import {mqtt_session_ctx} from './session.mjs'
+import {MQTTCoreClient} from './core.jsy'
 
-class MQTTClient_v5 extends MQTTCore {
+class MQTTClient_v5 extends MQTTCoreClient {
   _mqtt_session() { return mqtt_session_ctx(5)() }
 }