zmdms-utils 0.0.80 → 0.0.81

package/dist/es/node_modules/eventsource/lib/eventsource.js

@@ -0,0 +1,493 @@
+import require$$2 from 'url';
+import require$$1 from 'events';
+import require$$4 from 'https';
+import require$$3 from 'http';
+import require$$1$1 from 'util';
+
+var parse = require$$2.parse;
+var events = require$$1;
+var https = require$$4;
+var http = require$$3;
+var util = require$$1$1;
+
+var httpsOptions = [
+  'pfx', 'key', 'passphrase', 'cert', 'ca', 'ciphers',
+  'rejectUnauthorized', 'secureProtocol', 'servername', 'checkServerIdentity'
+];
+
+var bom = [239, 187, 191];
+var colon = 58;
+var space = 32;
+var lineFeed = 10;
+var carriageReturn = 13;
+
+function hasBom (buf) {
+  return bom.every(function (charCode, index) {
+    return buf[index] === charCode
+  })
+}
+
+/**
+ * Creates a new EventSource object
+ *
+ * @param {String} url the URL to which to connect
+ * @param {Object} [eventSourceInitDict] extra init params. See README for details.
+ * @api public
+ **/
+function EventSource (url, eventSourceInitDict) {
+  var readyState = EventSource.CONNECTING;
+  var headers = eventSourceInitDict && eventSourceInitDict.headers;
+  var hasNewOrigin = false;
+  Object.defineProperty(this, 'readyState', {
+    get: function () {
+      return readyState
+    }
+  });
+
+  Object.defineProperty(this, 'url', {
+    get: function () {
+      return url
+    }
+  });
+
+  var self = this;
+  self.reconnectInterval = 1000;
+  self.connectionInProgress = false;
+
+  function onConnectionClosed (message) {
+    if (readyState === EventSource.CLOSED) return
+    readyState = EventSource.CONNECTING;
+    _emit('error', new Event('error', {message: message}));
+
+    // The url may have been changed by a temporary redirect. If that's the case,
+    // revert it now, and flag that we are no longer pointing to a new origin
+    if (reconnectUrl) {
+      url = reconnectUrl;
+      reconnectUrl = null;
+      hasNewOrigin = false;
+    }
+    setTimeout(function () {
+      if (readyState !== EventSource.CONNECTING || self.connectionInProgress) {
+        return
+      }
+      self.connectionInProgress = true;
+      connect();
+    }, self.reconnectInterval);
+  }
+
+  var req;
+  var lastEventId = '';
+  if (headers && headers['Last-Event-ID']) {
+    lastEventId = headers['Last-Event-ID'];
+    delete headers['Last-Event-ID'];
+  }
+
+  var discardTrailingNewline = false;
+  var data = '';
+  var eventName = '';
+
+  var reconnectUrl = null;
+
+  function connect () {
+    var options = parse(url);
+    var isSecure = options.protocol === 'https:';
+    options.headers = { 'Cache-Control': 'no-cache', 'Accept': 'text/event-stream' };
+    if (lastEventId) options.headers['Last-Event-ID'] = lastEventId;
+    if (headers) {
+      var reqHeaders = hasNewOrigin ? removeUnsafeHeaders(headers) : headers;
+      for (var i in reqHeaders) {
+        var header = reqHeaders[i];
+        if (header) {
+          options.headers[i] = header;
+        }
+      }
+    }
+
+    // Legacy: this should be specified as `eventSourceInitDict.https.rejectUnauthorized`,
+    // but for now exists as a backwards-compatibility layer
+    options.rejectUnauthorized = !(eventSourceInitDict && !eventSourceInitDict.rejectUnauthorized);
+
+    if (eventSourceInitDict && eventSourceInitDict.createConnection !== undefined) {
+      options.createConnection = eventSourceInitDict.createConnection;
+    }
+
+    // If specify http proxy, make the request to sent to the proxy server,
+    // and include the original url in path and Host headers
+    var useProxy = eventSourceInitDict && eventSourceInitDict.proxy;
+    if (useProxy) {
+      var proxy = parse(eventSourceInitDict.proxy);
+      isSecure = proxy.protocol === 'https:';
+
+      options.protocol = isSecure ? 'https:' : 'http:';
+      options.path = url;
+      options.headers.Host = options.host;
+      options.hostname = proxy.hostname;
+      options.host = proxy.host;
+      options.port = proxy.port;
+    }
+
+    // If https options are specified, merge them into the request options
+    if (eventSourceInitDict && eventSourceInitDict.https) {
+      for (var optName in eventSourceInitDict.https) {
+        if (httpsOptions.indexOf(optName) === -1) {
+          continue
+        }
+
+        var option = eventSourceInitDict.https[optName];
+        if (option !== undefined) {
+          options[optName] = option;
+        }
+      }
+    }
+
+    // Pass this on to the XHR
+    if (eventSourceInitDict && eventSourceInitDict.withCredentials !== undefined) {
+      options.withCredentials = eventSourceInitDict.withCredentials;
+    }
+
+    req = (isSecure ? https : http).request(options, function (res) {
+      self.connectionInProgress = false;
+      // Handle HTTP errors
+      if (res.statusCode === 500 || res.statusCode === 502 || res.statusCode === 503 || res.statusCode === 504) {
+        _emit('error', new Event('error', {status: res.statusCode, message: res.statusMessage}));
+        onConnectionClosed();
+        return
+      }
+
+      // Handle HTTP redirects
+      if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) {
+        var location = res.headers.location;
+        if (!location) {
+          // Server sent redirect response without Location header.
+          _emit('error', new Event('error', {status: res.statusCode, message: res.statusMessage}));
+          return
+        }
+        var prevOrigin = getOrigin(url);
+        var nextOrigin = getOrigin(location);
+        hasNewOrigin = prevOrigin !== nextOrigin;
+        if (res.statusCode === 307) reconnectUrl = url;
+        url = location;
+        process.nextTick(connect);
+        return
+      }
+
+      if (res.statusCode !== 200) {
+        _emit('error', new Event('error', {status: res.statusCode, message: res.statusMessage}));
+        return self.close()
+      }
+
+      readyState = EventSource.OPEN;
+      res.on('close', function () {
+        res.removeAllListeners('close');
+        res.removeAllListeners('end');
+        onConnectionClosed();
+      });
+
+      res.on('end', function () {
+        res.removeAllListeners('close');
+        res.removeAllListeners('end');
+        onConnectionClosed();
+      });
+      _emit('open', new Event('open'));
+
+      // text/event-stream parser adapted from webkit's
+      // Source/WebCore/page/EventSource.cpp
+      var isFirst = true;
+      var buf;
+      var startingPos = 0;
+      var startingFieldLength = -1;
+      res.on('data', function (chunk) {
+        buf = buf ? Buffer.concat([buf, chunk]) : chunk;
+        if (isFirst && hasBom(buf)) {
+          buf = buf.slice(bom.length);
+        }
+
+        isFirst = false;
+        var pos = 0;
+        var length = buf.length;
+
+        while (pos < length) {
+          if (discardTrailingNewline) {
+            if (buf[pos] === lineFeed) {
+              ++pos;
+            }
+            discardTrailingNewline = false;
+          }
+
+          var lineLength = -1;
+          var fieldLength = startingFieldLength;
+          var c;
+
+          for (var i = startingPos; lineLength < 0 && i < length; ++i) {
+            c = buf[i];
+            if (c === colon) {
+              if (fieldLength < 0) {
+                fieldLength = i - pos;
+              }
+            } else if (c === carriageReturn) {
+              discardTrailingNewline = true;
+              lineLength = i - pos;
+            } else if (c === lineFeed) {
+              lineLength = i - pos;
+            }
+          }
+
+          if (lineLength < 0) {
+            startingPos = length - pos;
+            startingFieldLength = fieldLength;
+            break
+          } else {
+            startingPos = 0;
+            startingFieldLength = -1;
+          }
+
+          parseEventStreamLine(buf, pos, fieldLength, lineLength);
+
+          pos += lineLength + 1;
+        }
+
+        if (pos === length) {
+          buf = void 0;
+        } else if (pos > 0) {
+          buf = buf.slice(pos);
+        }
+      });
+    });
+
+    req.on('error', function (err) {
+      self.connectionInProgress = false;
+      onConnectionClosed(err.message);
+    });
+
+    if (req.setNoDelay) req.setNoDelay(true);
+    req.end();
+  }
+
+  connect();
+
+  function _emit () {
+    if (self.listeners(arguments[0]).length > 0) {
+      self.emit.apply(self, arguments);
+    }
+  }
+
+  this._close = function () {
+    if (readyState === EventSource.CLOSED) return
+    readyState = EventSource.CLOSED;
+    if (req.abort) req.abort();
+    if (req.xhr && req.xhr.abort) req.xhr.abort();
+  };
+
+  function parseEventStreamLine (buf, pos, fieldLength, lineLength) {
+    if (lineLength === 0) {
+      if (data.length > 0) {
+        var type = eventName || 'message';
+        _emit(type, new MessageEvent(type, {
+          data: data.slice(0, -1), // remove trailing newline
+          lastEventId: lastEventId,
+          origin: getOrigin(url)
+        }));
+        data = '';
+      }
+      eventName = void 0;
+    } else if (fieldLength > 0) {
+      var noValue = fieldLength < 0;
+      var step = 0;
+      var field = buf.slice(pos, pos + (noValue ? lineLength : fieldLength)).toString();
+
+      if (noValue) {
+        step = lineLength;
+      } else if (buf[pos + fieldLength + 1] !== space) {
+        step = fieldLength + 1;
+      } else {
+        step = fieldLength + 2;
+      }
+      pos += step;
+
+      var valueLength = lineLength - step;
+      var value = buf.slice(pos, pos + valueLength).toString();
+
+      if (field === 'data') {
+        data += value + '\n';
+      } else if (field === 'event') {
+        eventName = value;
+      } else if (field === 'id') {
+        lastEventId = value;
+      } else if (field === 'retry') {
+        var retry = parseInt(value, 10);
+        if (!Number.isNaN(retry)) {
+          self.reconnectInterval = retry;
+        }
+      }
+    }
+  }
+}
+
+var eventsource = EventSource;
+
+util.inherits(EventSource, events.EventEmitter);
+EventSource.prototype.constructor = EventSource; // make stacktraces readable
+
+['open', 'error', 'message'].forEach(function (method) {
+  Object.defineProperty(EventSource.prototype, 'on' + method, {
+    /**
+     * Returns the current listener
+     *
+     * @return {Mixed} the set function or undefined
+     * @api private
+     */
+    get: function get () {
+      var listener = this.listeners(method)[0];
+      return listener ? (listener._listener ? listener._listener : listener) : undefined
+    },
+
+    /**
+     * Start listening for events
+     *
+     * @param {Function} listener the listener
+     * @return {Mixed} the set function or undefined
+     * @api private
+     */
+    set: function set (listener) {
+      this.removeAllListeners(method);
+      this.addEventListener(method, listener);
+    }
+  });
+});
+
+/**
+ * Ready states
+ */
+Object.defineProperty(EventSource, 'CONNECTING', {enumerable: true, value: 0});
+Object.defineProperty(EventSource, 'OPEN', {enumerable: true, value: 1});
+Object.defineProperty(EventSource, 'CLOSED', {enumerable: true, value: 2});
+
+EventSource.prototype.CONNECTING = 0;
+EventSource.prototype.OPEN = 1;
+EventSource.prototype.CLOSED = 2;
+
+/**
+ * Closes the connection, if one is made, and sets the readyState attribute to 2 (closed)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventSource/close
+ * @api public
+ */
+EventSource.prototype.close = function () {
+  this._close();
+};
+
+/**
+ * Emulates the W3C Browser based WebSocket interface using addEventListener.
+ *
+ * @param {String} type A string representing the event type to listen out for
+ * @param {Function} listener callback
+ * @see https://developer.mozilla.org/en/DOM/element.addEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+EventSource.prototype.addEventListener = function addEventListener (type, listener) {
+  if (typeof listener === 'function') {
+    // store a reference so we can return the original function again
+    listener._listener = listener;
+    this.on(type, listener);
+  }
+};
+
+/**
+ * Emulates the W3C Browser based WebSocket interface using dispatchEvent.
+ *
+ * @param {Event} event An event to be dispatched
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent
+ * @api public
+ */
+EventSource.prototype.dispatchEvent = function dispatchEvent (event) {
+  if (!event.type) {
+    throw new Error('UNSPECIFIED_EVENT_TYPE_ERR')
+  }
+  // if event is instance of an CustomEvent (or has 'details' property),
+  // send the detail object as the payload for the event
+  this.emit(event.type, event.detail);
+};
+
+/**
+ * Emulates the W3C Browser based WebSocket interface using removeEventListener.
+ *
+ * @param {String} type A string representing the event type to remove
+ * @param {Function} listener callback
+ * @see https://developer.mozilla.org/en/DOM/element.removeEventListener
+ * @see http://dev.w3.org/html5/websockets/#the-websocket-interface
+ * @api public
+ */
+EventSource.prototype.removeEventListener = function removeEventListener (type, listener) {
+  if (typeof listener === 'function') {
+    listener._listener = undefined;
+    this.removeListener(type, listener);
+  }
+};
+
+/**
+ * W3C Event
+ *
+ * @see http://www.w3.org/TR/DOM-Level-3-Events/#interface-Event
+ * @api private
+ */
+function Event (type, optionalProperties) {
+  Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });
+  if (optionalProperties) {
+    for (var f in optionalProperties) {
+      if (optionalProperties.hasOwnProperty(f)) {
+        Object.defineProperty(this, f, { writable: false, value: optionalProperties[f], enumerable: true });
+      }
+    }
+  }
+}
+
+/**
+ * W3C MessageEvent
+ *
+ * @see http://www.w3.org/TR/webmessaging/#event-definitions
+ * @api private
+ */
+function MessageEvent (type, eventInitDict) {
+  Object.defineProperty(this, 'type', { writable: false, value: type, enumerable: true });
+  for (var f in eventInitDict) {
+    if (eventInitDict.hasOwnProperty(f)) {
+      Object.defineProperty(this, f, { writable: false, value: eventInitDict[f], enumerable: true });
+    }
+  }
+}
+
+/**
+ * Returns a new object of headers that does not include any authorization and cookie headers
+ *
+ * @param {Object} headers An object of headers ({[headerName]: headerValue})
+ * @return {Object} a new object of headers
+ * @api private
+ */
+function removeUnsafeHeaders (headers) {
+  var safe = {};
+  for (var key in headers) {
+    if (/^(cookie|authorization)$/i.test(key)) {
+      continue
+    }
+
+    safe[key] = headers[key];
+  }
+
+  return safe
+}
+
+/**
+ * Transform an URL to a valid origin value.
+ *
+ * @param {String|Object} url URL to transform to it's origin.
+ * @returns {String} The origin.
+ * @api private
+ */
+function getOrigin (url) {
+  if (typeof url === 'string') url = parse(url);
+  if (!url.protocol || !url.hostname) return 'null'
+  return (url.protocol + '//' + url.host).toLowerCase()
+}
+
+export { eventsource as default };

package/dist/es/node_modules/faye-websocket/lib/faye/eventsource.js

@@ -0,0 +1,150 @@
+import require$$0 from 'stream';
+import require$$1 from 'util';
+import driver from '../../../websocket-driver/lib/websocket/driver.js';
+import { __require as requireHeaders } from '../../../websocket-driver/lib/websocket/driver/headers.js';
+import api from './websocket/api.js';
+import { __require as requireEvent_target } from './websocket/api/event_target.js';
+import { __require as requireEvent } from './websocket/api/event.js';
+
+var eventsource;
+var hasRequiredEventsource;
+
+function requireEventsource () {
+	if (hasRequiredEventsource) return eventsource;
+	hasRequiredEventsource = 1;
+
+	var Stream      = require$$0.Stream,
+	    util        = require$$1,
+	    driver$1      = driver,
+	    Headers     = requireHeaders(),
+	    API         = api,
+	    EventTarget = requireEvent_target(),
+	    Event       = requireEvent();
+
+	var EventSource = function(request, response, options) {
+	  this.writable = true;
+	  options = options || {};
+
+	  this._stream = response.socket;
+	  this._ping   = options.ping  || this.DEFAULT_PING;
+	  this._retry  = options.retry || this.DEFAULT_RETRY;
+
+	  var scheme       = driver$1.isSecureRequest(request) ? 'https:' : 'http:';
+	  this.url         = scheme + '//' + request.headers.host + request.url;
+	  this.lastEventId = request.headers['last-event-id'] || '';
+	  this.readyState  = API.CONNECTING;
+
+	  var headers = new Headers(),
+	      self    = this;
+
+	  if (options.headers) {
+	    for (var key in options.headers) headers.set(key, options.headers[key]);
+	  }
+
+	  if (!this._stream || !this._stream.writable) return;
+	  process.nextTick(function() { self._open(); });
+
+	  this._stream.setTimeout(0);
+	  this._stream.setNoDelay(true);
+
+	  var handshake = 'HTTP/1.1 200 OK\r\n' +
+	                  'Content-Type: text/event-stream\r\n' +
+	                  'Cache-Control: no-cache, no-store\r\n' +
+	                  'Connection: close\r\n' +
+	                  headers.toString() +
+	                  '\r\n' +
+	                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
+
+	  this._write(handshake);
+
+	  this._stream.on('drain', function() { self.emit('drain'); });
+
+	  if (this._ping)
+	    this._pingTimer = setInterval(function() { self.ping(); }, this._ping * 1000);
+
+	  ['error', 'end'].forEach(function(event) {
+	    self._stream.on(event, function() { self.close(); });
+	  });
+	};
+	util.inherits(EventSource, Stream);
+
+	EventSource.isEventSource = function(request) {
+	  if (request.method !== 'GET') return false;
+	  var accept = (request.headers.accept || '').split(/\s*,\s*/);
+	  return accept.indexOf('text/event-stream') >= 0;
+	};
+
+	var instance = {
+	  DEFAULT_PING:   10,
+	  DEFAULT_RETRY:  5,
+
+	  _write: function(chunk) {
+	    if (!this.writable) return false;
+	    try {
+	      return this._stream.write(chunk, 'utf8');
+	    } catch (e) {
+	      return false;
+	    }
+	  },
+
+	  _open: function() {
+	    if (this.readyState !== API.CONNECTING) return;
+
+	    this.readyState = API.OPEN;
+
+	    var event = new Event('open');
+	    event.initEvent('open', false, false);
+	    this.dispatchEvent(event);
+	  },
+
+	  write: function(message) {
+	    return this.send(message);
+	  },
+
+	  end: function(message) {
+	    if (message !== undefined) this.write(message);
+	    this.close();
+	  },
+
+	  send: function(message, options) {
+	    if (this.readyState > API.OPEN) return false;
+
+	    message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
+	    options = options || {};
+
+	    var frame = '';
+	    if (options.event) frame += 'event: ' + options.event + '\r\n';
+	    if (options.id)    frame += 'id: '    + options.id    + '\r\n';
+	    frame += 'data: ' + message + '\r\n\r\n';
+
+	    return this._write(frame);
+	  },
+
+	  ping: function() {
+	    return this._write(':\r\n\r\n');
+	  },
+
+	  close: function() {
+	    if (this.readyState > API.OPEN) return false;
+
+	    this.readyState = API.CLOSED;
+	    this.writable = false;
+	    if (this._pingTimer) clearInterval(this._pingTimer);
+	    if (this._stream) this._stream.end();
+
+	    var event = new Event('close');
+	    event.initEvent('close', false, false);
+	    this.dispatchEvent(event);
+
+	    return true;
+	  }
+	};
+
+	for (var method in instance) EventSource.prototype[method] = instance[method];
+	for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
+
+	eventsource = EventSource;
+	return eventsource;
+}
+
+export { requireEventsource as __require };

package/dist/es/node_modules/faye-websocket/lib/faye/websocket/api/event.js

@@ -0,0 +1,31 @@
+var event;
+var hasRequiredEvent;
+
+function requireEvent () {
+	if (hasRequiredEvent) return event;
+	hasRequiredEvent = 1;
+
+	var Event = function(eventType, options) {
+	  this.type = eventType;
+	  for (var key in options)
+	    this[key] = options[key];
+	};
+
+	Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
+	  this.type       = eventType;
+	  this.bubbles    = canBubble;
+	  this.cancelable = cancelable;
+	};
+
+	Event.prototype.stopPropagation = function() {};
+	Event.prototype.preventDefault  = function() {};
+
+	Event.CAPTURING_PHASE = 1;
+	Event.AT_TARGET       = 2;
+	Event.BUBBLING_PHASE  = 3;
+
+	event = Event;
+	return event;
+}
+
+export { requireEvent as __require };

package/dist/es/node_modules/faye-websocket/lib/faye/websocket/api/event_target.js

@@ -0,0 +1,41 @@
+import { __require as requireEvent } from './event.js';
+
+var event_target;
+var hasRequiredEvent_target;
+
+function requireEvent_target () {
+	if (hasRequiredEvent_target) return event_target;
+	hasRequiredEvent_target = 1;
+
+	var Event = requireEvent();
+
+	var EventTarget = {
+	  onopen:     null,
+	  onmessage:  null,
+	  onerror:    null,
+	  onclose:    null,
+
+	  addEventListener: function(eventType, listener, useCapture) {
+	    this.on(eventType, listener);
+	  },
+
+	  removeEventListener: function(eventType, listener, useCapture) {
+	    this.removeListener(eventType, listener);
+	  },
+
+	  dispatchEvent: function(event) {
+	    event.target = event.currentTarget = this;
+	    event.eventPhase = Event.AT_TARGET;
+
+	    if (this['on' + event.type])
+	      this['on' + event.type](event);
+
+	    this.emit(event.type, event);
+	  }
+	};
+
+	event_target = EventTarget;
+	return event_target;
+}
+
+export { requireEvent_target as __require };