# tablepress/2.2.5/libraries/freemius/assets/js/nojquery.ba-postmessage.js

TablePress – Tables in WordPress made easy, version 2.2.5. 140 lines.

- Page: https://pluginprobe.com/plugins/tablepress/2.2.5/code/libraries/freemius/assets/js/nojquery.ba-postmessage.js
- Raw: https://pluginprobe.com/plugins/tablepress/2.2.5/raw/libraries/freemius/assets/js/nojquery.ba-postmessage.js
- Modified: 2022-12-19T11:32:06+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/tablepress/2.2.5/code/libraries/freemius/assets/js/nojquery.ba-postmessage.js#L10-L20`.

```javascript
/*!
 * jQuery postMessage - v0.5 - 9/11/2009
 * http://benalman.com/projects/jquery-postmessage-plugin/
 *
 * Copyright (c) 2009 "Cowboy" Ben Alman
 * Dual licensed under the MIT and GPL licenses.
 * http://benalman.com/about/license/
 *
 * Non-jQuery fork by Jeff Lee
 *
 * This fork consists of the following changes:
 * 1. Basic code cleanup and restructuring, for legibility.
 * 2. The `postMessage` and `receiveMessage` functions can be bound arbitrarily,
 *    in terms of both function names and object scope. Scope is specified by
 *    the the "this" context of NoJQueryPostMessageMixin();
 * 3. I've removed the check for Opera 9.64, which used `$.browser`. There were
 *    at least three different GitHub users requesting the removal of this
 *    "Opera sniff" on the original project's Issues page, so I figured this
 *    would be a relatively safe change.
 * 4. `postMessage` no longer uses `$.param` to serialize messages that are not
 *    strings. I actually prefer this structure anyway. `receiveMessage` does
 *    not implement a corresponding deserialization step, and as such it seems
 *    cleaner and more symmetric to leave both data serialization and
 *    deserialization to the client.
 * 5. The use of `$.isFunction` is replaced by a functionally-identical check.
 * 6. The `$:nomunge` YUI option is no longer necessary.
 */

function NoJQueryPostMessageMixin(postBinding, receiveBinding) {

	var setMessageCallback, unsetMessageCallback, currentMsgCallback,
		intervalId, lastHash, cacheBust = 1;

  if (window.postMessage) {

	if (window.addEventListener) {
	  setMessageCallback = function(callback) {
		window.addEventListener('message', callback, false);
	  }

	  unsetMessageCallback = function(callback) {
		window.removeEventListener('message', callback, false);
	  }
	} else {
	  setMessageCallback = function(callback) {
		window.attachEvent('onmessage', callback);
	  }

	  unsetMessageCallback = function(callback) {
		window.detachEvent('onmessage', callback);
	  }
	}

	this[postBinding] = function(message, targetUrl, target) {
	  if (!targetUrl) {
		return;
	  }

	  // The browser supports window.postMessage, so call it with a targetOrigin
	  // set appropriately, based on the targetUrl parameter.
	  target.postMessage( message, targetUrl.replace( /([^:]+:\/\/[^\/]+).*/, '$1' ) );
	}

	// Since the browser supports window.postMessage, the callback will be
	// bound to the actual event associated with window.postMessage.
	this[receiveBinding] = function(callback, sourceOrigin, delay) {
	  // Unbind an existing callback if it exists.
	  if (currentMsgCallback) {
		unsetMessageCallback(currentMsgCallback);
		currentMsgCallback = null;
	  }

	  if (!callback) {
		return false;
	  }

	  // Bind the callback. A reference to the callback is stored for ease of
	  // unbinding.
	  currentMsgCallback = setMessageCallback(function(e) {
		switch(Object.prototype.toString.call(sourceOrigin)) {
		case '[object String]':
		  if (sourceOrigin !== e.origin) {
			return false;
		  }
		  break;
		case '[object Function]':
		  if (sourceOrigin(e.origin)) {
			return false;
		  }
		  break;
		}

		callback(e);
	  });
	};

  } else {

	this[postBinding] = function(message, targetUrl, target) {
	  if (!targetUrl) {
		return;
	  }

	  // The browser does not support window.postMessage, so set the location
	  // of the target to targetUrl#message. A bit ugly, but it works! A cache
	  // bust parameter is added to ensure that repeat messages trigger the
	  // callback.
	  target.location = targetUrl.replace( /#.*$/, '' ) + '#' + (+new Date) + (cacheBust++) + '&' + message;
	}

	// Since the browser sucks, a polling loop will be started, and the
	// callback will be called whenever the location.hash changes.
	this[receiveBinding] = function(callback, sourceOrigin, delay) {
	  if (intervalId) {
		clearInterval(intervalId);
		intervalId = null;
	  }

	  if (callback) {
		delay = typeof sourceOrigin === 'number'
		  ? sourceOrigin
		  : typeof delay === 'number'
			? delay
			: 100;

		intervalId = setInterval(function(){
		  var hash = document.location.hash,
			re = /^#?\d+&/;
		  if ( hash !== lastHash && re.test( hash ) ) {
			lastHash = hash;
			callback({ data: hash.replace( re, '' ) });
		  }
		}, delay );
	  }
	};

  }

  return this;
}
```