immutable-devtools/dist/index.js

module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = install;

	var _createFormatter = __webpack_require__(1);

	var _createFormatter2 = _interopRequireDefault(_createFormatter);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; }

	var installed = false;

	// Check for globally defined Immutable and add an install method to it.
	if (typeof Immutable !== "undefined") {
	  Immutable.installDevTools = install.bind(null, Immutable);
	}

	// I imagine most people are using Immutable as a CommonJS module though...

	function install(Immutable) {

	  if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === undefined) {
	    throw new Error("Can only install immutable-devtools in a browser environment.");
	  }

	  // Don't install more than once.
	  if (installed === true) {
	    return;
	  }

	  window.devtoolsFormatters = window.devtoolsFormatters || [];

	  window.devtoolsFormatters.push((0, _createFormatter2.default)(Immutable));

	  installed = true;
	}

/***/ },
/* 1 */
/***/ function(module, exports) {

	"use strict";

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = createFormatter;

	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

	var listStyle = { style: "list-style-type: none; padding: 0; margin: 0 0 0 12px" };
	var keyStyle = { style: "color:#881391" };

	function createFormatter(Immutable) {

	  function reference(any, config) {
	    return ["object", { object: any, config: config }];
	  }

	  var stop = {}; // Signals formatter to stop infinite recursion

	  var defaultFormatter = {
	    header: function header(x, config) {
	      if (config === stop) return null;
	      return reference(x, stop);
	    },
	    hasBody: function hasBody(x, config) {
	      return false;
	    },
	    body: function body(x, config) {
	      return null;
	    }
	  };

	  function notEmpty(collection) {
	    return collection.size > 0;
	  }

	  function keySpan(key) {
	    return ["span", keyStyle, key + ": "];
	  }

	  function displayKeyValueList(collection) {
	    var children = collection.map(function (value, key) {
	      return ["li", keySpan(key), reference(value)];
	    }).toList().toJS();
	    return ["ol", listStyle].concat(_toConsumableArray(children));
	  }

	  var mapFormatter = {
	    header: function header() {
	      return ["span", "Map"];
	    },

	    hasBody: notEmpty,
	    body: displayKeyValueList
	  };

	  var orderedMapFormatter = {
	    header: function header() {
	      return ["span", "OrderedMap"];
	    },

	    hasBody: notEmpty,
	    body: displayKeyValueList
	  };

	  var listFormatter = {
	    header: function header() {
	      return ["span", "List"];
	    },

	    hasBody: notEmpty,
	    body: displayKeyValueList
	  };

	  function setBody(set) {
	    var children = set.map(function (item) {
	      return ["li", reference(item)];
	    }).toJS();
	    return ["ol", listStyle].concat(_toConsumableArray(children));
	  }

	  var stackFormatter = {
	    header: function header() {
	      return ["span", "Stack"];
	    },

	    hasBody: notEmpty,
	    body: setBody
	  };

	  var setFormatter = {
	    header: function header() {
	      return ["span", "Set"];
	    },

	    hasBody: notEmpty,
	    body: setBody
	  };

	  var orderedSetFormatter = {
	    header: function header() {
	      return ["span", "OrderedSet"];
	    },

	    hasBody: notEmpty,
	    body: setBody
	  };

	  var recordFormatter = {
	    header: function header() {
	      return ["span", "Record"];
	    },

	    hasBody: notEmpty,
	    body: function body(record) {
	      var children = record.keySeq().map(function (key) {
	        return ["li", keySpan(key), reference(record.get(key))];
	      }).toJS();
	      return ["ol", listStyle].concat(_toConsumableArray(children));
	    }
	  };

	  var immutableFormatters = {
	    List: listFormatter,
	    Map: mapFormatter,
	    OrderedMap: orderedMapFormatter,
	    Set: setFormatter,
	    OrderedSet: orderedSetFormatter,
	    Stack: stackFormatter
	  };

	  function getFormatter(any) {
	    if (any instanceof Immutable.Record) return recordFormatter;
	    return Object.keys(immutableFormatters).filter(function (type) {
	      return Immutable[type]["is" + type](any);
	    }).map(function (type) {
	      return immutableFormatters[type];
	    }).concat(defaultFormatter) // Fallback used when not immutable value
	    [0];
	  }

	  return {
	    header: function header(any, config) {
	      return getFormatter(any).header(any, config);
	    },
	    hasBody: function hasBody(any, config) {
	      return getFormatter(any).hasBody(any, config);
	    },
	    body: function body(any, config) {
	      return getFormatter(any).body(any, config);
	    }
	  };
	}

/***/ }
/******/ ]);