zmdms-utils 0.0.80 → 0.0.81

package/dist/es/node_modules/zt-sockjs-client/lib/event/trans-message.js

@@ -0,0 +1,19 @@
+import '../../../inherits/inherits.js';
+import event from './event.js';
+import { exports as inheritsExports } from '../../../../_virtual/inherits.js';
+
+var inherits = inheritsExports
+  , Event = event
+  ;
+
+function TransportMessageEvent(data) {
+  Event.call(this);
+  this.initEvent('message', false, false);
+  this.data = data;
+}
+
+inherits(TransportMessageEvent, Event);
+
+var transMessage = TransportMessageEvent;
+
+export { transMessage as default };

package/dist/es/node_modules/zt-sockjs-client/lib/facade.js

@@ -0,0 +1,40 @@
+import '../../json3/lib/json3.js';
+import { __require as requireIframe } from './utils/iframe.js';
+import { exports as json3Exports } from '../../../_virtual/json3.js';
+
+var facade;
+var hasRequiredFacade;
+
+function requireFacade () {
+	if (hasRequiredFacade) return facade;
+	hasRequiredFacade = 1;
+
+	var JSON3 = json3Exports
+	  , iframeUtils = requireIframe()
+	  ;
+
+	function FacadeJS(transport) {
+	  this._transport = transport;
+	  transport.on('message', this._transportMessage.bind(this));
+	  transport.on('close', this._transportClose.bind(this));
+	}
+
+	FacadeJS.prototype._transportClose = function(code, reason) {
+	  iframeUtils.postMessage('c', JSON3.stringify([code, reason]));
+	};
+	FacadeJS.prototype._transportMessage = function(frame) {
+	  iframeUtils.postMessage('t', frame);
+	};
+	FacadeJS.prototype._send = function(data) {
+	  this._transport.send(data);
+	};
+	FacadeJS.prototype._close = function() {
+	  this._transport.close();
+	  this._transport.removeAllListeners();
+	};
+
+	facade = FacadeJS;
+	return facade;
+}
+
+export { requireFacade as __require };

package/dist/es/node_modules/zt-sockjs-client/lib/iframe-bootstrap.js

@@ -0,0 +1,122 @@
+import url from './utils/url.js';
+import './utils/event.js';
+import '../../json3/lib/json3.js';
+import { __require as requireFacade } from './facade.js';
+import { __require as requireInfoIframeReceiver } from './info-iframe-receiver.js';
+import { __require as requireIframe } from './utils/iframe.js';
+import location from './location.js';
+import { __require as requireSrc } from '../../debug/src/index.js';
+import { exports as eventExports } from '../../../_virtual/event.js';
+import { exports as json3Exports } from '../../../_virtual/json3.js';
+
+var iframeBootstrap;
+var hasRequiredIframeBootstrap;
+
+function requireIframeBootstrap () {
+	if (hasRequiredIframeBootstrap) return iframeBootstrap;
+	hasRequiredIframeBootstrap = 1;
+
+	var urlUtils = url
+	  , eventUtils = eventExports
+	  , JSON3 = json3Exports
+	  , FacadeJS = requireFacade()
+	  , InfoIframeReceiver = requireInfoIframeReceiver()
+	  , iframeUtils = requireIframe()
+	  , loc = location
+	  ;
+
+	var debug = function() {};
+	if (process.env.NODE_ENV !== 'production') {
+	  debug = requireSrc()('sockjs-client:iframe-bootstrap');
+	}
+
+	iframeBootstrap = function(SockJS, availableTransports) {
+	  var transportMap = {};
+	  availableTransports.forEach(function(at) {
+	    if (at.facadeTransport) {
+	      transportMap[at.facadeTransport.transportName] = at.facadeTransport;
+	    }
+	  });
+
+	  // hard-coded for the info iframe
+	  // TODO see if we can make this more dynamic
+	  transportMap[InfoIframeReceiver.transportName] = InfoIframeReceiver;
+	  var parentOrigin;
+
+	  /* eslint-disable camelcase */
+	  SockJS.bootstrap_iframe = function() {
+	    /* eslint-enable camelcase */
+	    var facade;
+	    iframeUtils.currentWindowId = loc.hash.slice(1);
+	    var onMessage = function(e) {
+	      if (e.source !== parent) {
+	        return;
+	      }
+	      if (typeof parentOrigin === 'undefined') {
+	        parentOrigin = e.origin;
+	      }
+	      if (e.origin !== parentOrigin) {
+	        return;
+	      }
+
+	      var iframeMessage;
+	      try {
+	        iframeMessage = JSON3.parse(e.data);
+	      } catch (ignored) {
+	        debug('bad json', e.data);
+	        return;
+	      }
+
+	      if (iframeMessage.windowId !== iframeUtils.currentWindowId) {
+	        return;
+	      }
+	      switch (iframeMessage.type) {
+	      case 's':
+	        var p;
+	        try {
+	          p = JSON3.parse(iframeMessage.data);
+	        } catch (ignored) {
+	          debug('bad json', iframeMessage.data);
+	          break;
+	        }
+	        var version = p[0];
+	        var transport = p[1];
+	        var transUrl = p[2];
+	        var baseUrl = p[3];
+	        debug(version, transport, transUrl, baseUrl);
+	        // change this to semver logic
+	        if (version !== SockJS.version) {
+	          throw new Error('Incompatible SockJS! Main site uses:' +
+	                    ' "' + version + '", the iframe:' +
+	                    ' "' + SockJS.version + '".');
+	        }
+
+	        if (!urlUtils.isOriginEqual(transUrl, loc.href) ||
+	            !urlUtils.isOriginEqual(baseUrl, loc.href)) {
+	          throw new Error('Can\'t connect to different domain from within an ' +
+	                    'iframe. (' + loc.href + ', ' + transUrl + ', ' + baseUrl + ')');
+	        }
+	        facade = new FacadeJS(new transportMap[transport](transUrl, baseUrl));
+	        break;
+	      case 'm':
+	        facade._send(iframeMessage.data);
+	        break;
+	      case 'c':
+	        if (facade) {
+	          facade._close();
+	        }
+	        facade = null;
+	        break;
+	      }
+	    };
+
+	    eventUtils.attachEvent('message', onMessage);
+
+	    // Start
+	    iframeUtils.postMessage('s');
+	  };
+	};
+	return iframeBootstrap;
+}
+
+export { requireIframeBootstrap as __require };

package/dist/es/node_modules/zt-sockjs-client/lib/info-ajax.js

@@ -0,0 +1,57 @@
+import require$$1 from 'events';
+import '../../inherits/inherits.js';
+import '../../json3/lib/json3.js';
+import object from './utils/object.js';
+import { __require as requireSrc } from '../../debug/src/index.js';
+import { exports as inheritsExports } from '../../../_virtual/inherits.js';
+import { exports as json3Exports } from '../../../_virtual/json3.js';
+
+var EventEmitter = require$$1.EventEmitter
+  , inherits = inheritsExports
+  , JSON3 = json3Exports
+  , objectUtils = object
+  ;
+
+var debug = function() {};
+if (process.env.NODE_ENV !== 'production') {
+  debug = requireSrc()('sockjs-client:info-ajax');
+}
+
+function InfoAjax(url, AjaxObject) {
+  EventEmitter.call(this);
+
+  var self = this;
+  var t0 = +new Date();
+  this.xo = new AjaxObject('GET', url);
+
+  this.xo.once('finish', function(status, text) {
+    var info, rtt;
+    if (status === 200) {
+      rtt = (+new Date()) - t0;
+      if (text) {
+        try {
+          info = JSON3.parse(text);
+        } catch (e) {
+          debug('bad json', text);
+        }
+      }
+
+      if (!objectUtils.isObject(info)) {
+        info = {};
+      }
+    }
+    self.emit('finish', info, rtt);
+    self.removeAllListeners();
+  });
+}
+
+inherits(InfoAjax, EventEmitter);
+
+InfoAjax.prototype.close = function() {
+  this.removeAllListeners();
+  this.xo.close();
+};
+
+var infoAjax = InfoAjax;
+
+export { infoAjax as default };

package/dist/es/node_modules/zt-sockjs-client/lib/info-iframe-receiver.js

@@ -0,0 +1,50 @@
+import '../../inherits/inherits.js';
+import require$$1 from 'events';
+import '../../json3/lib/json3.js';
+import xhrLocal from './transport/sender/xhr-local.js';
+import infoAjax from './info-ajax.js';
+import { exports as inheritsExports } from '../../../_virtual/inherits.js';
+import { exports as json3Exports } from '../../../_virtual/json3.js';
+
+var infoIframeReceiver;
+var hasRequiredInfoIframeReceiver;
+
+function requireInfoIframeReceiver () {
+	if (hasRequiredInfoIframeReceiver) return infoIframeReceiver;
+	hasRequiredInfoIframeReceiver = 1;
+
+	var inherits = inheritsExports
+	  , EventEmitter = require$$1.EventEmitter
+	  , JSON3 = json3Exports
+	  , XHRLocalObject = xhrLocal
+	  , InfoAjax = infoAjax
+	  ;
+
+	function InfoReceiverIframe(transUrl) {
+	  var self = this;
+	  EventEmitter.call(this);
+
+	  this.ir = new InfoAjax(transUrl, XHRLocalObject);
+	  this.ir.once('finish', function(info, rtt) {
+	    self.ir = null;
+	    self.emit('message', JSON3.stringify([info, rtt]));
+	  });
+	}
+
+	inherits(InfoReceiverIframe, EventEmitter);
+
+	InfoReceiverIframe.transportName = 'iframe-info-receiver';
+
+	InfoReceiverIframe.prototype.close = function() {
+	  if (this.ir) {
+	    this.ir.close();
+	    this.ir = null;
+	  }
+	  this.removeAllListeners();
+	};
+
+	infoIframeReceiver = InfoReceiverIframe;
+	return infoIframeReceiver;
+}
+
+export { requireInfoIframeReceiver as __require };

package/dist/es/node_modules/zt-sockjs-client/lib/info-iframe.js

@@ -0,0 +1,81 @@
+import { commonjsGlobal } from '../../../_virtual/_commonjsHelpers.js';
+import require$$1 from 'events';
+import '../../inherits/inherits.js';
+import '../../json3/lib/json3.js';
+import './utils/event.js';
+import iframe from './transport/iframe.js';
+import { __require as requireInfoIframeReceiver } from './info-iframe-receiver.js';
+import { __require as requireSrc } from '../../debug/src/index.js';
+import { exports as inheritsExports } from '../../../_virtual/inherits.js';
+import { exports as eventExports } from '../../../_virtual/event.js';
+import { exports as json3Exports } from '../../../_virtual/json3.js';
+
+var EventEmitter = require$$1.EventEmitter
+  , inherits = inheritsExports
+  , JSON3 = json3Exports
+  , utils = eventExports
+  , IframeTransport = iframe
+  , InfoReceiverIframe = requireInfoIframeReceiver()
+  ;
+
+var debug = function() {};
+if (process.env.NODE_ENV !== 'production') {
+  debug = requireSrc()('sockjs-client:info-iframe');
+}
+
+function InfoIframe(baseUrl, url) {
+  var self = this;
+  EventEmitter.call(this);
+
+  var go = function() {
+    var ifr = self.ifr = new IframeTransport(InfoReceiverIframe.transportName, url, baseUrl);
+
+    ifr.once('message', function(msg) {
+      if (msg) {
+        var d;
+        try {
+          d = JSON3.parse(msg);
+        } catch (e) {
+          debug('bad json', msg);
+          self.emit('finish');
+          self.close();
+          return;
+        }
+
+        var info = d[0], rtt = d[1];
+        self.emit('finish', info, rtt);
+      }
+      self.close();
+    });
+
+    ifr.once('close', function() {
+      self.emit('finish');
+      self.close();
+    });
+  };
+
+  // TODO this seems the same as the 'needBody' from transports
+  if (!commonjsGlobal.document.body) {
+    utils.attachEvent('load', go);
+  } else {
+    go();
+  }
+}
+
+inherits(InfoIframe, EventEmitter);
+
+InfoIframe.enabled = function() {
+  return IframeTransport.enabled();
+};
+
+InfoIframe.prototype.close = function() {
+  if (this.ifr) {
+    this.ifr.close();
+  }
+  this.removeAllListeners();
+  this.ifr = null;
+};
+
+var infoIframe = InfoIframe;
+
+export { infoIframe as default };

package/dist/es/node_modules/zt-sockjs-client/lib/info-receiver.js

@@ -0,0 +1,101 @@
+import require$$1 from 'events';
+import '../../inherits/inherits.js';
+import url from './utils/url.js';
+import xdr from './transport/sender/xdr.js';
+import xhrCors from './transport/sender/xhr-cors.js';
+import xhrLocal from './transport/sender/xhr-local.js';
+import xhrFake from './transport/sender/xhr-fake.js';
+import infoIframe from './info-iframe.js';
+import infoAjax from './info-ajax.js';
+import { __require as requireSrc } from '../../debug/src/index.js';
+import { exports as inheritsExports } from '../../../_virtual/inherits.js';
+
+var EventEmitter = require$$1.EventEmitter
+  , inherits = inheritsExports
+  , urlUtils = url
+  , XDR = xdr
+  , XHRCors = xhrCors
+  , XHRLocal = xhrLocal
+  , XHRFake = xhrFake
+  , InfoIframe = infoIframe
+  , InfoAjax = infoAjax
+  ;
+
+var debug = function() {};
+if (process.env.NODE_ENV !== 'production') {
+  debug = requireSrc()('sockjs-client:info-receiver');
+}
+
+function InfoReceiver(baseUrl, urlInfo) {
+  debug(baseUrl);
+  var self = this;
+  EventEmitter.call(this);
+
+  setTimeout(function() {
+    self.doXhr(baseUrl, urlInfo);
+  }, 0);
+}
+
+inherits(InfoReceiver, EventEmitter);
+
+// TODO this is currently ignoring the list of available transports and the whitelist
+
+InfoReceiver._getReceiver = function(baseUrl, url, urlInfo) {
+  // determine method of CORS support (if needed)
+  if (urlInfo.sameOrigin) {
+    return new InfoAjax(url, XHRLocal);
+  }
+  if (XHRCors.enabled) {
+    return new InfoAjax(url, XHRCors);
+  }
+  if (XDR.enabled && urlInfo.sameScheme) {
+    return new InfoAjax(url, XDR);
+  }
+  if (InfoIframe.enabled()) {
+    return new InfoIframe(baseUrl, url);
+  }
+  return new InfoAjax(url, XHRFake);
+};
+
+InfoReceiver.prototype.doXhr = function(baseUrl, urlInfo) {
+  var self = this
+    , url = urlUtils.addPath(baseUrl, '/info')
+    ;
+  debug('doXhr', url);
+
+  this.xo = InfoReceiver._getReceiver(baseUrl, url, urlInfo);
+
+  this.timeoutRef = setTimeout(function() {
+    debug('timeout');
+    self._cleanup(false);
+    self.emit('finish');
+  }, InfoReceiver.timeout);
+
+  this.xo.once('finish', function(info, rtt) {
+    debug('finish', info, rtt);
+    self._cleanup(true);
+    self.emit('finish', info, rtt);
+  });
+};
+
+InfoReceiver.prototype._cleanup = function(wasClean) {
+  debug('_cleanup');
+  clearTimeout(this.timeoutRef);
+  this.timeoutRef = null;
+  if (!wasClean && this.xo) {
+    this.xo.close();
+  }
+  this.xo = null;
+};
+
+InfoReceiver.prototype.close = function() {
+  debug('close');
+  this.removeAllListeners();
+  this._cleanup(false);
+};
+
+InfoReceiver.timeout = 8000;
+
+var infoReceiver = InfoReceiver;
+
+export { infoReceiver as default };

package/dist/es/node_modules/zt-sockjs-client/lib/location.js

@@ -0,0 +1,12 @@
+import { commonjsGlobal } from '../../../_virtual/_commonjsHelpers.js';
+
+var location = commonjsGlobal.location || {
+  origin: 'http://localhost:80'
+, protocol: 'http:'
+, host: 'localhost'
+, port: 80
+, href: 'http://localhost/'
+, hash: ''
+};
+
+export { location as default };