u8-mqtt 0.4.0 → 0.5.0

package/esm/node/v5.js

@@ -150,7 +150,7 @@ class mqtt_reader_v4 {
 
 }
 
-class mqtt_reader_v5$1 extends mqtt_reader_v4 {
+let mqtt_reader_v5$1 = class mqtt_reader_v5 extends mqtt_reader_v4 {
   props() {
     let {buf, step} = this;
     let [n, vi, vi0] = decode_varint$1(buf, step.k|0);
@@ -185,7 +185,7 @@ class mqtt_reader_v5$1 extends mqtt_reader_v4 {
       : buf.subarray(vi, step.k|0)
   }
   */
-}
+};
 
 function mqtt_reader_info(mqtt_reader, ... info_fn_list) {
   mqtt_reader = class extends mqtt_reader {
@@ -815,30 +815,39 @@ const with_topic_router = mqtt_topic_router =>
       return super._aliases() +
         ' sub_topic:subscribe_topic unsub_topic:unsubscribe_topic'}
 
-    _init_router(opt) {
-      return mqtt_topic_router(opt, this)}
-
-    get on_topic() {return this.router.add}
+    _init_router(opt, self, target) {
+      this._subs = [];
+      let router = this.router = target.router =
+        mqtt_topic_router(opt, this, target);
+      return router?.invoke}
 
-    _sub_chain(topic, ex, topic_prefix) {
-      let res = this.subscribe([[ topic ]], ex, topic_prefix);
-      let subs = this.subs ||(this.subs = new Map());
-      subs.set((res.topic = topic), (subs.last = res));
-      return this }// fluent api -- return this and track side effects
+    on_sub(suback, pkt) {
+      suback.pkt = pkt;
+      this._subs.push(suback);
+      return suback}
+    subs_settled() {
+      return Promise.allSettled(
+        this._subs.splice(0,Infinity)) }
 
     // alias: sub_topic
     subscribe_topic(topic_route, ...args) {
       let router = this.router;
       router.add(topic_route, true, args.pop() );// handler
       let topic = router.mqtt_topic(topic_route);
-      return this._sub_chain(topic, ...args ) }// ex, topic_prefix
+      this.subscribe(topic, ...args );// ex, topic_prefix
+      return this }// fluent api -- return this and track side effects
 
     // alias: unsub_topic
     unsubscribe_topic(topic_route, ...args) {
       let router = this.router;
       router.remove(topic_route, true);
       let topic = router.mqtt_topic(topic_route);
-      return this.unsubscribe([[ topic ]], ...args ) } };// topic_prefix
+      return this.unsubscribe(topic, ...args ) }// topic_prefix
+
+    // add topic handlers without corresponding subscribe packet
+    on_topic(...args) {
+      this.router.add(...args);
+      return this} };
 
 // Use [regexparam][] for url-like topic parsing
 //  [regexparam]: https://github.com/lukeed/regexparam
@@ -851,16 +860,22 @@ const with_topic_path_router = /* #__PURE__ */
 const mqtt_topic = topic_route =>
   topic_route
     .replace(/[*].*$/, '#')
-    .replace(/:\w+\??/g, '+');
+    .replace(/:\w[^\/]*/g, '+');
 
-const as_topic_path = topic_route =>(
+/* From the [MQTT v5 Spec](https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Topic_Names_and)
+4.7.1.2 Multi-level wildcard -- (‘#’ U+0023)
+... MUST be specified either on its own or following a topic level separator.
+In either case it MUST be the last character specified in the Topic Filter
+
+4.7.1.3 Single-level wildcard -- (‘+’ U+002B)
+...it MUST occupy an entire level of the filter.
+*/
+
+const as_topic_path = (topic_route, id) =>(
+  id=1,
   topic_route
-    .replace(/#$/, '*') // replace MQTT # wildcard at end
-    .split(/([^\/]*[+][^\/]*)/) // split on MQTT + match tokens
-    .reduce (( sz, v, idx ) => sz +(
-      idx & 1 // even entires are body, odd are MQTT + tokens
-        ? `:$${1 + idx>>1}` // replace with `:$#` sequential ids, using ? for partial entries
-        : v ) ) );// pass through body
+    .replace(/#$/, '*' )// replace MQTT '#' multi-level wildcard at end
+    .replace(/\+/g, () => `:$${id++}` ) );// replace MQTT '+' single-level wildcards
 
 function _ignore(pkt, params, ctx) {ctx.done = true;}
 
@@ -875,9 +890,8 @@ function mqtt_topic_path_router() {
       let priority = args.pop();
 
       if ('function' !== typeof fn) {
-        if (false === fn) {
-          fn = _ignore;}
-        else throw new TypeError()}
+        if (fn) {throw new TypeError()}
+        fn = _ignore;}
 
       let rte = parse(as_topic_path(topic_route));
 
@@ -893,7 +907,7 @@ function mqtt_topic_path_router() {
   , clear(priority) {
       pri_lsts[priority ? 0 : 1] = [];
       if (null == priority) {
-        pri_lsts[1] = [];} }
+        pri_lsts[1] = []; } }// null clears both lists
 
   , async invoke(pkt, ctx) {
       ctx.idx = 0;
@@ -909,52 +923,34 @@ function mqtt_topic_path_router() {
           break}
         else ctx.idx++;}
 
-      let {pkt_id, qos} = pkt;
-      if (1 === qos) {
-        await ctx.mqtt._send('puback', {pkt_id});} } } }
+      if (1 === pkt.qos) {
+        await ctx.mqtt.puback(pkt);} } } }
 
 
 function * _routes_iter(all_route_lists, topic) {
+  topic = topic.replace(/^[\/]*/, '/'); // ensure '/' prefix for regexparam library
   for (let route_list of all_route_lists) {
-    for (let route of route_list) {
-      let res = _route_match_one(topic, route);
-      if (undefined !== res) {
-        yield res;} } } }
-
-
-function _route_match_one(topic, {keys, pattern, tgt}) {
-  let match = '/' !== topic[0]
-    ? pattern.exec('/'+topic)
-    : pattern.exec(topic);
-
-  if (null === match) {
-    return}
-
-  if (false === keys) {
-    let {groups} = match;
-    if (! groups) {
-      return [tgt]}
-
-    let params = {};
-    for (let k in groups) {
-      params[k] = groups[k];}
-
-    return [tgt, params]}
-
-  if (0 === keys.length) {
-    return [tgt]}
-
-  let params = {};
-  for (let i=0; i<keys.length; i++) {
-    params[ keys[i] ] = match[1+i];}
-  return [tgt, params]}
+    for (let {keys, pattern, tgt} of route_list) {
+      let match = pattern.exec(topic);
+      if (match) {
+        let params = keys
+          ? keys.reduce(
+              (o, k, i) => (o[k] = match[1+i], o)
+            , {})
+          : match.groups ?? match;
+        yield [tgt, params];} } } }
 
 
 function _route_remove(all_route_lists, query) {
-  let match = route => route===query || route.tgt===query || route.key===query;
+  let fn_match = route =>(
+    route===query
+    || route.tgt===query
+    || route.key===query);
   for (let lst of all_route_lists) {
-    let i = lst.findIndex(match);
-    if (0 <= i) {return !! lst.splice(i,1)} }
+    let i = lst.findIndex(fn_match);
+    if (0 <= i) {
+      lst.splice(i,1);
+      return true} }
   return false}
 
 /*
@@ -1215,6 +1211,22 @@ const _mqtt_cmdid_dispatch ={
 
       await fn?.call(target, pkt, ctx);} })()) };
 
+/*
+on_mqtt_type = {
+  mqtt_auth(pkt, ctx) ::
+  mqtt_connect(pkt, ctx) ::
+  mqtt_connack(pkt, ctx) ::
+  mqtt_disconnect(pkt, ctx) ::
+
+  mqtt_publish(pkt, ctx)
+  mqtt_subscribe(pkt, ctx) ::
+  mqtt_unsubscribe(pkt, ctx) ::
+
+  mqtt_pingreq(pkt, ctx) ::
+  mqtt_pingresp(pkt, ctx) ::
+}
+*/
+
 function _mqtt_dispatch(opt, target) {
   let _disp_ = _mqtt_cmdid_dispatch.create(target);
   let { cmdids } = _disp_;
@@ -1244,28 +1256,34 @@ class MQTTError extends Error {
 
 class MQTTBase {
   constructor(opt={}) {
+    this.with(opt);
     this._conn_ = _mqtt_conn(this,
       this._init_dispatch(opt, this)); }
 
+  with(fns_ns) {
+    for (let [k,v] of Object.entries(fns_ns)) {
+      if ('function' === typeof v) {this[k] = v;} }
+    return this}
+
   async conn_emit(evt, arg, err_arg) {
     this.log_conn?.(evt, arg, err_arg);
     try {
-      let fn_evt = this[await evt]; // microtask break
+      let fn_evt = this[await evt]; // microtask break using `await evt`
       if (fn_evt) {
         await fn_evt.call(this, this, arg, err_arg);}
-      else if (err_arg) {
-        await this.on_error(err_arg, evt);} }
+      else if (err_arg) {throw err_arg} }
     catch (err) {
       this.on_error(err, evt);} }
 
-  on_error(err, err_path) {
-    console.warn('[[u8-mqtt error: %s]]', err_path, err); }
+  on_error(err, evt) {
+    console.warn('[[u8-mqtt error: %s]]', evt, err); }
 
   // Handshaking Packets
 
   async connect(pkt={}) {
-    let cid = pkt.client_id || ['u8-mqtt--', ''];
-    if (Array.isArray(cid)) {
+    let cid = pkt.client_id || this.client_id;
+    if ('string' !== typeof cid) {
+      // see init_client_id implementation in core.jsy
       pkt.client_id = cid = this.init_client_id(cid);}
     this.client_id = cid;
 
@@ -1291,12 +1309,13 @@ class MQTTBase {
     return this._send('auth', pkt, 'auth')}
 
   ping() {return this._send('pingreq', null, 'pingresp')}
-
+  puback({pkt_id}) {return this._send('puback', {pkt_id})}
 
   // alias: sub
   subscribe(pkt, ex, topic_prefix) {
     pkt = _as_topics(pkt, ex, topic_prefix);
-    return this._send('subscribe', pkt, pkt)}
+    let suback = this._send('subscribe', pkt, pkt);
+    return this.on_sub?.(suback, pkt) ?? suback}
 
   // alias: unsub
   unsubscribe(pkt, ex, topic_prefix) {
@@ -1304,48 +1323,52 @@ class MQTTBase {
     return this._send('unsubscribe', pkt, pkt)}
 
 
-  // alias: pub
-  publish(pkt, pub_opt) {return _pub(this, pkt, pub_opt)}
-  post(topic, payload, pub_opt) {return _pub.m(this, topic, payload, pub_opt)}
-  send(topic, payload, pub_opt) {return _pub.mq(this, topic, payload, pub_opt)}
-  store(topic, payload, pub_opt) {return _pub.mqr(this, topic, payload, pub_opt)}
-
-  json_post(topic, msg, pub_opt) {return _pub.o(this, topic, msg, pub_opt)}
-  json_send(topic, msg, pub_opt) {return _pub.oq(this, topic, msg, pub_opt)}
-  json_store(topic, msg, pub_opt) {return _pub.oqr(this, topic, msg, pub_opt)}
-
-  obj_post(topic, msg, pub_opt) {return _pub.o(this, topic, msg, pub_opt)}
-  obj_send(topic, msg, pub_opt) {return _pub.oq(this, topic, msg, pub_opt)}
-  obj_store(topic, msg, pub_opt) {return _pub.oqr(this, topic, msg, pub_opt)}
-
-
-
-  // Utility Methods
-
-  init_client_id(parts) {
-    let cid = this.client_id;
-
-    if (undefined === cid) {
-      this.client_id = cid = (
-        
-          
-        
-          this.new_client_id(parts)
-        );}
-
-    return cid}
-
-  new_client_id(parts) {
-    return [parts[0], Math.random().toString(36).slice(2), parts[1]].join('')}
-
-  
-    
-      
-      
-      
-        
-        
-      
+  post(topic, payload, pub_opt) {// qos:0
+    return this.pub({topic, payload, qos:0}, pub_opt)}
+  send(topic, payload, pub_opt) {// qos:1
+    return this.pub({topic, payload, qos:1}, pub_opt)}
+  store(topic, payload, pub_opt) {// qos:1, retain: 1
+    return this.pub({topic, payload, qos:1, retain: 1}, pub_opt)}
+
+  // alias: json_post
+  obj_post(topic, msg, pub_opt) {// qos:0
+    return this.pub({topic, msg, arg: 'msg', qos:0}, pub_opt)}
+  // alias: json_send
+  obj_send(topic, msg, pub_opt) {// qos:1
+    return this.pub({topic, msg, arg: 'msg', qos:1}, pub_opt)}
+  // alias: json_store
+  obj_store(topic, msg, pub_opt) {// qos:1, retain: 1
+    return this.pub({topic, msg, arg: 'msg', qos:1, retain: 1}, pub_opt)}
+
+  // alias: publish -- because 'pub' is shorter for semantic aliases above
+  async pub(pkt, pub_opt) {
+    if (undefined === pkt.payload) {
+      if ('function' === typeof pub_opt) {
+        pub_opt = {fn_encode: pub_opt};}
+
+      let {msg} = pkt;
+      switch (typeof msg) {
+        case 'function':
+          pub_opt = {...pub_opt, fn_encode: msg};
+          // flow into 'undefined' case
+        case 'undefined':
+          // return a single-value closure to publish packets
+          return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)}
+
+      // Encode payload from msg; fn_encode allows alternative to JSON.stringify
+      let {fn_encode} = pub_opt || {};
+      pkt.payload = fn_encode
+        ? await fn_encode(msg)
+        : JSON.stringify(msg);}
+
+    if (pub_opt) {
+      if (pub_opt.props) {
+        pkt.props = pub_opt.props;}
+      if (pub_opt.xform) {
+        pkt = pub_opt.xform(pkt) || pkt;} }
+
+    return this._send('publish', pkt,
+      pkt.qos ? pkt : void 0 ) }// key
 
 
   // Internal API
@@ -1354,52 +1377,24 @@ class MQTTBase {
 
   _init_dispatch(opt) {
     this.constructor?._once_();
-    let router = this.router =
-      this._init_router?.(opt, this);
-
-    let tgt ={
-      __proto__: opt.on_mqtt_type || {}
-    , router};
-
-    tgt.mqtt_publish ||= router?.invoke;
-    return _mqtt_dispatch(this, tgt)}
+    let target ={__proto__: opt.on_mqtt_type};
+    target.mqtt_publish ||=
+      this._init_router?.(opt, this, target);
+    return _mqtt_dispatch(this, target)}
 
   static _aliases() {
-    return ' pub:publish sub:subscribe unsub:unsubscribe '}
+    return ' publish:pub sub:subscribe unsub:unsubscribe json_post:obj_post json_send:obj_send json_store:obj_store'}
 
   static _once_(self=this) {
     self._once_ = _=>0;
-    self.MQTTError = MQTTError;
     let p = self.prototype;
+    p.MQTTError = MQTTError;
     for (let alias of self._aliases().split(/\s+/)) {
       alias = alias.split(':');
       let fn = alias[1] && p[alias[1]];
       if (fn) {p[alias[0]] = fn;} } } }
 
 
-/*
-on_mqtt_type = {
-  mqtt_auth(pkt, ctx) ::
-  mqtt_connect(pkt, ctx) ::
-  mqtt_connack(pkt, ctx) ::
-  mqtt_disconnect(pkt, ctx) ::
-
-  mqtt_publish(pkt, ctx)
-  mqtt_subscribe(pkt, ctx) ::
-  mqtt_unsubscribe(pkt, ctx) ::
-
-  mqtt_pingreq(pkt, ctx) ::
-  mqtt_pingresp(pkt, ctx) ::
-}
-*/
-
-
-const _prefix_topics = (topic_prefix, iterable) =>
-  Array.from(iterable, value =>(
-    value.trim // string
-      ? _prefix_topics(topic_prefix, value)
-      : topic_prefix + value) );
-
 function _as_topics(pkt, ex, topic_prefix) {
   if (ex?.trim) {// string
     topic_prefix = ex;
@@ -1416,55 +1411,11 @@ function _as_topics(pkt, ex, topic_prefix) {
   if (topic_prefix) {
     // particularly useful with shared queues, e.g.
     //   topic_prefix = '$share/some-queue-name/'
-    pkt.topics = _prefix_topics(topic_prefix, pkt.topics);}
-  return pkt}
-
+    let _prefix_topics = v =>
+      v.trim ? topic_prefix+v : v.map(_prefix_topics);
 
-async function _pub(self, pkt, pub_opt) {
-  if (undefined === pkt.payload) {
-    if ('function' === typeof pub_opt) {
-      pub_opt = {fn_encode: pub_opt};}
-
-    let {msg} = pkt;
-    switch (typeof msg) {
-      case 'function':
-        pub_opt = {...pub_opt, fn_encode: msg};
-        // flow into 'undefined' case
-      case 'undefined':
-        // return a single-value closure to publish packets
-        return v => _pub(self, {...pkt, [pkt.arg || 'payload']: v}, pub_opt)
-
-      default:
-        // Encode payload from msg; fn_encode allows alternative to JSON.stringify
-        let {fn_encode} = pub_opt || {};
-        pkt.payload = fn_encode
-          ? await fn_encode(msg)
-          : JSON.stringify(msg);} }
-
-  if (pub_opt) {
-    if (pub_opt.props) {
-      pkt.props = pub_opt.props;}
-    if (pub_opt.xform) {
-      pkt = pub_opt.xform(pkt) || pkt;} }
-
-  return self._send('publish', pkt,
-    pkt.qos ? pkt : void 0 ) }// key
-
- {
-  Object.assign(_pub,{
-    m: (self, topic, payload, pub_opt) =>
-      _pub(self, {topic, payload, qos:0}, pub_opt)
-  , mq: (self, topic, payload, pub_opt) =>
-      _pub(self, {topic, payload, qos:1}, pub_opt)
-  , mqr: (self, topic, payload, pub_opt) =>
-      _pub(self, {topic, payload, qos:1, retain: 1}, pub_opt)
-
-  , o: (self, topic, msg, pub_opt) =>
-      _pub(self, {topic, msg, arg: 'msg', qos:0}, pub_opt)
-  , oq: (self, topic, msg, pub_opt) =>
-      _pub(self, {topic, msg, arg: 'msg', qos:1}, pub_opt)
-  , oqr: (self, topic, msg, pub_opt) =>
-      _pub(self, {topic, msg, arg: 'msg', qos:1, retain: 1}, pub_opt)} ); }
+    pkt.topics = pkt.topics.map(_prefix_topics);}
+  return pkt}
 
 const pkt_api = {
   utf8(u8) { return new TextDecoder('utf-8').decode(u8 || this.payload ) },
@@ -1473,20 +1424,27 @@ const pkt_api = {
 };
 
 class MQTTCore extends MQTTBase {
-  constructor(opt={}) {
-    super(opt);
-    this.with(opt);}
-
   static mqtt_ctx(mqtt_level, mqtt_opts, pkt_ctx=pkt_api) {
     let self = class extends this {};
     self.prototype.mqtt_ctx =
       mqtt_pkt_ctx(mqtt_level, mqtt_opts, pkt_ctx);
     return self}
 
-  with(fns_ns) {
-    for (let [k,v] of Object.entries(fns_ns)) {
-      if ('function' === typeof v) {this[k] = v;} }
-    return this}
+
+  // automatic Client Id for connect()
+  init_client_id(parts=['u8-mqtt--','']) {
+    let sess_stg=this.sess_stg;
+    let key, cid = sess_stg?.getItem(key=parts.join(' '));
+    if (! cid) {
+      cid = parts.join(Math.random().toString(36).slice(2));
+      sess_stg?.setItem(key, cid);}
+    return cid}
+
+  get sess_stg() {return globalThis.sessionStorage}
+
+
+  //on_error(err, evt) ::
+  //  console.warn @ '[[u8-mqtt error: %s]]', evt, err
 
   //log_conn(evt, arg, err_arg) ::
   //  console.info @ '[[u8-mqtt log: %s]]', evt, arg, err_arg
@@ -1563,7 +1521,6 @@ class MQTTCore extends MQTTBase {
   
     with_tcp(...opt) {
       opt = this._conn_opt(opt);
-      console.log({opt});
       return this._use_conn (() =>
         this.with_stream(
           connect(opt)) ) }
@@ -1625,7 +1582,7 @@ class MQTTCore extends MQTTBase {
 
     return this} }
 
-const version = '0.4.0';
+const version = '0.5.0';
 
 const MQTTClient_v4 = /* #__PURE__ */
   with_topic_path_router(