zmdms-utils 0.0.80 → 0.0.81

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

@@ -0,0 +1,205 @@
+import require$$0 from 'stream';
+import require$$1 from 'util';
+import driver$1 from '../../../../websocket-driver/lib/websocket/driver.js';
+import { __require as requireEvent_target } from './api/event_target.js';
+import { __require as requireEvent } from './api/event.js';
+
+var Stream      = require$$0.Stream,
+    util        = require$$1,
+    driver      = driver$1,
+    EventTarget = requireEvent_target(),
+    Event       = requireEvent();
+
+var API = function(options) {
+  options = options || {};
+  driver.validateOptions(options, ['headers', 'extensions', 'maxLength', 'ping', 'proxy', 'tls', 'ca']);
+
+  this.readable = this.writable = true;
+
+  var headers = options.headers;
+  if (headers) {
+    for (var name in headers) this._driver.setHeader(name, headers[name]);
+  }
+
+  var extensions = options.extensions;
+  if (extensions) {
+    [].concat(extensions).forEach(this._driver.addExtension, this._driver);
+  }
+
+  this._ping          = options.ping;
+  this._pingId        = 0;
+  this.readyState     = API.CONNECTING;
+  this.bufferedAmount = 0;
+  this.protocol       = '';
+  this.url            = this._driver.url;
+  this.version        = this._driver.version;
+
+  var self = this;
+
+  this._driver.on('open',    function(e) { self._open(); });
+  this._driver.on('message', function(e) { self._receiveMessage(e.data); });
+  this._driver.on('close',   function(e) { self._beginClose(e.reason, e.code); });
+
+  this._driver.on('error', function(error) {
+    self._emitError(error.message);
+  });
+  this.on('error', function() {});
+
+  this._driver.messages.on('drain', function() {
+    self.emit('drain');
+  });
+
+  if (this._ping)
+    this._pingTimer = setInterval(function() {
+      self._pingId += 1;
+      self.ping(self._pingId.toString());
+    }, this._ping * 1000);
+
+  this._configureStream();
+
+  if (!this._proxy) {
+    this._stream.pipe(this._driver.io);
+    this._driver.io.pipe(this._stream);
+  }
+};
+util.inherits(API, Stream);
+
+API.CONNECTING = 0;
+API.OPEN       = 1;
+API.CLOSING    = 2;
+API.CLOSED     = 3;
+
+API.CLOSE_TIMEOUT = 30000;
+
+var instance = {
+  write: function(data) {
+    return this.send(data);
+  },
+
+  end: function(data) {
+    if (data !== undefined) this.send(data);
+    this.close();
+  },
+
+  pause: function() {
+    return this._driver.messages.pause();
+  },
+
+  resume: function() {
+    return this._driver.messages.resume();
+  },
+
+  send: function(data) {
+    if (this.readyState > API.OPEN) return false;
+    if (!(data instanceof Buffer)) data = String(data);
+    return this._driver.messages.write(data);
+  },
+
+  ping: function(message, callback) {
+    if (this.readyState > API.OPEN) return false;
+    return this._driver.ping(message, callback);
+  },
+
+  close: function(code, reason) {
+    if (code === undefined) code = 1000;
+    if (reason === undefined) reason = '';
+
+    if (code !== 1000 && (code < 3000 || code > 4999))
+      throw new Error("Failed to execute 'close' on WebSocket: " +
+                      "The code must be either 1000, or between 3000 and 4999. " +
+                      code + " is neither.");
+
+    if (this.readyState < API.CLOSING) {
+      var self = this;
+      this._closeTimer = setTimeout(function() {
+        self._beginClose('', 1006);
+      }, API.CLOSE_TIMEOUT);
+    }
+
+    if (this.readyState !== API.CLOSED) this.readyState = API.CLOSING;
+
+    this._driver.close(reason, code);
+  },
+
+  _configureStream: function() {
+    var self = this;
+
+    this._stream.setTimeout(0);
+    this._stream.setNoDelay(true);
+
+    ['close', 'end'].forEach(function(event) {
+      this._stream.on(event, function() { self._finalizeClose(); });
+    }, this);
+
+    this._stream.on('error', function(error) {
+      self._emitError('Network error: ' + self.url + ': ' + error.message);
+      self._finalizeClose();
+    });
+  },
+
+  _open: function() {
+    if (this.readyState !== API.CONNECTING) return;
+
+    this.readyState = API.OPEN;
+    this.protocol = this._driver.protocol || '';
+
+    var event = new Event('open');
+    event.initEvent('open', false, false);
+    this.dispatchEvent(event);
+  },
+
+  _receiveMessage: function(data) {
+    if (this.readyState > API.OPEN) return false;
+
+    if (this.readable) this.emit('data', data);
+
+    var event = new Event('message', { data: data });
+    event.initEvent('message', false, false);
+    this.dispatchEvent(event);
+  },
+
+  _emitError: function(message) {
+    if (this.readyState >= API.CLOSING) return;
+
+    var event = new Event('error', { message: message });
+    event.initEvent('error', false, false);
+    this.dispatchEvent(event);
+  },
+
+  _beginClose: function(reason, code) {
+    if (this.readyState === API.CLOSED) return;
+    this.readyState = API.CLOSING;
+    this._closeParams = [reason, code];
+
+    if (this._stream) {
+      this._stream.destroy();
+      if (!this._stream.readable) this._finalizeClose();
+    }
+  },
+
+  _finalizeClose: function() {
+    if (this.readyState === API.CLOSED) return;
+    this.readyState = API.CLOSED;
+
+    if (this._closeTimer) clearTimeout(this._closeTimer);
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    if (this._stream) this._stream.end();
+
+    if (this.readable) this.emit('end');
+    this.readable = this.writable = false;
+
+    var reason = this._closeParams ? this._closeParams[0] : '',
+        code   = this._closeParams ? this._closeParams[1] : 1006;
+
+    var event = new Event('close', { code: code, reason: reason });
+    event.initEvent('close', false, false);
+    this.dispatchEvent(event);
+  }
+};
+
+for (var method in instance) API.prototype[method] = instance[method];
+for (var key in EventTarget) API.prototype[key] = EventTarget[key];
+
+var api = API;
+
+export { api as default };

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

@@ -0,0 +1,107 @@
+import require$$1 from 'util';
+import require$$1$1 from 'net';
+import require$$2 from 'tls';
+import require$$2$1 from 'url';
+import driver from '../../../../websocket-driver/lib/websocket/driver.js';
+import api from './api.js';
+import { __require as requireEvent } from './api/event.js';
+
+var client;
+var hasRequiredClient;
+
+function requireClient () {
+	if (hasRequiredClient) return client;
+	hasRequiredClient = 1;
+
+	var util   = require$$1,
+	    net    = require$$1$1,
+	    tls    = require$$2,
+	    url    = require$$2$1,
+	    driver$1 = driver,
+	    API    = api;
+	    requireEvent();
+
+	var DEFAULT_PORTS    = { 'http:': 80, 'https:': 443, 'ws:':80, 'wss:': 443 },
+	    SECURE_PROTOCOLS = ['https:', 'wss:'];
+
+	var Client = function(_url, protocols, options) {
+	  options = options || {};
+
+	  this.url     = _url;
+	  this._driver = driver$1.client(this.url, { maxLength: options.maxLength, protocols: protocols });
+
+	  ['open', 'error'].forEach(function(event) {
+	    this._driver.on(event, function() {
+	      self.headers    = self._driver.headers;
+	      self.statusCode = self._driver.statusCode;
+	    });
+	  }, this);
+
+	  var proxy      = options.proxy || {},
+	      endpoint   = url.parse(proxy.origin || this.url),
+	      port       = endpoint.port || DEFAULT_PORTS[endpoint.protocol],
+	      secure     = SECURE_PROTOCOLS.indexOf(endpoint.protocol) >= 0,
+	      onConnect  = function() { self._onConnect(); },
+	      netOptions = options.net || {},
+	      originTLS  = options.tls || {},
+	      socketTLS  = proxy.origin ? (proxy.tls || {}) : originTLS,
+	      self       = this;
+
+	  netOptions.host = socketTLS.host = endpoint.hostname;
+	  netOptions.port = socketTLS.port = port;
+
+	  originTLS.ca = originTLS.ca || options.ca;
+	  socketTLS.servername = socketTLS.servername || endpoint.hostname;
+
+	  this._stream = secure
+	               ? tls.connect(socketTLS, onConnect)
+	               : net.connect(netOptions, onConnect);
+
+	  if (proxy.origin) this._configureProxy(proxy, originTLS);
+
+	  API.call(this, options);
+	};
+	util.inherits(Client, API);
+
+	Client.prototype._onConnect = function() {
+	  var worker = this._proxy || this._driver;
+	  worker.start();
+	};
+
+	Client.prototype._configureProxy = function(proxy, originTLS) {
+	  var uri    = url.parse(this.url),
+	      secure = SECURE_PROTOCOLS.indexOf(uri.protocol) >= 0,
+	      self   = this,
+	      name;
+
+	  this._proxy = this._driver.proxy(proxy.origin);
+
+	  if (proxy.headers) {
+	    for (name in proxy.headers) this._proxy.setHeader(name, proxy.headers[name]);
+	  }
+
+	  this._proxy.pipe(this._stream, { end: false });
+	  this._stream.pipe(this._proxy);
+
+	  this._proxy.on('connect', function() {
+	    if (secure) {
+	      var options = { socket: self._stream, servername: uri.hostname };
+	      for (name in originTLS) options[name] = originTLS[name];
+	      self._stream = tls.connect(options);
+	      self._configureStream();
+	    }
+	    self._driver.io.pipe(self._stream);
+	    self._stream.pipe(self._driver.io);
+	    self._driver.start();
+	  });
+
+	  this._proxy.on('error', function(error) {
+	    self._driver.emit('error', error);
+	  });
+	};
+
+	client = Client;
+	return client;
+}
+
+export { requireClient as __require };

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

@@ -0,0 +1,47 @@
+import require$$1 from 'util';
+import driver$1 from '../../../websocket-driver/lib/websocket/driver.js';
+import api from './websocket/api.js';
+import { __require as requireClient } from './websocket/client.js';
+import { __require as requireEventsource } from './eventsource.js';
+
+var util   = require$$1,
+    driver = driver$1,
+    API    = api;
+
+var WebSocket = function(request, socket, body, protocols, options) {
+  options = options || {};
+
+  this._stream = socket;
+  this._driver = driver.http(request, { maxLength: options.maxLength, protocols: protocols });
+
+  var self = this;
+  if (!this._stream || !this._stream.writable) return;
+  if (!this._stream.readable) return this._stream.end();
+
+  var catchup = function() { self._stream.removeListener('data', catchup); };
+  this._stream.on('data', catchup);
+
+  API.call(this, options);
+
+  process.nextTick(function() {
+    self._driver.start();
+    self._driver.io.write(body);
+  });
+};
+util.inherits(WebSocket, API);
+
+WebSocket.isWebSocket = function(request) {
+  return driver.isWebSocket(request);
+};
+
+WebSocket.validateOptions = function(options, validKeys) {
+  driver.validateOptions(options, validKeys);
+};
+
+WebSocket.WebSocket   = WebSocket;
+WebSocket.Client      = requireClient();
+WebSocket.EventSource = requireEventsource();
+
+var websocket        = WebSocket;
+
+export { websocket as default };

package/dist/es/node_modules/has-flag/index.js

@@ -0,0 +1,17 @@
+var hasFlag;
+var hasRequiredHasFlag;
+
+function requireHasFlag () {
+	if (hasRequiredHasFlag) return hasFlag;
+	hasRequiredHasFlag = 1;
+	hasFlag = (flag, argv) => {
+		argv = argv || process.argv;
+		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+		const pos = argv.indexOf(prefix + flag);
+		const terminatorPos = argv.indexOf('--');
+		return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+	};
+	return hasFlag;
+}
+
+export { requireHasFlag as __require };