redhotmagma-visualization 1.28.4 → 1.29.0

package/VisualizationContainer.js

@@ -0,0 +1,279 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.VisualizationContainerSwitch = exports.VisualizationContainer = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _cssElementQueries = require("css-element-queries");
+
+var _VisualizationProvider = require("./VisualizationProvider");
+
+var _VisualizationInterface = require("./VisualizationInterface");
+
+var _AlignTargetProvider = require("./AlignTargetProvider");
+
+var _alignToElement = require("./Utils/alignToElement");
+
+var _updateFitSizeToElement = require("./Utils/updateFitSizeToElement");
+
+var _Constants = require("./Constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var defaultContainerStyle = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  width: "100%",
+  height: "100%",
+  overflow: "hidden"
+};
+/**
+ * Component for the Three.js visualization
+ * Responsibilities:
+ *  - renders the placeholder for the THREE.js visualization
+ *  - adds the Three instance to the placeholder, initializes the controls
+ *  - loads the current model and starts the animation
+ *  - will handle probably the positioning of the 3D component
+ */
+
+var VisualizationContainer = /*#__PURE__*/function (_React$Component) {
+  _inherits(VisualizationContainer, _React$Component);
+
+  var _super = _createSuper(VisualizationContainer);
+
+  function VisualizationContainer() {
+    var _this;
+
+    _classCallCheck(this, VisualizationContainer);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      loading: false,
+      broken: false
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "setLoading", function (loading) {
+      _this.setState({
+        loading: loading
+      });
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "onSizeChange", function (size) {
+      var _this$props = _this.props,
+          visualization = _this$props.visualization,
+          alignTargetElement = _this$props.alignTargetElement;
+
+      if (!visualization.isInitialized()) {
+        return;
+      }
+
+      visualization.setSize(size);
+
+      if (alignTargetElement && alignTargetElement.clientWidth > 0 && alignTargetElement.clientHeight > 0) {
+        (0, _alignToElement.alignToElement)(visualization, alignTargetElement);
+        (0, _updateFitSizeToElement.updateFitSizeToElement)(visualization, alignTargetElement).updateCameraPosition({
+          animate: visualization.isAnimating() || !!alignTargetElement
+        });
+      }
+
+      visualization.render();
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "containerRef", /*#__PURE__*/_react["default"].createRef());
+
+    return _this;
+  }
+
+  _createClass(VisualizationContainer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var visualization = this.props.visualization;
+
+      if (!visualization) {
+        // eslint-disable-next-line no-console
+        console.warn("Visualization component is not provided! Visualization will not be rendered.");
+        return;
+      }
+
+      if (!(visualization instanceof _VisualizationInterface.VisualizationInterface)) {
+        throw new Error('The provided "three" prop should always be a subclass of VisualizationInterface!');
+      }
+
+      this.initResizeSensor();
+      this.updateVisualization();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      this.updateVisualization(prevProps);
+    }
+  }, {
+    key: "initResizeSensor",
+    value: function initResizeSensor() {
+      var container = this.containerRef.current;
+      this.resizeSensor = new _cssElementQueries.ResizeSensor(container, this.onSizeChange);
+    }
+  }, {
+    key: "updateVisualization",
+    value: function updateVisualization() {
+      var prevProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var _this$props2 = this.props,
+          visualization = _this$props2.visualization,
+          alignTargetElement = _this$props2.alignTargetElement;
+      var container = this.containerRef.current;
+
+      if (visualization !== prevProps.visualization) {
+        if (prevProps.visualization) {
+          prevProps.visualization.dispose();
+        }
+
+        if (visualization.isInitialized()) {
+          // Three is already initialized, just add it to the current container instead of reloading it completely
+          visualization.addToContainer(container);
+        } else {
+          this.initVisualization(container);
+        } // init resize sensor if it's not done in the componentDidUpdate
+
+
+        !this.resizeSensor && this.initResizeSensor();
+      }
+
+      if (alignTargetElement && alignTargetElement !== prevProps.alignTargetElement || visualization && visualization !== prevProps.visualization) {
+        (0, _alignToElement.alignToElement)(visualization, alignTargetElement);
+        (0, _updateFitSizeToElement.updateFitSizeToElement)(visualization, alignTargetElement).updateCameraPosition({
+          animate: visualization.isAnimating() || !!prevProps.alignTargetElement
+        });
+        visualization.render();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var _this$props3 = this.props,
+          autoDispose = _this$props3.autoDispose,
+          visualization = _this$props3.visualization;
+      autoDispose && visualization.dispose();
+      this.resizeSensor && this.resizeSensor.detach();
+    }
+  }, {
+    key: "initVisualization",
+    value: function initVisualization(container) {
+      var _this2 = this;
+
+      var visualization = this.props.visualization;
+      visualization.init(container);
+      visualization.observable.on(_Constants.EventTypes.LoadError, function (_ref) {
+        var screenshot = _ref.data.screenshot;
+        return !screenshot && _this2.setState({
+          broken: true
+        });
+      });
+      visualization.observable.on(_Constants.EventTypes.LoadFinished, function (_ref2) {
+        var screenshot = _ref2.data.screenshot;
+        return !screenshot && _this2.setState({
+          broken: false
+        });
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+          className = _this$props4.className,
+          ProgressComponent = _this$props4.ProgressComponent,
+          BrokenComponent = _this$props4.BrokenComponent;
+      var broken = this.state.broken;
+
+      var style = _objectSpread(_objectSpread({}, className ? {} : defaultContainerStyle), broken && BrokenComponent && {
+        display: "none"
+      });
+
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(ProgressComponent, {
+        loading: this.props.isLoading
+      }), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "".concat(className || ""),
+        style: style,
+        ref: this.containerRef
+      }), broken && BrokenComponent && /*#__PURE__*/_react["default"].createElement(BrokenComponent, null));
+    }
+  }]);
+
+  return VisualizationContainer;
+}(_react["default"].Component);
+
+exports.VisualizationContainer = VisualizationContainer;
+
+_defineProperty(VisualizationContainer, "propTypes", {
+  visualization: _propTypes["default"].instanceOf(_VisualizationInterface.VisualizationInterface).isRequired,
+  autoDispose: _propTypes["default"].bool,
+  alignTargetElement: _propTypes["default"].instanceOf(Element)
+});
+
+_defineProperty(VisualizationContainer, "defaultProps", {
+  ProgressComponent: function ProgressComponent(_ref3) {
+    var loading = _ref3.loading;
+    return loading ? /*#__PURE__*/_react["default"].createElement("div", null, "Loading component...") : null;
+  },
+  autoDispose: false,
+  alignTargetElement: null
+});
+
+var VisualizationContainerSwitch = function VisualizationContainerSwitch(props) {
+  // eslint-disable-next-line react/prop-types
+  var visualization = props.visualization,
+      VisualizationContainerComponent = props.VisualizationContainerComponent,
+      FallbackComponent = props.FallbackComponent;
+  var Component = visualization ? VisualizationContainerComponent : FallbackComponent;
+  return /*#__PURE__*/_react["default"].createElement(Component, props);
+};
+
+exports.VisualizationContainerSwitch = VisualizationContainerSwitch;
+VisualizationContainerSwitch.defaultProps = {
+  VisualizationContainerComponent: VisualizationContainer,
+  FallbackComponent: function FallbackComponent() {
+    return null;
+  }
+};
+
+var _default = (0, _AlignTargetProvider.withCurrentTarget)((0, _VisualizationProvider.withVisualization)(VisualizationContainerSwitch));
+
+exports["default"] = _default;

package/VisualizationInterface.js

@@ -0,0 +1,298 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VisualizationInterface = void 0;
+
+var _Observable = _interopRequireDefault(require("./CommonUtils/Observable"));
+
+var _Constants = require("./Constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var VisualizationInterface = /*#__PURE__*/function () {
+  function VisualizationInterface() {
+    var _this = this;
+
+    var cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, VisualizationInterface);
+
+    _defineProperty(this, "_basePath", "");
+
+    _defineProperty(this, "_itemPath", "");
+
+    _defineProperty(this, "_materialVariantPath", "");
+
+    _defineProperty(this, "_isInitialized", false);
+
+    _defineProperty(this, "_screenshottingInProgress", false);
+
+    _defineProperty(this, "observable", new _Observable["default"](this));
+
+    _defineProperty(this, "dispatchErrorEvent", function (data) {
+      _this.observable.dispatch(_Constants.EventTypes.Error, data);
+    });
+
+    _defineProperty(this, "onLoadError", function (url) {
+      var errorMessage = "Could not load file: ".concat(url); // eslint-disable-next-line no-console
+
+      console.error(errorMessage);
+
+      _this.observable.dispatch(_Constants.EventTypes.LoadError, {
+        url: url,
+        screenshot: !!_this._screenshottingInProgress
+      });
+    });
+
+    _defineProperty(this, "onLoadStart", function () {
+      return _this.observable.dispatch(_Constants.EventTypes.LoadStart, {
+        screenshot: !!_this._screenshottingInProgress
+      });
+    });
+
+    _defineProperty(this, "onLoadFinished", function () {
+      return _this.observable.dispatch(_Constants.EventTypes.LoadFinished, {
+        screenshot: !!_this._screenshottingInProgress
+      });
+    });
+
+    if (cfg.basePath) {
+      this.setBasePath(cfg.basePath);
+    }
+  }
+  /**
+   * Initializes the visualization
+   * This function is called from the container component.
+   * It provides the opportunity to add any visualization element to the container, and do initial setup if needed.
+   * @param {HTMLElement} [container=<div>]
+   * @param {boolean} [useDefaultSetup]
+   */
+  // eslint-disable-next-line no-unused-vars
+
+
+  _createClass(VisualizationInterface, [{
+    key: "init",
+    value: function init(container, useDefaultSetup) {}
+    /**
+     * Adds the visualization element to the container
+     * This function is called from the container component, when the visualization is already initialized.
+     * (see isInitialized method below)
+     * This function should add the visualization element to the container, and do other updates if needed.
+     * @param container
+     */
+    // eslint-disable-next-line no-unused-vars
+
+  }, {
+    key: "addToContainer",
+    value: function addToContainer(container) {}
+  }, {
+    key: "isInitialized",
+    value: function isInitialized() {
+      return this._isInitialized;
+    }
+    /**
+     * Sets the base path for loading models
+     * @see getModelPaths
+     * @param {string} path
+     */
+
+  }, {
+    key: "setBasePath",
+    value: function setBasePath(path) {
+      this._basePath = path;
+    }
+    /**
+     * Sets the item path for loading models
+     * @see getModelPaths
+     * @param {string} path
+     */
+
+  }, {
+    key: "setItemPath",
+    value: function setItemPath(path) {
+      this._itemPath = path;
+    }
+  }, {
+    key: "updateItemPath",
+    value: function updateItemPath(path) {
+      this.setItemPath(path);
+      return this.loadModel();
+    }
+    /**
+     * Sets the material variant path for loading models
+     * @see getModelPaths
+     * @param {string} path
+     */
+
+  }, {
+    key: "setMaterialVariantPath",
+    value: function setMaterialVariantPath(path) {
+      this._materialVariantPath = path;
+    }
+  }, {
+    key: "updateMaterialVariantPath",
+    value: function updateMaterialVariantPath(path) {
+      this.setMaterialVariantPath(path);
+      return this.updateMaterial();
+    }
+    /**
+     * A helper function to split the given relative url to path and fileName parts
+     * @param {string|{path: string, fileName: string}} value
+     * @returns {{path: string, fileName: string}}
+     */
+
+  }, {
+    key: "getPathAndFileName",
+    value: function getPathAndFileName(value) {
+      if (_typeof(value) === "object" && value.path && value.fileName) {
+        return value;
+      } else if (typeof value === "string") {
+        var matches = value.match(/(.*\/)?([^/]+)$/);
+
+        if (matches) {
+          return {
+            path: matches[1],
+            fileName: matches[2]
+          };
+        }
+
+        throw new Error("Could not match path and filename for the string: '".concat(value, "', is it a valid path?"));
+      }
+
+      throw new Error("Unknown path value type given in getPathAndFileName. " + "It should be a string or an object { path, fileName }");
+    }
+    /**
+     * Sets the canvas size
+     * @param {number} width
+     * @param {number} height
+     * @param {boolean} rerender
+     */
+    // eslint-disable-next-line no-unused-vars
+
+  }, {
+    key: "setSize",
+    value: function setSize(_ref) {
+      var width = _ref.width,
+          height = _ref.height;
+      var rerender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    }
+    /**
+     * Loads the model from the pre-configured paths
+     * Implement this function to load resources and add them to the visualization.
+     * @see updateItemPath
+     * @see setItemPath
+     */
+
+  }, {
+    key: "loadModel",
+    value: function loadModel() {}
+    /**
+     * Updates the material on the model
+     * Implement this function to load a material and apply it on the visualization object.
+     * @see updateMaterialVariantPath
+     * @see setMaterialVariantPath
+     */
+
+  }, {
+    key: "updateMaterial",
+    value: function updateMaterial() {}
+    /**
+     * Handle updates of design area list if needed in the custom implementation
+     */
+    // eslint-disable-next-line no-unused-vars
+
+  }, {
+    key: "updateDesignAreaList",
+    value: function updateDesignAreaList(designAreaList) {}
+    /**
+     * Calls the given drawing function for custom drawing implementations
+     * It provides the drawing context (among with other custom parameters if needed) in the callback function.
+     * @param {function(ctx: CanvasRenderingContext2D, image: HTMLImageElement)} drawingFn
+     * @param {boolean} updateAlpha Indicates that the alpha map needs to be updated
+     * @param {boolean} clearTexture Indicates that the texture has to be cleared before drawing
+     * @param {string|undefined} materialName Request for a specific material texture context
+     */
+
+  }, {
+    key: "getDrawingContext",
+    value: function getDrawingContext(drawingFn) {
+      var updateAlpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var clearTexture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var materialName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+    }
+    /**
+     * Redraw the visualization
+     */
+
+  }, {
+    key: "render",
+    value: function render() {}
+  }, {
+    key: "isAnimating",
+    value: function isAnimating() {
+      return false;
+    }
+  }, {
+    key: "getScreenshots",
+    value:
+    /**
+     * A function to create screenshots from the visualization
+     * It can include switching views and async loading of resources, so the results are better returned
+     * in a callback function. If there is no result, simply return null.
+     * @param {function} callback The callback function should get the generated screenshots in the first arg
+     * @param {object} options The options object to pass extra data
+     */
+    // eslint-disable-next-line no-unused-vars
+    function () {
+      var _getScreenshots = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(callback, options) {
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                callback && callback(null);
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function getScreenshots(_x, _x2) {
+        return _getScreenshots.apply(this, arguments);
+      }
+
+      return getScreenshots;
+    }()
+    /**
+     * This function has to be called when the visualization instance is not needed any longer
+     * The implementation has to free all the allocated resources including the removal of the element appended
+     * to the container, if there is any
+     */
+
+  }, {
+    key: "dispose",
+    value: function dispose() {}
+  }]);
+
+  return VisualizationInterface;
+}();
+
+exports.VisualizationInterface = VisualizationInterface;

package/VisualizationProvider.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withVisualization = exports.VisualizationProvider = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var VisualizationContext = /*#__PURE__*/_react["default"].createContext({
+  visualization: null
+});
+
+var VisualizationProvider = function VisualizationProvider(_ref) {
+  var visualization = _ref.visualization,
+      children = _ref.children;
+  return /*#__PURE__*/_react["default"].createElement(VisualizationContext.Provider, {
+    value: {
+      visualization: visualization
+    }
+  }, children);
+};
+
+exports.VisualizationProvider = VisualizationProvider;
+
+var withVisualization = function withVisualization(Component) {
+  return function (props) {
+    return /*#__PURE__*/_react["default"].createElement(VisualizationContext.Consumer, null, function (state) {
+      return /*#__PURE__*/_react["default"].createElement(Component, _extends({}, state, props));
+    });
+  };
+};
+
+exports.withVisualization = withVisualization;