vcc-ui/lib/styleguide/provider.js

VCC UI is a collection of React UI Components that can be used for developing front-end applications at Volvo Car Corporation.

"use strict";

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

var _react = _interopRequireWildcard(require("react"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _reactFela = require("react-fela");

var _styleRenderer = require("../style-renderer");

var _index = require("../index");

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _typeof(obj) { 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 _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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

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 _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 clientRenderer = (0, _styleRenderer.styleRenderer)();
(0, _index.loadFonts)({
  fonts: ["Volvo Sans Light", "Volvo Sans Regular", "Volvo Sans Medium", "Volvo Sans Bold", "Volvo Sans Super", "Volvo Novum Light", "Volvo Novum Light Italic", "Volvo Novum Semi Light", "Volvo Novum Semi Light Italic", "Volvo Novum Regular", "Volvo Novum Italic", "Volvo Novum Medium", "Volvo Novum Medium Italic", "Volvo Novum Bold", "Volvo Novum Bold Italic", "Volvo Serif Regular", "Volvo Serif Italic", "Volvo Serif Bold", "Volvo Serif Bold Italic", "Volvo Broad"],
  pathPrefix: "/"
}, clientRenderer);

var StyleProvider =
/*#__PURE__*/
function (_Component) {
  _inherits(StyleProvider, _Component);

  function StyleProvider() {
    _classCallCheck(this, StyleProvider);

    return _possibleConstructorReturn(this, _getPrototypeOf(StyleProvider).apply(this, arguments));
  }

  _createClass(StyleProvider, [{
    key: "render",
    value: function render() {
      if (this.context.renderer) {
        return this.props.children;
      }

      return _react.default.createElement(_reactFela.Provider, {
        renderer: clientRenderer
      }, this.props.children);
    }
  }]);

  return StyleProvider;
}(_react.Component);

_defineProperty(StyleProvider, "contextTypes", {
  renderer: _propTypes.default.object
});

var _default = StyleProvider;
exports.default = _default;