This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2566 lines
137 KiB
2566 lines
137 KiB
!function(root, factory) { |
|
"object" == typeof exports && "object" == typeof module ? module.exports = factory() : "function" == typeof define && define.amd ? define([], factory) : "object" == typeof exports ? exports.ReactDevToolsBackend = factory() : root.ReactDevToolsBackend = factory(); |
|
}(this, function() { |
|
return function(modules) { |
|
function __webpack_require__(moduleId) { |
|
if (installedModules[moduleId]) return installedModules[moduleId].exports; |
|
var module = installedModules[moduleId] = { |
|
exports: {}, |
|
id: moduleId, |
|
loaded: !1 |
|
}; |
|
return modules[moduleId].call(module.exports, module, module.exports, __webpack_require__), |
|
module.loaded = !0, module.exports; |
|
} |
|
var installedModules = {}; |
|
return __webpack_require__.m = modules, __webpack_require__.c = installedModules, |
|
__webpack_require__.p = "", __webpack_require__(0); |
|
}([ function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function connectToDevTools(options) { |
|
function scheduleRetry() { |
|
setTimeout(function() { |
|
return connectToDevTools(options); |
|
}, 2e3); |
|
} |
|
function handleClose() { |
|
hasClosed || (hasClosed = !0, scheduleRetry(), closeListeners.forEach(function(fn) { |
|
return fn(); |
|
})); |
|
} |
|
function handleMessage(evt) { |
|
var data; |
|
try { |
|
data = JSON.parse(evt.data); |
|
} catch (e) { |
|
return void console.error("failed to parse json: " + evt.data); |
|
} |
|
messageListeners.forEach(function(fn) { |
|
try { |
|
fn(data); |
|
} catch (e) { |
|
throw console.log(data), e; |
|
} |
|
}); |
|
} |
|
var _ref = options || {}, _ref$host = _ref.host, host = void 0 === _ref$host ? "localhost" : _ref$host, _ref$port = _ref.port, port = void 0 === _ref$port ? 8097 : _ref$port, websocket = _ref.websocket, _ref$resolveRNStyle = _ref.resolveRNStyle, resolveRNStyle = void 0 === _ref$resolveRNStyle ? null : _ref$resolveRNStyle, _ref$isAppActive = _ref.isAppActive, isAppActive = void 0 === _ref$isAppActive ? function() { |
|
return !0; |
|
} : _ref$isAppActive; |
|
if (!isAppActive()) return void scheduleRetry(); |
|
var messageListeners = [], closeListeners = [], uri = "ws://" + host + ":" + port, ws = websocket ? websocket : new window.WebSocket(uri); |
|
ws.onclose = handleClose, ws.onerror = handleClose, ws.onmessage = handleMessage, |
|
ws.onopen = function() { |
|
var wall = { |
|
listen: function(fn) { |
|
messageListeners.push(fn); |
|
}, |
|
onClose: function(fn) { |
|
closeListeners.push(fn); |
|
}, |
|
send: function(data) { |
|
ws.send(JSON.stringify(data)); |
|
} |
|
}; |
|
setupBackend(wall, resolveRNStyle); |
|
}; |
|
var hasClosed = !1; |
|
} |
|
function setupBackend(wall, resolveRNStyle) { |
|
wall.onClose(function() { |
|
agent && agent.emit("shutdown"), window.__REACT_DEVTOOLS_GLOBAL_HOOK__.emit("shutdown"), |
|
bridge = null, agent = null, console.log("closing devtools"); |
|
}); |
|
var bridge = new Bridge(wall), agent = new Agent(window, { |
|
rnStyle: !!resolveRNStyle, |
|
rnStyleMeasure: !!resolveRNStyle |
|
}); |
|
agent.addBridge(bridge), resolveRNStyle && setupRNStyle(bridge, agent, resolveRNStyle), |
|
setupRelay(bridge, agent, window.__REACT_DEVTOOLS_GLOBAL_HOOK__); |
|
var _connectTimeout = setTimeout(function() { |
|
console.warn("react-devtools agent got no connection"); |
|
}, 2e4); |
|
agent.once("connected", function() { |
|
agent && (inject(window.__REACT_DEVTOOLS_GLOBAL_HOOK__, agent), clearTimeout(_connectTimeout)); |
|
}); |
|
} |
|
var Agent = __webpack_require__(1), Bridge = __webpack_require__(6), installGlobalHook = __webpack_require__(31), installRelayHook = __webpack_require__(32), inject = __webpack_require__(33), setupRNStyle = __webpack_require__(46), setupRelay = __webpack_require__(48); |
|
installGlobalHook(window), installRelayHook(window), window.document && window.__REACT_DEVTOOLS_GLOBAL_HOOK__.on("react-devtools", function(agent) { |
|
var setupHighlighter = __webpack_require__(49); |
|
setupHighlighter(agent); |
|
}), module.exports = { |
|
connectToDevTools: connectToDevTools |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function _classCallCheck(instance, Constructor) { |
|
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); |
|
} |
|
function _possibleConstructorReturn(self, call) { |
|
if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); |
|
return !call || "object" != typeof call && "function" != typeof call ? self : call; |
|
} |
|
function _inherits(subClass, superClass) { |
|
if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); |
|
subClass.prototype = Object.create(superClass && superClass.prototype, { |
|
constructor: { |
|
value: subClass, |
|
enumerable: !1, |
|
writable: !0, |
|
configurable: !0 |
|
} |
|
}), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); |
|
} |
|
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { |
|
return typeof obj; |
|
} : function(obj) { |
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; |
|
}, _createClass = function() { |
|
function defineProperties(target, props) { |
|
for (var i = 0; i < props.length; i++) { |
|
var descriptor = props[i]; |
|
descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, |
|
"value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); |
|
} |
|
} |
|
return function(Constructor, protoProps, staticProps) { |
|
return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), |
|
Constructor; |
|
}; |
|
}(), _require = __webpack_require__(2), EventEmitter = _require.EventEmitter, assign = __webpack_require__(3), guid = __webpack_require__(4), getIn = __webpack_require__(5), Agent = function(_EventEmitter) { |
|
function Agent(global, capabilities) { |
|
_classCallCheck(this, Agent); |
|
var _this = _possibleConstructorReturn(this, (Agent.__proto__ || Object.getPrototypeOf(Agent)).call(this)); |
|
_this.global = global, _this.internalInstancesById = new Map(), _this.idsByInternalInstances = new WeakMap(), |
|
_this.renderers = new Map(), _this.elementData = new Map(), _this.roots = new Set(), |
|
_this.reactInternals = {}; |
|
var lastSelected; |
|
_this.on("selected", function(id) { |
|
var data = _this.elementData.get(id); |
|
data && data.publicInstance && _this.global.$r === lastSelected && (_this.global.$r = data.publicInstance, |
|
lastSelected = data.publicInstance); |
|
}), _this._prevSelected = null, _this._scrollUpdate = !1; |
|
var isReactDOM = window.document && "function" == typeof window.document.createElement; |
|
return _this.capabilities = assign({ |
|
scroll: isReactDOM && "function" == typeof window.document.body.scrollIntoView, |
|
dom: isReactDOM, |
|
editTextContent: !1 |
|
}, capabilities), isReactDOM && (_this._updateScroll = _this._updateScroll.bind(_this), |
|
window.addEventListener("scroll", _this._onScroll.bind(_this), !0), window.addEventListener("click", _this._onClick.bind(_this), !0), |
|
window.addEventListener("mouseover", _this._onMouseOver.bind(_this), !0), window.addEventListener("resize", _this._onResize.bind(_this), !0)), |
|
_this; |
|
} |
|
return _inherits(Agent, _EventEmitter), _createClass(Agent, [ { |
|
key: "sub", |
|
value: function(ev, fn) { |
|
var _this2 = this; |
|
return this.on(ev, fn), function() { |
|
_this2.removeListener(ev, fn); |
|
}; |
|
} |
|
}, { |
|
key: "setReactInternals", |
|
value: function(renderer, reactInternals) { |
|
this.reactInternals[renderer] = reactInternals; |
|
} |
|
}, { |
|
key: "addBridge", |
|
value: function(bridge) { |
|
var _this3 = this; |
|
bridge.on("requestCapabilities", function() { |
|
bridge.send("capabilities", _this3.capabilities), _this3.emit("connected"); |
|
}), bridge.on("setState", this._setState.bind(this)), bridge.on("setProps", this._setProps.bind(this)), |
|
bridge.on("setContext", this._setContext.bind(this)), bridge.on("makeGlobal", this._makeGlobal.bind(this)), |
|
bridge.on("highlight", function(id) { |
|
return _this3.highlight(id); |
|
}), bridge.on("highlightMany", function(id) { |
|
return _this3.highlightMany(id); |
|
}), bridge.on("hideHighlight", function() { |
|
return _this3.emit("hideHighlight"); |
|
}), bridge.on("startInspecting", function() { |
|
return _this3.emit("startInspecting"); |
|
}), bridge.on("stopInspecting", function() { |
|
return _this3.emit("stopInspecting"); |
|
}), bridge.on("selected", function(id) { |
|
return _this3.emit("selected", id); |
|
}), bridge.on("setInspectEnabled", function(enabled) { |
|
_this3._inspectEnabled = enabled, _this3.emit("stopInspecting"); |
|
}), bridge.on("shutdown", function() { |
|
return _this3.emit("shutdown"); |
|
}), bridge.on("changeTextContent", function(_ref) { |
|
var id = _ref.id, text = _ref.text, node = _this3.getNodeForID(id); |
|
node && (node.textContent = text); |
|
}), bridge.on("putSelectedNode", function(id) { |
|
window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node = _this3.getNodeForID(id); |
|
}), bridge.on("putSelectedInstance", function(id) { |
|
var node = _this3.elementData.get(id); |
|
node ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = node.type : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = null, |
|
node && node.publicInstance ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = node.publicInstance : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = null; |
|
}), bridge.on("checkSelection", function() { |
|
var newSelected = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0; |
|
if (newSelected !== _this3._prevSelected) { |
|
_this3._prevSelected = newSelected; |
|
var sentSelected = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node; |
|
newSelected !== sentSelected && _this3.selectFromDOMNode(newSelected, !0); |
|
} |
|
}), bridge.on("scrollToNode", function(id) { |
|
return _this3.scrollToNode(id); |
|
}), bridge.on("traceupdatesstatechange", function(value) { |
|
return _this3.emit("traceupdatesstatechange", value); |
|
}), bridge.on("colorizerchange", function(value) { |
|
return _this3.emit("colorizerchange", value); |
|
}), this.on("root", function(id) { |
|
return bridge.send("root", id); |
|
}), this.on("mount", function(data) { |
|
return bridge.send("mount", data); |
|
}), this.on("update", function(data) { |
|
return bridge.send("update", data); |
|
}), this.on("unmount", function(id) { |
|
bridge.send("unmount", id), bridge.forget(id); |
|
}), this.on("setSelection", function(data) { |
|
return bridge.send("select", data); |
|
}), this.on("setInspectEnabled", function(data) { |
|
return bridge.send("setInspectEnabled", data); |
|
}); |
|
} |
|
}, { |
|
key: "scrollToNode", |
|
value: function(id) { |
|
var node = this.getNodeForID(id); |
|
if (!node) return void console.warn("unable to get the node for scrolling"); |
|
var domElement = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement; |
|
return domElement ? ("function" == typeof domElement.scrollIntoViewIfNeeded ? domElement.scrollIntoViewIfNeeded() : "function" == typeof domElement.scrollIntoView && domElement.scrollIntoView(), |
|
void this.highlight(id)) : void console.warn("unable to get the domElement for scrolling"); |
|
} |
|
}, { |
|
key: "highlight", |
|
value: function(id) { |
|
var data = this.elementData.get(id), node = this.getNodeForID(id); |
|
data && node && this.emit("highlight", { |
|
node: node, |
|
name: data.name, |
|
props: data.props |
|
}); |
|
} |
|
}, { |
|
key: "highlightMany", |
|
value: function(ids) { |
|
var _this4 = this, nodes = []; |
|
ids.forEach(function(id) { |
|
var node = _this4.getNodeForID(id); |
|
node && nodes.push(node); |
|
}), nodes.length && this.emit("highlightMany", nodes); |
|
} |
|
}, { |
|
key: "getNodeForID", |
|
value: function(id) { |
|
var component = this.internalInstancesById.get(id); |
|
if (!component) return null; |
|
var renderer = this.renderers.get(id); |
|
return renderer && this.reactInternals[renderer].getNativeFromReactElement ? this.reactInternals[renderer].getNativeFromReactElement(component) : null; |
|
} |
|
}, { |
|
key: "selectFromDOMNode", |
|
value: function(node, quiet) { |
|
var offsetFromLeaf = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0, id = this.getIDForNode(node); |
|
id && this.emit("setSelection", { |
|
id: id, |
|
quiet: quiet, |
|
offsetFromLeaf: offsetFromLeaf |
|
}); |
|
} |
|
}, { |
|
key: "selectFromReactInstance", |
|
value: function(instance, quiet) { |
|
var id = this.getId(instance); |
|
return id ? void this.emit("setSelection", { |
|
id: id, |
|
quiet: quiet |
|
}) : void console.log("no instance id", instance); |
|
} |
|
}, { |
|
key: "getIDForNode", |
|
value: function(node) { |
|
if (!this.reactInternals) return null; |
|
var component; |
|
for (var renderer in this.reactInternals) { |
|
try { |
|
component = this.reactInternals[renderer].getReactElementFromNative(node); |
|
} catch (e) {} |
|
if (component) return this.getId(component); |
|
} |
|
return null; |
|
} |
|
}, { |
|
key: "_setProps", |
|
value: function(_ref2) { |
|
var id = _ref2.id, path = _ref2.path, value = _ref2.value, data = this.elementData.get(id); |
|
data && data.updater && data.updater.setInProps ? data.updater.setInProps(path, value) : console.warn("trying to set props on a component that doesn't support it"); |
|
} |
|
}, { |
|
key: "_setState", |
|
value: function(_ref3) { |
|
var id = _ref3.id, path = _ref3.path, value = _ref3.value, data = this.elementData.get(id); |
|
data && data.updater && data.updater.setInState ? data.updater.setInState(path, value) : console.warn("trying to set state on a component that doesn't support it"); |
|
} |
|
}, { |
|
key: "_setContext", |
|
value: function(_ref4) { |
|
var id = _ref4.id, path = _ref4.path, value = _ref4.value, data = this.elementData.get(id); |
|
data && data.updater && data.updater.setInContext ? data.updater.setInContext(path, value) : console.warn("trying to set context on a component that doesn't support it"); |
|
} |
|
}, { |
|
key: "_makeGlobal", |
|
value: function(_ref5) { |
|
var id = _ref5.id, path = _ref5.path, data = this.elementData.get(id); |
|
if (data) { |
|
var value; |
|
value = "instance" === path ? data.publicInstance : getIn(data, path), this.global.$tmp = value, |
|
console.log("$tmp =", value); |
|
} |
|
} |
|
}, { |
|
key: "getId", |
|
value: function(internalInstance) { |
|
return "object" === ("undefined" == typeof internalInstance ? "undefined" : _typeof(internalInstance)) && internalInstance ? (this.idsByInternalInstances.has(internalInstance) || (this.idsByInternalInstances.set(internalInstance, guid()), |
|
this.internalInstancesById.set(this.idsByInternalInstances.get(internalInstance), internalInstance)), |
|
this.idsByInternalInstances.get(internalInstance)) : internalInstance; |
|
} |
|
}, { |
|
key: "addRoot", |
|
value: function(renderer, internalInstance) { |
|
var id = this.getId(internalInstance); |
|
this.roots.add(id), this.emit("root", id); |
|
} |
|
}, { |
|
key: "onMounted", |
|
value: function(renderer, component, data) { |
|
var _this5 = this, id = this.getId(component); |
|
this.renderers.set(id, renderer), this.elementData.set(id, data); |
|
var send = assign({}, data); |
|
send.children && send.children.map && (send.children = send.children.map(function(c) { |
|
return _this5.getId(c); |
|
})), send.id = id, send.canUpdate = send.updater && !!send.updater.forceUpdate, |
|
delete send.type, delete send.updater, this.emit("mount", send); |
|
} |
|
}, { |
|
key: "onUpdated", |
|
value: function(component, data) { |
|
var _this6 = this, id = this.getId(component); |
|
this.elementData.set(id, data); |
|
var send = assign({}, data); |
|
send.children && send.children.map && (send.children = send.children.map(function(c) { |
|
return _this6.getId(c); |
|
})), send.id = id, send.canUpdate = send.updater && !!send.updater.forceUpdate, |
|
delete send.type, delete send.updater, this.emit("update", send); |
|
} |
|
}, { |
|
key: "onUnmounted", |
|
value: function(component) { |
|
var id = this.getId(component); |
|
this.elementData["delete"](id), this.roots["delete"](id), this.renderers["delete"](id), |
|
this.emit("unmount", id), this.idsByInternalInstances["delete"](component); |
|
} |
|
}, { |
|
key: "_onScroll", |
|
value: function() { |
|
this._scrollUpdate || (this._scrollUpdate = !0, window.requestAnimationFrame(this._updateScroll)); |
|
} |
|
}, { |
|
key: "_updateScroll", |
|
value: function() { |
|
this.emit("refreshMultiOverlay"), this.emit("stopInspecting"), this._scrollUpdate = !1; |
|
} |
|
}, { |
|
key: "_onClick", |
|
value: function(event) { |
|
if (this._inspectEnabled) { |
|
var id = this.getIDForNode(event.target); |
|
id && (event.stopPropagation(), event.preventDefault(), this.emit("setSelection", { |
|
id: id |
|
}), this.emit("setInspectEnabled", !1)); |
|
} |
|
} |
|
}, { |
|
key: "_onMouseOver", |
|
value: function(event) { |
|
if (this._inspectEnabled) { |
|
var id = this.getIDForNode(event.target); |
|
if (!id) return; |
|
this.highlight(id); |
|
} |
|
} |
|
}, { |
|
key: "_onResize", |
|
value: function(event) { |
|
this.emit("stopInspecting"); |
|
} |
|
} ]), Agent; |
|
}(EventEmitter); |
|
module.exports = Agent; |
|
}, function(module, exports) { |
|
function EventEmitter() { |
|
this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0; |
|
} |
|
function isFunction(arg) { |
|
return "function" == typeof arg; |
|
} |
|
function isNumber(arg) { |
|
return "number" == typeof arg; |
|
} |
|
function isObject(arg) { |
|
return "object" == typeof arg && null !== arg; |
|
} |
|
function isUndefined(arg) { |
|
return void 0 === arg; |
|
} |
|
module.exports = EventEmitter, EventEmitter.EventEmitter = EventEmitter, EventEmitter.prototype._events = void 0, |
|
EventEmitter.prototype._maxListeners = void 0, EventEmitter.defaultMaxListeners = 10, |
|
EventEmitter.prototype.setMaxListeners = function(n) { |
|
if (!isNumber(n) || n < 0 || isNaN(n)) throw TypeError("n must be a positive number"); |
|
return this._maxListeners = n, this; |
|
}, EventEmitter.prototype.emit = function(type) { |
|
var er, handler, len, args, i, listeners; |
|
if (this._events || (this._events = {}), "error" === type && (!this._events.error || isObject(this._events.error) && !this._events.error.length)) { |
|
if (er = arguments[1], er instanceof Error) throw er; |
|
var err = new Error('Uncaught, unspecified "error" event. (' + er + ")"); |
|
throw err.context = er, err; |
|
} |
|
if (handler = this._events[type], isUndefined(handler)) return !1; |
|
if (isFunction(handler)) switch (arguments.length) { |
|
case 1: |
|
handler.call(this); |
|
break; |
|
|
|
case 2: |
|
handler.call(this, arguments[1]); |
|
break; |
|
|
|
case 3: |
|
handler.call(this, arguments[1], arguments[2]); |
|
break; |
|
|
|
default: |
|
args = Array.prototype.slice.call(arguments, 1), handler.apply(this, args); |
|
} else if (isObject(handler)) for (args = Array.prototype.slice.call(arguments, 1), |
|
listeners = handler.slice(), len = listeners.length, i = 0; i < len; i++) listeners[i].apply(this, args); |
|
return !0; |
|
}, EventEmitter.prototype.addListener = function(type, listener) { |
|
var m; |
|
if (!isFunction(listener)) throw TypeError("listener must be a function"); |
|
return this._events || (this._events = {}), this._events.newListener && this.emit("newListener", type, isFunction(listener.listener) ? listener.listener : listener), |
|
this._events[type] ? isObject(this._events[type]) ? this._events[type].push(listener) : this._events[type] = [ this._events[type], listener ] : this._events[type] = listener, |
|
isObject(this._events[type]) && !this._events[type].warned && (m = isUndefined(this._maxListeners) ? EventEmitter.defaultMaxListeners : this._maxListeners, |
|
m && m > 0 && this._events[type].length > m && (this._events[type].warned = !0, |
|
console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.", this._events[type].length), |
|
"function" == typeof console.trace && console.trace())), this; |
|
}, EventEmitter.prototype.on = EventEmitter.prototype.addListener, EventEmitter.prototype.once = function(type, listener) { |
|
function g() { |
|
this.removeListener(type, g), fired || (fired = !0, listener.apply(this, arguments)); |
|
} |
|
if (!isFunction(listener)) throw TypeError("listener must be a function"); |
|
var fired = !1; |
|
return g.listener = listener, this.on(type, g), this; |
|
}, EventEmitter.prototype.removeListener = function(type, listener) { |
|
var list, position, length, i; |
|
if (!isFunction(listener)) throw TypeError("listener must be a function"); |
|
if (!this._events || !this._events[type]) return this; |
|
if (list = this._events[type], length = list.length, position = -1, list === listener || isFunction(list.listener) && list.listener === listener) delete this._events[type], |
|
this._events.removeListener && this.emit("removeListener", type, listener); else if (isObject(list)) { |
|
for (i = length; i-- > 0; ) if (list[i] === listener || list[i].listener && list[i].listener === listener) { |
|
position = i; |
|
break; |
|
} |
|
if (position < 0) return this; |
|
1 === list.length ? (list.length = 0, delete this._events[type]) : list.splice(position, 1), |
|
this._events.removeListener && this.emit("removeListener", type, listener); |
|
} |
|
return this; |
|
}, EventEmitter.prototype.removeAllListeners = function(type) { |
|
var key, listeners; |
|
if (!this._events) return this; |
|
if (!this._events.removeListener) return 0 === arguments.length ? this._events = {} : this._events[type] && delete this._events[type], |
|
this; |
|
if (0 === arguments.length) { |
|
for (key in this._events) "removeListener" !== key && this.removeAllListeners(key); |
|
return this.removeAllListeners("removeListener"), this._events = {}, this; |
|
} |
|
if (listeners = this._events[type], isFunction(listeners)) this.removeListener(type, listeners); else if (listeners) for (;listeners.length; ) this.removeListener(type, listeners[listeners.length - 1]); |
|
return delete this._events[type], this; |
|
}, EventEmitter.prototype.listeners = function(type) { |
|
var ret; |
|
return ret = this._events && this._events[type] ? isFunction(this._events[type]) ? [ this._events[type] ] : this._events[type].slice() : []; |
|
}, EventEmitter.prototype.listenerCount = function(type) { |
|
if (this._events) { |
|
var evlistener = this._events[type]; |
|
if (isFunction(evlistener)) return 1; |
|
if (evlistener) return evlistener.length; |
|
} |
|
return 0; |
|
}, EventEmitter.listenerCount = function(emitter, type) { |
|
return emitter.listenerCount(type); |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function toObject(val) { |
|
if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined"); |
|
return Object(val); |
|
} |
|
var hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable; |
|
module.exports = Object.assign || function(target, source) { |
|
for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) { |
|
from = Object(arguments[s]); |
|
for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]); |
|
if (Object.getOwnPropertySymbols) { |
|
symbols = Object.getOwnPropertySymbols(from); |
|
for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]); |
|
} |
|
} |
|
return to; |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function guid() { |
|
return "g" + Math.random().toString(16).substr(2); |
|
} |
|
module.exports = guid; |
|
}, function(module, exports) { |
|
"use strict"; |
|
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; |
|
} |
|
return Array.from(arr); |
|
} |
|
function getIn(base, path) { |
|
return path.reduce(function(obj, attr) { |
|
if (obj) { |
|
if (obj.hasOwnProperty(attr)) return obj[attr]; |
|
if ("function" == typeof obj[Symbol.iterator]) return [].concat(_toConsumableArray(obj))[attr]; |
|
} |
|
return null; |
|
}, base); |
|
} |
|
module.exports = getIn; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
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; |
|
} |
|
return Array.from(arr); |
|
} |
|
function _classCallCheck(instance, Constructor) { |
|
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); |
|
} |
|
function getWindowFunction(name, polyfill) { |
|
return String(window[name]).indexOf("[native code]") === -1 ? polyfill : window[name]; |
|
} |
|
var _extends = Object.assign || function(target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i]; |
|
for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); |
|
} |
|
return target; |
|
}, _createClass = function() { |
|
function defineProperties(target, props) { |
|
for (var i = 0; i < props.length; i++) { |
|
var descriptor = props[i]; |
|
descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, |
|
"value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); |
|
} |
|
} |
|
return function(Constructor, protoProps, staticProps) { |
|
return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), |
|
Constructor; |
|
}; |
|
}(), consts = __webpack_require__(7), hydrate = __webpack_require__(26), dehydrate = __webpack_require__(27), getIn = __webpack_require__(5), performanceNow = __webpack_require__(28), lastRunTimeMS = 5, cancelIdleCallback = getWindowFunction("cancelIdleCallback", clearTimeout), requestIdleCallback = getWindowFunction("requestIdleCallback", function(cb, options) { |
|
var delayMS = 3e3 * lastRunTimeMS; |
|
return delayMS > 500 && (delayMS = 500), setTimeout(function() { |
|
var startTime = performanceNow(); |
|
cb({ |
|
didTimeout: !1, |
|
timeRemaining: function() { |
|
return 1 / 0; |
|
} |
|
}); |
|
var endTime = performanceNow(); |
|
lastRunTimeMS = (endTime - startTime) / 1e3; |
|
}, delayMS); |
|
}), Bridge = function() { |
|
function Bridge(wall) { |
|
_classCallCheck(this, Bridge), this._cbs = new Map(), this._inspectables = new Map(), |
|
this._cid = 0, this._listeners = {}, this._buffer = [], this._flushHandle = null, |
|
this._callers = {}, this._paused = !1, this._wall = wall, wall.listen(this._handleMessage.bind(this)); |
|
} |
|
return _createClass(Bridge, [ { |
|
key: "inspect", |
|
value: function(id, path, cb) { |
|
var _cid = this._cid++; |
|
this._cbs.set(_cid, function(data, cleaned, proto, protoclean) { |
|
cleaned.length && hydrate(data, cleaned), proto && protoclean.length && hydrate(proto, protoclean), |
|
proto && (data[consts.proto] = proto), cb(data); |
|
}), this._wall.send({ |
|
type: "inspect", |
|
callback: _cid, |
|
path: path, |
|
id: id |
|
}); |
|
} |
|
}, { |
|
key: "call", |
|
value: function(name, args, cb) { |
|
var _cid = this._cid++; |
|
this._cbs.set(_cid, cb), this._wall.send({ |
|
type: "call", |
|
callback: _cid, |
|
args: args, |
|
name: name |
|
}); |
|
} |
|
}, { |
|
key: "onCall", |
|
value: function(name, handler) { |
|
if (this._callers[name]) throw new Error("only one call handler per call name allowed"); |
|
this._callers[name] = handler; |
|
} |
|
}, { |
|
key: "pause", |
|
value: function() { |
|
this._wall.send({ |
|
type: "pause" |
|
}); |
|
} |
|
}, { |
|
key: "resume", |
|
value: function() { |
|
this._wall.send({ |
|
type: "resume" |
|
}); |
|
} |
|
}, { |
|
key: "setInspectable", |
|
value: function(id, data) { |
|
var prev = this._inspectables.get(id); |
|
return prev ? void this._inspectables.set(id, _extends({}, prev, data)) : void this._inspectables.set(id, data); |
|
} |
|
}, { |
|
key: "send", |
|
value: function(evt, data) { |
|
this._buffer.push({ |
|
evt: evt, |
|
data: data |
|
}), this.scheduleFlush(); |
|
} |
|
}, { |
|
key: "scheduleFlush", |
|
value: function() { |
|
if (!this._flushHandle && this._buffer.length) { |
|
var timeout = this._paused ? 5e3 : 500; |
|
this._flushHandle = requestIdleCallback(this.flushBufferWhileIdle.bind(this), { |
|
timeout: timeout |
|
}); |
|
} |
|
} |
|
}, { |
|
key: "cancelFlush", |
|
value: function() { |
|
this._flushHandle && (cancelIdleCallback(this._flushHandle), this._flushHandle = null); |
|
} |
|
}, { |
|
key: "flushBufferWhileIdle", |
|
value: function(deadline) { |
|
this._flushHandle = null; |
|
for (var chunkCount = this._paused ? 20 : 10, chunkSize = Math.round(this._buffer.length / chunkCount), minChunkSize = this._paused ? 50 : 100; this._buffer.length && (deadline.timeRemaining() > 0 || deadline.didTimeout); ) { |
|
var take = Math.min(this._buffer.length, Math.max(minChunkSize, chunkSize)), currentBuffer = this._buffer.splice(0, take); |
|
this.flushBufferSlice(currentBuffer); |
|
} |
|
this._buffer.length && this.scheduleFlush(); |
|
} |
|
}, { |
|
key: "flushBufferSlice", |
|
value: function(bufferSlice) { |
|
var _this = this, events = bufferSlice.map(function(_ref) { |
|
var evt = _ref.evt, data = _ref.data, cleaned = [], san = dehydrate(data, cleaned); |
|
return cleaned.length && _this.setInspectable(data.id, data), { |
|
type: "event", |
|
evt: evt, |
|
data: san, |
|
cleaned: cleaned |
|
}; |
|
}); |
|
this._wall.send({ |
|
type: "many-events", |
|
events: events |
|
}); |
|
} |
|
}, { |
|
key: "forget", |
|
value: function(id) { |
|
this._inspectables["delete"](id); |
|
} |
|
}, { |
|
key: "on", |
|
value: function(evt, fn) { |
|
this._listeners[evt] ? this._listeners[evt].push(fn) : this._listeners[evt] = [ fn ]; |
|
} |
|
}, { |
|
key: "off", |
|
value: function(evt, fn) { |
|
if (this._listeners[evt]) { |
|
var ix = this._listeners[evt].indexOf(fn); |
|
ix !== -1 && this._listeners[evt].splice(ix, 1); |
|
} |
|
} |
|
}, { |
|
key: "once", |
|
value: function(evt, fn) { |
|
var self = this, listener = function listener() { |
|
fn.apply(this, arguments), self.off(evt, listener); |
|
}; |
|
this.on(evt, listener); |
|
} |
|
}, { |
|
key: "_handleMessage", |
|
value: function(payload) { |
|
var _this2 = this; |
|
if ("resume" === payload.type) return this._paused = !1, void this.scheduleFlush(); |
|
if ("pause" === payload.type) return this._paused = !0, void this.cancelFlush(); |
|
if ("callback" === payload.type) { |
|
var callback = this._cbs.get(payload.id); |
|
return void (callback && (callback.apply(void 0, _toConsumableArray(payload.args)), |
|
this._cbs["delete"](payload.id))); |
|
} |
|
if ("call" === payload.type) return void this._handleCall(payload.name, payload.args, payload.callback); |
|
if ("inspect" === payload.type) return void this._inspectResponse(payload.id, payload.path, payload.callback); |
|
if ("event" === payload.type) { |
|
payload.cleaned && hydrate(payload.data, payload.cleaned); |
|
var fns = this._listeners[payload.evt], data = payload.data; |
|
fns && fns.forEach(function(fn) { |
|
return fn(data); |
|
}); |
|
} |
|
"many-events" === payload.type && payload.events.forEach(function(event) { |
|
event.cleaned && hydrate(event.data, event.cleaned); |
|
var handlers = _this2._listeners[event.evt]; |
|
handlers && handlers.forEach(function(fn) { |
|
return fn(event.data); |
|
}); |
|
}); |
|
} |
|
}, { |
|
key: "_handleCall", |
|
value: function(name, args, callback) { |
|
if (!this._callers[name]) return void console.warn('unknown call: "' + name + '"'); |
|
args = Array.isArray(args) ? args : [ args ]; |
|
var result; |
|
try { |
|
result = this._callers[name].apply(null, args); |
|
} catch (e) { |
|
return void console.error("Failed to call", e); |
|
} |
|
this._wall.send({ |
|
type: "callback", |
|
id: callback, |
|
args: [ result ] |
|
}); |
|
} |
|
}, { |
|
key: "_inspectResponse", |
|
value: function(id, path, callback) { |
|
var inspectable = this._inspectables.get(id), result = {}, cleaned = [], proto = null, protoclean = []; |
|
if (inspectable) { |
|
var val = getIn(inspectable, path), protod = !1, isFn = "function" == typeof val; |
|
if (val && "function" == typeof val[Symbol.iterator]) { |
|
var iterVal = Object.create({}), count = 0, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0; |
|
try { |
|
for (var _step, _iterator = val[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) { |
|
var entry = _step.value; |
|
if (count > 100) break; |
|
iterVal[count] = entry, count++; |
|
} |
|
} catch (err) { |
|
_didIteratorError = !0, _iteratorError = err; |
|
} finally { |
|
try { |
|
!_iteratorNormalCompletion && _iterator["return"] && _iterator["return"](); |
|
} finally { |
|
if (_didIteratorError) throw _iteratorError; |
|
} |
|
} |
|
val = iterVal; |
|
} |
|
if (Object.getOwnPropertyNames(val).forEach(function(name) { |
|
"__proto__" === name && (protod = !0), (!isFn || "arguments" !== name && "callee" !== name && "caller" !== name) && (result[name] = dehydrate(val[name], cleaned, [ name ])); |
|
}), !protod && val.__proto__ && "Object" !== val.constructor.name) { |
|
var newProto = {}, pIsFn = "function" == typeof val.__proto__; |
|
Object.getOwnPropertyNames(val.__proto__).forEach(function(name) { |
|
(!pIsFn || "arguments" !== name && "callee" !== name && "caller" !== name) && (newProto[name] = dehydrate(val.__proto__[name], protoclean, [ name ])); |
|
}), proto = newProto; |
|
} |
|
} |
|
this._wall.send({ |
|
type: "callback", |
|
id: callback, |
|
args: [ result, cleaned, proto, protoclean ] |
|
}); |
|
} |
|
} ]), Bridge; |
|
}(); |
|
module.exports = Bridge; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var _Symbol = __webpack_require__(8); |
|
module.exports = { |
|
name: _Symbol("name"), |
|
type: _Symbol("type"), |
|
inspected: _Symbol("inspected"), |
|
meta: _Symbol("meta"), |
|
proto: _Symbol("proto") |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
module.exports = __webpack_require__(9)() ? Symbol : __webpack_require__(10); |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = function() { |
|
var symbol; |
|
if ("function" != typeof Symbol) return !1; |
|
symbol = Symbol("test symbol"); |
|
try { |
|
String(symbol); |
|
} catch (e) { |
|
return !1; |
|
} |
|
return "symbol" == typeof Symbol.iterator || "object" == typeof Symbol.isConcatSpreadable && ("object" == typeof Symbol.iterator && ("object" == typeof Symbol.toPrimitive && ("object" == typeof Symbol.toStringTag && "object" == typeof Symbol.unscopables))); |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var NativeSymbol, SymbolPolyfill, HiddenSymbol, d = __webpack_require__(11), validateSymbol = __webpack_require__(24), create = Object.create, defineProperties = Object.defineProperties, defineProperty = Object.defineProperty, objPrototype = Object.prototype, globalSymbols = create(null); |
|
"function" == typeof Symbol && (NativeSymbol = Symbol); |
|
var generateName = function() { |
|
var created = create(null); |
|
return function(desc) { |
|
for (var name, ie11BugWorkaround, postfix = 0; created[desc + (postfix || "")]; ) ++postfix; |
|
return desc += postfix || "", created[desc] = !0, name = "@@" + desc, defineProperty(objPrototype, name, d.gs(null, function(value) { |
|
ie11BugWorkaround || (ie11BugWorkaround = !0, defineProperty(this, name, d(value)), |
|
ie11BugWorkaround = !1); |
|
})), name; |
|
}; |
|
}(); |
|
HiddenSymbol = function(description) { |
|
if (this instanceof HiddenSymbol) throw new TypeError("TypeError: Symbol is not a constructor"); |
|
return SymbolPolyfill(description); |
|
}, module.exports = SymbolPolyfill = function Symbol(description) { |
|
var symbol; |
|
if (this instanceof Symbol) throw new TypeError("TypeError: Symbol is not a constructor"); |
|
return symbol = create(HiddenSymbol.prototype), description = void 0 === description ? "" : String(description), |
|
defineProperties(symbol, { |
|
__description__: d("", description), |
|
__name__: d("", generateName(description)) |
|
}); |
|
}, defineProperties(SymbolPolyfill, { |
|
"for": d(function(key) { |
|
return globalSymbols[key] ? globalSymbols[key] : globalSymbols[key] = SymbolPolyfill(String(key)); |
|
}), |
|
keyFor: d(function(s) { |
|
var key; |
|
validateSymbol(s); |
|
for (key in globalSymbols) if (globalSymbols[key] === s) return key; |
|
}), |
|
hasInstance: d("", NativeSymbol && NativeSymbol.hasInstance || SymbolPolyfill("hasInstance")), |
|
isConcatSpreadable: d("", NativeSymbol && NativeSymbol.isConcatSpreadable || SymbolPolyfill("isConcatSpreadable")), |
|
iterator: d("", NativeSymbol && NativeSymbol.iterator || SymbolPolyfill("iterator")), |
|
match: d("", NativeSymbol && NativeSymbol.match || SymbolPolyfill("match")), |
|
replace: d("", NativeSymbol && NativeSymbol.replace || SymbolPolyfill("replace")), |
|
search: d("", NativeSymbol && NativeSymbol.search || SymbolPolyfill("search")), |
|
species: d("", NativeSymbol && NativeSymbol.species || SymbolPolyfill("species")), |
|
split: d("", NativeSymbol && NativeSymbol.split || SymbolPolyfill("split")), |
|
toPrimitive: d("", NativeSymbol && NativeSymbol.toPrimitive || SymbolPolyfill("toPrimitive")), |
|
toStringTag: d("", NativeSymbol && NativeSymbol.toStringTag || SymbolPolyfill("toStringTag")), |
|
unscopables: d("", NativeSymbol && NativeSymbol.unscopables || SymbolPolyfill("unscopables")) |
|
}), defineProperties(HiddenSymbol.prototype, { |
|
constructor: d(SymbolPolyfill), |
|
toString: d("", function() { |
|
return this.__name__; |
|
}) |
|
}), defineProperties(SymbolPolyfill.prototype, { |
|
toString: d(function() { |
|
return "Symbol (" + validateSymbol(this).__description__ + ")"; |
|
}), |
|
valueOf: d(function() { |
|
return validateSymbol(this); |
|
}) |
|
}), defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d("", function() { |
|
return validateSymbol(this); |
|
})), defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d("c", "Symbol")), |
|
defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag, d("c", SymbolPolyfill.prototype[SymbolPolyfill.toStringTag])), |
|
defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive, d("c", SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive])); |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var d, assign = __webpack_require__(12), normalizeOpts = __webpack_require__(19), isCallable = __webpack_require__(20), contains = __webpack_require__(21); |
|
d = module.exports = function(dscr, value) { |
|
var c, e, w, options, desc; |
|
return arguments.length < 2 || "string" != typeof dscr ? (options = value, value = dscr, |
|
dscr = null) : options = arguments[2], null == dscr ? (c = w = !0, e = !1) : (c = contains.call(dscr, "c"), |
|
e = contains.call(dscr, "e"), w = contains.call(dscr, "w")), desc = { |
|
value: value, |
|
configurable: c, |
|
enumerable: e, |
|
writable: w |
|
}, options ? assign(normalizeOpts(options), desc) : desc; |
|
}, d.gs = function(dscr, get, set) { |
|
var c, e, options, desc; |
|
return "string" != typeof dscr ? (options = set, set = get, get = dscr, dscr = null) : options = arguments[3], |
|
null == get ? get = void 0 : isCallable(get) ? null == set ? set = void 0 : isCallable(set) || (options = set, |
|
set = void 0) : (options = get, get = set = void 0), null == dscr ? (c = !0, e = !1) : (c = contains.call(dscr, "c"), |
|
e = contains.call(dscr, "e")), desc = { |
|
get: get, |
|
set: set, |
|
configurable: c, |
|
enumerable: e |
|
}, options ? assign(normalizeOpts(options), desc) : desc; |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
module.exports = __webpack_require__(13)() ? Object.assign : __webpack_require__(14); |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = function() { |
|
var obj, assign = Object.assign; |
|
return "function" == typeof assign && (obj = { |
|
foo: "raz" |
|
}, assign(obj, { |
|
bar: "dwa" |
|
}, { |
|
trzy: "trzy" |
|
}), obj.foo + obj.bar + obj.trzy === "razdwatrzy"); |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var keys = __webpack_require__(15), value = __webpack_require__(18), max = Math.max; |
|
module.exports = function(dest, src) { |
|
var error, i, assign, l = max(arguments.length, 2); |
|
for (dest = Object(value(dest)), assign = function(key) { |
|
try { |
|
dest[key] = src[key]; |
|
} catch (e) { |
|
error || (error = e); |
|
} |
|
}, i = 1; i < l; ++i) src = arguments[i], keys(src).forEach(assign); |
|
if (void 0 !== error) throw error; |
|
return dest; |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
module.exports = __webpack_require__(16)() ? Object.keys : __webpack_require__(17); |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = function() { |
|
try { |
|
return Object.keys("primitive"), !0; |
|
} catch (e) { |
|
return !1; |
|
} |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
var keys = Object.keys; |
|
module.exports = function(object) { |
|
return keys(null == object ? object : Object(object)); |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = function(value) { |
|
if (null == value) throw new TypeError("Cannot use null or undefined"); |
|
return value; |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
var forEach = Array.prototype.forEach, create = Object.create, process = function(src, obj) { |
|
var key; |
|
for (key in src) obj[key] = src[key]; |
|
}; |
|
module.exports = function(options) { |
|
var result = create(null); |
|
return forEach.call(arguments, function(options) { |
|
null != options && process(Object(options), result); |
|
}), result; |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = function(obj) { |
|
return "function" == typeof obj; |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
module.exports = __webpack_require__(22)() ? String.prototype.contains : __webpack_require__(23); |
|
}, function(module, exports) { |
|
"use strict"; |
|
var str = "razdwatrzy"; |
|
module.exports = function() { |
|
return "function" == typeof str.contains && (str.contains("dwa") === !0 && str.contains("foo") === !1); |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
var indexOf = String.prototype.indexOf; |
|
module.exports = function(searchString) { |
|
return indexOf.call(this, searchString, arguments[1]) > -1; |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var isSymbol = __webpack_require__(25); |
|
module.exports = function(value) { |
|
if (!isSymbol(value)) throw new TypeError(value + " is not a symbol"); |
|
return value; |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = function(x) { |
|
return x && ("symbol" == typeof x || "Symbol" === x["@@toStringTag"]) || !1; |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function hydrate(data, cleaned) { |
|
cleaned.forEach(function(path) { |
|
var last = path.pop(), obj = path.reduce(function(obj_, attr) { |
|
return obj_ ? obj_[attr] : null; |
|
}, data); |
|
if (obj && obj[last]) { |
|
var replace = {}; |
|
replace[consts.name] = obj[last].name, replace[consts.type] = obj[last].type, replace[consts.meta] = obj[last].meta, |
|
replace[consts.inspected] = !1, obj[last] = replace; |
|
} |
|
}); |
|
} |
|
var consts = __webpack_require__(7); |
|
module.exports = hydrate; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function getPropType(data) { |
|
if (!data) return null; |
|
var type = "undefined" == typeof data ? "undefined" : _typeof(data); |
|
if ("object" === type) { |
|
if (data._reactFragment) return "react_fragment"; |
|
if (Array.isArray(data)) return "array"; |
|
if (ArrayBuffer.isView(data)) return data instanceof DataView ? "data_view" : "typed_array"; |
|
if (data instanceof ArrayBuffer) return "array_buffer"; |
|
if ("function" == typeof data[Symbol.iterator]) return "iterator"; |
|
if ("[object Date]" === Object.prototype.toString.call(data)) return "date"; |
|
} |
|
return type; |
|
} |
|
function createDehydrated(type, data, cleaned, path) { |
|
var meta = {}; |
|
return "array" !== type && "typed_array" !== type || (meta.length = data.length), |
|
"iterator" !== type && "typed_array" !== type || (meta.readOnly = !0), cleaned.push(path), |
|
{ |
|
type: type, |
|
meta: meta, |
|
name: data.constructor && "Object" !== data.constructor.name ? data.constructor.name : "" |
|
}; |
|
} |
|
function dehydrate(data, cleaned) { |
|
var path = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [], level = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0, type = getPropType(data); |
|
switch (type) { |
|
case "function": |
|
return cleaned.push(path), { |
|
name: data.name, |
|
type: "function" |
|
}; |
|
|
|
case "string": |
|
return data.length <= 500 ? data : data.slice(0, 500) + "..."; |
|
|
|
case "symbol": |
|
return cleaned.push(path), { |
|
type: "symbol", |
|
name: data.toString() |
|
}; |
|
|
|
case "react_fragment": |
|
return "A React Fragment"; |
|
|
|
case "array_buffer": |
|
case "data_view": |
|
return cleaned.push(path), { |
|
type: type, |
|
name: "data_view" === type ? "DataView" : "ArrayBuffer", |
|
meta: { |
|
length: data.byteLength, |
|
uninspectable: !0 |
|
} |
|
}; |
|
|
|
case "array": |
|
return level > 2 ? createDehydrated(type, data, cleaned, path) : data.map(function(item, i) { |
|
return dehydrate(item, cleaned, path.concat([ i ]), level + 1); |
|
}); |
|
|
|
case "typed_array": |
|
case "iterator": |
|
return createDehydrated(type, data, cleaned, path); |
|
|
|
case "date": |
|
return cleaned.push(path), { |
|
name: data.toString(), |
|
type: "date", |
|
meta: { |
|
uninspectable: !0 |
|
} |
|
}; |
|
|
|
case "object": |
|
if (level > 2 || data.constructor && "function" == typeof data.constructor && "Object" !== data.constructor.name) return createDehydrated(type, data, cleaned, path); |
|
var res = {}; |
|
for (var name in data) res[name] = dehydrate(data[name], cleaned, path.concat([ name ]), level + 1); |
|
return res; |
|
|
|
default: |
|
return data; |
|
} |
|
} |
|
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { |
|
return typeof obj; |
|
} : function(obj) { |
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; |
|
}; |
|
module.exports = dehydrate; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var performanceNow, performance = __webpack_require__(29); |
|
performanceNow = performance.now ? function() { |
|
return performance.now(); |
|
} : function() { |
|
return Date.now(); |
|
}, module.exports = performanceNow; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var performance, ExecutionEnvironment = __webpack_require__(30); |
|
ExecutionEnvironment.canUseDOM && (performance = window.performance || window.msPerformance || window.webkitPerformance), |
|
module.exports = performance || {}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
var canUseDOM = !("undefined" == typeof window || !window.document || !window.document.createElement), ExecutionEnvironment = { |
|
canUseDOM: canUseDOM, |
|
canUseWorkers: "undefined" != typeof Worker, |
|
canUseEventListeners: canUseDOM && !(!window.addEventListener && !window.attachEvent), |
|
canUseViewport: canUseDOM && !!window.screen, |
|
isInWorker: !canUseDOM |
|
}; |
|
module.exports = ExecutionEnvironment; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function installGlobalHook(window) { |
|
function detectReactBuildType(renderer) { |
|
try { |
|
if ("string" == typeof renderer.version) return renderer.bundleType > 0 ? "development" : "production"; |
|
var toString = Function.prototype.toString; |
|
if (renderer.Mount && renderer.Mount._renderNewRootComponent) { |
|
var renderRootCode = toString.call(renderer.Mount._renderNewRootComponent); |
|
return 0 !== renderRootCode.indexOf("function") ? "production" : renderRootCode.indexOf("storedMeasure") !== -1 ? "development" : renderRootCode.indexOf("should be a pure function") !== -1 ? renderRootCode.indexOf("NODE_ENV") !== -1 ? "development" : renderRootCode.indexOf("development") !== -1 ? "development" : renderRootCode.indexOf("true") !== -1 ? "development" : renderRootCode.indexOf("nextElement") !== -1 || renderRootCode.indexOf("nextComponent") !== -1 ? "unminified" : "development" : renderRootCode.indexOf("nextElement") !== -1 || renderRootCode.indexOf("nextComponent") !== -1 ? "unminified" : renderRootCode.indexOf("._registerComponent") !== -1 ? "outdated" : "production"; |
|
} |
|
} catch (err) {} |
|
return "production"; |
|
} |
|
if (!window.__REACT_DEVTOOLS_GLOBAL_HOOK__) { |
|
var hasDetectedBadDCE = !1, hook = { |
|
_renderers: {}, |
|
helpers: {}, |
|
checkDCE: function(fn) { |
|
try { |
|
var toString = Function.prototype.toString, code = toString.call(fn); |
|
code.indexOf("^_^") > -1 && (hasDetectedBadDCE = !0, setTimeout(function() { |
|
throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://fb.me/react-perf-use-the-production-build"); |
|
})); |
|
} catch (err) {} |
|
}, |
|
inject: function(renderer) { |
|
var id = Math.random().toString(16).slice(2); |
|
hook._renderers[id] = renderer; |
|
var reactBuildType = hasDetectedBadDCE ? "deadcode" : detectReactBuildType(renderer); |
|
return hook.emit("renderer", { |
|
id: id, |
|
renderer: renderer, |
|
reactBuildType: reactBuildType |
|
}), id; |
|
}, |
|
_listeners: {}, |
|
sub: function(evt, fn) { |
|
return hook.on(evt, fn), function() { |
|
return hook.off(evt, fn); |
|
}; |
|
}, |
|
on: function(evt, fn) { |
|
hook._listeners[evt] || (hook._listeners[evt] = []), hook._listeners[evt].push(fn); |
|
}, |
|
off: function(evt, fn) { |
|
if (hook._listeners[evt]) { |
|
var ix = hook._listeners[evt].indexOf(fn); |
|
ix !== -1 && hook._listeners[evt].splice(ix, 1), hook._listeners[evt].length || (hook._listeners[evt] = null); |
|
} |
|
}, |
|
emit: function(evt, data) { |
|
hook._listeners[evt] && hook._listeners[evt].map(function(fn) { |
|
return fn(data); |
|
}); |
|
}, |
|
supportsFiber: !0, |
|
_fiberRoots: {}, |
|
getFiberRoots: function(rendererID) { |
|
var roots = hook._fiberRoots; |
|
return roots[rendererID] || (roots[rendererID] = new Set()), roots[rendererID]; |
|
}, |
|
onCommitFiberUnmount: function(rendererID, fiber) { |
|
hook.helpers[rendererID] && hook.helpers[rendererID].handleCommitFiberUnmount(fiber); |
|
}, |
|
onCommitFiberRoot: function(rendererID, root) { |
|
var mountedRoots = hook.getFiberRoots(rendererID), current = root.current, isKnownRoot = mountedRoots.has(root), isUnmounting = null == current.memoizedState || null == current.memoizedState.element; |
|
isKnownRoot || isUnmounting ? isKnownRoot && isUnmounting && mountedRoots["delete"](root) : mountedRoots.add(root), |
|
hook.helpers[rendererID] && hook.helpers[rendererID].handleCommitFiberRoot(root); |
|
} |
|
}; |
|
Object.defineProperty(window, "__REACT_DEVTOOLS_GLOBAL_HOOK__", { |
|
value: hook |
|
}); |
|
} |
|
} |
|
module.exports = installGlobalHook; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function installRelayHook(window) { |
|
function decorate(obj, attr, fn) { |
|
var old = obj[attr]; |
|
obj[attr] = function() { |
|
var res = old.apply(this, arguments); |
|
return fn.apply(this, arguments), res; |
|
}; |
|
} |
|
function emit(name, data) { |
|
_eventQueue.push({ |
|
name: name, |
|
data: data |
|
}), _listener && _listener(name, data); |
|
} |
|
function setRequestListener(listener) { |
|
if (_listener) throw new Error("Relay Devtools: Called only call setRequestListener once."); |
|
return _listener = listener, _eventQueue.forEach(function(_ref) { |
|
var name = _ref.name, data = _ref.data; |
|
listener(name, data); |
|
}), function() { |
|
_listener = null; |
|
}; |
|
} |
|
function recordRequest(type, start, request, requestNumber) { |
|
var id = Math.random().toString(16).substr(2); |
|
request.then(function(response) { |
|
emit("relay:success", { |
|
id: id, |
|
end: performanceNow(), |
|
response: response.response |
|
}); |
|
}, function(error) { |
|
emit("relay:failure", { |
|
id: id, |
|
end: performanceNow(), |
|
error: error |
|
}); |
|
}); |
|
for (var textChunks = [], text = request.getQueryString(); text.length > 0; ) textChunks.push(text.substr(0, TEXT_CHUNK_LENGTH)), |
|
text = text.substr(TEXT_CHUNK_LENGTH); |
|
return { |
|
id: id, |
|
name: request.getDebugName(), |
|
requestNumber: requestNumber, |
|
start: start, |
|
text: textChunks, |
|
type: type, |
|
variables: request.getVariables() |
|
}; |
|
} |
|
function instrumentRelayRequests(relayInternals) { |
|
var NetworkLayer = relayInternals.NetworkLayer; |
|
decorate(NetworkLayer, "sendMutation", function(mutation) { |
|
requestNumber++, emit("relay:pending", [ recordRequest("mutation", performanceNow(), mutation, requestNumber) ]); |
|
}), decorate(NetworkLayer, "sendQueries", function(queries) { |
|
requestNumber++; |
|
var start = performanceNow(); |
|
emit("relay:pending", queries.map(function(query) { |
|
return recordRequest("query", start, query, requestNumber); |
|
})); |
|
}); |
|
var instrumented = {}; |
|
for (var key in relayInternals) relayInternals.hasOwnProperty(key) && (instrumented[key] = relayInternals[key]); |
|
return instrumented.setRequestListener = setRequestListener, instrumented; |
|
} |
|
var performanceNow, performance = window.performance; |
|
performanceNow = performance && "function" == typeof performance.now ? function() { |
|
return performance.now(); |
|
} : function() { |
|
return Date.now(); |
|
}; |
|
var TEXT_CHUNK_LENGTH = 500, hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__; |
|
if (hook) { |
|
var _eventQueue = [], _listener = null, requestNumber = 0, _relayInternals = null; |
|
Object.defineProperty(hook, "_relayInternals", { |
|
configurable: !0, |
|
set: function(relayInternals) { |
|
_relayInternals = instrumentRelayRequests(relayInternals); |
|
}, |
|
get: function() { |
|
return _relayInternals; |
|
} |
|
}); |
|
} |
|
} |
|
module.exports = installRelayHook; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var setupBackend = __webpack_require__(34); |
|
module.exports = function(hook, agent) { |
|
var subs = [ hook.sub("renderer-attached", function(_ref) { |
|
var id = _ref.id, helpers = (_ref.renderer, _ref.helpers); |
|
agent.setReactInternals(id, helpers), helpers.walkTree(agent.onMounted.bind(agent, id), agent.addRoot.bind(agent, id)); |
|
}), hook.sub("root", function(_ref2) { |
|
var renderer = _ref2.renderer, internalInstance = _ref2.internalInstance; |
|
return agent.addRoot(renderer, internalInstance); |
|
}), hook.sub("mount", function(_ref3) { |
|
var renderer = _ref3.renderer, internalInstance = _ref3.internalInstance, data = _ref3.data; |
|
return agent.onMounted(renderer, internalInstance, data); |
|
}), hook.sub("update", function(_ref4) { |
|
var internalInstance = (_ref4.renderer, _ref4.internalInstance), data = _ref4.data; |
|
return agent.onUpdated(internalInstance, data); |
|
}), hook.sub("unmount", function(_ref5) { |
|
var internalInstance = (_ref5.renderer, _ref5.internalInstance); |
|
return agent.onUnmounted(internalInstance); |
|
}) ], success = setupBackend(hook); |
|
success && (hook.emit("react-devtools", agent), hook.reactDevtoolsAgent = agent, |
|
agent.on("shutdown", function() { |
|
subs.forEach(function(fn) { |
|
return fn(); |
|
}), hook.reactDevtoolsAgent = null; |
|
})); |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var attachRenderer = __webpack_require__(35); |
|
module.exports = function(hook) { |
|
var oldReact = window.React && window.React.__internals; |
|
oldReact && 0 === Object.keys(hook._renderers).length && hook.inject(oldReact); |
|
for (var rid in hook._renderers) hook.helpers[rid] = attachRenderer(hook, rid, hook._renderers[rid]), |
|
hook.emit("renderer-attached", { |
|
id: rid, |
|
renderer: hook._renderers[rid], |
|
helpers: hook.helpers[rid] |
|
}); |
|
hook.on("renderer", function(_ref) { |
|
var id = _ref.id, renderer = _ref.renderer; |
|
hook.helpers[id] = attachRenderer(hook, id, renderer), hook.emit("renderer-attached", { |
|
id: id, |
|
renderer: renderer, |
|
helpers: hook.helpers[id] |
|
}); |
|
}); |
|
var shutdown = function shutdown() { |
|
for (var id in hook.helpers) hook.helpers[id].cleanup(); |
|
hook.off("shutdown", shutdown); |
|
}; |
|
return hook.on("shutdown", shutdown), !0; |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function attachRenderer(hook, rid, renderer) { |
|
var rootNodeIDMap = new Map(), extras = {}, isPre013 = !renderer.Reconciler; |
|
if ("function" == typeof renderer.findFiberByHostInstance) return attachRendererFiber(hook, rid, renderer); |
|
renderer.Mount.findNodeHandle && renderer.Mount.nativeTagToRootNodeID ? (extras.getNativeFromReactElement = function(component) { |
|
return renderer.Mount.findNodeHandle(component); |
|
}, extras.getReactElementFromNative = function(nativeTag) { |
|
var id = renderer.Mount.nativeTagToRootNodeID(nativeTag); |
|
return rootNodeIDMap.get(id); |
|
}) : renderer.ComponentTree ? (extras.getNativeFromReactElement = function(component) { |
|
return renderer.ComponentTree.getNodeFromInstance(component); |
|
}, extras.getReactElementFromNative = function(node) { |
|
return renderer.ComponentTree.getClosestInstanceFromNode(node); |
|
}) : renderer.Mount.getID && renderer.Mount.getNode ? (extras.getNativeFromReactElement = function(component) { |
|
try { |
|
return renderer.Mount.getNode(component._rootNodeID); |
|
} catch (e) { |
|
return; |
|
} |
|
}, extras.getReactElementFromNative = function(node) { |
|
for (var id = renderer.Mount.getID(node); node && node.parentNode && !id; ) node = node.parentNode, |
|
id = renderer.Mount.getID(node); |
|
return rootNodeIDMap.get(id); |
|
}) : console.warn("Unknown react version (does not have getID), probably an unshimmed React Native"); |
|
var oldMethods, oldRenderComponent, oldRenderRoot; |
|
return renderer.Mount._renderNewRootComponent ? oldRenderRoot = decorateResult(renderer.Mount, "_renderNewRootComponent", function(internalInstance) { |
|
hook.emit("root", { |
|
renderer: rid, |
|
internalInstance: internalInstance |
|
}); |
|
}) : renderer.Mount.renderComponent && (oldRenderComponent = decorateResult(renderer.Mount, "renderComponent", function(internalInstance) { |
|
hook.emit("root", { |
|
renderer: rid, |
|
internalInstance: internalInstance._reactInternalInstance |
|
}); |
|
})), renderer.Component ? (console.error("You are using a version of React with limited support in this version of the devtools.\nPlease upgrade to use at least 0.13, or you can downgrade to use the old version of the devtools:\ninstructions here https://github.com/facebook/react-devtools/tree/devtools-next#how-do-i-use-this-for-react--013"), |
|
oldMethods = decorateMany(renderer.Component.Mixin, { |
|
mountComponent: function() { |
|
var _this = this; |
|
rootNodeIDMap.set(this._rootNodeID, this), setTimeout(function() { |
|
hook.emit("mount", { |
|
internalInstance: _this, |
|
data: getData012(_this), |
|
renderer: rid |
|
}); |
|
}, 0); |
|
}, |
|
updateComponent: function() { |
|
var _this2 = this; |
|
setTimeout(function() { |
|
hook.emit("update", { |
|
internalInstance: _this2, |
|
data: getData012(_this2), |
|
renderer: rid |
|
}); |
|
}, 0); |
|
}, |
|
unmountComponent: function() { |
|
hook.emit("unmount", { |
|
internalInstance: this, |
|
renderer: rid |
|
}), rootNodeIDMap["delete"](this._rootNodeID, this); |
|
} |
|
})) : renderer.Reconciler && (oldMethods = decorateMany(renderer.Reconciler, { |
|
mountComponent: function(internalInstance, rootID, transaction, context) { |
|
var data = getData(internalInstance); |
|
rootNodeIDMap.set(internalInstance._rootNodeID, internalInstance), hook.emit("mount", { |
|
internalInstance: internalInstance, |
|
data: data, |
|
renderer: rid |
|
}); |
|
}, |
|
performUpdateIfNecessary: function(internalInstance, nextChild, transaction, context) { |
|
hook.emit("update", { |
|
internalInstance: internalInstance, |
|
data: getData(internalInstance), |
|
renderer: rid |
|
}); |
|
}, |
|
receiveComponent: function(internalInstance, nextChild, transaction, context) { |
|
hook.emit("update", { |
|
internalInstance: internalInstance, |
|
data: getData(internalInstance), |
|
renderer: rid |
|
}); |
|
}, |
|
unmountComponent: function(internalInstance) { |
|
hook.emit("unmount", { |
|
internalInstance: internalInstance, |
|
renderer: rid |
|
}), rootNodeIDMap["delete"](internalInstance._rootNodeID, internalInstance); |
|
} |
|
})), extras.walkTree = function(visit, visitRoot) { |
|
var onMount = function(component, data) { |
|
rootNodeIDMap.set(component._rootNodeID, component), visit(component, data); |
|
}; |
|
walkRoots(renderer.Mount._instancesByReactRootID || renderer.Mount._instancesByContainerID, onMount, visitRoot, isPre013); |
|
}, extras.cleanup = function() { |
|
oldMethods && (renderer.Component ? restoreMany(renderer.Component.Mixin, oldMethods) : restoreMany(renderer.Reconciler, oldMethods)), |
|
oldRenderRoot && (renderer.Mount._renderNewRootComponent = oldRenderRoot), oldRenderComponent && (renderer.Mount.renderComponent = oldRenderComponent), |
|
oldMethods = null, oldRenderRoot = null, oldRenderComponent = null; |
|
}, extras; |
|
} |
|
function walkRoots(roots, onMount, onRoot, isPre013) { |
|
for (var name in roots) walkNode(roots[name], onMount, isPre013), onRoot(roots[name]); |
|
} |
|
function walkNode(internalInstance, onMount, isPre013) { |
|
var data = isPre013 ? getData012(internalInstance) : getData(internalInstance); |
|
data.children && Array.isArray(data.children) && data.children.forEach(function(child) { |
|
return walkNode(child, onMount, isPre013); |
|
}), onMount(internalInstance, data); |
|
} |
|
function decorateResult(obj, attr, fn) { |
|
var old = obj[attr]; |
|
return obj[attr] = function(instance) { |
|
var res = old.apply(this, arguments); |
|
return fn(res), res; |
|
}, old; |
|
} |
|
function decorate(obj, attr, fn) { |
|
var old = obj[attr]; |
|
return obj[attr] = function(instance) { |
|
var res = old.apply(this, arguments); |
|
return fn.apply(this, arguments), res; |
|
}, old; |
|
} |
|
function decorateMany(source, fns) { |
|
var olds = {}; |
|
for (var name in fns) olds[name] = decorate(source, name, fns[name]); |
|
return olds; |
|
} |
|
function restoreMany(source, olds) { |
|
for (var name in olds) source[name] = olds[name]; |
|
} |
|
var getData = __webpack_require__(36), getData012 = __webpack_require__(41), attachRendererFiber = __webpack_require__(42); |
|
module.exports = attachRenderer; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function getData(internalInstance) { |
|
var children = null, props = null, state = null, context = null, updater = null, name = null, type = null, key = null, ref = null, source = null, text = null, publicInstance = null, nodeType = "Native"; |
|
if ("object" !== ("undefined" == typeof internalInstance ? "undefined" : _typeof(internalInstance))) nodeType = "Text", |
|
text = internalInstance + ""; else if (null === internalInstance._currentElement || internalInstance._currentElement === !1) nodeType = "Empty"; else if (internalInstance._renderedComponent) nodeType = "NativeWrapper", |
|
children = [ internalInstance._renderedComponent ], props = internalInstance._instance.props, |
|
state = internalInstance._instance.state, context = internalInstance._instance.context, |
|
context && 0 === Object.keys(context).length && (context = null); else if (internalInstance._renderedChildren) children = childrenList(internalInstance._renderedChildren); else if (internalInstance._currentElement && internalInstance._currentElement.props) { |
|
var unfilteredChildren = internalInstance._currentElement.props.children, filteredChildren = []; |
|
traverseAllChildrenImpl(unfilteredChildren, "", function(_traverseContext, child) { |
|
var childType = "undefined" == typeof child ? "undefined" : _typeof(child); |
|
"string" !== childType && "number" !== childType || filteredChildren.push(child); |
|
}), children = filteredChildren.length <= 1 ? filteredChildren.length ? String(filteredChildren[0]) : void 0 : filteredChildren; |
|
} |
|
if (!props && internalInstance._currentElement && internalInstance._currentElement.props && (props = internalInstance._currentElement.props), |
|
null != internalInstance._currentElement && (type = internalInstance._currentElement.type, |
|
internalInstance._currentElement.key && (key = String(internalInstance._currentElement.key)), |
|
source = internalInstance._currentElement._source, ref = internalInstance._currentElement.ref, |
|
"string" == typeof type ? (name = type, null != internalInstance._nativeNode && (publicInstance = internalInstance._nativeNode), |
|
null != internalInstance._hostNode && (publicInstance = internalInstance._hostNode)) : "function" == typeof type ? (nodeType = "Composite", |
|
name = getDisplayName(type), internalInstance._renderedComponent && (internalInstance._currentElement.props === internalInstance._renderedComponent._currentElement || internalInstance._currentElement.type.isReactTopLevelWrapper) && (nodeType = "Wrapper"), |
|
null === name && (name = "No display name")) : "string" == typeof internalInstance._stringText ? (nodeType = "Text", |
|
text = internalInstance._stringText) : name = getDisplayName(type)), internalInstance._instance) { |
|
var inst = internalInstance._instance, forceUpdate = inst.forceUpdate || inst.updater && inst.updater.enqueueForceUpdate && function(cb) { |
|
inst.updater.enqueueForceUpdate(this, cb, "forceUpdate"); |
|
}; |
|
updater = { |
|
setState: inst.setState && inst.setState.bind(inst), |
|
forceUpdate: forceUpdate && forceUpdate.bind(inst), |
|
setInProps: forceUpdate && setInProps.bind(null, internalInstance, forceUpdate), |
|
setInState: inst.forceUpdate && setInState.bind(null, inst), |
|
setInContext: forceUpdate && setInContext.bind(null, inst, forceUpdate) |
|
}, "function" == typeof type && (publicInstance = inst), inst._renderedChildren && (children = childrenList(inst._renderedChildren)); |
|
} |
|
return "function" == typeof internalInstance.setNativeProps && (updater = { |
|
setNativeProps: function(nativeProps) { |
|
internalInstance.setNativeProps(nativeProps); |
|
} |
|
}), { |
|
nodeType: nodeType, |
|
type: type, |
|
key: key, |
|
ref: ref, |
|
source: source, |
|
name: name, |
|
props: props, |
|
state: state, |
|
context: context, |
|
children: children, |
|
text: text, |
|
updater: updater, |
|
publicInstance: publicInstance |
|
}; |
|
} |
|
function setInProps(internalInst, forceUpdate, path, value) { |
|
var element = internalInst._currentElement; |
|
internalInst._currentElement = _extends({}, element, { |
|
props: copyWithSet(element.props, path, value) |
|
}), forceUpdate.call(internalInst._instance); |
|
} |
|
function setInState(inst, path, value) { |
|
setIn(inst.state, path, value), inst.forceUpdate(); |
|
} |
|
function setInContext(inst, forceUpdate, path, value) { |
|
setIn(inst.context, path, value), forceUpdate.call(inst); |
|
} |
|
function setIn(obj, path, value) { |
|
var last = path.pop(), parent = path.reduce(function(obj_, attr) { |
|
return obj_ ? obj_[attr] : null; |
|
}, obj); |
|
parent && (parent[last] = value); |
|
} |
|
function childrenList(children) { |
|
var res = []; |
|
for (var name in children) res.push(children[name]); |
|
return res; |
|
} |
|
var _extends = Object.assign || function(target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i]; |
|
for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); |
|
} |
|
return target; |
|
}, _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { |
|
return typeof obj; |
|
} : function(obj) { |
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; |
|
}, copyWithSet = __webpack_require__(37), getDisplayName = __webpack_require__(38), traverseAllChildrenImpl = __webpack_require__(39); |
|
module.exports = getData; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function copyWithSetImpl(obj, path, idx, value) { |
|
if (idx >= path.length) return value; |
|
var key = path[idx], updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj); |
|
return updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value), updated; |
|
} |
|
function copyWithSet(obj, path, value) { |
|
return copyWithSetImpl(obj, path, 0, value); |
|
} |
|
var _extends = Object.assign || function(target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i]; |
|
for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); |
|
} |
|
return target; |
|
}; |
|
module.exports = copyWithSet; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function getDisplayName(type) { |
|
if (cachedDisplayNames.has(type)) return cachedDisplayNames.get(type); |
|
var displayName = void 0; |
|
"string" == typeof type.displayName && (displayName = type.displayName), displayName || (displayName = type.name || "Unknown"); |
|
var match = displayName.match(FB_MODULE_RE); |
|
if (match) { |
|
var componentName = match[1], moduleName = match[2]; |
|
componentName && moduleName && (moduleName === componentName || moduleName.startsWith(componentName + ".")) && (displayName = componentName); |
|
} |
|
return cachedDisplayNames.set(type, displayName), displayName; |
|
} |
|
var FB_MODULE_RE = /^(.*) \[from (.*)\]$/, cachedDisplayNames = new WeakMap(); |
|
module.exports = getDisplayName; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function escape(key) { |
|
var escapeRegex = /[=:]/g, escaperLookup = { |
|
"=": "=0", |
|
":": "=2" |
|
}, escapedString = ("" + key).replace(escapeRegex, function(match) { |
|
return escaperLookup[match]; |
|
}); |
|
return "$" + escapedString; |
|
} |
|
function getComponentKey(component, index) { |
|
return "object" === ("undefined" == typeof component ? "undefined" : _typeof(component)) && null !== component && null != component.key ? escape(component.key) : index.toString(36); |
|
} |
|
function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) { |
|
var type = "undefined" == typeof children ? "undefined" : _typeof(children); |
|
if ("undefined" !== type && "boolean" !== type || (children = null), null === children || "string" === type || "number" === type || "object" === type && children.$$typeof === REACT_ELEMENT_TYPE) return callback(traverseContext, children, "" === nameSoFar ? SEPARATOR + getComponentKey(children, 0) : nameSoFar), |
|
1; |
|
var child, nextName, subtreeCount = 0, nextNamePrefix = "" === nameSoFar ? SEPARATOR : nameSoFar + SUBSEPARATOR; |
|
if (Array.isArray(children)) for (var i = 0; i < children.length; i++) child = children[i], |
|
nextName = nextNamePrefix + getComponentKey(child, i), subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); else { |
|
var iteratorFn = ITERATOR_SYMBOL && children[ITERATOR_SYMBOL] || children[FAUX_ITERATOR_SYMBOL]; |
|
if ("function" == typeof iteratorFn) for (var step, iterator = iteratorFn.call(children), ii = 0; !(step = iterator.next()).done; ) child = step.value, |
|
nextName = nextNamePrefix + getComponentKey(child, ii++), subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); else if ("object" === type) { |
|
var addendum = " If you meant to render a collection of children, use an array instead.", childrenString = "" + children; |
|
invariant(!1, "The React Devtools cannot render an object as a child. (found: %s).%s", "[object Object]" === childrenString ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString, addendum); |
|
} |
|
} |
|
return subtreeCount; |
|
} |
|
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { |
|
return typeof obj; |
|
} : function(obj) { |
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; |
|
}, invariant = __webpack_require__(40), SEPARATOR = ".", SUBSEPARATOR = ":", FAUX_ITERATOR_SYMBOL = "@@iterator", ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103; |
|
module.exports = traverseAllChildrenImpl; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function invariant(condition, format, a, b, c, d, e, f) { |
|
if (!condition) { |
|
var error; |
|
if (void 0 === format) error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); else { |
|
var args = [ a, b, c, d, e, f ], argIndex = 0; |
|
error = new Error(format.replace(/%s/g, function() { |
|
return args[argIndex++]; |
|
})), error.name = "Invariant Violation"; |
|
} |
|
throw error.framesToPop = 1, error; |
|
} |
|
} |
|
module.exports = invariant; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function getData012(internalInstance) { |
|
var children = null, props = internalInstance.props, state = internalInstance.state, context = internalInstance.context, updater = null, name = null, type = null, key = null, ref = null, text = null, publicInstance = null, nodeType = "Native"; |
|
return internalInstance._renderedComponent ? (nodeType = "Wrapper", children = [ internalInstance._renderedComponent ], |
|
context && 0 === Object.keys(context).length && (context = null)) : internalInstance._renderedChildren ? (name = internalInstance.constructor.displayName, |
|
children = childrenList(internalInstance._renderedChildren)) : "string" == typeof props.children && (name = internalInstance.constructor.displayName, |
|
children = props.children, nodeType = "Native"), !props && internalInstance._currentElement && internalInstance._currentElement.props && (props = internalInstance._currentElement.props), |
|
internalInstance._currentElement && (type = internalInstance._currentElement.type, |
|
internalInstance._currentElement.key && (key = String(internalInstance._currentElement.key)), |
|
ref = internalInstance._currentElement.ref, "string" == typeof type ? name = type : (nodeType = "Composite", |
|
name = type.displayName, name || (name = "No display name"))), name || (name = internalInstance.constructor.displayName || "No display name", |
|
nodeType = "Composite"), "string" == typeof props && (nodeType = "Text", text = props, |
|
props = null, name = null), internalInstance.forceUpdate && (updater = { |
|
setState: internalInstance.setState.bind(internalInstance), |
|
forceUpdate: internalInstance.forceUpdate.bind(internalInstance), |
|
setInProps: internalInstance.forceUpdate && setInProps.bind(null, internalInstance), |
|
setInState: internalInstance.forceUpdate && setInState.bind(null, internalInstance), |
|
setInContext: internalInstance.forceUpdate && setInContext.bind(null, internalInstance) |
|
}, publicInstance = internalInstance), { |
|
nodeType: nodeType, |
|
type: type, |
|
key: key, |
|
ref: ref, |
|
source: null, |
|
name: name, |
|
props: props, |
|
state: state, |
|
context: context, |
|
children: children, |
|
text: text, |
|
updater: updater, |
|
publicInstance: publicInstance |
|
}; |
|
} |
|
function setInProps(inst, path, value) { |
|
inst.props = copyWithSet(inst.props, path, value), inst.forceUpdate(); |
|
} |
|
function setInState(inst, path, value) { |
|
setIn(inst.state, path, value), inst.forceUpdate(); |
|
} |
|
function setInContext(inst, path, value) { |
|
setIn(inst.context, path, value), inst.forceUpdate(); |
|
} |
|
function setIn(obj, path, value) { |
|
var last = path.pop(), parent = path.reduce(function(obj_, attr) { |
|
return obj_ ? obj_[attr] : null; |
|
}, obj); |
|
parent && (parent[last] = value); |
|
} |
|
function childrenList(children) { |
|
var res = []; |
|
for (var name in children) res.push(children[name]); |
|
return res; |
|
} |
|
var copyWithSet = __webpack_require__(37); |
|
module.exports = getData012; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function attachRendererFiber(hook, rid, renderer) { |
|
function getOpaqueNode(fiber) { |
|
if (opaqueNodes.has(fiber)) return fiber; |
|
var alternate = fiber.alternate; |
|
return null != alternate && opaqueNodes.has(alternate) ? alternate : (opaqueNodes.add(fiber), |
|
fiber); |
|
} |
|
function hasDataChanged(prevFiber, nextFiber) { |
|
if (prevFiber.tag === ClassComponent) { |
|
if ((nextFiber.effectTag & PerformedWork) !== PerformedWork) return !1; |
|
if (prevFiber.stateNode.context !== nextFiber.stateNode.context) return !0; |
|
if (null != nextFiber.updateQueue && nextFiber.updateQueue.hasForceUpdate) return !0; |
|
} |
|
return prevFiber.memoizedProps !== nextFiber.memoizedProps || prevFiber.memoizedState !== nextFiber.memoizedState || prevFiber.ref !== nextFiber.ref || prevFiber._debugSource !== nextFiber._debugSource; |
|
} |
|
function flushPendingEvents() { |
|
var events = pendingEvents; |
|
pendingEvents = []; |
|
for (var i = 0; i < events.length; i++) { |
|
var event = events[i]; |
|
hook.emit(event.type, event); |
|
} |
|
} |
|
function enqueueMount(fiber) { |
|
pendingEvents.push({ |
|
internalInstance: getOpaqueNode(fiber), |
|
data: getDataFiber(fiber, getOpaqueNode), |
|
renderer: rid, |
|
type: "mount" |
|
}); |
|
var isRoot = fiber.tag === HostRoot; |
|
isRoot && pendingEvents.push({ |
|
internalInstance: getOpaqueNode(fiber), |
|
renderer: rid, |
|
type: "root" |
|
}); |
|
} |
|
function enqueueUpdateIfNecessary(fiber, hasChildOrderChanged) { |
|
(hasChildOrderChanged || hasDataChanged(fiber.alternate, fiber)) && pendingEvents.push({ |
|
internalInstance: getOpaqueNode(fiber), |
|
data: getDataFiber(fiber, getOpaqueNode), |
|
renderer: rid, |
|
type: "update" |
|
}); |
|
} |
|
function enqueueUnmount(fiber) { |
|
var isRoot = fiber.tag === HostRoot, opaqueNode = getOpaqueNode(fiber), event = { |
|
internalInstance: opaqueNode, |
|
renderer: rid, |
|
type: "unmount" |
|
}; |
|
isRoot ? pendingEvents.push(event) : pendingEvents.unshift(event), opaqueNodes["delete"](opaqueNode); |
|
} |
|
function mountFiber(fiber) { |
|
var node = fiber; |
|
outer: for (;;) if (node.child) node.child["return"] = node, node = node.child; else { |
|
if (enqueueMount(node), node == fiber) return; |
|
if (!node.sibling) { |
|
for (;node["return"]; ) { |
|
if (node = node["return"], enqueueMount(node), node == fiber) return; |
|
if (node.sibling) { |
|
node.sibling["return"] = node["return"], node = node.sibling; |
|
continue outer; |
|
} |
|
} |
|
return; |
|
} |
|
node.sibling["return"] = node["return"], node = node.sibling; |
|
} |
|
} |
|
function updateFiber(nextFiber, prevFiber) { |
|
var hasChildOrderChanged = !1; |
|
if (nextFiber.child !== prevFiber.child) { |
|
for (var nextChild = nextFiber.child, prevChildAtSameIndex = prevFiber.child; nextChild; ) { |
|
if (nextChild.alternate) { |
|
var prevChild = nextChild.alternate; |
|
updateFiber(nextChild, prevChild), hasChildOrderChanged || prevChild === prevChildAtSameIndex || (hasChildOrderChanged = !0); |
|
} else mountFiber(nextChild), hasChildOrderChanged || (hasChildOrderChanged = !0); |
|
nextChild = nextChild.sibling, hasChildOrderChanged || null == prevChildAtSameIndex || (prevChildAtSameIndex = prevChildAtSameIndex.sibling); |
|
} |
|
hasChildOrderChanged || null == prevChildAtSameIndex || (hasChildOrderChanged = !0); |
|
} |
|
enqueueUpdateIfNecessary(nextFiber, hasChildOrderChanged); |
|
} |
|
function walkTree() { |
|
hook.getFiberRoots(rid).forEach(function(root) { |
|
mountFiber(root.current); |
|
}), flushPendingEvents(); |
|
} |
|
function cleanup() {} |
|
function handleCommitFiberUnmount(fiber) { |
|
enqueueUnmount(fiber); |
|
} |
|
function handleCommitFiberRoot(root) { |
|
var current = root.current, alternate = current.alternate; |
|
if (alternate) { |
|
var wasMounted = null != alternate.memoizedState && null != alternate.memoizedState.element, isMounted = null != current.memoizedState && null != current.memoizedState.element; |
|
!wasMounted && isMounted ? mountFiber(current) : wasMounted && isMounted ? updateFiber(current, alternate) : wasMounted && !isMounted && enqueueUnmount(current); |
|
} else mountFiber(current); |
|
flushPendingEvents(); |
|
} |
|
function getNativeFromReactElement(fiber) { |
|
try { |
|
var opaqueNode = fiber, hostInstance = renderer.findHostInstanceByFiber(opaqueNode); |
|
return hostInstance; |
|
} catch (err) { |
|
return null; |
|
} |
|
} |
|
function getReactElementFromNative(hostInstance) { |
|
var fiber = renderer.findFiberByHostInstance(hostInstance); |
|
if (null != fiber) { |
|
var opaqueNode = getOpaqueNode(fiber); |
|
return opaqueNode; |
|
} |
|
return null; |
|
} |
|
var opaqueNodes = new Set(), pendingEvents = []; |
|
return { |
|
getNativeFromReactElement: getNativeFromReactElement, |
|
getReactElementFromNative: getReactElementFromNative, |
|
handleCommitFiberRoot: handleCommitFiberRoot, |
|
handleCommitFiberUnmount: handleCommitFiberUnmount, |
|
cleanup: cleanup, |
|
walkTree: walkTree |
|
}; |
|
} |
|
var getDataFiber = __webpack_require__(43), _require = __webpack_require__(44), ClassComponent = _require.ClassComponent, HostRoot = _require.HostRoot, PerformedWork = 1; |
|
module.exports = attachRendererFiber; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function getDataFiber(fiber, getOpaqueNode) { |
|
var type = fiber.type, key = fiber.key, ref = fiber.ref, source = fiber._debugSource, publicInstance = null, props = null, state = null, children = null, context = null, updater = null, nodeType = null, name = null, text = null; |
|
switch (fiber.tag) { |
|
case FunctionalComponent: |
|
case ClassComponent: |
|
nodeType = "Composite", name = getDisplayName(fiber.type), publicInstance = fiber.stateNode, |
|
props = fiber.memoizedProps, state = fiber.memoizedState, null != publicInstance && (context = publicInstance.context, |
|
context && 0 === Object.keys(context).length && (context = null)); |
|
var inst = publicInstance; |
|
inst && (updater = { |
|
setState: inst.setState && inst.setState.bind(inst), |
|
forceUpdate: inst.forceUpdate && inst.forceUpdate.bind(inst), |
|
setInProps: inst.forceUpdate && setInProps.bind(null, fiber), |
|
setInState: inst.forceUpdate && setInState.bind(null, inst), |
|
setInContext: inst.forceUpdate && setInContext.bind(null, inst) |
|
}), children = []; |
|
break; |
|
|
|
case HostRoot: |
|
nodeType = "Wrapper", children = []; |
|
break; |
|
|
|
case HostPortal: |
|
nodeType = "Portal", name = "ReactPortal", props = { |
|
target: fiber.stateNode.containerInfo |
|
}, children = []; |
|
break; |
|
|
|
case HostComponent: |
|
nodeType = "Native", name = fiber.type, name = name.replace("topsecret-", ""), publicInstance = fiber.stateNode, |
|
props = fiber.memoizedProps, children = "string" == typeof props.children || "number" == typeof props.children ? props.children.toString() : [], |
|
"function" == typeof fiber.stateNode.setNativeProps && (updater = { |
|
setNativeProps: function(nativeProps) { |
|
fiber.stateNode.setNativeProps(nativeProps); |
|
} |
|
}); |
|
break; |
|
|
|
case HostText: |
|
nodeType = "Text", text = fiber.memoizedProps; |
|
break; |
|
|
|
case Fragment: |
|
nodeType = "Wrapper", children = []; |
|
break; |
|
|
|
default: |
|
var symbolOrNumber = "object" === ("undefined" == typeof type ? "undefined" : _typeof(type)) && null !== type ? type.$$typeof : type, switchValue = "symbol" === ("undefined" == typeof symbolOrNumber ? "undefined" : _typeof(symbolOrNumber)) ? symbolOrNumber.toString() : symbolOrNumber; |
|
switch (switchValue) { |
|
case ASYNC_MODE_NUMBER: |
|
case ASYNC_MODE_SYMBOL_STRING: |
|
nodeType = "Composite", name = "AsyncMode", children = []; |
|
break; |
|
|
|
case CONTEXT_PROVIDER_NUMBER: |
|
case CONTEXT_PROVIDER_SYMBOL_STRING: |
|
nodeType = "Composite", props = fiber.memoizedProps, name = "Context.Provider", |
|
children = []; |
|
break; |
|
|
|
case CONTEXT_CONSUMER_NUMBER: |
|
case CONTEXT_CONSUMER_SYMBOL_STRING: |
|
nodeType = "Composite", props = fiber.memoizedProps, name = "Context.Consumer", |
|
children = []; |
|
break; |
|
|
|
case STRICT_MODE_NUMBER: |
|
case STRICT_MODE_SYMBOL_STRING: |
|
nodeType = "Composite", name = "StrictMode", children = []; |
|
break; |
|
|
|
default: |
|
nodeType = "Native", props = fiber.memoizedProps, name = "TODO_NOT_IMPLEMENTED_YET", |
|
children = []; |
|
} |
|
} |
|
if (Array.isArray(children)) for (var child = fiber.child; child; ) children.push(getOpaqueNode(child)), |
|
child = child.sibling; |
|
return { |
|
nodeType: nodeType, |
|
type: type, |
|
key: key, |
|
ref: ref, |
|
source: source, |
|
name: name, |
|
props: props, |
|
state: state, |
|
context: context, |
|
children: children, |
|
text: text, |
|
updater: updater, |
|
publicInstance: publicInstance |
|
}; |
|
} |
|
function setInProps(fiber, path, value) { |
|
var inst = fiber.stateNode; |
|
fiber.pendingProps = copyWithSet(inst.props, path, value), fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps), |
|
fiber.stateNode.forceUpdate(); |
|
} |
|
function setInState(inst, path, value) { |
|
setIn(inst.state, path, value), inst.forceUpdate(); |
|
} |
|
function setInContext(inst, path, value) { |
|
setIn(inst.context, path, value), inst.forceUpdate(); |
|
} |
|
function setIn(obj, path, value) { |
|
var last = path.pop(), parent = path.reduce(function(obj_, attr) { |
|
return obj_ ? obj_[attr] : null; |
|
}, obj); |
|
parent && (parent[last] = value); |
|
} |
|
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { |
|
return typeof obj; |
|
} : function(obj) { |
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; |
|
}, copyWithSet = __webpack_require__(37), getDisplayName = __webpack_require__(38), _require = __webpack_require__(44), FunctionalComponent = _require.FunctionalComponent, ClassComponent = _require.ClassComponent, HostRoot = _require.HostRoot, HostPortal = _require.HostPortal, HostComponent = _require.HostComponent, HostText = _require.HostText, Fragment = _require.Fragment, _require2 = __webpack_require__(45), ASYNC_MODE_NUMBER = _require2.ASYNC_MODE_NUMBER, ASYNC_MODE_SYMBOL_STRING = _require2.ASYNC_MODE_SYMBOL_STRING, CONTEXT_CONSUMER_NUMBER = _require2.CONTEXT_CONSUMER_NUMBER, CONTEXT_CONSUMER_SYMBOL_STRING = _require2.CONTEXT_CONSUMER_SYMBOL_STRING, CONTEXT_PROVIDER_NUMBER = _require2.CONTEXT_PROVIDER_NUMBER, CONTEXT_PROVIDER_SYMBOL_STRING = _require2.CONTEXT_PROVIDER_SYMBOL_STRING, STRICT_MODE_NUMBER = _require2.STRICT_MODE_NUMBER, STRICT_MODE_SYMBOL_STRING = _require2.STRICT_MODE_SYMBOL_STRING; |
|
module.exports = getDataFiber; |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = { |
|
IndeterminateComponent: 0, |
|
FunctionalComponent: 1, |
|
ClassComponent: 2, |
|
HostRoot: 3, |
|
HostPortal: 4, |
|
HostComponent: 5, |
|
HostText: 6, |
|
CoroutineComponent: 7, |
|
CoroutineHandlerPhase: 8, |
|
YieldComponent: 9, |
|
Fragment: 10 |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = { |
|
ASYNC_MODE_NUMBER: 60111, |
|
ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)", |
|
CONTEXT_CONSUMER_NUMBER: 60110, |
|
CONTEXT_CONSUMER_SYMBOL_STRING: "Symbol(react.context)", |
|
CONTEXT_PROVIDER_NUMBER: 60109, |
|
CONTEXT_PROVIDER_SYMBOL_STRING: "Symbol(react.provider)", |
|
STRICT_MODE_NUMBER: 60108, |
|
STRICT_MODE_SYMBOL_STRING: "Symbol(react.strict_mode)" |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function _defineProperty(obj, key, value) { |
|
return key in obj ? Object.defineProperty(obj, key, { |
|
value: value, |
|
enumerable: !0, |
|
configurable: !0, |
|
writable: !0 |
|
}) : obj[key] = value, obj; |
|
} |
|
function measureStyle(agent, bridge, resolveRNStyle, id) { |
|
var node = agent.elementData.get(id); |
|
if (!node || !node.props) return void bridge.send("rn-style:measure", {}); |
|
var style = resolveRNStyle(node.props.style); |
|
styleOverridesByHostComponentId[id] && (style = Object.assign({}, style, styleOverridesByHostComponentId[id])); |
|
var instance = node.publicInstance; |
|
return instance && instance.measure ? void instance.measure(function(x, y, width, height, left, top) { |
|
if ("number" != typeof x) return void bridge.send("rn-style:measure", { |
|
style: style |
|
}); |
|
var margin = style && resolveBoxStyle("margin", style) || blank, padding = style && resolveBoxStyle("padding", style) || blank; |
|
bridge.send("rn-style:measure", { |
|
style: style, |
|
measuredLayout: { |
|
x: x, |
|
y: y, |
|
width: width, |
|
height: height, |
|
left: left, |
|
top: top, |
|
margin: margin, |
|
padding: padding |
|
} |
|
}); |
|
}) : void bridge.send("rn-style:measure", { |
|
style: style |
|
}); |
|
} |
|
function shallowClone(obj) { |
|
var nobj = {}; |
|
for (var n in obj) nobj[n] = obj[n]; |
|
return nobj; |
|
} |
|
function renameStyle(agent, id, oldName, newName, val) { |
|
var _ref3, data = agent.elementData.get(id), newStyle = newName ? (_ref3 = {}, _defineProperty(_ref3, oldName, void 0), |
|
_defineProperty(_ref3, newName, val), _ref3) : _defineProperty({}, oldName, void 0); |
|
if (data && data.updater && data.updater.setInProps) { |
|
var customStyle, style = data && data.props && data.props.style; |
|
if (Array.isArray(style)) { |
|
var lastLength = style.length - 1; |
|
"object" !== _typeof(style[lastLength]) || Array.isArray(style[lastLength]) ? (style = style.concat([ newStyle ]), |
|
data.updater.setInProps([ "style" ], style)) : (customStyle = shallowClone(style[lastLength]), |
|
delete customStyle[oldName], newName ? customStyle[newName] = val : customStyle[oldName] = void 0, |
|
data.updater.setInProps([ "style", lastLength ], customStyle)); |
|
} else "object" === ("undefined" == typeof style ? "undefined" : _typeof(style)) ? (customStyle = shallowClone(style), |
|
delete customStyle[oldName], newName ? customStyle[newName] = val : customStyle[oldName] = void 0, |
|
data.updater.setInProps([ "style" ], customStyle)) : (style = [ style, newStyle ], |
|
data.updater.setInProps([ "style" ], style)); |
|
} else { |
|
if (!(data && data.updater && data.updater.setNativeProps)) return; |
|
styleOverridesByHostComponentId[id] ? Object.assign(styleOverridesByHostComponentId[id], newStyle) : styleOverridesByHostComponentId[id] = newStyle, |
|
data.updater.setNativeProps({ |
|
style: newStyle |
|
}); |
|
} |
|
agent.emit("hideHighlight"); |
|
} |
|
function setStyle(agent, id, attr, val) { |
|
var data = agent.elementData.get(id), newStyle = _defineProperty({}, attr, val); |
|
if (data && data.updater && data.updater.setInProps) { |
|
var style = data.props && data.props.style; |
|
if (Array.isArray(style)) { |
|
var lastLength = style.length - 1; |
|
"object" !== _typeof(style[lastLength]) || Array.isArray(style[lastLength]) ? (style = style.concat([ newStyle ]), |
|
data.updater.setInProps([ "style" ], style)) : data.updater.setInProps([ "style", lastLength, attr ], val); |
|
} else style = [ style, newStyle ], data.updater.setInProps([ "style" ], style); |
|
} else { |
|
if (!(data && data.updater && data.updater.setNativeProps)) return; |
|
styleOverridesByHostComponentId[id] ? Object.assign(styleOverridesByHostComponentId[id], newStyle) : styleOverridesByHostComponentId[id] = newStyle, |
|
data.updater.setNativeProps({ |
|
style: newStyle |
|
}); |
|
} |
|
agent.emit("hideHighlight"); |
|
} |
|
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { |
|
return typeof obj; |
|
} : function(obj) { |
|
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; |
|
}, resolveBoxStyle = __webpack_require__(47), styleOverridesByHostComponentId = {}; |
|
module.exports = function(bridge, agent, resolveRNStyle) { |
|
bridge.onCall("rn-style:get", function(id) { |
|
var node = agent.elementData.get(id); |
|
return node && node.props ? resolveRNStyle(node.props.style) : null; |
|
}), bridge.on("rn-style:measure", function(id) { |
|
measureStyle(agent, bridge, resolveRNStyle, id); |
|
}), bridge.on("rn-style:rename", function(_ref) { |
|
var id = _ref.id, oldName = _ref.oldName, newName = _ref.newName, val = _ref.val; |
|
renameStyle(agent, id, oldName, newName, val), setTimeout(function() { |
|
return measureStyle(agent, bridge, resolveRNStyle, id); |
|
}); |
|
}), bridge.on("rn-style:set", function(_ref2) { |
|
var id = _ref2.id, attr = _ref2.attr, val = _ref2.val; |
|
setStyle(agent, id, attr, val), setTimeout(function() { |
|
return measureStyle(agent, bridge, resolveRNStyle, id); |
|
}); |
|
}); |
|
}; |
|
var blank = { |
|
top: 0, |
|
left: 0, |
|
right: 0, |
|
bottom: 0 |
|
}; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function resolveBoxStyle(prefix, style) { |
|
var res = {}, subs = [ "top", "left", "bottom", "right" ], set = !1; |
|
return subs.forEach(function(sub) { |
|
res[sub] = style[prefix] || 0; |
|
}), style[prefix] && (set = !0), style[prefix + "Vertical"] && (res.top = res.bottom = style[prefix + "Vertical"], |
|
set = !0), style[prefix + "Horizontal"] && (res.left = res.right = style[prefix + "Horizontal"], |
|
set = !0), subs.forEach(function(sub) { |
|
var val = style[prefix + capFirst(sub)]; |
|
val && (res[sub] = val, set = !0); |
|
}), set ? res : null; |
|
} |
|
function capFirst(text) { |
|
return text[0].toUpperCase() + text.slice(1); |
|
} |
|
module.exports = resolveBoxStyle; |
|
}, function(module, exports) { |
|
"use strict"; |
|
function decorate(obj, attr, fn) { |
|
var old = obj[attr]; |
|
return obj[attr] = function() { |
|
var res = old.apply(this, arguments); |
|
return fn.apply(this, arguments), res; |
|
}, function() { |
|
obj[attr] = old; |
|
}; |
|
} |
|
var subscriptionEnabled = !1; |
|
module.exports = function(bridge, agent, hook) { |
|
function sendStoreData() { |
|
subscriptionEnabled && bridge.send("relay:store", { |
|
id: "relay:store", |
|
nodes: DefaultStoreData.getNodeData() |
|
}); |
|
} |
|
var shouldEnable = !!hook._relayInternals; |
|
if (bridge.onCall("relay:check", function() { |
|
return shouldEnable; |
|
}), shouldEnable) { |
|
var _hook$_relayInternals = hook._relayInternals, DefaultStoreData = _hook$_relayInternals.DefaultStoreData, setRequestListener = _hook$_relayInternals.setRequestListener; |
|
bridge.onCall("relay:store:enable", function() { |
|
subscriptionEnabled = !0, sendStoreData(); |
|
}), bridge.onCall("relay:store:disable", function() { |
|
subscriptionEnabled = !1; |
|
}), sendStoreData(), decorate(DefaultStoreData, "handleUpdatePayload", sendStoreData), |
|
decorate(DefaultStoreData, "handleQueryPayload", sendStoreData); |
|
var removeListener = setRequestListener(function(event, data) { |
|
bridge.send(event, data); |
|
}); |
|
hook.on("shutdown", removeListener); |
|
} |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
var Highlighter = __webpack_require__(50); |
|
module.exports = function(agent) { |
|
var hl = new Highlighter(window, function(node) { |
|
agent.selectFromDOMNode(node); |
|
}); |
|
agent.on("highlight", function(data) { |
|
return hl.highlight(data.node, data.name); |
|
}), agent.on("highlightMany", function(nodes) { |
|
return hl.highlightMany(nodes); |
|
}), agent.on("hideHighlight", function() { |
|
return hl.hideHighlight(); |
|
}), agent.on("refreshMultiOverlay", function() { |
|
return hl.refreshMultiOverlay(); |
|
}), agent.on("startInspecting", function() { |
|
return hl.startInspecting(); |
|
}), agent.on("stopInspecting", function() { |
|
return hl.stopInspecting(); |
|
}), agent.on("shutdown", function() { |
|
hl.remove(); |
|
}); |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function _classCallCheck(instance, Constructor) { |
|
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); |
|
} |
|
function captureSubscription(obj, evt, cb) { |
|
return obj.addEventListener(evt, cb, !0), function() { |
|
return obj.removeEventListener(evt, cb, !0); |
|
}; |
|
} |
|
function makeMagnifier() { |
|
var button = window.document.createElement("button"); |
|
return button.innerHTML = "🔍", button.style.backgroundColor = "transparent", |
|
button.style.border = "none", button.style.outline = "none", button.style.cursor = "pointer", |
|
button.style.position = "fixed", button.style.bottom = "10px", button.style.right = "10px", |
|
button.style.fontSize = "30px", button.style.zIndex = 1e7, button; |
|
} |
|
var _createClass = function() { |
|
function defineProperties(target, props) { |
|
for (var i = 0; i < props.length; i++) { |
|
var descriptor = props[i]; |
|
descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, |
|
"value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); |
|
} |
|
} |
|
return function(Constructor, protoProps, staticProps) { |
|
return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), |
|
Constructor; |
|
}; |
|
}(), Overlay = __webpack_require__(51), MultiOverlay = __webpack_require__(53), Highlighter = function() { |
|
function Highlighter(win, onSelect) { |
|
_classCallCheck(this, Highlighter), this._win = win, this._onSelect = onSelect, |
|
this._overlay = null, this._multiOverlay = null, this._subs = []; |
|
} |
|
return _createClass(Highlighter, [ { |
|
key: "startInspecting", |
|
value: function() { |
|
this._inspecting = !0, this._subs = [ captureSubscription(this._win, "mouseover", this.onHover.bind(this)), captureSubscription(this._win, "mousedown", this.onMouseDown.bind(this)), captureSubscription(this._win, "click", this.onClick.bind(this)) ]; |
|
} |
|
}, { |
|
key: "stopInspecting", |
|
value: function() { |
|
this._subs.forEach(function(unsub) { |
|
return unsub(); |
|
}), this.hideHighlight(); |
|
} |
|
}, { |
|
key: "remove", |
|
value: function() { |
|
this.stopInspecting(), this._button && this._button.parentNode && this._button.parentNode.removeChild(this._button); |
|
} |
|
}, { |
|
key: "highlight", |
|
value: function(node, name) { |
|
this.removeMultiOverlay(), node.nodeType !== Node.COMMENT_NODE && (this._overlay || (this._overlay = new Overlay(this._win)), |
|
this._overlay.inspect(node, name)); |
|
} |
|
}, { |
|
key: "highlightMany", |
|
value: function(nodes) { |
|
this.removeOverlay(), this._multiOverlay || (this._multiOverlay = new MultiOverlay(this._win)), |
|
this._multiOverlay.highlightMany(nodes); |
|
} |
|
}, { |
|
key: "hideHighlight", |
|
value: function() { |
|
this._inspecting = !1, this.removeOverlay(), this.removeMultiOverlay(); |
|
} |
|
}, { |
|
key: "refreshMultiOverlay", |
|
value: function() { |
|
this._multiOverlay && this._multiOverlay.refresh(); |
|
} |
|
}, { |
|
key: "removeOverlay", |
|
value: function() { |
|
this._overlay && (this._overlay.remove(), this._overlay = null); |
|
} |
|
}, { |
|
key: "removeMultiOverlay", |
|
value: function() { |
|
this._multiOverlay && (this._multiOverlay.remove(), this._multiOverlay = null); |
|
} |
|
}, { |
|
key: "onMouseDown", |
|
value: function(evt) { |
|
this._inspecting && (evt.preventDefault(), evt.stopPropagation(), evt.cancelBubble = !0, |
|
this._onSelect(evt.target)); |
|
} |
|
}, { |
|
key: "onClick", |
|
value: function(evt) { |
|
this._inspecting && (this._subs.forEach(function(unsub) { |
|
return unsub(); |
|
}), evt.preventDefault(), evt.stopPropagation(), evt.cancelBubble = !0, this.hideHighlight()); |
|
} |
|
}, { |
|
key: "onHover", |
|
value: function(evt) { |
|
this._inspecting && (evt.preventDefault(), evt.stopPropagation(), evt.cancelBubble = !0, |
|
this.highlight(evt.target)); |
|
} |
|
}, { |
|
key: "injectButton", |
|
value: function() { |
|
this._button = makeMagnifier(), this._button.onclick = this.startInspecting.bind(this), |
|
this._win.document.body.appendChild(this._button); |
|
} |
|
} ]), Highlighter; |
|
}(); |
|
module.exports = Highlighter; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function _classCallCheck(instance, Constructor) { |
|
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); |
|
} |
|
function findTipPos(dims, win) { |
|
var top, tipHeight = 20, margin = 5; |
|
return top = dims.top + dims.height + tipHeight <= win.innerHeight ? dims.top + dims.height < 0 ? margin : dims.top + dims.height + margin : dims.top - tipHeight <= win.innerHeight ? dims.top - tipHeight - margin < margin ? margin : dims.top - tipHeight - margin : win.innerHeight - tipHeight - margin, |
|
top += "px", dims.left < 0 ? { |
|
top: top, |
|
left: margin |
|
} : dims.left + 200 > win.innerWidth ? { |
|
top: top, |
|
right: margin |
|
} : { |
|
top: top, |
|
left: dims.left + margin + "px" |
|
}; |
|
} |
|
function getElementDimensions(domElement) { |
|
var calculatedStyle = window.getComputedStyle(domElement); |
|
return { |
|
borderLeft: +calculatedStyle.borderLeftWidth.match(/[0-9]*/)[0], |
|
borderRight: +calculatedStyle.borderRightWidth.match(/[0-9]*/)[0], |
|
borderTop: +calculatedStyle.borderTopWidth.match(/[0-9]*/)[0], |
|
borderBottom: +calculatedStyle.borderBottomWidth.match(/[0-9]*/)[0], |
|
marginLeft: +calculatedStyle.marginLeft.match(/[0-9]*/)[0], |
|
marginRight: +calculatedStyle.marginRight.match(/[0-9]*/)[0], |
|
marginTop: +calculatedStyle.marginTop.match(/[0-9]*/)[0], |
|
marginBottom: +calculatedStyle.marginBottom.match(/[0-9]*/)[0], |
|
paddingLeft: +calculatedStyle.paddingLeft.match(/[0-9]*/)[0], |
|
paddingRight: +calculatedStyle.paddingRight.match(/[0-9]*/)[0], |
|
paddingTop: +calculatedStyle.paddingTop.match(/[0-9]*/)[0], |
|
paddingBottom: +calculatedStyle.paddingBottom.match(/[0-9]*/)[0] |
|
}; |
|
} |
|
function getOwnerWindow(node) { |
|
return node.ownerDocument ? node.ownerDocument.defaultView : null; |
|
} |
|
function getOwnerIframe(node) { |
|
var nodeWindow = getOwnerWindow(node); |
|
return nodeWindow ? nodeWindow.frameElement : null; |
|
} |
|
function getBoundingClientRectWithBorderOffset(node) { |
|
var dimensions = getElementDimensions(node); |
|
return mergeRectOffsets([ node.getBoundingClientRect(), { |
|
top: dimensions.borderTop, |
|
left: dimensions.borderLeft, |
|
bottom: dimensions.borderBottom, |
|
right: dimensions.borderRight, |
|
width: 0, |
|
height: 0 |
|
} ]); |
|
} |
|
function mergeRectOffsets(rects) { |
|
return rects.reduce(function(previousRect, rect) { |
|
return null == previousRect ? rect : { |
|
top: previousRect.top + rect.top, |
|
left: previousRect.left + rect.left, |
|
width: previousRect.width, |
|
height: previousRect.height, |
|
bottom: previousRect.bottom + rect.bottom, |
|
right: previousRect.right + rect.right |
|
}; |
|
}); |
|
} |
|
function getNestedBoundingClientRect(node, boundaryWindow) { |
|
var ownerIframe = getOwnerIframe(node); |
|
if (ownerIframe && ownerIframe !== boundaryWindow) { |
|
for (var rects = [ node.getBoundingClientRect() ], currentIframe = ownerIframe, onlyOneMore = !1; currentIframe; ) { |
|
var rect = getBoundingClientRectWithBorderOffset(currentIframe); |
|
if (rects.push(rect), currentIframe = getOwnerIframe(currentIframe), onlyOneMore) break; |
|
currentIframe && getOwnerWindow(currentIframe) === boundaryWindow && (onlyOneMore = !0); |
|
} |
|
return mergeRectOffsets(rects); |
|
} |
|
return node.getBoundingClientRect(); |
|
} |
|
function boxWrap(dims, what, node) { |
|
assign(node.style, { |
|
borderTopWidth: dims[what + "Top"] + "px", |
|
borderLeftWidth: dims[what + "Left"] + "px", |
|
borderRightWidth: dims[what + "Right"] + "px", |
|
borderBottomWidth: dims[what + "Bottom"] + "px", |
|
borderStyle: "solid" |
|
}); |
|
} |
|
var _createClass = function() { |
|
function defineProperties(target, props) { |
|
for (var i = 0; i < props.length; i++) { |
|
var descriptor = props[i]; |
|
descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, |
|
"value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); |
|
} |
|
} |
|
return function(Constructor, protoProps, staticProps) { |
|
return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), |
|
Constructor; |
|
}; |
|
}(), assign = __webpack_require__(3), _require = __webpack_require__(52), monospace = _require.monospace, Overlay = function() { |
|
function Overlay(window) { |
|
_classCallCheck(this, Overlay); |
|
var doc = window.document; |
|
this.win = window, this.container = doc.createElement("div"), this.node = doc.createElement("div"), |
|
this.border = doc.createElement("div"), this.padding = doc.createElement("div"), |
|
this.content = doc.createElement("div"), this.border.style.borderColor = overlayStyles.border, |
|
this.padding.style.borderColor = overlayStyles.padding, this.content.style.backgroundColor = overlayStyles.background, |
|
assign(this.node.style, { |
|
borderColor: overlayStyles.margin, |
|
pointerEvents: "none", |
|
position: "fixed" |
|
}), this.tip = doc.createElement("div"), assign(this.tip.style, { |
|
backgroundColor: "#333740", |
|
borderRadius: "2px", |
|
fontFamily: monospace.family, |
|
fontWeight: "bold", |
|
padding: "3px 5px", |
|
position: "fixed", |
|
fontSize: monospace.sizes.normal |
|
}), this.nameSpan = doc.createElement("span"), this.tip.appendChild(this.nameSpan), |
|
assign(this.nameSpan.style, { |
|
color: "#ee78e6", |
|
borderRight: "1px solid #aaaaaa", |
|
paddingRight: "0.5rem", |
|
marginRight: "0.5rem" |
|
}), this.dimSpan = doc.createElement("span"), this.tip.appendChild(this.dimSpan), |
|
assign(this.dimSpan.style, { |
|
color: "#d7d7d7" |
|
}), this.container.style.zIndex = 1e7, this.node.style.zIndex = 1e7, this.tip.style.zIndex = 1e7, |
|
this.container.appendChild(this.node), this.container.appendChild(this.tip), this.node.appendChild(this.border), |
|
this.border.appendChild(this.padding), this.padding.appendChild(this.content), doc.body.appendChild(this.container); |
|
} |
|
return _createClass(Overlay, [ { |
|
key: "remove", |
|
value: function() { |
|
this.container.parentNode && this.container.parentNode.removeChild(this.container); |
|
} |
|
}, { |
|
key: "inspect", |
|
value: function(node, name) { |
|
if (node.nodeType === Node.ELEMENT_NODE) { |
|
var box = getNestedBoundingClientRect(node, this.win), dims = getElementDimensions(node); |
|
boxWrap(dims, "margin", this.node), boxWrap(dims, "border", this.border), boxWrap(dims, "padding", this.padding), |
|
assign(this.content.style, { |
|
height: box.height - dims.borderTop - dims.borderBottom - dims.paddingTop - dims.paddingBottom + "px", |
|
width: box.width - dims.borderLeft - dims.borderRight - dims.paddingLeft - dims.paddingRight + "px" |
|
}), assign(this.node.style, { |
|
top: box.top - dims.marginTop + "px", |
|
left: box.left - dims.marginLeft + "px" |
|
}), this.nameSpan.textContent = name || node.nodeName.toLowerCase(), this.dimSpan.textContent = box.width + "px × " + box.height + "px"; |
|
var tipPos = findTipPos({ |
|
top: box.top - dims.marginTop, |
|
left: box.left - dims.marginLeft, |
|
height: box.height + dims.marginTop + dims.marginBottom, |
|
width: box.width + dims.marginLeft + dims.marginRight |
|
}, this.win); |
|
assign(this.tip.style, tipPos); |
|
} |
|
} |
|
} ]), Overlay; |
|
}(), overlayStyles = { |
|
background: "rgba(120, 170, 210, 0.7)", |
|
padding: "rgba(77, 200, 0, 0.3)", |
|
margin: "rgba(255, 155, 0, 0.3)", |
|
border: "rgba(255, 200, 50, 0.3)" |
|
}; |
|
module.exports = Overlay; |
|
}, function(module, exports) { |
|
"use strict"; |
|
module.exports = { |
|
monospace: { |
|
family: "Menlo, Consolas, monospace", |
|
sizes: { |
|
normal: 11, |
|
large: 14 |
|
} |
|
}, |
|
sansSerif: { |
|
family: '"Helvetica Neue", "Lucida Grande", -apple-system, BlinkMacSystemFont, "Segoe UI", Ubuntu, sans-serif', |
|
sizes: { |
|
small: 10, |
|
normal: 12, |
|
large: 14 |
|
} |
|
} |
|
}; |
|
}, function(module, exports, __webpack_require__) { |
|
"use strict"; |
|
function _classCallCheck(instance, Constructor) { |
|
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); |
|
} |
|
var _createClass = function() { |
|
function defineProperties(target, props) { |
|
for (var i = 0; i < props.length; i++) { |
|
var descriptor = props[i]; |
|
descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, |
|
"value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); |
|
} |
|
} |
|
return function(Constructor, protoProps, staticProps) { |
|
return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), |
|
Constructor; |
|
}; |
|
}(), assign = __webpack_require__(3), MultiOverlay = function() { |
|
function MultiOverlay(window) { |
|
_classCallCheck(this, MultiOverlay), this.win = window; |
|
var doc = window.document; |
|
this.container = doc.createElement("div"), doc.body.appendChild(this.container), |
|
this._currentNodes = null; |
|
} |
|
return _createClass(MultiOverlay, [ { |
|
key: "highlightMany", |
|
value: function(nodes) { |
|
var _this = this; |
|
this._currentNodes = nodes, this.container.innerHTML = "", nodes.forEach(function(node) { |
|
var div = _this.win.document.createElement("div"); |
|
if ("function" == typeof node.getBoundingClientRect) { |
|
var box = node.getBoundingClientRect(); |
|
box.bottom < 0 || box.top > window.innerHeight || (assign(div.style, { |
|
top: box.top + "px", |
|
left: box.left + "px", |
|
width: box.width + "px", |
|
height: box.height + "px", |
|
border: "2px dotted rgba(200, 100, 100, .8)", |
|
boxSizing: "border-box", |
|
backgroundColor: "rgba(200, 100, 100, .2)", |
|
position: "fixed", |
|
zIndex: 1e7, |
|
pointerEvents: "none" |
|
}), _this.container.appendChild(div)); |
|
} |
|
}); |
|
} |
|
}, { |
|
key: "refresh", |
|
value: function() { |
|
this._currentNodes && this.highlightMany(this._currentNodes); |
|
} |
|
}, { |
|
key: "remove", |
|
value: function() { |
|
this.container.parentNode && (this.container.parentNode.removeChild(this.container), |
|
this._currentNodes = null); |
|
} |
|
} ]), MultiOverlay; |
|
}(); |
|
module.exports = MultiOverlay; |
|
} ]); |
|
}); |
|
//# sourceMappingURL=backend.js.map
|