diff --git a/index.js b/index.js new file mode 100644 index 00000000..2cfccd8e --- /dev/null +++ b/index.js @@ -0,0 +1,1969 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (factory((global.Mock = global.Mock || {}))); +}(this, (function (exports) { 'use strict'; + +var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +/** + * Check if we're required to add a port number. + * + * @see https://url.spec.whatwg.org/#default-port + * @param {Number|String} port Port number we need to check + * @param {String} protocol Protocol we need to check against. + * @returns {Boolean} Is it a default port for the given protocol + * @api private + */ +var requiresPort = function required(port, protocol) { + protocol = protocol.split(':')[0]; + port = +port; + + if (!port) { return false; } + + switch (protocol) { + case 'http': + case 'ws': + return port !== 80; + + case 'https': + case 'wss': + return port !== 443; + + case 'ftp': + return port !== 21; + + case 'gopher': + return port !== 70; + + case 'file': + return false; + } + + return port !== 0; +}; + +var has = Object.prototype.hasOwnProperty; +var undef; + +/** + * Decode a URI encoded string. + * + * @param {String} input The URI encoded string. + * @returns {String} The decoded string. + * @api private + */ +function decode(input) { + return decodeURIComponent(input.replace(/\+/g, ' ')); +} + +/** + * Simple query string parser. + * + * @param {String} query The query string that needs to be parsed. + * @returns {Object} + * @api public + */ +function querystring(query) { + var parser = /([^=?&]+)=?([^&]*)/g + , result = {} + , part; + + while (part = parser.exec(query)) { + var key = decode(part[1]) + , value = decode(part[2]); + + // + // Prevent overriding of existing properties. This ensures that build-in + // methods like `toString` or __proto__ are not overriden by malicious + // querystrings. + // + if (key in result) { continue; } + result[key] = value; + } + + return result; +} + +/** + * Transform a query string to an object. + * + * @param {Object} obj Object that should be transformed. + * @param {String} prefix Optional prefix. + * @returns {String} + * @api public + */ +function querystringify(obj, prefix) { + prefix = prefix || ''; + + var pairs = [] + , value + , key; + + // + // Optionally prefix with a '?' if needed + // + if ('string' !== typeof prefix) { prefix = '?'; } + + for (key in obj) { + if (has.call(obj, key)) { + value = obj[key]; + + // + // Edge cases where we actually want to encode the value to an empty + // string instead of the stringified value. + // + if (!value && (value === null || value === undef || isNaN(value))) { + value = ''; + } + + pairs.push(encodeURIComponent(key) +'='+ encodeURIComponent(value)); + } + } + + return pairs.length ? prefix + pairs.join('&') : ''; +} + +// +// Expose the module. +// +var stringify = querystringify; +var parse = querystring; + +var querystringify_1 = { + stringify: stringify, + parse: parse +}; + +var protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\S\s]*)/i; +var slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//; + +/** + * These are the parse rules for the URL parser, it informs the parser + * about: + * + * 0. The char it Needs to parse, if it's a string it should be done using + * indexOf, RegExp using exec and NaN means set as current value. + * 1. The property we should set when parsing this value. + * 2. Indication if it's backwards or forward parsing, when set as number it's + * the value of extra chars that should be split off. + * 3. Inherit from location if non existing in the parser. + * 4. `toLowerCase` the resulting value. + */ +var rules = [ + ['#', 'hash'], // Extract from the back. + ['?', 'query'], // Extract from the back. + function sanitize(address) { // Sanitize what is left of the address + return address.replace('\\', '/'); + }, + ['/', 'pathname'], // Extract from the back. + ['@', 'auth', 1], // Extract from the front. + [NaN, 'host', undefined, 1, 1], // Set left over value. + [/:(\d+)$/, 'port', undefined, 1], // RegExp the back. + [NaN, 'hostname', undefined, 1, 1] // Set left over. +]; + +/** + * These properties should not be copied or inherited from. This is only needed + * for all non blob URL's as a blob URL does not include a hash, only the + * origin. + * + * @type {Object} + * @private + */ +var ignore = { hash: 1, query: 1 }; + +/** + * The location object differs when your code is loaded through a normal page, + * Worker or through a worker using a blob. And with the blobble begins the + * trouble as the location object will contain the URL of the blob, not the + * location of the page where our code is loaded in. The actual origin is + * encoded in the `pathname` so we can thankfully generate a good "default" + * location from it so we can generate proper relative URL's again. + * + * @param {Object|String} loc Optional default location object. + * @returns {Object} lolcation object. + * @public + */ +function lolcation(loc) { + var globalVar; + + if (typeof window !== 'undefined') { globalVar = window; } + else if (typeof commonjsGlobal !== 'undefined') { globalVar = commonjsGlobal; } + else if (typeof self !== 'undefined') { globalVar = self; } + else { globalVar = {}; } + + var location = globalVar.location || {}; + loc = loc || location; + + var finaldestination = {} + , type = typeof loc + , key; + + if ('blob:' === loc.protocol) { + finaldestination = new Url(unescape(loc.pathname), {}); + } else if ('string' === type) { + finaldestination = new Url(loc, {}); + for (key in ignore) { delete finaldestination[key]; } + } else if ('object' === type) { + for (key in loc) { + if (key in ignore) { continue; } + finaldestination[key] = loc[key]; + } + + if (finaldestination.slashes === undefined) { + finaldestination.slashes = slashes.test(loc.href); + } + } + + return finaldestination; +} + +/** + * @typedef ProtocolExtract + * @type Object + * @property {String} protocol Protocol matched in the URL, in lowercase. + * @property {Boolean} slashes `true` if protocol is followed by "//", else `false`. + * @property {String} rest Rest of the URL that is not part of the protocol. + */ + +/** + * Extract protocol information from a URL with/without double slash ("//"). + * + * @param {String} address URL we want to extract from. + * @return {ProtocolExtract} Extracted information. + * @private + */ +function extractProtocol(address) { + var match = protocolre.exec(address); + + return { + protocol: match[1] ? match[1].toLowerCase() : '', + slashes: !!match[2], + rest: match[3] + }; +} + +/** + * Resolve a relative URL pathname against a base URL pathname. + * + * @param {String} relative Pathname of the relative URL. + * @param {String} base Pathname of the base URL. + * @return {String} Resolved pathname. + * @private + */ +function resolve(relative, base) { + var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/')) + , i = path.length + , last = path[i - 1] + , unshift = false + , up = 0; + + while (i--) { + if (path[i] === '.') { + path.splice(i, 1); + } else if (path[i] === '..') { + path.splice(i, 1); + up++; + } else if (up) { + if (i === 0) { unshift = true; } + path.splice(i, 1); + up--; + } + } + + if (unshift) { path.unshift(''); } + if (last === '.' || last === '..') { path.push(''); } + + return path.join('/'); +} + +/** + * The actual URL instance. Instead of returning an object we've opted-in to + * create an actual constructor as it's much more memory efficient and + * faster and it pleases my OCD. + * + * It is worth noting that we should not use `URL` as class name to prevent + * clashes with the global URL instance that got introduced in browsers. + * + * @constructor + * @param {String} address URL we want to parse. + * @param {Object|String} [location] Location defaults for relative paths. + * @param {Boolean|Function} [parser] Parser for the query string. + * @private + */ +function Url(address, location, parser) { + if (!(this instanceof Url)) { + return new Url(address, location, parser); + } + + var relative, extracted, parse, instruction, index, key + , instructions = rules.slice() + , type = typeof location + , url = this + , i = 0; + + // + // The following if statements allows this module two have compatibility with + // 2 different API: + // + // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments + // where the boolean indicates that the query string should also be parsed. + // + // 2. The `URL` interface of the browser which accepts a URL, object as + // arguments. The supplied object will be used as default values / fall-back + // for relative paths. + // + if ('object' !== type && 'string' !== type) { + parser = location; + location = null; + } + + if (parser && 'function' !== typeof parser) { parser = querystringify_1.parse; } + + location = lolcation(location); + + // + // Extract protocol information before running the instructions. + // + extracted = extractProtocol(address || ''); + relative = !extracted.protocol && !extracted.slashes; + url.slashes = extracted.slashes || relative && location.slashes; + url.protocol = extracted.protocol || location.protocol || ''; + address = extracted.rest; + + // + // When the authority component is absent the URL starts with a path + // component. + // + if (!extracted.slashes) { instructions[3] = [/(.*)/, 'pathname']; } + + for (; i < instructions.length; i++) { + instruction = instructions[i]; + + if (typeof instruction === 'function') { + address = instruction(address); + continue; + } + + parse = instruction[0]; + key = instruction[1]; + + if (parse !== parse) { + url[key] = address; + } else if ('string' === typeof parse) { + if (~(index = address.indexOf(parse))) { + if ('number' === typeof instruction[2]) { + url[key] = address.slice(0, index); + address = address.slice(index + instruction[2]); + } else { + url[key] = address.slice(index); + address = address.slice(0, index); + } + } + } else if ((index = parse.exec(address))) { + url[key] = index[1]; + address = address.slice(0, index.index); + } + + url[key] = url[key] || ( + relative && instruction[3] ? location[key] || '' : '' + ); + + // + // Hostname, host and protocol should be lowercased so they can be used to + // create a proper `origin`. + // + if (instruction[4]) { url[key] = url[key].toLowerCase(); } + } + + // + // Also parse the supplied query string in to an object. If we're supplied + // with a custom parser as function use that instead of the default build-in + // parser. + // + if (parser) { url.query = parser(url.query); } + + // + // If the URL is relative, resolve the pathname against the base URL. + // + if ( + relative + && location.slashes + && url.pathname.charAt(0) !== '/' + && (url.pathname !== '' || location.pathname !== '') + ) { + url.pathname = resolve(url.pathname, location.pathname); + } + + // + // We should not add port numbers if they are already the default port number + // for a given protocol. As the host also contains the port number we're going + // override it with the hostname which contains no port number. + // + if (!requiresPort(url.port, url.protocol)) { + url.host = url.hostname; + url.port = ''; + } + + // + // Parse down the `auth` for the username and password. + // + url.username = url.password = ''; + if (url.auth) { + instruction = url.auth.split(':'); + url.username = instruction[0] || ''; + url.password = instruction[1] || ''; + } + + url.origin = url.protocol && url.host && url.protocol !== 'file:' + ? url.protocol +'//'+ url.host + : 'null'; + + // + // The href is just the compiled result. + // + url.href = url.toString(); +} + +/** + * This is convenience method for changing properties in the URL instance to + * insure that they all propagate correctly. + * + * @param {String} part Property we need to adjust. + * @param {Mixed} value The newly assigned value. + * @param {Boolean|Function} fn When setting the query, it will be the function + * used to parse the query. + * When setting the protocol, double slash will be + * removed from the final url if it is true. + * @returns {URL} URL instance for chaining. + * @public + */ +function set(part, value, fn) { + var url = this; + + switch (part) { + case 'query': + if ('string' === typeof value && value.length) { + value = (fn || querystringify_1.parse)(value); + } + + url[part] = value; + break; + + case 'port': + url[part] = value; + + if (!requiresPort(value, url.protocol)) { + url.host = url.hostname; + url[part] = ''; + } else if (value) { + url.host = url.hostname +':'+ value; + } + + break; + + case 'hostname': + url[part] = value; + + if (url.port) { value += ':'+ url.port; } + url.host = value; + break; + + case 'host': + url[part] = value; + + if (/:\d+$/.test(value)) { + value = value.split(':'); + url.port = value.pop(); + url.hostname = value.join(':'); + } else { + url.hostname = value; + url.port = ''; + } + + break; + + case 'protocol': + url.protocol = value.toLowerCase(); + url.slashes = !fn; + break; + + case 'pathname': + case 'hash': + if (value) { + var char = part === 'pathname' ? '/' : '#'; + url[part] = value.charAt(0) !== char ? char + value : value; + } else { + url[part] = value; + } + break; + + default: + url[part] = value; + } + + for (var i = 0; i < rules.length; i++) { + var ins = rules[i]; + + if (ins[4]) { url[ins[1]] = url[ins[1]].toLowerCase(); } + } + + url.origin = url.protocol && url.host && url.protocol !== 'file:' + ? url.protocol +'//'+ url.host + : 'null'; + + url.href = url.toString(); + + return url; +} + +/** + * Transform the properties back in to a valid and full URL string. + * + * @param {Function} stringify Optional query stringify function. + * @returns {String} Compiled version of the URL. + * @public + */ +function toString(stringify) { + if (!stringify || 'function' !== typeof stringify) { stringify = querystringify_1.stringify; } + + var query + , url = this + , protocol = url.protocol; + + if (protocol && protocol.charAt(protocol.length - 1) !== ':') { protocol += ':'; } + + var result = protocol + (url.slashes ? '//' : ''); + + if (url.username) { + result += url.username; + if (url.password) { result += ':'+ url.password; } + result += '@'; + } + + result += url.host + url.pathname; + + query = 'object' === typeof url.query ? stringify(url.query) : url.query; + if (query) { result += '?' !== query.charAt(0) ? '?'+ query : query; } + + if (url.hash) { result += url.hash; } + + return result; +} + +Url.prototype = { set: set, toString: toString }; + +// +// Expose the URL parser and some additional properties that might be useful for +// others or testing. +// +Url.extractProtocol = extractProtocol; +Url.location = lolcation; +Url.qs = querystringify_1; + +var urlParse = Url; + +/* + * This delay allows the thread to finish assigning its on* methods + * before invoking the delay callback. This is purely a timing hack. + * http://geekabyte.blogspot.com/2014/01/javascript-effect-of-setting-settimeout.html + * + * @param {callback: function} the callback which will be invoked after the timeout + * @parma {context: object} the context in which to invoke the function + */ +function delay(callback, context) { + setTimeout(function (timeoutContext) { return callback.call(timeoutContext); }, 4, context); +} + +function log(method, message) { + /* eslint-disable no-console */ + if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'test') { + console[method].call(null, message); + } + /* eslint-enable no-console */ +} + +function reject(array, callback) { + var results = []; + array.forEach(function (itemInArray) { + if (!callback(itemInArray)) { + results.push(itemInArray); + } + }); + + return results; +} + +function filter(array, callback) { + var results = []; + array.forEach(function (itemInArray) { + if (callback(itemInArray)) { + results.push(itemInArray); + } + }); + + return results; +} + +/* + * EventTarget is an interface implemented by objects that can + * receive events and may have listeners for them. + * + * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget + */ +var EventTarget = function EventTarget() { + this.listeners = {}; +}; + +/* + * Ties a listener function to an event type which can later be invoked via the + * dispatchEvent method. + * + * @param {string} type - the type of event (ie: 'open', 'message', etc.) + * @param {function} listener - callback function to invoke when an event is dispatched matching the type + * @param {boolean} useCapture - N/A TODO: implement useCapture functionality + */ +EventTarget.prototype.addEventListener = function addEventListener (type, listener /* , useCapture */) { + if (typeof listener === 'function') { + if (!Array.isArray(this.listeners[type])) { + this.listeners[type] = []; + } + + // Only add the same function once + if (filter(this.listeners[type], function (item) { return item === listener; }).length === 0) { + this.listeners[type].push(listener); + } + } +}; + +/* + * Removes the listener so it will no longer be invoked via the dispatchEvent method. + * + * @param {string} type - the type of event (ie: 'open', 'message', etc.) + * @param {function} listener - callback function to invoke when an event is dispatched matching the type + * @param {boolean} useCapture - N/A TODO: implement useCapture functionality + */ +EventTarget.prototype.removeEventListener = function removeEventListener (type, removingListener /* , useCapture */) { + var arrayOfListeners = this.listeners[type]; + this.listeners[type] = reject(arrayOfListeners, function (listener) { return listener === removingListener; }); +}; + +/* + * Invokes all listener functions that are listening to the given event.type property. Each + * listener will be passed the event as the first argument. + * + * @param {object} event - event object which will be passed to all listeners of the event.type property + */ +EventTarget.prototype.dispatchEvent = function dispatchEvent (event) { + var this$1 = this; + var customArguments = [], len = arguments.length - 1; + while ( len-- > 0 ) customArguments[ len ] = arguments[ len + 1 ]; + + var eventName = event.type; + var listeners = this.listeners[eventName]; + + if (!Array.isArray(listeners)) { + return false; + } + + listeners.forEach(function (listener) { + if (customArguments.length > 0) { + listener.apply(this$1, customArguments); + } else { + listener.call(this$1, event); + } + }); + + return true; +}; + +/* + * The network bridge is a way for the mock websocket object to 'communicate' with + * all available servers. This is a singleton object so it is important that you + * clean up urlMap whenever you are finished. + */ +var NetworkBridge = function NetworkBridge() { + this.urlMap = {}; +}; + +/* + * Attaches a websocket object to the urlMap hash so that it can find the server + * it is connected to and the server in turn can find it. + * + * @param {object} websocket - websocket object to add to the urlMap hash + * @param {string} url + */ +NetworkBridge.prototype.attachWebSocket = function attachWebSocket (websocket, url) { + var queryIndex = url.indexOf('?'); + var serverURL = queryIndex >= 0 ? url.slice(0, queryIndex) : url; + var connectionLookup = this.urlMap[serverURL]; + + if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) === -1) { + connectionLookup.websockets.push(websocket); + return connectionLookup.server; + } +}; + +/* + * Attaches a websocket to a room + */ +NetworkBridge.prototype.addMembershipToRoom = function addMembershipToRoom (websocket, room) { + var connectionLookup = this.urlMap[websocket.url]; + + if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) !== -1) { + if (!connectionLookup.roomMemberships[room]) { + connectionLookup.roomMemberships[room] = []; + } + + connectionLookup.roomMemberships[room].push(websocket); + } +}; + +/* + * Attaches a server object to the urlMap hash so that it can find a websockets + * which are connected to it and so that websockets can in turn can find it. + * + * @param {object} server - server object to add to the urlMap hash + * @param {string} url + */ +NetworkBridge.prototype.attachServer = function attachServer (server, url) { + var connectionLookup = this.urlMap[url]; + + if (!connectionLookup) { + this.urlMap[url] = { + server: server, + websockets: [], + roomMemberships: {} + }; + + return server; + } +}; + +/* + * Finds the server which is 'running' on the given url. + * + * @param {string} url - the url to use to find which server is running on it + */ +NetworkBridge.prototype.serverLookup = function serverLookup (url) { + var connectionLookup = this.urlMap[url]; + + if (connectionLookup) { + return connectionLookup.server; + } +}; + +/* + * Finds all websockets which is 'listening' on the given url. + * + * @param {string} url - the url to use to find all websockets which are associated with it + * @param {string} room - if a room is provided, will only return sockets in this room + * @param {class} broadcaster - socket that is broadcasting and is to be excluded from the lookup + */ +NetworkBridge.prototype.websocketsLookup = function websocketsLookup (url, room, broadcaster) { + var websockets; + var connectionLookup = this.urlMap[url]; + + websockets = connectionLookup ? connectionLookup.websockets : []; + + if (room) { + var members = connectionLookup.roomMemberships[room]; + websockets = members || []; + } + + return broadcaster ? websockets.filter(function (websocket) { return websocket !== broadcaster; }) : websockets; +}; + +/* + * Removes the entry associated with the url. + * + * @param {string} url + */ +NetworkBridge.prototype.removeServer = function removeServer (url) { + delete this.urlMap[url]; +}; + +/* + * Removes the individual websocket from the map of associated websockets. + * + * @param {object} websocket - websocket object to remove from the url map + * @param {string} url + */ +NetworkBridge.prototype.removeWebSocket = function removeWebSocket (websocket, url) { + var connectionLookup = this.urlMap[url]; + + if (connectionLookup) { + connectionLookup.websockets = reject(connectionLookup.websockets, function (socket) { return socket === websocket; }); + } +}; + +/* + * Removes a websocket from a room + */ +NetworkBridge.prototype.removeMembershipFromRoom = function removeMembershipFromRoom (websocket, room) { + var connectionLookup = this.urlMap[websocket.url]; + var memberships = connectionLookup.roomMemberships[room]; + + if (connectionLookup && memberships !== null) { + connectionLookup.roomMemberships[room] = reject(memberships, function (socket) { return socket === websocket; }); + } +}; + +var networkBridge = new NetworkBridge(); // Note: this is a singleton + +/* + * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent + */ +var CLOSE_CODES = { + CLOSE_NORMAL: 1000, + CLOSE_GOING_AWAY: 1001, + CLOSE_PROTOCOL_ERROR: 1002, + CLOSE_UNSUPPORTED: 1003, + CLOSE_NO_STATUS: 1005, + CLOSE_ABNORMAL: 1006, + UNSUPPORTED_DATA: 1007, + POLICY_VIOLATION: 1008, + CLOSE_TOO_LARGE: 1009, + MISSING_EXTENSION: 1010, + INTERNAL_ERROR: 1011, + SERVICE_RESTART: 1012, + TRY_AGAIN_LATER: 1013, + TLS_HANDSHAKE: 1015 +}; + +var ERROR_PREFIX = { + CONSTRUCTOR_ERROR: "Failed to construct 'WebSocket':", + CLOSE_ERROR: "Failed to execute 'close' on 'WebSocket':", + EVENT: { + CONSTRUCT: "Failed to construct 'Event':", + MESSAGE: "Failed to construct 'MessageEvent':", + CLOSE: "Failed to construct 'CloseEvent':" + } +}; + +var EventPrototype = function EventPrototype () {}; + +EventPrototype.prototype.stopPropagation = function stopPropagation () {}; +EventPrototype.prototype.stopImmediatePropagation = function stopImmediatePropagation () {}; + +// if no arguments are passed then the type is set to "undefined" on +// chrome and safari. +EventPrototype.prototype.initEvent = function initEvent (type, bubbles, cancelable) { + if ( type === void 0 ) type = 'undefined'; + if ( bubbles === void 0 ) bubbles = false; + if ( cancelable === void 0 ) cancelable = false; + + this.type = "" + type; + this.bubbles = Boolean(bubbles); + this.cancelable = Boolean(cancelable); +}; + +var Event = (function (EventPrototype$$1) { + function Event(type, eventInitConfig) { + if ( eventInitConfig === void 0 ) eventInitConfig = {}; + + EventPrototype$$1.call(this); + + if (!type) { + throw new TypeError(((ERROR_PREFIX.EVENT_ERROR) + " 1 argument required, but only 0 present.")); + } + + if (typeof eventInitConfig !== 'object') { + throw new TypeError(((ERROR_PREFIX.EVENT_ERROR) + " parameter 2 ('eventInitDict') is not an object.")); + } + + var bubbles = eventInitConfig.bubbles; + var cancelable = eventInitConfig.cancelable; + + this.type = "" + type; + this.timeStamp = Date.now(); + this.target = null; + this.srcElement = null; + this.returnValue = true; + this.isTrusted = false; + this.eventPhase = 0; + this.defaultPrevented = false; + this.currentTarget = null; + this.cancelable = cancelable ? Boolean(cancelable) : false; + this.canncelBubble = false; + this.bubbles = bubbles ? Boolean(bubbles) : false; + } + + if ( EventPrototype$$1 ) Event.__proto__ = EventPrototype$$1; + Event.prototype = Object.create( EventPrototype$$1 && EventPrototype$$1.prototype ); + Event.prototype.constructor = Event; + + return Event; +}(EventPrototype)); + +var MessageEvent = (function (EventPrototype$$1) { + function MessageEvent(type, eventInitConfig) { + if ( eventInitConfig === void 0 ) eventInitConfig = {}; + + EventPrototype$$1.call(this); + + if (!type) { + throw new TypeError(((ERROR_PREFIX.EVENT.MESSAGE) + " 1 argument required, but only 0 present.")); + } + + if (typeof eventInitConfig !== 'object') { + throw new TypeError(((ERROR_PREFIX.EVENT.MESSAGE) + " parameter 2 ('eventInitDict') is not an object")); + } + + var bubbles = eventInitConfig.bubbles; + var cancelable = eventInitConfig.cancelable; + var data = eventInitConfig.data; + var origin = eventInitConfig.origin; + var lastEventId = eventInitConfig.lastEventId; + var ports = eventInitConfig.ports; + + this.type = "" + type; + this.timeStamp = Date.now(); + this.target = null; + this.srcElement = null; + this.returnValue = true; + this.isTrusted = false; + this.eventPhase = 0; + this.defaultPrevented = false; + this.currentTarget = null; + this.cancelable = cancelable ? Boolean(cancelable) : false; + this.canncelBubble = false; + this.bubbles = bubbles ? Boolean(bubbles) : false; + this.origin = "" + origin; + this.ports = typeof ports === 'undefined' ? null : ports; + this.data = typeof data === 'undefined' ? null : data; + this.lastEventId = "" + (lastEventId || ''); + } + + if ( EventPrototype$$1 ) MessageEvent.__proto__ = EventPrototype$$1; + MessageEvent.prototype = Object.create( EventPrototype$$1 && EventPrototype$$1.prototype ); + MessageEvent.prototype.constructor = MessageEvent; + + return MessageEvent; +}(EventPrototype)); + +var CloseEvent = (function (EventPrototype$$1) { + function CloseEvent(type, eventInitConfig) { + if ( eventInitConfig === void 0 ) eventInitConfig = {}; + + EventPrototype$$1.call(this); + + if (!type) { + throw new TypeError(((ERROR_PREFIX.EVENT.CLOSE) + " 1 argument required, but only 0 present.")); + } + + if (typeof eventInitConfig !== 'object') { + throw new TypeError(((ERROR_PREFIX.EVENT.CLOSE) + " parameter 2 ('eventInitDict') is not an object")); + } + + var bubbles = eventInitConfig.bubbles; + var cancelable = eventInitConfig.cancelable; + var code = eventInitConfig.code; + var reason = eventInitConfig.reason; + var wasClean = eventInitConfig.wasClean; + + this.type = "" + type; + this.timeStamp = Date.now(); + this.target = null; + this.srcElement = null; + this.returnValue = true; + this.isTrusted = false; + this.eventPhase = 0; + this.defaultPrevented = false; + this.currentTarget = null; + this.cancelable = cancelable ? Boolean(cancelable) : false; + this.cancelBubble = false; + this.bubbles = bubbles ? Boolean(bubbles) : false; + this.code = typeof code === 'number' ? parseInt(code, 10) : 0; + this.reason = "" + (reason || ''); + this.wasClean = wasClean ? Boolean(wasClean) : false; + } + + if ( EventPrototype$$1 ) CloseEvent.__proto__ = EventPrototype$$1; + CloseEvent.prototype = Object.create( EventPrototype$$1 && EventPrototype$$1.prototype ); + CloseEvent.prototype.constructor = CloseEvent; + + return CloseEvent; +}(EventPrototype)); + +/* + * Creates an Event object and extends it to allow full modification of + * its properties. + * + * @param {object} config - within config you will need to pass type and optionally target + */ +function createEvent(config) { + var type = config.type; + var target = config.target; + var eventObject = new Event(type); + + if (target) { + eventObject.target = target; + eventObject.srcElement = target; + eventObject.currentTarget = target; + } + + return eventObject; +} + +/* + * Creates a MessageEvent object and extends it to allow full modification of + * its properties. + * + * @param {object} config - within config: type, origin, data and optionally target + */ +function createMessageEvent(config) { + var type = config.type; + var origin = config.origin; + var data = config.data; + var target = config.target; + var messageEvent = new MessageEvent(type, { + data: data, + origin: origin + }); + + if (target) { + messageEvent.target = target; + messageEvent.srcElement = target; + messageEvent.currentTarget = target; + } + + return messageEvent; +} + +/* + * Creates a CloseEvent object and extends it to allow full modification of + * its properties. + * + * @param {object} config - within config: type and optionally target, code, and reason + */ +function createCloseEvent(config) { + var code = config.code; + var reason = config.reason; + var type = config.type; + var target = config.target; + var wasClean = config.wasClean; + + if (!wasClean) { + wasClean = code === 1000; + } + + var closeEvent = new CloseEvent(type, { + code: code, + reason: reason, + wasClean: wasClean + }); + + if (target) { + closeEvent.target = target; + closeEvent.srcElement = target; + closeEvent.currentTarget = target; + } + + return closeEvent; +} + +function closeWebSocketConnection(context, code, reason) { + context.readyState = WebSocket$1.CLOSING; + + var server = networkBridge.serverLookup(context.url); + var closeEvent = createCloseEvent({ + type: 'close', + target: context, + code: code, + reason: reason + }); + + delay(function () { + networkBridge.removeWebSocket(context, context.url); + + context.readyState = WebSocket$1.CLOSED; + context.dispatchEvent(closeEvent); + + if (server) { + server.dispatchEvent(closeEvent, server); + } + }, context); +} + +function failWebSocketConnection(context, code, reason) { + context.readyState = WebSocket$1.CLOSING; + + var server = networkBridge.serverLookup(context.url); + var closeEvent = createCloseEvent({ + type: 'close', + target: context, + code: code, + reason: reason, + wasClean: false + }); + + var errorEvent = createEvent({ + type: 'error', + target: context + }); + + delay(function () { + networkBridge.removeWebSocket(context, context.url); + + context.readyState = WebSocket$1.CLOSED; + context.dispatchEvent(errorEvent); + context.dispatchEvent(closeEvent); + + if (server) { + server.dispatchEvent(closeEvent, server); + } + }, context); +} + +function normalizeSendData(data) { + var type = Object.prototype.toString.call(data); + if (type !== '[object Blob]' && !(data instanceof ArrayBuffer) && type !== '[object Object]') { + data = String(data); + } + + return data; +} + +function proxyFactory(target) { + var handler = { + get: function get(obj, prop) { + if (prop === 'close') { + return function close(options) { + if ( options === void 0 ) options = {}; + + var code = options.code || CLOSE_CODES.CLOSE_NORMAL; + var reason = options.reason || ''; + + closeWebSocketConnection(target, code, reason); + }; + } + + if (prop === 'send') { + return function send(data) { + data = normalizeSendData(data); + + target.dispatchEvent( + createMessageEvent({ + type: 'message', + data: data, + origin: this.url, + target: target + }) + ); + }; + } + + if (prop === 'on') { + return function onWrapper(type, cb) { + target.addEventListener(("server::" + type), cb); + }; + } + + return obj[prop]; + } + }; + + var proxy = new Proxy(target, handler); + return proxy; +} + +function lengthInUtf8Bytes(str) { + // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence. + var m = encodeURIComponent(str).match(/%[89ABab]/g); + return str.length + (m ? m.length : 0); +} + +function urlVerification(url) { + var urlRecord = new urlParse(url); + var pathname = urlRecord.pathname; + var protocol = urlRecord.protocol; + var hash = urlRecord.hash; + + if (!url) { + throw new TypeError(((ERROR_PREFIX.CONSTRUCTOR_ERROR) + " 1 argument required, but only 0 present.")); + } + + if (!pathname) { + urlRecord.pathname = '/'; + } + + if (protocol === '') { + throw new SyntaxError(((ERROR_PREFIX.CONSTRUCTOR_ERROR) + " The URL '" + (urlRecord.toString()) + "' is invalid.")); + } + + if (protocol !== 'ws:' && protocol !== 'wss:') { + throw new SyntaxError( + ((ERROR_PREFIX.CONSTRUCTOR_ERROR) + " The URL's scheme must be either 'ws' or 'wss'. '" + protocol + "' is not allowed.") + ); + } + + if (hash !== '') { + /* eslint-disable max-len */ + throw new SyntaxError( + ((ERROR_PREFIX.CONSTRUCTOR_ERROR) + " The URL contains a fragment identifier ('" + hash + "'). Fragment identifiers are not allowed in WebSocket URLs.") + ); + /* eslint-enable max-len */ + } + + return urlRecord.toString(); +} + +function protocolVerification(protocols) { + if ( protocols === void 0 ) protocols = []; + + if (!Array.isArray(protocols) && typeof protocols !== 'string') { + throw new SyntaxError(((ERROR_PREFIX.CONSTRUCTOR_ERROR) + " The subprotocol '" + (protocols.toString()) + "' is invalid.")); + } + + if (typeof protocols === 'string') { + protocols = [protocols]; + } + + var uniq = protocols + .map(function (p) { return ({ count: 1, protocol: p }); }) + .reduce(function (a, b) { + a[b.protocol] = (a[b.protocol] || 0) + b.count; + return a; + }, {}); + + var duplicates = Object.keys(uniq).filter(function (a) { return uniq[a] > 1; }); + + if (duplicates.length > 0) { + throw new SyntaxError(((ERROR_PREFIX.CONSTRUCTOR_ERROR) + " The subprotocol '" + (duplicates[0]) + "' is duplicated.")); + } + + return protocols; +} + +/* + * The main websocket class which is designed to mimick the native WebSocket class as close + * as possible. + * + * https://html.spec.whatwg.org/multipage/web-sockets.html + */ +var WebSocket$1 = (function (EventTarget$$1) { + function WebSocket(url, protocols) { + EventTarget$$1.call(this); + + this.url = urlVerification(url); + protocols = protocolVerification(protocols); + this.protocol = protocols[0] || ''; + + this.binaryType = 'blob'; + this.readyState = WebSocket.CONNECTING; + + var server = networkBridge.attachWebSocket(this, this.url); + + /* + * This delay is needed so that we dont trigger an event before the callbacks have been + * setup. For example: + * + * var socket = new WebSocket('ws://localhost'); + * + * If we dont have the delay then the event would be triggered right here and this is + * before the onopen had a chance to register itself. + * + * socket.onopen = () => { // this would never be called }; + * + * and with the delay the event gets triggered here after all of the callbacks have been + * registered :-) + */ + delay(function delayCallback() { + if (server) { + if ( + server.options.verifyClient && + typeof server.options.verifyClient === 'function' && + !server.options.verifyClient() + ) { + this.readyState = WebSocket.CLOSED; + + log( + 'error', + ("WebSocket connection to '" + (this.url) + "' failed: HTTP Authentication failed; no valid credentials available") + ); + + networkBridge.removeWebSocket(this, this.url); + this.dispatchEvent(createEvent({ type: 'error', target: this })); + this.dispatchEvent(createCloseEvent({ type: 'close', target: this, code: CLOSE_CODES.CLOSE_NORMAL })); + } else { + if (server.options.selectProtocol && typeof server.options.selectProtocol === 'function') { + var selectedProtocol = server.options.selectProtocol(protocols); + var isFilled = selectedProtocol !== ''; + var isRequested = protocols.indexOf(selectedProtocol) !== -1; + if (isFilled && !isRequested) { + this.readyState = WebSocket.CLOSED; + + log('error', ("WebSocket connection to '" + (this.url) + "' failed: Invalid Sub-Protocol")); + + networkBridge.removeWebSocket(this, this.url); + this.dispatchEvent(createEvent({ type: 'error', target: this })); + this.dispatchEvent(createCloseEvent({ type: 'close', target: this, code: CLOSE_CODES.CLOSE_NORMAL })); + return; + } + this.protocol = selectedProtocol; + } + this.readyState = WebSocket.OPEN; + this.dispatchEvent(createEvent({ type: 'open', target: this })); + server.dispatchEvent(createEvent({ type: 'connection' }), proxyFactory(this)); + } + } else { + this.readyState = WebSocket.CLOSED; + this.dispatchEvent(createEvent({ type: 'error', target: this })); + this.dispatchEvent(createCloseEvent({ type: 'close', target: this, code: CLOSE_CODES.CLOSE_NORMAL })); + + log('error', ("WebSocket connection to '" + (this.url) + "' failed")); + } + }, this); + } + + if ( EventTarget$$1 ) WebSocket.__proto__ = EventTarget$$1; + WebSocket.prototype = Object.create( EventTarget$$1 && EventTarget$$1.prototype ); + WebSocket.prototype.constructor = WebSocket; + + var prototypeAccessors = { onopen: {},onmessage: {},onclose: {},onerror: {} }; + + prototypeAccessors.onopen.get = function () { + return this.listeners.open; + }; + + prototypeAccessors.onmessage.get = function () { + return this.listeners.message; + }; + + prototypeAccessors.onclose.get = function () { + return this.listeners.close; + }; + + prototypeAccessors.onerror.get = function () { + return this.listeners.error; + }; + + prototypeAccessors.onopen.set = function (listener) { + delete this.listeners.open; + this.addEventListener('open', listener); + }; + + prototypeAccessors.onmessage.set = function (listener) { + delete this.listeners.message; + this.addEventListener('message', listener); + }; + + prototypeAccessors.onclose.set = function (listener) { + delete this.listeners.close; + this.addEventListener('close', listener); + }; + + prototypeAccessors.onerror.set = function (listener) { + delete this.listeners.error; + this.addEventListener('error', listener); + }; + + WebSocket.prototype.send = function send (data) { + var this$1 = this; + + if (this.readyState === WebSocket.CLOSING || this.readyState === WebSocket.CLOSED) { + throw new Error('WebSocket is already in CLOSING or CLOSED state'); + } + + // TODO: handle bufferedAmount + + var messageEvent = createMessageEvent({ + type: 'server::message', + origin: this.url, + data: normalizeSendData(data) + }); + + var server = networkBridge.serverLookup(this.url); + + if (server) { + delay(function () { + this$1.dispatchEvent(messageEvent, data); + }, server); + } + }; + + WebSocket.prototype.close = function close (code, reason) { + if (code !== undefined) { + if (typeof code !== 'number' || (code !== 1000 && (code < 3000 || code > 4999))) { + throw new TypeError( + ((ERROR_PREFIX.CLOSE_ERROR) + " The code must be either 1000, or between 3000 and 4999. " + code + " is neither.") + ); + } + } + + if (reason !== undefined) { + var length = lengthInUtf8Bytes(reason); + + if (length > 123) { + throw new SyntaxError(((ERROR_PREFIX.CLOSE_ERROR) + " The message must not be greater than 123 bytes.")); + } + } + + if (this.readyState === WebSocket.CLOSING || this.readyState === WebSocket.CLOSED) { + return; + } + + if (this.readyState === WebSocket.CONNECTING) { + failWebSocketConnection(this, code, reason); + } else { + closeWebSocketConnection(this, code, reason); + } + }; + + Object.defineProperties( WebSocket.prototype, prototypeAccessors ); + + return WebSocket; +}(EventTarget)); + +WebSocket$1.CONNECTING = 0; +WebSocket$1.prototype.CONNECTING = WebSocket$1.CONNECTING; +WebSocket$1.OPEN = 1; +WebSocket$1.prototype.OPEN = WebSocket$1.OPEN; +WebSocket$1.CLOSING = 2; +WebSocket$1.prototype.CLOSING = WebSocket$1.CLOSING; +WebSocket$1.CLOSED = 3; +WebSocket$1.prototype.CLOSED = WebSocket$1.CLOSED; + +var dedupe = function (arr) { return arr.reduce(function (deduped, b) { + if (deduped.indexOf(b) > -1) { return deduped; } + return deduped.concat(b); + }, []); }; + +function retrieveGlobalObject() { + if (typeof window !== 'undefined') { + return window; + } + + return typeof process === 'object' && typeof require === 'function' && typeof global === 'object' ? global : this; +} + +var Server$1 = (function (EventTarget$$1) { + function Server(url, options) { + if ( options === void 0 ) options = {}; + + EventTarget$$1.call(this); + var urlRecord = new urlParse(url); + + if (!urlRecord.pathname) { + urlRecord.pathname = '/'; + } + + this.url = urlRecord.toString(); + + this.originalWebSocket = null; + var server = networkBridge.attachServer(this, this.url); + + if (!server) { + this.dispatchEvent(createEvent({ type: 'error' })); + throw new Error('A mock server is already listening on this url'); + } + + if (typeof options.verifyClient === 'undefined') { + options.verifyClient = null; + } + + if (typeof options.selectProtocol === 'undefined') { + options.selectProtocol = null; + } + + this.options = options; + this.start(); + } + + if ( EventTarget$$1 ) Server.__proto__ = EventTarget$$1; + Server.prototype = Object.create( EventTarget$$1 && EventTarget$$1.prototype ); + Server.prototype.constructor = Server; + + /* + * Attaches the mock websocket object to the global object + */ + Server.prototype.start = function start () { + var globalObj = retrieveGlobalObject(); + + if (globalObj.WebSocket) { + this.originalWebSocket = globalObj.WebSocket; + } + + globalObj.WebSocket = WebSocket$1; + }; + + /* + * Removes the mock websocket object from the global object + */ + Server.prototype.stop = function stop (callback) { + if ( callback === void 0 ) callback = function () {}; + + var globalObj = retrieveGlobalObject(); + + if (this.originalWebSocket) { + globalObj.WebSocket = this.originalWebSocket; + } else { + delete globalObj.WebSocket; + } + + this.originalWebSocket = null; + + networkBridge.removeServer(this.url); + + if (typeof callback === 'function') { + callback(); + } + }; + + /* + * This is the main function for the mock server to subscribe to the on events. + * + * ie: mockServer.on('connection', function() { console.log('a mock client connected'); }); + * + * @param {string} type - The event key to subscribe to. Valid keys are: connection, message, and close. + * @param {function} callback - The callback which should be called when a certain event is fired. + */ + Server.prototype.on = function on (type, callback) { + this.addEventListener(type, callback); + }; + + /* + * Closes the connection and triggers the onclose method of all listening + * websockets. After that it removes itself from the urlMap so another server + * could add itself to the url. + * + * @param {object} options + */ + Server.prototype.close = function close (options) { + if ( options === void 0 ) options = {}; + + var code = options.code; + var reason = options.reason; + var wasClean = options.wasClean; + var listeners = networkBridge.websocketsLookup(this.url); + + // Remove server before notifications to prevent immediate reconnects from + // socket onclose handlers + networkBridge.removeServer(this.url); + + listeners.forEach(function (socket) { + socket.readyState = WebSocket$1.CLOSE; + socket.dispatchEvent( + createCloseEvent({ + type: 'close', + target: socket, + code: code || CLOSE_CODES.CLOSE_NORMAL, + reason: reason || '', + wasClean: wasClean + }) + ); + }); + + this.dispatchEvent(createCloseEvent({ type: 'close' }), this); + }; + + /* + * Sends a generic message event to all mock clients. + */ + Server.prototype.emit = function emit (event, data, options) { + var this$1 = this; + if ( options === void 0 ) options = {}; + + var websockets = options.websockets; + + if (!websockets) { + websockets = networkBridge.websocketsLookup(this.url); + } + + if (typeof options !== 'object' || arguments.length > 3) { + data = Array.prototype.slice.call(arguments, 1, arguments.length); + data = data.map(function (item) { return normalizeSendData(item); }); + } else { + data = normalizeSendData(data); + } + + websockets.forEach(function (socket) { + if (Array.isArray(data)) { + socket.dispatchEvent.apply( + socket, [ createMessageEvent({ + type: event, + data: data, + origin: this$1.url, + target: socket + }) ].concat( data ) + ); + } else { + socket.dispatchEvent( + createMessageEvent({ + type: event, + data: data, + origin: this$1.url, + target: socket + }) + ); + } + }); + }; + + /* + * Returns an array of websockets which are listening to this server + * TOOD: this should return a set and not be a method + */ + Server.prototype.clients = function clients () { + return networkBridge.websocketsLookup(this.url); + }; + + /* + * Prepares a method to submit an event to members of the room + * + * e.g. server.to('my-room').emit('hi!'); + */ + Server.prototype.to = function to (room, broadcaster, broadcastList) { + var this$1 = this; + if ( broadcastList === void 0 ) broadcastList = []; + + var self = this; + var websockets = dedupe(broadcastList.concat(networkBridge.websocketsLookup(this.url, room, broadcaster))); + + return { + to: function (chainedRoom, chainedBroadcaster) { return this$1.to.call(this$1, chainedRoom, chainedBroadcaster, websockets); }, + emit: function emit(event, data) { + self.emit(event, data, { websockets: websockets }); + } + }; + }; + + /* + * Alias for Server.to + */ + Server.prototype.in = function in$1 () { + var args = [], len = arguments.length; + while ( len-- ) args[ len ] = arguments[ len ]; + + return this.to.apply(null, args); + }; + + /* + * Simulate an event from the server to the clients. Useful for + * simulating errors. + */ + Server.prototype.simulate = function simulate (event) { + var listeners = networkBridge.websocketsLookup(this.url); + + if (event === 'error') { + listeners.forEach(function (socket) { + socket.readyState = WebSocket$1.CLOSE; + socket.dispatchEvent(createEvent({ type: 'error' })); + }); + } + }; + + return Server; +}(EventTarget)); + +/* + * Alternative constructor to support namespaces in socket.io + * + * http://socket.io/docs/rooms-and-namespaces/#custom-namespaces + */ +Server$1.of = function of(url) { + return new Server$1(url); +}; + +/* + * The socket-io class is designed to mimick the real API as closely as possible. + * + * http://socket.io/docs/ + */ +var SocketIO$1 = (function (EventTarget$$1) { + function SocketIO(url, protocol) { + var this$1 = this; + if ( url === void 0 ) url = 'socket.io'; + if ( protocol === void 0 ) protocol = ''; + + EventTarget$$1.call(this); + + this.binaryType = 'blob'; + var urlRecord = new urlParse(url); + + if (!urlRecord.pathname) { + urlRecord.pathname = '/'; + } + + this.url = urlRecord.toString(); + this.readyState = SocketIO.CONNECTING; + this.protocol = ''; + + if (typeof protocol === 'string' || (typeof protocol === 'object' && protocol !== null)) { + this.protocol = protocol; + } else if (Array.isArray(protocol) && protocol.length > 0) { + this.protocol = protocol[0]; + } + + var server = networkBridge.attachWebSocket(this, this.url); + + /* + * Delay triggering the connection events so they can be defined in time. + */ + delay(function delayCallback() { + if (server) { + this.readyState = SocketIO.OPEN; + server.dispatchEvent(createEvent({ type: 'connection' }), server, this); + server.dispatchEvent(createEvent({ type: 'connect' }), server, this); // alias + this.dispatchEvent(createEvent({ type: 'connect', target: this })); + } else { + this.readyState = SocketIO.CLOSED; + this.dispatchEvent(createEvent({ type: 'error', target: this })); + this.dispatchEvent( + createCloseEvent({ + type: 'close', + target: this, + code: CLOSE_CODES.CLOSE_NORMAL + }) + ); + + log('error', ("Socket.io connection to '" + (this.url) + "' failed")); + } + }, this); + + /** + Add an aliased event listener for close / disconnect + */ + this.addEventListener('close', function (event) { + this$1.dispatchEvent( + createCloseEvent({ + type: 'disconnect', + target: event.target, + code: event.code + }) + ); + }); + } + + if ( EventTarget$$1 ) SocketIO.__proto__ = EventTarget$$1; + SocketIO.prototype = Object.create( EventTarget$$1 && EventTarget$$1.prototype ); + SocketIO.prototype.constructor = SocketIO; + + var prototypeAccessors = { broadcast: {} }; + + /* + * Closes the SocketIO connection or connection attempt, if any. + * If the connection is already CLOSED, this method does nothing. + */ + SocketIO.prototype.close = function close () { + if (this.readyState !== SocketIO.OPEN) { + return undefined; + } + + var server = networkBridge.serverLookup(this.url); + networkBridge.removeWebSocket(this, this.url); + + this.readyState = SocketIO.CLOSED; + this.dispatchEvent( + createCloseEvent({ + type: 'close', + target: this, + code: CLOSE_CODES.CLOSE_NORMAL + }) + ); + + if (server) { + server.dispatchEvent( + createCloseEvent({ + type: 'disconnect', + target: this, + code: CLOSE_CODES.CLOSE_NORMAL + }), + server + ); + } + + return this; + }; + + /* + * Alias for Socket#close + * + * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L383 + */ + SocketIO.prototype.disconnect = function disconnect () { + return this.close(); + }; + + /* + * Submits an event to the server with a payload + */ + SocketIO.prototype.emit = function emit (event) { + var data = [], len = arguments.length - 1; + while ( len-- > 0 ) data[ len ] = arguments[ len + 1 ]; + + if (this.readyState !== SocketIO.OPEN) { + throw new Error('SocketIO is already in CLOSING or CLOSED state'); + } + + var messageEvent = createMessageEvent({ + type: event, + origin: this.url, + data: data + }); + + var server = networkBridge.serverLookup(this.url); + + if (server) { + server.dispatchEvent.apply(server, [ messageEvent ].concat( data )); + } + + return this; + }; + + /* + * Submits a 'message' event to the server. + * + * Should behave exactly like WebSocket#send + * + * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L113 + */ + SocketIO.prototype.send = function send (data) { + this.emit('message', data); + return this; + }; + + /* + * For broadcasting events to other connected sockets. + * + * e.g. socket.broadcast.emit('hi!'); + * e.g. socket.broadcast.to('my-room').emit('hi!'); + */ + prototypeAccessors.broadcast.get = function () { + if (this.readyState !== SocketIO.OPEN) { + throw new Error('SocketIO is already in CLOSING or CLOSED state'); + } + + var self = this; + var server = networkBridge.serverLookup(this.url); + if (!server) { + throw new Error(("SocketIO can not find a server at the specified URL (" + (this.url) + ")")); + } + + return { + emit: function emit(event, data) { + server.emit(event, data, { websockets: networkBridge.websocketsLookup(self.url, null, self) }); + return self; + }, + to: function to(room) { + return server.to(room, self); + }, + in: function in$1(room) { + return server.in(room, self); + } + }; + }; + + /* + * For registering events to be received from the server + */ + SocketIO.prototype.on = function on (type, callback) { + this.addEventListener(type, callback); + return this; + }; + + /* + * Remove event listener + * + * https://socket.io/docs/client-api/#socket-on-eventname-callback + */ + SocketIO.prototype.off = function off (type) { + this.removeEventListener(type); + }; + + /* + * Join a room on a server + * + * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving + */ + SocketIO.prototype.join = function join (room) { + networkBridge.addMembershipToRoom(this, room); + }; + + /* + * Get the websocket to leave the room + * + * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving + */ + SocketIO.prototype.leave = function leave (room) { + networkBridge.removeMembershipFromRoom(this, room); + }; + + SocketIO.prototype.to = function to (room) { + return this.broadcast.to(room); + }; + + SocketIO.prototype.in = function in$1 () { + return this.to.apply(null, arguments); + }; + + /* + * Invokes all listener functions that are listening to the given event.type property. Each + * listener will be passed the event as the first argument. + * + * @param {object} event - event object which will be passed to all listeners of the event.type property + */ + SocketIO.prototype.dispatchEvent = function dispatchEvent (event) { + var this$1 = this; + var customArguments = [], len = arguments.length - 1; + while ( len-- > 0 ) customArguments[ len ] = arguments[ len + 1 ]; + + var eventName = event.type; + var listeners = this.listeners[eventName]; + + if (!Array.isArray(listeners)) { + return false; + } + + listeners.forEach(function (listener) { + if (customArguments.length > 0) { + listener.apply(this$1, customArguments); + } else { + // Regular WebSockets expect a MessageEvent but Socketio.io just wants raw data + // payload instanceof MessageEvent works, but you can't isntance of NodeEvent + // for now we detect if the output has data defined on it + listener.call(this$1, event.data ? event.data : event); + } + }); + }; + + Object.defineProperties( SocketIO.prototype, prototypeAccessors ); + + return SocketIO; +}(EventTarget)); + +SocketIO$1.CONNECTING = 0; +SocketIO$1.OPEN = 1; +SocketIO$1.CLOSING = 2; +SocketIO$1.CLOSED = 3; + +/* + * Static constructor methods for the IO Socket + */ +var IO = function ioConstructor(url, protocol) { + return new SocketIO$1(url, protocol); +}; + +/* + * Alias the raw IO() constructor + */ +IO.connect = function ioConnect(url, protocol) { + /* eslint-disable new-cap */ + return IO(url, protocol); + /* eslint-enable new-cap */ +}; + +var Server = Server$1; +var WebSocket = WebSocket$1; +var SocketIO = IO; + +exports.Server = Server; +exports.WebSocket = WebSocket; +exports.SocketIO = SocketIO; + +Object.defineProperty(exports, '__esModule', { value: true }); + +}))); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mock-socket.js","sources":["../node_modules/requires-port/index.js","../node_modules/querystringify/index.js","../node_modules/url-parse/index.js","../src/helpers/delay.js","../src/helpers/logger.js","../src/helpers/array-helpers.js","../src/event/target.js","../src/network-bridge.js","../src/constants.js","../src/event/prototype.js","../src/event/event.js","../src/event/message.js","../src/event/close.js","../src/event/factory.js","../src/algorithms/close.js","../src/helpers/normalize-send.js","../src/helpers/proxy-factory.js","../src/helpers/byte-length.js","../src/helpers/url-verification.js","../src/helpers/protocol-verification.js","../src/websocket.js","../src/helpers/dedupe.js","../src/helpers/global-object.js","../src/server.js","../src/socket-io.js","../src/index.js"],"sourcesContent":["'use strict';\n\n/**\n * Check if we're required to add a port number.\n *\n * @see https://url.spec.whatwg.org/#default-port\n * @param {Number|String} port Port number we need to check\n * @param {String} protocol Protocol we need to check against.\n * @returns {Boolean} Is it a default port for the given protocol\n * @api private\n */\nmodule.exports = function required(port, protocol) {\n  protocol = protocol.split(':')[0];\n  port = +port;\n\n  if (!port) return false;\n\n  switch (protocol) {\n    case 'http':\n    case 'ws':\n    return port !== 80;\n\n    case 'https':\n    case 'wss':\n    return port !== 443;\n\n    case 'ftp':\n    return port !== 21;\n\n    case 'gopher':\n    return port !== 70;\n\n    case 'file':\n    return false;\n  }\n\n  return port !== 0;\n};\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n  , undef;\n\n/**\n * Decode a URI encoded string.\n *\n * @param {String} input The URI encoded string.\n * @returns {String} The decoded string.\n * @api private\n */\nfunction decode(input) {\n  return decodeURIComponent(input.replace(/\\+/g, ' '));\n}\n\n/**\n * Simple query string parser.\n *\n * @param {String} query The query string that needs to be parsed.\n * @returns {Object}\n * @api public\n */\nfunction querystring(query) {\n  var parser = /([^=?&]+)=?([^&]*)/g\n    , result = {}\n    , part;\n\n  while (part = parser.exec(query)) {\n    var key = decode(part[1])\n      , value = decode(part[2]);\n\n    //\n    // Prevent overriding of existing properties. This ensures that build-in\n    // methods like `toString` or __proto__ are not overriden by malicious\n    // querystrings.\n    //\n    if (key in result) continue;\n    result[key] = value;\n  }\n\n  return result;\n}\n\n/**\n * Transform a query string to an object.\n *\n * @param {Object} obj Object that should be transformed.\n * @param {String} prefix Optional prefix.\n * @returns {String}\n * @api public\n */\nfunction querystringify(obj, prefix) {\n  prefix = prefix || '';\n\n  var pairs = []\n    , value\n    , key;\n\n  //\n  // Optionally prefix with a '?' if needed\n  //\n  if ('string' !== typeof prefix) prefix = '?';\n\n  for (key in obj) {\n    if (has.call(obj, key)) {\n      value = obj[key];\n\n      //\n      // Edge cases where we actually want to encode the value to an empty\n      // string instead of the stringified value.\n      //\n      if (!value && (value === null || value === undef || isNaN(value))) {\n        value = '';\n      }\n\n      pairs.push(encodeURIComponent(key) +'='+ encodeURIComponent(value));\n    }\n  }\n\n  return pairs.length ? prefix + pairs.join('&') : '';\n}\n\n//\n// Expose the module.\n//\nexports.stringify = querystringify;\nexports.parse = querystring;\n","'use strict';\n\nvar required = require('requires-port')\n  , qs = require('querystringify')\n  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\\/\\/)?([\\S\\s]*)/i\n  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\\/\\//;\n\n/**\n * These are the parse rules for the URL parser, it informs the parser\n * about:\n *\n * 0. The char it Needs to parse, if it's a string it should be done using\n *    indexOf, RegExp using exec and NaN means set as current value.\n * 1. The property we should set when parsing this value.\n * 2. Indication if it's backwards or forward parsing, when set as number it's\n *    the value of extra chars that should be split off.\n * 3. Inherit from location if non existing in the parser.\n * 4. `toLowerCase` the resulting value.\n */\nvar rules = [\n  ['#', 'hash'],                        // Extract from the back.\n  ['?', 'query'],                       // Extract from the back.\n  function sanitize(address) {          // Sanitize what is left of the address\n    return address.replace('\\\\', '/');\n  },\n  ['/', 'pathname'],                    // Extract from the back.\n  ['@', 'auth', 1],                     // Extract from the front.\n  [NaN, 'host', undefined, 1, 1],       // Set left over value.\n  [/:(\\d+)$/, 'port', undefined, 1],    // RegExp the back.\n  [NaN, 'hostname', undefined, 1, 1]    // Set left over.\n];\n\n/**\n * These properties should not be copied or inherited from. This is only needed\n * for all non blob URL's as a blob URL does not include a hash, only the\n * origin.\n *\n * @type {Object}\n * @private\n */\nvar ignore = { hash: 1, query: 1 };\n\n/**\n * The location object differs when your code is loaded through a normal page,\n * Worker or through a worker using a blob. And with the blobble begins the\n * trouble as the location object will contain the URL of the blob, not the\n * location of the page where our code is loaded in. The actual origin is\n * encoded in the `pathname` so we can thankfully generate a good \"default\"\n * location from it so we can generate proper relative URL's again.\n *\n * @param {Object|String} loc Optional default location object.\n * @returns {Object} lolcation object.\n * @public\n */\nfunction lolcation(loc) {\n  var globalVar;\n\n  if (typeof window !== 'undefined') globalVar = window;\n  else if (typeof global !== 'undefined') globalVar = global;\n  else if (typeof self !== 'undefined') globalVar = self;\n  else globalVar = {};\n\n  var location = globalVar.location || {};\n  loc = loc || location;\n\n  var finaldestination = {}\n    , type = typeof loc\n    , key;\n\n  if ('blob:' === loc.protocol) {\n    finaldestination = new Url(unescape(loc.pathname), {});\n  } else if ('string' === type) {\n    finaldestination = new Url(loc, {});\n    for (key in ignore) delete finaldestination[key];\n  } else if ('object' === type) {\n    for (key in loc) {\n      if (key in ignore) continue;\n      finaldestination[key] = loc[key];\n    }\n\n    if (finaldestination.slashes === undefined) {\n      finaldestination.slashes = slashes.test(loc.href);\n    }\n  }\n\n  return finaldestination;\n}\n\n/**\n * @typedef ProtocolExtract\n * @type Object\n * @property {String} protocol Protocol matched in the URL, in lowercase.\n * @property {Boolean} slashes `true` if protocol is followed by \"//\", else `false`.\n * @property {String} rest Rest of the URL that is not part of the protocol.\n */\n\n/**\n * Extract protocol information from a URL with/without double slash (\"//\").\n *\n * @param {String} address URL we want to extract from.\n * @return {ProtocolExtract} Extracted information.\n * @private\n */\nfunction extractProtocol(address) {\n  var match = protocolre.exec(address);\n\n  return {\n    protocol: match[1] ? match[1].toLowerCase() : '',\n    slashes: !!match[2],\n    rest: match[3]\n  };\n}\n\n/**\n * Resolve a relative URL pathname against a base URL pathname.\n *\n * @param {String} relative Pathname of the relative URL.\n * @param {String} base Pathname of the base URL.\n * @return {String} Resolved pathname.\n * @private\n */\nfunction resolve(relative, base) {\n  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))\n    , i = path.length\n    , last = path[i - 1]\n    , unshift = false\n    , up = 0;\n\n  while (i--) {\n    if (path[i] === '.') {\n      path.splice(i, 1);\n    } else if (path[i] === '..') {\n      path.splice(i, 1);\n      up++;\n    } else if (up) {\n      if (i === 0) unshift = true;\n      path.splice(i, 1);\n      up--;\n    }\n  }\n\n  if (unshift) path.unshift('');\n  if (last === '.' || last === '..') path.push('');\n\n  return path.join('/');\n}\n\n/**\n * The actual URL instance. Instead of returning an object we've opted-in to\n * create an actual constructor as it's much more memory efficient and\n * faster and it pleases my OCD.\n *\n * It is worth noting that we should not use `URL` as class name to prevent\n * clashes with the global URL instance that got introduced in browsers.\n *\n * @constructor\n * @param {String} address URL we want to parse.\n * @param {Object|String} [location] Location defaults for relative paths.\n * @param {Boolean|Function} [parser] Parser for the query string.\n * @private\n */\nfunction Url(address, location, parser) {\n  if (!(this instanceof Url)) {\n    return new Url(address, location, parser);\n  }\n\n  var relative, extracted, parse, instruction, index, key\n    , instructions = rules.slice()\n    , type = typeof location\n    , url = this\n    , i = 0;\n\n  //\n  // The following if statements allows this module two have compatibility with\n  // 2 different API:\n  //\n  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments\n  //    where the boolean indicates that the query string should also be parsed.\n  //\n  // 2. The `URL` interface of the browser which accepts a URL, object as\n  //    arguments. The supplied object will be used as default values / fall-back\n  //    for relative paths.\n  //\n  if ('object' !== type && 'string' !== type) {\n    parser = location;\n    location = null;\n  }\n\n  if (parser && 'function' !== typeof parser) parser = qs.parse;\n\n  location = lolcation(location);\n\n  //\n  // Extract protocol information before running the instructions.\n  //\n  extracted = extractProtocol(address || '');\n  relative = !extracted.protocol && !extracted.slashes;\n  url.slashes = extracted.slashes || relative && location.slashes;\n  url.protocol = extracted.protocol || location.protocol || '';\n  address = extracted.rest;\n\n  //\n  // When the authority component is absent the URL starts with a path\n  // component.\n  //\n  if (!extracted.slashes) instructions[3] = [/(.*)/, 'pathname'];\n\n  for (; i < instructions.length; i++) {\n    instruction = instructions[i];\n\n    if (typeof instruction === 'function') {\n      address = instruction(address);\n      continue;\n    }\n\n    parse = instruction[0];\n    key = instruction[1];\n\n    if (parse !== parse) {\n      url[key] = address;\n    } else if ('string' === typeof parse) {\n      if (~(index = address.indexOf(parse))) {\n        if ('number' === typeof instruction[2]) {\n          url[key] = address.slice(0, index);\n          address = address.slice(index + instruction[2]);\n        } else {\n          url[key] = address.slice(index);\n          address = address.slice(0, index);\n        }\n      }\n    } else if ((index = parse.exec(address))) {\n      url[key] = index[1];\n      address = address.slice(0, index.index);\n    }\n\n    url[key] = url[key] || (\n      relative && instruction[3] ? location[key] || '' : ''\n    );\n\n    //\n    // Hostname, host and protocol should be lowercased so they can be used to\n    // create a proper `origin`.\n    //\n    if (instruction[4]) url[key] = url[key].toLowerCase();\n  }\n\n  //\n  // Also parse the supplied query string in to an object. If we're supplied\n  // with a custom parser as function use that instead of the default build-in\n  // parser.\n  //\n  if (parser) url.query = parser(url.query);\n\n  //\n  // If the URL is relative, resolve the pathname against the base URL.\n  //\n  if (\n      relative\n    && location.slashes\n    && url.pathname.charAt(0) !== '/'\n    && (url.pathname !== '' || location.pathname !== '')\n  ) {\n    url.pathname = resolve(url.pathname, location.pathname);\n  }\n\n  //\n  // We should not add port numbers if they are already the default port number\n  // for a given protocol. As the host also contains the port number we're going\n  // override it with the hostname which contains no port number.\n  //\n  if (!required(url.port, url.protocol)) {\n    url.host = url.hostname;\n    url.port = '';\n  }\n\n  //\n  // Parse down the `auth` for the username and password.\n  //\n  url.username = url.password = '';\n  if (url.auth) {\n    instruction = url.auth.split(':');\n    url.username = instruction[0] || '';\n    url.password = instruction[1] || '';\n  }\n\n  url.origin = url.protocol && url.host && url.protocol !== 'file:'\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  //\n  // The href is just the compiled result.\n  //\n  url.href = url.toString();\n}\n\n/**\n * This is convenience method for changing properties in the URL instance to\n * insure that they all propagate correctly.\n *\n * @param {String} part          Property we need to adjust.\n * @param {Mixed} value          The newly assigned value.\n * @param {Boolean|Function} fn  When setting the query, it will be the function\n *                               used to parse the query.\n *                               When setting the protocol, double slash will be\n *                               removed from the final url if it is true.\n * @returns {URL} URL instance for chaining.\n * @public\n */\nfunction set(part, value, fn) {\n  var url = this;\n\n  switch (part) {\n    case 'query':\n      if ('string' === typeof value && value.length) {\n        value = (fn || qs.parse)(value);\n      }\n\n      url[part] = value;\n      break;\n\n    case 'port':\n      url[part] = value;\n\n      if (!required(value, url.protocol)) {\n        url.host = url.hostname;\n        url[part] = '';\n      } else if (value) {\n        url.host = url.hostname +':'+ value;\n      }\n\n      break;\n\n    case 'hostname':\n      url[part] = value;\n\n      if (url.port) value += ':'+ url.port;\n      url.host = value;\n      break;\n\n    case 'host':\n      url[part] = value;\n\n      if (/:\\d+$/.test(value)) {\n        value = value.split(':');\n        url.port = value.pop();\n        url.hostname = value.join(':');\n      } else {\n        url.hostname = value;\n        url.port = '';\n      }\n\n      break;\n\n    case 'protocol':\n      url.protocol = value.toLowerCase();\n      url.slashes = !fn;\n      break;\n\n    case 'pathname':\n    case 'hash':\n      if (value) {\n        var char = part === 'pathname' ? '/' : '#';\n        url[part] = value.charAt(0) !== char ? char + value : value;\n      } else {\n        url[part] = value;\n      }\n      break;\n\n    default:\n      url[part] = value;\n  }\n\n  for (var i = 0; i < rules.length; i++) {\n    var ins = rules[i];\n\n    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();\n  }\n\n  url.origin = url.protocol && url.host && url.protocol !== 'file:'\n    ? url.protocol +'//'+ url.host\n    : 'null';\n\n  url.href = url.toString();\n\n  return url;\n}\n\n/**\n * Transform the properties back in to a valid and full URL string.\n *\n * @param {Function} stringify Optional query stringify function.\n * @returns {String} Compiled version of the URL.\n * @public\n */\nfunction toString(stringify) {\n  if (!stringify || 'function' !== typeof stringify) stringify = qs.stringify;\n\n  var query\n    , url = this\n    , protocol = url.protocol;\n\n  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';\n\n  var result = protocol + (url.slashes ? '//' : '');\n\n  if (url.username) {\n    result += url.username;\n    if (url.password) result += ':'+ url.password;\n    result += '@';\n  }\n\n  result += url.host + url.pathname;\n\n  query = 'object' === typeof url.query ? stringify(url.query) : url.query;\n  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;\n\n  if (url.hash) result += url.hash;\n\n  return result;\n}\n\nUrl.prototype = { set: set, toString: toString };\n\n//\n// Expose the URL parser and some additional properties that might be useful for\n// others or testing.\n//\nUrl.extractProtocol = extractProtocol;\nUrl.location = lolcation;\nUrl.qs = qs;\n\nmodule.exports = Url;\n","/*\n * This delay allows the thread to finish assigning its on* methods\n * before invoking the delay callback. This is purely a timing hack.\n * http://geekabyte.blogspot.com/2014/01/javascript-effect-of-setting-settimeout.html\n *\n * @param {callback: function} the callback which will be invoked after the timeout\n * @parma {context: object} the context in which to invoke the function\n */\nexport default function delay(callback, context) {\n  setTimeout(timeoutContext => callback.call(timeoutContext), 4, context);\n}\n","export default function log(method, message) {\n  /* eslint-disable no-console */\n  if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'test') {\n    console[method].call(null, message);\n  }\n  /* eslint-enable no-console */\n}\n","export function reject(array, callback) {\n  const results = [];\n  array.forEach(itemInArray => {\n    if (!callback(itemInArray)) {\n      results.push(itemInArray);\n    }\n  });\n\n  return results;\n}\n\nexport function filter(array, callback) {\n  const results = [];\n  array.forEach(itemInArray => {\n    if (callback(itemInArray)) {\n      results.push(itemInArray);\n    }\n  });\n\n  return results;\n}\n","import { reject, filter } from '../helpers/array-helpers';\n\n/*\n * EventTarget is an interface implemented by objects that can\n * receive events and may have listeners for them.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget\n */\nclass EventTarget {\n  constructor() {\n    this.listeners = {};\n  }\n\n  /*\n   * Ties a listener function to an event type which can later be invoked via the\n   * dispatchEvent method.\n   *\n   * @param {string} type - the type of event (ie: 'open', 'message', etc.)\n   * @param {function} listener - callback function to invoke when an event is dispatched matching the type\n   * @param {boolean} useCapture - N/A TODO: implement useCapture functionality\n   */\n  addEventListener(type, listener /* , useCapture */) {\n    if (typeof listener === 'function') {\n      if (!Array.isArray(this.listeners[type])) {\n        this.listeners[type] = [];\n      }\n\n      // Only add the same function once\n      if (filter(this.listeners[type], item => item === listener).length === 0) {\n        this.listeners[type].push(listener);\n      }\n    }\n  }\n\n  /*\n   * Removes the listener so it will no longer be invoked via the dispatchEvent method.\n   *\n   * @param {string} type - the type of event (ie: 'open', 'message', etc.)\n   * @param {function} listener - callback function to invoke when an event is dispatched matching the type\n   * @param {boolean} useCapture - N/A TODO: implement useCapture functionality\n   */\n  removeEventListener(type, removingListener /* , useCapture */) {\n    const arrayOfListeners = this.listeners[type];\n    this.listeners[type] = reject(arrayOfListeners, listener => listener === removingListener);\n  }\n\n  /*\n   * Invokes all listener functions that are listening to the given event.type property. Each\n   * listener will be passed the event as the first argument.\n   *\n   * @param {object} event - event object which will be passed to all listeners of the event.type property\n   */\n  dispatchEvent(event, ...customArguments) {\n    const eventName = event.type;\n    const listeners = this.listeners[eventName];\n\n    if (!Array.isArray(listeners)) {\n      return false;\n    }\n\n    listeners.forEach(listener => {\n      if (customArguments.length > 0) {\n        listener.apply(this, customArguments);\n      } else {\n        listener.call(this, event);\n      }\n    });\n\n    return true;\n  }\n}\n\nexport default EventTarget;\n","import { reject } from './helpers/array-helpers';\n\n/*\n * The network bridge is a way for the mock websocket object to 'communicate' with\n * all available servers. This is a singleton object so it is important that you\n * clean up urlMap whenever you are finished.\n */\nclass NetworkBridge {\n  constructor() {\n    this.urlMap = {};\n  }\n\n  /*\n   * Attaches a websocket object to the urlMap hash so that it can find the server\n   * it is connected to and the server in turn can find it.\n   *\n   * @param {object} websocket - websocket object to add to the urlMap hash\n   * @param {string} url\n   */\n  attachWebSocket(websocket, url) {\n    const queryIndex = url.indexOf('?');\n    const serverURL = queryIndex >= 0 ? url.slice(0, queryIndex) : url;\n    const connectionLookup = this.urlMap[serverURL];\n\n    if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) === -1) {\n      connectionLookup.websockets.push(websocket);\n      return connectionLookup.server;\n    }\n  }\n\n  /*\n   * Attaches a websocket to a room\n   */\n  addMembershipToRoom(websocket, room) {\n    const connectionLookup = this.urlMap[websocket.url];\n\n    if (connectionLookup && connectionLookup.server && connectionLookup.websockets.indexOf(websocket) !== -1) {\n      if (!connectionLookup.roomMemberships[room]) {\n        connectionLookup.roomMemberships[room] = [];\n      }\n\n      connectionLookup.roomMemberships[room].push(websocket);\n    }\n  }\n\n  /*\n   * Attaches a server object to the urlMap hash so that it can find a websockets\n   * which are connected to it and so that websockets can in turn can find it.\n   *\n   * @param {object} server - server object to add to the urlMap hash\n   * @param {string} url\n   */\n  attachServer(server, url) {\n    const connectionLookup = this.urlMap[url];\n\n    if (!connectionLookup) {\n      this.urlMap[url] = {\n        server,\n        websockets: [],\n        roomMemberships: {}\n      };\n\n      return server;\n    }\n  }\n\n  /*\n   * Finds the server which is 'running' on the given url.\n   *\n   * @param {string} url - the url to use to find which server is running on it\n   */\n  serverLookup(url) {\n    const connectionLookup = this.urlMap[url];\n\n    if (connectionLookup) {\n      return connectionLookup.server;\n    }\n  }\n\n  /*\n   * Finds all websockets which is 'listening' on the given url.\n   *\n   * @param {string} url - the url to use to find all websockets which are associated with it\n   * @param {string} room - if a room is provided, will only return sockets in this room\n   * @param {class} broadcaster - socket that is broadcasting and is to be excluded from the lookup\n   */\n  websocketsLookup(url, room, broadcaster) {\n    let websockets;\n    const connectionLookup = this.urlMap[url];\n\n    websockets = connectionLookup ? connectionLookup.websockets : [];\n\n    if (room) {\n      const members = connectionLookup.roomMemberships[room];\n      websockets = members || [];\n    }\n\n    return broadcaster ? websockets.filter(websocket => websocket !== broadcaster) : websockets;\n  }\n\n  /*\n   * Removes the entry associated with the url.\n   *\n   * @param {string} url\n   */\n  removeServer(url) {\n    delete this.urlMap[url];\n  }\n\n  /*\n   * Removes the individual websocket from the map of associated websockets.\n   *\n   * @param {object} websocket - websocket object to remove from the url map\n   * @param {string} url\n   */\n  removeWebSocket(websocket, url) {\n    const connectionLookup = this.urlMap[url];\n\n    if (connectionLookup) {\n      connectionLookup.websockets = reject(connectionLookup.websockets, socket => socket === websocket);\n    }\n  }\n\n  /*\n   * Removes a websocket from a room\n   */\n  removeMembershipFromRoom(websocket, room) {\n    const connectionLookup = this.urlMap[websocket.url];\n    const memberships = connectionLookup.roomMemberships[room];\n\n    if (connectionLookup && memberships !== null) {\n      connectionLookup.roomMemberships[room] = reject(memberships, socket => socket === websocket);\n    }\n  }\n}\n\nexport default new NetworkBridge(); // Note: this is a singleton\n","/*\n * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent\n */\nexport const CLOSE_CODES = {\n  CLOSE_NORMAL: 1000,\n  CLOSE_GOING_AWAY: 1001,\n  CLOSE_PROTOCOL_ERROR: 1002,\n  CLOSE_UNSUPPORTED: 1003,\n  CLOSE_NO_STATUS: 1005,\n  CLOSE_ABNORMAL: 1006,\n  UNSUPPORTED_DATA: 1007,\n  POLICY_VIOLATION: 1008,\n  CLOSE_TOO_LARGE: 1009,\n  MISSING_EXTENSION: 1010,\n  INTERNAL_ERROR: 1011,\n  SERVICE_RESTART: 1012,\n  TRY_AGAIN_LATER: 1013,\n  TLS_HANDSHAKE: 1015\n};\n\nexport const ERROR_PREFIX = {\n  CONSTRUCTOR_ERROR: \"Failed to construct 'WebSocket':\",\n  CLOSE_ERROR: \"Failed to execute 'close' on 'WebSocket':\",\n  EVENT: {\n    CONSTRUCT: \"Failed to construct 'Event':\",\n    MESSAGE: \"Failed to construct 'MessageEvent':\",\n    CLOSE: \"Failed to construct 'CloseEvent':\"\n  }\n};\n","export default class EventPrototype {\n  // Noops\n  stopPropagation() {}\n  stopImmediatePropagation() {}\n\n  // if no arguments are passed then the type is set to \"undefined\" on\n  // chrome and safari.\n  initEvent(type = 'undefined', bubbles = false, cancelable = false) {\n    this.type = `${type}`;\n    this.bubbles = Boolean(bubbles);\n    this.cancelable = Boolean(cancelable);\n  }\n}\n","import EventPrototype from './prototype';\nimport { ERROR_PREFIX } from '../constants';\n\nexport default class Event extends EventPrototype {\n  constructor(type, eventInitConfig = {}) {\n    super();\n\n    if (!type) {\n      throw new TypeError(`${ERROR_PREFIX.EVENT_ERROR} 1 argument required, but only 0 present.`);\n    }\n\n    if (typeof eventInitConfig !== 'object') {\n      throw new TypeError(`${ERROR_PREFIX.EVENT_ERROR} parameter 2 ('eventInitDict') is not an object.`);\n    }\n\n    const { bubbles, cancelable } = eventInitConfig;\n\n    this.type = `${type}`;\n    this.timeStamp = Date.now();\n    this.target = null;\n    this.srcElement = null;\n    this.returnValue = true;\n    this.isTrusted = false;\n    this.eventPhase = 0;\n    this.defaultPrevented = false;\n    this.currentTarget = null;\n    this.cancelable = cancelable ? Boolean(cancelable) : false;\n    this.canncelBubble = false;\n    this.bubbles = bubbles ? Boolean(bubbles) : false;\n  }\n}\n","import EventPrototype from './prototype';\nimport { ERROR_PREFIX } from '../constants';\n\nexport default class MessageEvent extends EventPrototype {\n  constructor(type, eventInitConfig = {}) {\n    super();\n\n    if (!type) {\n      throw new TypeError(`${ERROR_PREFIX.EVENT.MESSAGE} 1 argument required, but only 0 present.`);\n    }\n\n    if (typeof eventInitConfig !== 'object') {\n      throw new TypeError(`${ERROR_PREFIX.EVENT.MESSAGE} parameter 2 ('eventInitDict') is not an object`);\n    }\n\n    const { bubbles, cancelable, data, origin, lastEventId, ports } = eventInitConfig;\n\n    this.type = `${type}`;\n    this.timeStamp = Date.now();\n    this.target = null;\n    this.srcElement = null;\n    this.returnValue = true;\n    this.isTrusted = false;\n    this.eventPhase = 0;\n    this.defaultPrevented = false;\n    this.currentTarget = null;\n    this.cancelable = cancelable ? Boolean(cancelable) : false;\n    this.canncelBubble = false;\n    this.bubbles = bubbles ? Boolean(bubbles) : false;\n    this.origin = `${origin}`;\n    this.ports = typeof ports === 'undefined' ? null : ports;\n    this.data = typeof data === 'undefined' ? null : data;\n    this.lastEventId = `${lastEventId || ''}`;\n  }\n}\n","import EventPrototype from './prototype';\nimport { ERROR_PREFIX } from '../constants';\n\nexport default class CloseEvent extends EventPrototype {\n  constructor(type, eventInitConfig = {}) {\n    super();\n\n    if (!type) {\n      throw new TypeError(`${ERROR_PREFIX.EVENT.CLOSE} 1 argument required, but only 0 present.`);\n    }\n\n    if (typeof eventInitConfig !== 'object') {\n      throw new TypeError(`${ERROR_PREFIX.EVENT.CLOSE} parameter 2 ('eventInitDict') is not an object`);\n    }\n\n    const { bubbles, cancelable, code, reason, wasClean } = eventInitConfig;\n\n    this.type = `${type}`;\n    this.timeStamp = Date.now();\n    this.target = null;\n    this.srcElement = null;\n    this.returnValue = true;\n    this.isTrusted = false;\n    this.eventPhase = 0;\n    this.defaultPrevented = false;\n    this.currentTarget = null;\n    this.cancelable = cancelable ? Boolean(cancelable) : false;\n    this.cancelBubble = false;\n    this.bubbles = bubbles ? Boolean(bubbles) : false;\n    this.code = typeof code === 'number' ? parseInt(code, 10) : 0;\n    this.reason = `${reason || ''}`;\n    this.wasClean = wasClean ? Boolean(wasClean) : false;\n  }\n}\n","import Event from './event';\nimport MessageEvent from './message';\nimport CloseEvent from './close';\n\n/*\n * Creates an Event object and extends it to allow full modification of\n * its properties.\n *\n * @param {object} config - within config you will need to pass type and optionally target\n */\nfunction createEvent(config) {\n  const { type, target } = config;\n  const eventObject = new Event(type);\n\n  if (target) {\n    eventObject.target = target;\n    eventObject.srcElement = target;\n    eventObject.currentTarget = target;\n  }\n\n  return eventObject;\n}\n\n/*\n * Creates a MessageEvent object and extends it to allow full modification of\n * its properties.\n *\n * @param {object} config - within config: type, origin, data and optionally target\n */\nfunction createMessageEvent(config) {\n  const { type, origin, data, target } = config;\n  const messageEvent = new MessageEvent(type, {\n    data,\n    origin\n  });\n\n  if (target) {\n    messageEvent.target = target;\n    messageEvent.srcElement = target;\n    messageEvent.currentTarget = target;\n  }\n\n  return messageEvent;\n}\n\n/*\n * Creates a CloseEvent object and extends it to allow full modification of\n * its properties.\n *\n * @param {object} config - within config: type and optionally target, code, and reason\n */\nfunction createCloseEvent(config) {\n  const { code, reason, type, target } = config;\n  let { wasClean } = config;\n\n  if (!wasClean) {\n    wasClean = code === 1000;\n  }\n\n  const closeEvent = new CloseEvent(type, {\n    code,\n    reason,\n    wasClean\n  });\n\n  if (target) {\n    closeEvent.target = target;\n    closeEvent.srcElement = target;\n    closeEvent.currentTarget = target;\n  }\n\n  return closeEvent;\n}\n\nexport { createEvent, createMessageEvent, createCloseEvent };\n","import WebSocket from '../websocket';\nimport delay from '../helpers/delay';\nimport networkBridge from '../network-bridge';\nimport { createCloseEvent, createEvent } from '../event/factory';\n\nexport function closeWebSocketConnection(context, code, reason) {\n  context.readyState = WebSocket.CLOSING;\n\n  const server = networkBridge.serverLookup(context.url);\n  const closeEvent = createCloseEvent({\n    type: 'close',\n    target: context,\n    code,\n    reason\n  });\n\n  delay(() => {\n    networkBridge.removeWebSocket(context, context.url);\n\n    context.readyState = WebSocket.CLOSED;\n    context.dispatchEvent(closeEvent);\n\n    if (server) {\n      server.dispatchEvent(closeEvent, server);\n    }\n  }, context);\n}\n\nexport function failWebSocketConnection(context, code, reason) {\n  context.readyState = WebSocket.CLOSING;\n\n  const server = networkBridge.serverLookup(context.url);\n  const closeEvent = createCloseEvent({\n    type: 'close',\n    target: context,\n    code,\n    reason,\n    wasClean: false\n  });\n\n  const errorEvent = createEvent({\n    type: 'error',\n    target: context\n  });\n\n  delay(() => {\n    networkBridge.removeWebSocket(context, context.url);\n\n    context.readyState = WebSocket.CLOSED;\n    context.dispatchEvent(errorEvent);\n    context.dispatchEvent(closeEvent);\n\n    if (server) {\n      server.dispatchEvent(closeEvent, server);\n    }\n  }, context);\n}\n","export default function normalizeSendData(data) {\n  const type = Object.prototype.toString.call(data);\n  if (type !== '[object Blob]' && !(data instanceof ArrayBuffer) && type !== '[object Object]') {\n    data = String(data);\n  }\n\n  return data;\n}\n","import { CLOSE_CODES } from '../constants';\nimport { closeWebSocketConnection } from '../algorithms/close';\nimport normalizeSendData from './normalize-send';\nimport { createMessageEvent } from '../event/factory';\n\nexport default function proxyFactory(target) {\n  const handler = {\n    get(obj, prop) {\n      if (prop === 'close') {\n        return function close(options = {}) {\n          const code = options.code || CLOSE_CODES.CLOSE_NORMAL;\n          const reason = options.reason || '';\n\n          closeWebSocketConnection(target, code, reason);\n        };\n      }\n\n      if (prop === 'send') {\n        return function send(data) {\n          data = normalizeSendData(data);\n\n          target.dispatchEvent(\n            createMessageEvent({\n              type: 'message',\n              data,\n              origin: this.url,\n              target\n            })\n          );\n        };\n      }\n\n      if (prop === 'on') {\n        return function onWrapper(type, cb) {\n          target.addEventListener(`server::${type}`, cb);\n        };\n      }\n\n      return obj[prop];\n    }\n  };\n\n  const proxy = new Proxy(target, handler);\n  return proxy;\n}\n","export default function lengthInUtf8Bytes(str) {\n  // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence.\n  const m = encodeURIComponent(str).match(/%[89ABab]/g);\n  return str.length + (m ? m.length : 0);\n}\n","import URL from 'url-parse';\nimport { ERROR_PREFIX } from '../constants';\n\nexport default function urlVerification(url) {\n  const urlRecord = new URL(url);\n  const { pathname, protocol, hash } = urlRecord;\n\n  if (!url) {\n    throw new TypeError(`${ERROR_PREFIX.CONSTRUCTOR_ERROR} 1 argument required, but only 0 present.`);\n  }\n\n  if (!pathname) {\n    urlRecord.pathname = '/';\n  }\n\n  if (protocol === '') {\n    throw new SyntaxError(`${ERROR_PREFIX.CONSTRUCTOR_ERROR} The URL '${urlRecord.toString()}' is invalid.`);\n  }\n\n  if (protocol !== 'ws:' && protocol !== 'wss:') {\n    throw new SyntaxError(\n      `${ERROR_PREFIX.CONSTRUCTOR_ERROR} The URL's scheme must be either 'ws' or 'wss'. '${protocol}' is not allowed.`\n    );\n  }\n\n  if (hash !== '') {\n    /* eslint-disable max-len */\n    throw new SyntaxError(\n      `${\n        ERROR_PREFIX.CONSTRUCTOR_ERROR\n      } The URL contains a fragment identifier ('${hash}'). Fragment identifiers are not allowed in WebSocket URLs.`\n    );\n    /* eslint-enable max-len */\n  }\n\n  return urlRecord.toString();\n}\n","import { ERROR_PREFIX } from '../constants';\n\nexport default function protocolVerification(protocols = []) {\n  if (!Array.isArray(protocols) && typeof protocols !== 'string') {\n    throw new SyntaxError(`${ERROR_PREFIX.CONSTRUCTOR_ERROR} The subprotocol '${protocols.toString()}' is invalid.`);\n  }\n\n  if (typeof protocols === 'string') {\n    protocols = [protocols];\n  }\n\n  const uniq = protocols\n    .map(p => ({ count: 1, protocol: p }))\n    .reduce((a, b) => {\n      a[b.protocol] = (a[b.protocol] || 0) + b.count;\n      return a;\n    }, {});\n\n  const duplicates = Object.keys(uniq).filter(a => uniq[a] > 1);\n\n  if (duplicates.length > 0) {\n    throw new SyntaxError(`${ERROR_PREFIX.CONSTRUCTOR_ERROR} The subprotocol '${duplicates[0]}' is duplicated.`);\n  }\n\n  return protocols;\n}\n","import delay from './helpers/delay';\nimport logger from './helpers/logger';\nimport EventTarget from './event/target';\nimport networkBridge from './network-bridge';\nimport proxyFactory from './helpers/proxy-factory';\nimport lengthInUtf8Bytes from './helpers/byte-length';\nimport { CLOSE_CODES, ERROR_PREFIX } from './constants';\nimport urlVerification from './helpers/url-verification';\nimport normalizeSendData from './helpers/normalize-send';\nimport protocolVerification from './helpers/protocol-verification';\nimport { createEvent, createMessageEvent, createCloseEvent } from './event/factory';\nimport { closeWebSocketConnection, failWebSocketConnection } from './algorithms/close';\n\n/*\n * The main websocket class which is designed to mimick the native WebSocket class as close\n * as possible.\n *\n * https://html.spec.whatwg.org/multipage/web-sockets.html\n */\nclass WebSocket extends EventTarget {\n  constructor(url, protocols) {\n    super();\n\n    this.url = urlVerification(url);\n    protocols = protocolVerification(protocols);\n    this.protocol = protocols[0] || '';\n\n    this.binaryType = 'blob';\n    this.readyState = WebSocket.CONNECTING;\n\n    const server = networkBridge.attachWebSocket(this, this.url);\n\n    /*\n     * This delay is needed so that we dont trigger an event before the callbacks have been\n     * setup. For example:\n     *\n     * var socket = new WebSocket('ws://localhost');\n     *\n     * If we dont have the delay then the event would be triggered right here and this is\n     * before the onopen had a chance to register itself.\n     *\n     * socket.onopen = () => { // this would never be called };\n     *\n     * and with the delay the event gets triggered here after all of the callbacks have been\n     * registered :-)\n     */\n    delay(function delayCallback() {\n      if (server) {\n        if (\n          server.options.verifyClient &&\n          typeof server.options.verifyClient === 'function' &&\n          !server.options.verifyClient()\n        ) {\n          this.readyState = WebSocket.CLOSED;\n\n          logger(\n            'error',\n            `WebSocket connection to '${this.url}' failed: HTTP Authentication failed; no valid credentials available`\n          );\n\n          networkBridge.removeWebSocket(this, this.url);\n          this.dispatchEvent(createEvent({ type: 'error', target: this }));\n          this.dispatchEvent(createCloseEvent({ type: 'close', target: this, code: CLOSE_CODES.CLOSE_NORMAL }));\n        } else {\n          if (server.options.selectProtocol && typeof server.options.selectProtocol === 'function') {\n            const selectedProtocol = server.options.selectProtocol(protocols);\n            const isFilled = selectedProtocol !== '';\n            const isRequested = protocols.indexOf(selectedProtocol) !== -1;\n            if (isFilled && !isRequested) {\n              this.readyState = WebSocket.CLOSED;\n\n              logger('error', `WebSocket connection to '${this.url}' failed: Invalid Sub-Protocol`);\n\n              networkBridge.removeWebSocket(this, this.url);\n              this.dispatchEvent(createEvent({ type: 'error', target: this }));\n              this.dispatchEvent(createCloseEvent({ type: 'close', target: this, code: CLOSE_CODES.CLOSE_NORMAL }));\n              return;\n            }\n            this.protocol = selectedProtocol;\n          }\n          this.readyState = WebSocket.OPEN;\n          this.dispatchEvent(createEvent({ type: 'open', target: this }));\n          server.dispatchEvent(createEvent({ type: 'connection' }), proxyFactory(this));\n        }\n      } else {\n        this.readyState = WebSocket.CLOSED;\n        this.dispatchEvent(createEvent({ type: 'error', target: this }));\n        this.dispatchEvent(createCloseEvent({ type: 'close', target: this, code: CLOSE_CODES.CLOSE_NORMAL }));\n\n        logger('error', `WebSocket connection to '${this.url}' failed`);\n      }\n    }, this);\n  }\n\n  get onopen() {\n    return this.listeners.open;\n  }\n\n  get onmessage() {\n    return this.listeners.message;\n  }\n\n  get onclose() {\n    return this.listeners.close;\n  }\n\n  get onerror() {\n    return this.listeners.error;\n  }\n\n  set onopen(listener) {\n    delete this.listeners.open;\n    this.addEventListener('open', listener);\n  }\n\n  set onmessage(listener) {\n    delete this.listeners.message;\n    this.addEventListener('message', listener);\n  }\n\n  set onclose(listener) {\n    delete this.listeners.close;\n    this.addEventListener('close', listener);\n  }\n\n  set onerror(listener) {\n    delete this.listeners.error;\n    this.addEventListener('error', listener);\n  }\n\n  send(data) {\n    if (this.readyState === WebSocket.CLOSING || this.readyState === WebSocket.CLOSED) {\n      throw new Error('WebSocket is already in CLOSING or CLOSED state');\n    }\n\n    // TODO: handle bufferedAmount\n\n    const messageEvent = createMessageEvent({\n      type: 'server::message',\n      origin: this.url,\n      data: normalizeSendData(data)\n    });\n\n    const server = networkBridge.serverLookup(this.url);\n\n    if (server) {\n      delay(() => {\n        this.dispatchEvent(messageEvent, data);\n      }, server);\n    }\n  }\n\n  close(code, reason) {\n    if (code !== undefined) {\n      if (typeof code !== 'number' || (code !== 1000 && (code < 3000 || code > 4999))) {\n        throw new TypeError(\n          `${ERROR_PREFIX.CLOSE_ERROR} The code must be either 1000, or between 3000 and 4999. ${code} is neither.`\n        );\n      }\n    }\n\n    if (reason !== undefined) {\n      const length = lengthInUtf8Bytes(reason);\n\n      if (length > 123) {\n        throw new SyntaxError(`${ERROR_PREFIX.CLOSE_ERROR} The message must not be greater than 123 bytes.`);\n      }\n    }\n\n    if (this.readyState === WebSocket.CLOSING || this.readyState === WebSocket.CLOSED) {\n      return;\n    }\n\n    if (this.readyState === WebSocket.CONNECTING) {\n      failWebSocketConnection(this, code, reason);\n    } else {\n      closeWebSocketConnection(this, code, reason);\n    }\n  }\n}\n\nWebSocket.CONNECTING = 0;\nWebSocket.prototype.CONNECTING = WebSocket.CONNECTING;\nWebSocket.OPEN = 1;\nWebSocket.prototype.OPEN = WebSocket.OPEN;\nWebSocket.CLOSING = 2;\nWebSocket.prototype.CLOSING = WebSocket.CLOSING;\nWebSocket.CLOSED = 3;\nWebSocket.prototype.CLOSED = WebSocket.CLOSED;\n\nexport default WebSocket;\n","export default arr =>\n  arr.reduce((deduped, b) => {\n    if (deduped.indexOf(b) > -1) return deduped;\n    return deduped.concat(b);\n  }, []);\n","export default function retrieveGlobalObject() {\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n\n  return typeof process === 'object' && typeof require === 'function' && typeof global === 'object' ? global : this;\n}\n","import URL from 'url-parse';\nimport WebSocket from './websocket';\nimport dedupe from './helpers/dedupe';\nimport EventTarget from './event/target';\nimport { CLOSE_CODES } from './constants';\nimport networkBridge from './network-bridge';\nimport globalObject from './helpers/global-object';\nimport normalizeSendData from './helpers/normalize-send';\nimport { createEvent, createMessageEvent, createCloseEvent } from './event/factory';\n\nclass Server extends EventTarget {\n  constructor(url, options = {}) {\n    super();\n    const urlRecord = new URL(url);\n\n    if (!urlRecord.pathname) {\n      urlRecord.pathname = '/';\n    }\n\n    this.url = urlRecord.toString();\n\n    this.originalWebSocket = null;\n    const server = networkBridge.attachServer(this, this.url);\n\n    if (!server) {\n      this.dispatchEvent(createEvent({ type: 'error' }));\n      throw new Error('A mock server is already listening on this url');\n    }\n\n    if (typeof options.verifyClient === 'undefined') {\n      options.verifyClient = null;\n    }\n\n    if (typeof options.selectProtocol === 'undefined') {\n      options.selectProtocol = null;\n    }\n\n    this.options = options;\n    this.start();\n  }\n\n  /*\n   * Attaches the mock websocket object to the global object\n   */\n  start() {\n    const globalObj = globalObject();\n\n    if (globalObj.WebSocket) {\n      this.originalWebSocket = globalObj.WebSocket;\n    }\n\n    globalObj.WebSocket = WebSocket;\n  }\n\n  /*\n   * Removes the mock websocket object from the global object\n   */\n  stop(callback = () => {}) {\n    const globalObj = globalObject();\n\n    if (this.originalWebSocket) {\n      globalObj.WebSocket = this.originalWebSocket;\n    } else {\n      delete globalObj.WebSocket;\n    }\n\n    this.originalWebSocket = null;\n\n    networkBridge.removeServer(this.url);\n\n    if (typeof callback === 'function') {\n      callback();\n    }\n  }\n\n  /*\n   * This is the main function for the mock server to subscribe to the on events.\n   *\n   * ie: mockServer.on('connection', function() { console.log('a mock client connected'); });\n   *\n   * @param {string} type - The event key to subscribe to. Valid keys are: connection, message, and close.\n   * @param {function} callback - The callback which should be called when a certain event is fired.\n   */\n  on(type, callback) {\n    this.addEventListener(type, callback);\n  }\n\n  /*\n   * Closes the connection and triggers the onclose method of all listening\n   * websockets. After that it removes itself from the urlMap so another server\n   * could add itself to the url.\n   *\n   * @param {object} options\n   */\n  close(options = {}) {\n    const { code, reason, wasClean } = options;\n    const listeners = networkBridge.websocketsLookup(this.url);\n\n    // Remove server before notifications to prevent immediate reconnects from\n    // socket onclose handlers\n    networkBridge.removeServer(this.url);\n\n    listeners.forEach(socket => {\n      socket.readyState = WebSocket.CLOSE;\n      socket.dispatchEvent(\n        createCloseEvent({\n          type: 'close',\n          target: socket,\n          code: code || CLOSE_CODES.CLOSE_NORMAL,\n          reason: reason || '',\n          wasClean\n        })\n      );\n    });\n\n    this.dispatchEvent(createCloseEvent({ type: 'close' }), this);\n  }\n\n  /*\n   * Sends a generic message event to all mock clients.\n   */\n  emit(event, data, options = {}) {\n    let { websockets } = options;\n\n    if (!websockets) {\n      websockets = networkBridge.websocketsLookup(this.url);\n    }\n\n    if (typeof options !== 'object' || arguments.length > 3) {\n      data = Array.prototype.slice.call(arguments, 1, arguments.length);\n      data = data.map(item => normalizeSendData(item));\n    } else {\n      data = normalizeSendData(data);\n    }\n\n    websockets.forEach(socket => {\n      if (Array.isArray(data)) {\n        socket.dispatchEvent(\n          createMessageEvent({\n            type: event,\n            data,\n            origin: this.url,\n            target: socket\n          }),\n          ...data\n        );\n      } else {\n        socket.dispatchEvent(\n          createMessageEvent({\n            type: event,\n            data,\n            origin: this.url,\n            target: socket\n          })\n        );\n      }\n    });\n  }\n\n  /*\n   * Returns an array of websockets which are listening to this server\n   * TOOD: this should return a set and not be a method\n   */\n  clients() {\n    return networkBridge.websocketsLookup(this.url);\n  }\n\n  /*\n   * Prepares a method to submit an event to members of the room\n   *\n   * e.g. server.to('my-room').emit('hi!');\n   */\n  to(room, broadcaster, broadcastList = []) {\n    const self = this;\n    const websockets = dedupe(broadcastList.concat(networkBridge.websocketsLookup(this.url, room, broadcaster)));\n\n    return {\n      to: (chainedRoom, chainedBroadcaster) => this.to.call(this, chainedRoom, chainedBroadcaster, websockets),\n      emit(event, data) {\n        self.emit(event, data, { websockets });\n      }\n    };\n  }\n\n  /*\n   * Alias for Server.to\n   */\n  in(...args) {\n    return this.to.apply(null, args);\n  }\n\n  /*\n   * Simulate an event from the server to the clients. Useful for\n   * simulating errors.\n   */\n  simulate(event) {\n    const listeners = networkBridge.websocketsLookup(this.url);\n\n    if (event === 'error') {\n      listeners.forEach(socket => {\n        socket.readyState = WebSocket.CLOSE;\n        socket.dispatchEvent(createEvent({ type: 'error' }));\n      });\n    }\n  }\n}\n\n/*\n * Alternative constructor to support namespaces in socket.io\n *\n * http://socket.io/docs/rooms-and-namespaces/#custom-namespaces\n */\nServer.of = function of(url) {\n  return new Server(url);\n};\n\nexport default Server;\n","import URL from 'url-parse';\nimport delay from './helpers/delay';\nimport EventTarget from './event/target';\nimport networkBridge from './network-bridge';\nimport { CLOSE_CODES } from './constants';\nimport logger from './helpers/logger';\nimport { createEvent, createMessageEvent, createCloseEvent } from './event/factory';\n\n/*\n * The socket-io class is designed to mimick the real API as closely as possible.\n *\n * http://socket.io/docs/\n */\nclass SocketIO extends EventTarget {\n  /*\n   * @param {string} url\n   */\n  constructor(url = 'socket.io', protocol = '') {\n    super();\n\n    this.binaryType = 'blob';\n    const urlRecord = new URL(url);\n\n    if (!urlRecord.pathname) {\n      urlRecord.pathname = '/';\n    }\n\n    this.url = urlRecord.toString();\n    this.readyState = SocketIO.CONNECTING;\n    this.protocol = '';\n\n    if (typeof protocol === 'string' || (typeof protocol === 'object' && protocol !== null)) {\n      this.protocol = protocol;\n    } else if (Array.isArray(protocol) && protocol.length > 0) {\n      this.protocol = protocol[0];\n    }\n\n    const server = networkBridge.attachWebSocket(this, this.url);\n\n    /*\n     * Delay triggering the connection events so they can be defined in time.\n     */\n    delay(function delayCallback() {\n      if (server) {\n        this.readyState = SocketIO.OPEN;\n        server.dispatchEvent(createEvent({ type: 'connection' }), server, this);\n        server.dispatchEvent(createEvent({ type: 'connect' }), server, this); // alias\n        this.dispatchEvent(createEvent({ type: 'connect', target: this }));\n      } else {\n        this.readyState = SocketIO.CLOSED;\n        this.dispatchEvent(createEvent({ type: 'error', target: this }));\n        this.dispatchEvent(\n          createCloseEvent({\n            type: 'close',\n            target: this,\n            code: CLOSE_CODES.CLOSE_NORMAL\n          })\n        );\n\n        logger('error', `Socket.io connection to '${this.url}' failed`);\n      }\n    }, this);\n\n    /**\n      Add an aliased event listener for close / disconnect\n     */\n    this.addEventListener('close', event => {\n      this.dispatchEvent(\n        createCloseEvent({\n          type: 'disconnect',\n          target: event.target,\n          code: event.code\n        })\n      );\n    });\n  }\n\n  /*\n   * Closes the SocketIO connection or connection attempt, if any.\n   * If the connection is already CLOSED, this method does nothing.\n   */\n  close() {\n    if (this.readyState !== SocketIO.OPEN) {\n      return undefined;\n    }\n\n    const server = networkBridge.serverLookup(this.url);\n    networkBridge.removeWebSocket(this, this.url);\n\n    this.readyState = SocketIO.CLOSED;\n    this.dispatchEvent(\n      createCloseEvent({\n        type: 'close',\n        target: this,\n        code: CLOSE_CODES.CLOSE_NORMAL\n      })\n    );\n\n    if (server) {\n      server.dispatchEvent(\n        createCloseEvent({\n          type: 'disconnect',\n          target: this,\n          code: CLOSE_CODES.CLOSE_NORMAL\n        }),\n        server\n      );\n    }\n\n    return this;\n  }\n\n  /*\n   * Alias for Socket#close\n   *\n   * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L383\n   */\n  disconnect() {\n    return this.close();\n  }\n\n  /*\n   * Submits an event to the server with a payload\n   */\n  emit(event, ...data) {\n    if (this.readyState !== SocketIO.OPEN) {\n      throw new Error('SocketIO is already in CLOSING or CLOSED state');\n    }\n\n    const messageEvent = createMessageEvent({\n      type: event,\n      origin: this.url,\n      data\n    });\n\n    const server = networkBridge.serverLookup(this.url);\n\n    if (server) {\n      server.dispatchEvent(messageEvent, ...data);\n    }\n\n    return this;\n  }\n\n  /*\n   * Submits a 'message' event to the server.\n   *\n   * Should behave exactly like WebSocket#send\n   *\n   * https://github.com/socketio/socket.io-client/blob/master/lib/socket.js#L113\n   */\n  send(data) {\n    this.emit('message', data);\n    return this;\n  }\n\n  /*\n   * For broadcasting events to other connected sockets.\n   *\n   * e.g. socket.broadcast.emit('hi!');\n   * e.g. socket.broadcast.to('my-room').emit('hi!');\n   */\n  get broadcast() {\n    if (this.readyState !== SocketIO.OPEN) {\n      throw new Error('SocketIO is already in CLOSING or CLOSED state');\n    }\n\n    const self = this;\n    const server = networkBridge.serverLookup(this.url);\n    if (!server) {\n      throw new Error(`SocketIO can not find a server at the specified URL (${this.url})`);\n    }\n\n    return {\n      emit(event, data) {\n        server.emit(event, data, { websockets: networkBridge.websocketsLookup(self.url, null, self) });\n        return self;\n      },\n      to(room) {\n        return server.to(room, self);\n      },\n      in(room) {\n        return server.in(room, self);\n      }\n    };\n  }\n\n  /*\n   * For registering events to be received from the server\n   */\n  on(type, callback) {\n    this.addEventListener(type, callback);\n    return this;\n  }\n\n  /*\n   * Remove event listener\n   *\n   * https://socket.io/docs/client-api/#socket-on-eventname-callback\n   */\n  off(type) {\n    this.removeEventListener(type);\n  }\n\n  /*\n   * Join a room on a server\n   *\n   * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving\n   */\n  join(room) {\n    networkBridge.addMembershipToRoom(this, room);\n  }\n\n  /*\n   * Get the websocket to leave the room\n   *\n   * http://socket.io/docs/rooms-and-namespaces/#joining-and-leaving\n   */\n  leave(room) {\n    networkBridge.removeMembershipFromRoom(this, room);\n  }\n\n  to(room) {\n    return this.broadcast.to(room);\n  }\n\n  in() {\n    return this.to.apply(null, arguments);\n  }\n\n  /*\n   * Invokes all listener functions that are listening to the given event.type property. Each\n   * listener will be passed the event as the first argument.\n   *\n   * @param {object} event - event object which will be passed to all listeners of the event.type property\n   */\n  dispatchEvent(event, ...customArguments) {\n    const eventName = event.type;\n    const listeners = this.listeners[eventName];\n\n    if (!Array.isArray(listeners)) {\n      return false;\n    }\n\n    listeners.forEach(listener => {\n      if (customArguments.length > 0) {\n        listener.apply(this, customArguments);\n      } else {\n        // Regular WebSockets expect a MessageEvent but Socketio.io just wants raw data\n        //  payload instanceof MessageEvent works, but you can't isntance of NodeEvent\n        //  for now we detect if the output has data defined on it\n        listener.call(this, event.data ? event.data : event);\n      }\n    });\n  }\n}\n\nSocketIO.CONNECTING = 0;\nSocketIO.OPEN = 1;\nSocketIO.CLOSING = 2;\nSocketIO.CLOSED = 3;\n\n/*\n * Static constructor methods for the IO Socket\n */\nconst IO = function ioConstructor(url, protocol) {\n  return new SocketIO(url, protocol);\n};\n\n/*\n * Alias the raw IO() constructor\n */\nIO.connect = function ioConnect(url, protocol) {\n  /* eslint-disable new-cap */\n  return IO(url, protocol);\n  /* eslint-enable new-cap */\n};\n\nexport default IO;\n","import MockServer from './server';\nimport MockSocketIO from './socket-io';\nimport MockWebSocket from './websocket';\n\nexport const Server = MockServer;\nexport const WebSocket = MockWebSocket;\nexport const SocketIO = MockSocketIO;\n"],"names":["global","qs","required","const","this","super","WebSocket","URL","logger","Server","globalObject","SocketIO","MockServer","MockWebSocket","MockSocketIO"],"mappings":"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"} diff --git a/package.json b/package.json index 8da30732..bcfa8f53 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "mock-socket", "description": "Javascript mocking library for websockets and socket.io", - "version": "9.0.2", + "version": "9.0.3", "license": "MIT", "author": "Travis Hoover", "main": "./dist/mock-socket", diff --git a/src/helpers/normalize-send.js b/src/helpers/normalize-send.js index ebb209bb..dd722395 100644 --- a/src/helpers/normalize-send.js +++ b/src/helpers/normalize-send.js @@ -1,5 +1,6 @@ export default function normalizeSendData(data) { - if (Object.prototype.toString.call(data) !== '[object Blob]' && !(data instanceof ArrayBuffer)) { + const type = Object.prototype.toString.call(data); + if (type !== '[object Blob]' && !(data instanceof ArrayBuffer) && type !== '[object Object]') { data = String(data); } diff --git a/tests/unit/server.test.js b/tests/unit/server.test.js index cdd3738b..ac58d4f2 100644 --- a/tests/unit/server.test.js +++ b/tests/unit/server.test.js @@ -103,13 +103,20 @@ test.cb('that send will normalize data', t => { myServer.on('connection', socket => { socket.send([1, 2]); + socket.send({ foo: 'bar' }); }); const socketFoo = new WebSocket('ws://not-real/'); + let counter = 0; socketFoo.onmessage = message => { - t.is(message.data, '1,2', 'data non string, non blob/arraybuffers get toStringed'); - myServer.close(); - t.end(); + if (counter === 0) { + t.is(message.data, '1,2', 'data non string, non blob/arraybuffers get toStringed'); + counter += 1; + } else if (counter === 1) { + t.is(message.data.foo, 'bar', 'object does not get toStringed'); + myServer.close(); + t.end(); + } }; });