u8-mqtt 0.0.22 → 0.0.27

package/esm/node/v5.mjs

@@ -394,6 +394,50 @@ function mqtt_decode_pingxxx(ns) {
   return ns[0xc] = ns[0xd] = pkt => pkt
 }
 
+function mqtt_decode_disconnect(ns) {
+  const _disconnect_reason_ = bind_reason_lookup([
+    // MQTT 5.0
+    [ 0x00, 'Normal disconnection'],
+    [ 0x04, 'Disconnect with Will Message'],
+    [ 0x80, 'Unspecified error'],
+    [ 0x81, 'Malformed Packet'],
+    [ 0x82, 'Protocol Error'],
+    [ 0x83, 'Implementation specific error'],
+    [ 0x87, 'Not authorized'],
+    [ 0x89, 'Server busy'],
+    [ 0x8B, 'Server shutting down'],
+    [ 0x8D, 'Keep Alive timeout'],
+    [ 0x8E, 'Session taken over'],
+    [ 0x8F, 'Topic Filter invalid'],
+    [ 0x90, 'Topic Name invalid'],
+    [ 0x93, 'Receive Maximum exceeded'],
+    [ 0x94, 'Topic Alias invalid'],
+    [ 0x95, 'Packet too large'],
+    [ 0x96, 'Message rate too high'],
+    [ 0x97, 'Quota exceeded'],
+    [ 0x98, 'Administrative action'],
+    [ 0x99, 'Payload format invalid'],
+    [ 0x9A, 'Retain not supported'],
+    [ 0x9B, 'QoS not supported'],
+    [ 0x9C, 'Use another server'],
+    [ 0x9D, 'Server moved'],
+    [ 0x9E, 'Shared Subscriptions not supported'],
+    [ 0x9F, 'Connection rate exceeded'],
+    [ 0xA0, 'Maximum connect time'],
+    [ 0xA1, 'Subscription Identifiers not supported'],
+    [ 0xA2, 'Wildcard Subscriptions not supported'],
+  ]);
+
+
+  return ns[0xe] = (pkt, u8_body) => {
+    if (u8_body && 5 <= pkt.mqtt_level) {
+      const rdr = new mqtt_type_reader(u8_body, 0);
+      pkt.reason = rdr.u8_reason(_disconnect_reason_);
+      pkt.props = rdr.props();
+    }
+    return pkt }
+}
+
 function mqtt_decode_auth(ns) {
   const _auth_reason_ = bind_reason_lookup([
     // MQTT 5.0
@@ -770,18 +814,19 @@ function _bind_mqtt_session_ctx(sess_decode, sess_encode, _pkt_ctx_) {
 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,
@@ -807,14 +852,14 @@ function mqtt_session_ctx(mqtt_level) {
 }
 
 function _mqtt_conn(client, [on_mqtt, pkt_future]) {
-  const q0 = _tiny_deferred_queue();
-  const q = _tiny_deferred_queue();
+  let q0 = _tiny_deferred_queue();
+  let q = _tiny_deferred_queue();
 
-  const _asy_send = async (...args) =>
+  let _asy_send = async (...args) =>
     (await q)(...args);
   let _send = client._send = _asy_send;
 
-  const _ping = () => client._send('pingreq');
+  let _ping = () => client._send('pingreq');
   let tid_ping, _is_set = false;
 
   return {
@@ -841,7 +886,7 @@ function _mqtt_conn(client, [on_mqtt, pkt_future]) {
         _send = await q0;}
 
       // await connack response
-      const res = await _send(...args);
+      let res = await _send(...args);
 
       client._send = _send;
       q.notify(_send);
@@ -850,15 +895,15 @@ function _mqtt_conn(client, [on_mqtt, pkt_future]) {
   , set(mqtt_session, send_u8_pkt) {
       _is_set = true;
 
-      const [mqtt_decode, mqtt_encode] = mqtt_session;
+      let [mqtt_decode, mqtt_encode] = mqtt_session;
 
-      const on_mqtt_chunk = u8_buf =>
+      let on_mqtt_chunk = u8_buf =>
         on_mqtt(
           mqtt_decode(u8_buf),
           {mqtt: client});
 
       _send = async (type, pkt, key) => {
-        const res = undefined !== key
+        let res = undefined !== key
           ? pkt_future(key) : true;
 
         await send_u8_pkt(
@@ -877,13 +922,16 @@ function _mqtt_conn(client, [on_mqtt, pkt_future]) {
 
 async function _async_evt(obj, evt) {
   // microtask break lookup
-  if (undefined !== evt)
+  if (undefined !== evt) {
     await evt.call(obj, await obj);
+  }
 }
 function _tiny_deferred_queue() {
-  const q = []; // tiny resetting deferred queue
+  let q = []; // tiny resetting deferred queue
   q.then = y => { q.push(y); };
-  q.notify = v => { for (const fn of q.splice(0,q.length)) fn(v); };
+  q.notify = v => {
+    for (let fn of q.splice(0,q.length))
+      fn(v); };
   return q
 }
 
@@ -919,14 +967,14 @@ function parse(str, loose) {
 function _ignore(pkt, params, ctx) {ctx.done = true;}
 
 function _mqtt_topic_router() {
-  const pri_lsts=[[],[]];
-  const find = topic => _mqtt_routes_iter(pri_lsts, topic);
+  let pri_lsts = [[],[]];
+  let find = topic => _mqtt_routes_iter(pri_lsts, topic);
 
   return {find,
 
     add(topic_route, ...args) {
       let fn = args.pop();
-      const priority = args.pop();
+      let priority = args.pop();
 
       if ('function' !== typeof fn) {
         if (false === fn) {
@@ -936,44 +984,55 @@ function _mqtt_topic_router() {
       let rte = parse(
         topic_route.replace(/[+#]$/, '*'));
 
+      rte.key = topic_route;
       rte.tgt = fn;
       pri_lsts[priority ? 0 : 1].push(rte);
       return this}
 
+  , remove(topic_route, priority) {
+      let lst = pri_lsts[priority ? 0 : 1];
+      lst = lst.filter(e => e.key !== topic_route);
+      pri_lsts[priority ? 0 : 1] = lst;}
+
+  , clear(priority) {
+      pri_lsts[priority ? 0 : 1] = [];
+      if (null == priority) {
+        pri_lsts[1] = [];} }
+
   , async invoke(pkt, ctx) {
       ctx.idx = 0;
 
-      for (const [fn, params] of find(pkt.topic)) {
+      for (let [fn, params] of find(pkt.topic)) {
         await fn(pkt, params, ctx);
 
         if (ctx.done) {
           break}
         else ctx.idx++;}
 
-      const {pkt_id, qos} = pkt;
+      let {pkt_id, qos} = pkt;
       if (1 === qos) {
         await ctx.mqtt._send('puback', {pkt_id});} } } }
 
 
 function * _mqtt_routes_iter(all_route_lists, topic) {
-  for (const route_list of all_route_lists) {
-    for (const route of route_list) {
-      const res = _mqtt_route_match_one(topic, route);
+  for (let route_list of all_route_lists) {
+    for (let route of route_list) {
+      let res = _mqtt_route_match_one(topic, route);
       if (undefined !== res) {
         yield res;} } } }
 
 
 function _mqtt_route_match_one(topic, {keys, pattern, tgt}) {
-  const match = pattern.exec('/'+topic);
+  let match = pattern.exec('/'+topic);
   if (null === match) {
     return}
 
   if (false === keys) {
-    const {groups} = match;
+    let {groups} = match;
     if (! groups) {
       return [tgt]}
 
-    const params = {};
+    let params = {};
     for (let k in groups) {
       params[k] = groups[k];}
 
@@ -982,7 +1041,7 @@ function _mqtt_route_match_one(topic, {keys, pattern, tgt}) {
   if (0 === keys.length) {
     return [tgt]}
 
-  const params = {};
+  let params = {};
   for (let i=0; i<keys.length; i++) {
     params[ keys[i] ] = match[1+i];}
   return [tgt, params]}
@@ -992,10 +1051,10 @@ const _mqtt_cmdid_dispatch ={
     return {__proto__: this, target, hashbelt: [new Map()]} }
 
 , bind_pkt_future(_pkt_id=100) {
-    const {hashbelt} = this;
+    let {hashbelt} = this;
 
     let _tmp_; // use _tmp_ to reuse _by_key closure
-    const _by_key = answer_monad =>
+    let _by_key = answer_monad =>
       hashbelt[0].set(_tmp_, answer_monad);
 
     return (( pkt_or_key ) => {
@@ -1008,8 +1067,8 @@ const _mqtt_cmdid_dispatch ={
       return new Promise(_by_key)}) }
 
 , answer(key, pkt) {
-    for (const map of this.hashbelt) {
-      const answer_monad = map.get(key);
+    for (let map of this.hashbelt) {
+      let answer_monad = map.get(key);
       if (undefined !== answer_monad) {
         map.delete(key);
 
@@ -1018,10 +1077,10 @@ const _mqtt_cmdid_dispatch ={
     return false}
 
 , rotate_belt(n) {
-    const {hashbelt} = this;
+    let {hashbelt} = this;
     hashbelt.unshift(new Map());
-    for (const old of hashbelt.splice(n || 5)) {
-      for (const answer_monad of old.values()) {
+    for (let old of hashbelt.splice(n || 5)) {
+      for (let answer_monad of old.values()) {
         answer_monad([/*pkt*/, 'expired']); } } }// option/maybe monad
 
 , cmdids: ((() => {
@@ -1052,18 +1111,18 @@ const _mqtt_cmdid_dispatch ={
       by_evt(disp, pkt, ctx);}
 
     async function by_evt({target}, pkt, ctx) {
-      const fn = target[`mqtt_${pkt.type}`]
+      let fn = target[`mqtt_${pkt.type}`]
         || target.mqtt_pkt;
 
       if (undefined !== fn) {
         await fn.call(target, pkt, ctx);} } })()) };
 
 function _mqtt_dispatch(opt, target) {
-  const _disp_ = _mqtt_cmdid_dispatch.create(target);
-  const { cmdids } = _disp_;
+  let _disp_ = _mqtt_cmdid_dispatch.create(target);
+  let { cmdids } = _disp_;
 
   // default rotate at 1s across 5 buckets
-  const { td: rotate_td=1000, n: rotate_n=5 } =
+  let { td: rotate_td=1000, n: rotate_n=5 } =
     opt && opt.rotate || {};
 
   let rotate_ts = rotate_td + Date.now();
@@ -1072,7 +1131,7 @@ function _mqtt_dispatch(opt, target) {
     _disp_.bind_pkt_future()]
 
   function on_mqtt(pkt_list, ctx) {
-    for (const pkt of pkt_list) {
+    for (let pkt of pkt_list) {
       cmdids[pkt.id](_disp_, pkt, ctx); }
 
     if (Date.now() > rotate_ts) {
@@ -1097,7 +1156,7 @@ class MQTTBaseClient {
     if (null == pkt.keep_alive) {
       pkt.keep_alive = 60;}
 
-    const res = await this._conn_
+    let res = await this._conn_
       .send_connect('connect', pkt, 'connack');
 
     // TODO: merge with server's keep_alive frequency
@@ -1105,7 +1164,7 @@ class MQTTBaseClient {
     return res}
 
   async disconnect(pkt={}) {
-    const res = await this._send('disconnect', pkt);
+    let res = await this._send('disconnect', pkt);
     this._conn_.reset();
     return res}
 
@@ -1125,20 +1184,38 @@ 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)}
 
 
 
@@ -1175,27 +1252,29 @@ class MQTTBaseClient {
   /* async _send(type, pkt) -- provided by _conn_ and transport */
 
   _init_router(opt) {
-    const router = _mqtt_topic_router();
-    this.on_topic = router.add;
-    return this.router = router}
+    return this.router = _mqtt_topic_router()}
 
   _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} );
+  , sub_topic: p.subscribe_topic
+  , unsub_topic: p.unsubscribe_topic} );
 
   /*
     p.on_mqtt_type = {
@@ -1204,6 +1283,7 @@ class MQTTBaseClient {
       mqtt_connack(pkt, ctx) ::
       mqtt_disconnect(pkt, ctx) ::
 
+      mqtt_publish(pkt, ctx)
       mqtt_subscribe(pkt, ctx) ::
       mqtt_unsubscribe(pkt, ctx) ::
 
@@ -1213,18 +1293,6 @@ 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}}
@@ -1232,6 +1300,43 @@ 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)} ); }
+
 class MQTTCoreClient extends MQTTBaseClient {
   static _with_session(mqtt_session) {
     this.prototype._mqtt_session = mqtt_session;}
@@ -1239,7 +1344,7 @@ 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) ::
@@ -1250,24 +1355,24 @@ 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 () => {
       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();})());
@@ -1295,7 +1400,7 @@ class MQTTCoreClient extends MQTTBaseClient {
     if (!Number.isFinite(port)) {
       ({port, host: hostname} = port);}
 
-    const sock = connect(port, hostname);
+    let sock = connect(port, hostname);
     return this.with_stream(sock)}
 
 
@@ -1304,7 +1409,6 @@ 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)) }
 
@@ -1329,8 +1433,8 @@ 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
@@ -1355,6 +1459,5 @@ class MQTTClient_v5 extends MQTTCoreClient {
 
 const mqtt_v5 = opt => new MQTTClient_v5(opt);
 
-export default mqtt_v5;
-export { MQTTClient_v5 as MQTTClient, MQTTClient_v5, mqtt_v5 as mqtt, mqtt_v5 };
+export { MQTTClient_v5 as MQTTClient, MQTTClient_v5, mqtt_v5 as default, mqtt_v5 as mqtt, mqtt_v5 };
 //# sourceMappingURL=v5.mjs.map