7042 lines
209 KiB
JavaScript
7042 lines
209 KiB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory(require("React"));
|
|
else if(typeof define === 'function' && define.amd)
|
|
define(["React"], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["reactJss"] = factory(require("React"));
|
|
else
|
|
root["reactJss"] = factory(root["React"]);
|
|
})(this, function(__WEBPACK_EXTERNAL_MODULE_3__) {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId])
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ exports: {},
|
|
/******/ id: moduleId,
|
|
/******/ loaded: false
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.loaded = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _theming = __webpack_require__(1);
|
|
|
|
Object.defineProperty(exports, 'ThemeProvider', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _theming.ThemeProvider;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'withTheme', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _theming.withTheme;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'createTheming', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _theming.createTheming;
|
|
}
|
|
});
|
|
|
|
var _JssProvider = __webpack_require__(19);
|
|
|
|
Object.defineProperty(exports, 'JssProvider', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_JssProvider)['default'];
|
|
}
|
|
});
|
|
|
|
var _jss = __webpack_require__(20);
|
|
|
|
Object.defineProperty(exports, 'jss', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_jss)['default'];
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'SheetsRegistry', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _jss.SheetsRegistry;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'createGenerateClassName', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _jss.createGenerateClassNameDefault;
|
|
}
|
|
});
|
|
|
|
var _injectSheet = __webpack_require__(78);
|
|
|
|
Object.defineProperty(exports, 'default', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_injectSheet)['default'];
|
|
}
|
|
});
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.themeListener = exports.ThemeProvider = exports.withTheme = exports.channel = undefined;
|
|
exports.createTheming = createTheming;
|
|
|
|
var _createThemeProvider = __webpack_require__(2);
|
|
|
|
var _createThemeProvider2 = _interopRequireDefault(_createThemeProvider);
|
|
|
|
var _createWithTheme = __webpack_require__(17);
|
|
|
|
var _createWithTheme2 = _interopRequireDefault(_createWithTheme);
|
|
|
|
var _createThemeListener = __webpack_require__(18);
|
|
|
|
var _createThemeListener2 = _interopRequireDefault(_createThemeListener);
|
|
|
|
var _channel = __webpack_require__(15);
|
|
|
|
var _channel2 = _interopRequireDefault(_channel);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var channel = exports.channel = _channel2.default;
|
|
var withTheme = exports.withTheme = (0, _createWithTheme2.default)();
|
|
var ThemeProvider = exports.ThemeProvider = (0, _createThemeProvider2.default)();
|
|
var themeListener = exports.themeListener = (0, _createThemeListener2.default)();
|
|
function createTheming() {
|
|
var customChannel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _channel2.default;
|
|
|
|
return {
|
|
channel: customChannel,
|
|
withTheme: (0, _createWithTheme2.default)(customChannel),
|
|
ThemeProvider: (0, _createThemeProvider2.default)(customChannel),
|
|
themeListener: (0, _createThemeListener2.default)(customChannel)
|
|
};
|
|
}
|
|
|
|
exports.default = {
|
|
channel: _channel2.default,
|
|
withTheme: withTheme,
|
|
ThemeProvider: ThemeProvider,
|
|
themeListener: themeListener,
|
|
createTheming: createTheming
|
|
};
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
exports.default = createThemeProvider;
|
|
|
|
var _react = __webpack_require__(3);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(4);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _isFunction = __webpack_require__(12);
|
|
|
|
var _isFunction2 = _interopRequireDefault(_isFunction);
|
|
|
|
var _isPlainObject = __webpack_require__(13);
|
|
|
|
var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
|
|
|
|
var _channel = __webpack_require__(15);
|
|
|
|
var _channel2 = _interopRequireDefault(_channel);
|
|
|
|
var _brcast = __webpack_require__(16);
|
|
|
|
var _brcast2 = _interopRequireDefault(_brcast);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
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; }
|
|
|
|
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 && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { 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: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
/**
|
|
* Provide a theme to an entire react component tree via context
|
|
* and event listeners (have to do both context
|
|
* and event emitter as pure components block context updates)
|
|
*/
|
|
|
|
function createThemeProvider() {
|
|
var _class, _temp2;
|
|
|
|
var CHANNEL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _channel2.default;
|
|
|
|
return _temp2 = _class = function (_React$Component) {
|
|
_inherits(ThemeProvider, _React$Component);
|
|
|
|
function ThemeProvider() {
|
|
var _ref;
|
|
|
|
var _temp, _this, _ret;
|
|
|
|
_classCallCheck(this, ThemeProvider);
|
|
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = ThemeProvider.__proto__ || Object.getPrototypeOf(ThemeProvider)).call.apply(_ref, [this].concat(args))), _this), _this.broadcast = (0, _brcast2.default)(_this.getTheme()), _this.setOuterTheme = function (theme) {
|
|
_this.outerTheme = theme;
|
|
}, _temp), _possibleConstructorReturn(_this, _ret);
|
|
}
|
|
|
|
_createClass(ThemeProvider, [{
|
|
key: 'getTheme',
|
|
|
|
|
|
// Get the theme from the props, supporting both (outerTheme) => {} as well as object notation
|
|
value: function getTheme(passedTheme) {
|
|
var theme = passedTheme || this.props.theme;
|
|
if ((0, _isFunction2.default)(theme)) {
|
|
var mergedTheme = theme(this.outerTheme);
|
|
if (!(0, _isPlainObject2.default)(mergedTheme)) {
|
|
throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
|
|
}
|
|
return mergedTheme;
|
|
}
|
|
if (!(0, _isPlainObject2.default)(theme)) {
|
|
throw new Error('[ThemeProvider] Please make your theme prop a plain object');
|
|
}
|
|
|
|
if (!this.outerTheme) {
|
|
return theme;
|
|
}
|
|
|
|
return _extends({}, this.outerTheme, theme);
|
|
}
|
|
}, {
|
|
key: 'getChildContext',
|
|
value: function getChildContext() {
|
|
return _defineProperty({}, CHANNEL, this.broadcast);
|
|
}
|
|
}, {
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
// create a new subscription for keeping track of outer theme, if present
|
|
if (this.context[CHANNEL]) {
|
|
this.subscriptionId = this.context[CHANNEL].subscribe(this.setOuterTheme);
|
|
}
|
|
}
|
|
|
|
// set broadcast state by merging outer theme with own
|
|
|
|
}, {
|
|
key: 'componentWillMount',
|
|
value: function componentWillMount() {
|
|
if (this.context[CHANNEL]) {
|
|
this.setOuterTheme(this.context[CHANNEL].getState());
|
|
this.broadcast.setState(this.getTheme());
|
|
}
|
|
}
|
|
}, {
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(nextProps) {
|
|
if (this.props.theme !== nextProps.theme) {
|
|
this.broadcast.setState(this.getTheme(nextProps.theme));
|
|
}
|
|
}
|
|
}, {
|
|
key: 'componentWillUnmount',
|
|
value: function componentWillUnmount() {
|
|
if (this.subscriptionId !== undefined) {
|
|
this.context[CHANNEL].unsubscribe(this.subscriptionId);
|
|
delete this.subscriptionId;
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
if (!this.props.children) {
|
|
return null;
|
|
}
|
|
return _react2.default.Children.only(this.props.children);
|
|
}
|
|
}]);
|
|
|
|
return ThemeProvider;
|
|
}(_react2.default.Component), _class.propTypes = {
|
|
children: _propTypes2.default.element,
|
|
theme: _propTypes2.default.oneOfType([_propTypes2.default.shape({}), _propTypes2.default.func]).isRequired
|
|
}, _class.childContextTypes = _defineProperty({}, CHANNEL, _propTypes2.default.object.isRequired), _class.contextTypes = _defineProperty({}, CHANNEL, _propTypes2.default.object), _temp2;
|
|
}
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
if (true) {
|
|
var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&
|
|
Symbol.for &&
|
|
Symbol.for('react.element')) ||
|
|
0xeac7;
|
|
|
|
var isValidElement = function(object) {
|
|
return typeof object === 'object' &&
|
|
object !== null &&
|
|
object.$$typeof === REACT_ELEMENT_TYPE;
|
|
};
|
|
|
|
// By explicitly using `prop-types` you are opting into new development behavior.
|
|
// http://fb.me/prop-types-in-prod
|
|
var throwOnDirectAccess = true;
|
|
module.exports = __webpack_require__(5)(isValidElement, throwOnDirectAccess);
|
|
} else {
|
|
// By explicitly using `prop-types` you are opting into new production behavior.
|
|
// http://fb.me/prop-types-in-prod
|
|
module.exports = require('./factoryWithThrowingShims')();
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var emptyFunction = __webpack_require__(6);
|
|
var invariant = __webpack_require__(7);
|
|
var warning = __webpack_require__(8);
|
|
var assign = __webpack_require__(9);
|
|
|
|
var ReactPropTypesSecret = __webpack_require__(10);
|
|
var checkPropTypes = __webpack_require__(11);
|
|
|
|
module.exports = function(isValidElement, throwOnDirectAccess) {
|
|
/* global Symbol */
|
|
var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
|
|
var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
|
|
|
|
/**
|
|
* Returns the iterator method function contained on the iterable object.
|
|
*
|
|
* Be sure to invoke the function with the iterable as context:
|
|
*
|
|
* var iteratorFn = getIteratorFn(myIterable);
|
|
* if (iteratorFn) {
|
|
* var iterator = iteratorFn.call(myIterable);
|
|
* ...
|
|
* }
|
|
*
|
|
* @param {?object} maybeIterable
|
|
* @return {?function}
|
|
*/
|
|
function getIteratorFn(maybeIterable) {
|
|
var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
|
|
if (typeof iteratorFn === 'function') {
|
|
return iteratorFn;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collection of methods that allow declaration and validation of props that are
|
|
* supplied to React components. Example usage:
|
|
*
|
|
* var Props = require('ReactPropTypes');
|
|
* var MyArticle = React.createClass({
|
|
* propTypes: {
|
|
* // An optional string prop named "description".
|
|
* description: Props.string,
|
|
*
|
|
* // A required enum prop named "category".
|
|
* category: Props.oneOf(['News','Photos']).isRequired,
|
|
*
|
|
* // A prop named "dialog" that requires an instance of Dialog.
|
|
* dialog: Props.instanceOf(Dialog).isRequired
|
|
* },
|
|
* render: function() { ... }
|
|
* });
|
|
*
|
|
* A more formal specification of how these methods are used:
|
|
*
|
|
* type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
|
|
* decl := ReactPropTypes.{type}(.isRequired)?
|
|
*
|
|
* Each and every declaration produces a function with the same signature. This
|
|
* allows the creation of custom validation functions. For example:
|
|
*
|
|
* var MyLink = React.createClass({
|
|
* propTypes: {
|
|
* // An optional string or URI prop named "href".
|
|
* href: function(props, propName, componentName) {
|
|
* var propValue = props[propName];
|
|
* if (propValue != null && typeof propValue !== 'string' &&
|
|
* !(propValue instanceof URI)) {
|
|
* return new Error(
|
|
* 'Expected a string or an URI for ' + propName + ' in ' +
|
|
* componentName
|
|
* );
|
|
* }
|
|
* }
|
|
* },
|
|
* render: function() {...}
|
|
* });
|
|
*
|
|
* @internal
|
|
*/
|
|
|
|
var ANONYMOUS = '<<anonymous>>';
|
|
|
|
// Important!
|
|
// Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
|
|
var ReactPropTypes = {
|
|
array: createPrimitiveTypeChecker('array'),
|
|
bool: createPrimitiveTypeChecker('boolean'),
|
|
func: createPrimitiveTypeChecker('function'),
|
|
number: createPrimitiveTypeChecker('number'),
|
|
object: createPrimitiveTypeChecker('object'),
|
|
string: createPrimitiveTypeChecker('string'),
|
|
symbol: createPrimitiveTypeChecker('symbol'),
|
|
|
|
any: createAnyTypeChecker(),
|
|
arrayOf: createArrayOfTypeChecker,
|
|
element: createElementTypeChecker(),
|
|
instanceOf: createInstanceTypeChecker,
|
|
node: createNodeChecker(),
|
|
objectOf: createObjectOfTypeChecker,
|
|
oneOf: createEnumTypeChecker,
|
|
oneOfType: createUnionTypeChecker,
|
|
shape: createShapeTypeChecker,
|
|
exact: createStrictShapeTypeChecker,
|
|
};
|
|
|
|
/**
|
|
* inlined Object.is polyfill to avoid requiring consumers ship their own
|
|
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
|
|
*/
|
|
/*eslint-disable no-self-compare*/
|
|
function is(x, y) {
|
|
// SameValue algorithm
|
|
if (x === y) {
|
|
// Steps 1-5, 7-10
|
|
// Steps 6.b-6.e: +0 != -0
|
|
return x !== 0 || 1 / x === 1 / y;
|
|
} else {
|
|
// Step 6.a: NaN == NaN
|
|
return x !== x && y !== y;
|
|
}
|
|
}
|
|
/*eslint-enable no-self-compare*/
|
|
|
|
/**
|
|
* We use an Error-like object for backward compatibility as people may call
|
|
* PropTypes directly and inspect their output. However, we don't use real
|
|
* Errors anymore. We don't inspect their stack anyway, and creating them
|
|
* is prohibitively expensive if they are created too often, such as what
|
|
* happens in oneOfType() for any type before the one that matched.
|
|
*/
|
|
function PropTypeError(message) {
|
|
this.message = message;
|
|
this.stack = '';
|
|
}
|
|
// Make `instanceof Error` still work for returned errors.
|
|
PropTypeError.prototype = Error.prototype;
|
|
|
|
function createChainableTypeChecker(validate) {
|
|
if (true) {
|
|
var manualPropTypeCallCache = {};
|
|
var manualPropTypeWarningCount = 0;
|
|
}
|
|
function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
|
|
componentName = componentName || ANONYMOUS;
|
|
propFullName = propFullName || propName;
|
|
|
|
if (secret !== ReactPropTypesSecret) {
|
|
if (throwOnDirectAccess) {
|
|
// New behavior only for users of `prop-types` package
|
|
invariant(
|
|
false,
|
|
'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
|
|
'Use `PropTypes.checkPropTypes()` to call them. ' +
|
|
'Read more at http://fb.me/use-check-prop-types'
|
|
);
|
|
} else if (("development") !== 'production' && typeof console !== 'undefined') {
|
|
// Old behavior for people using React.PropTypes
|
|
var cacheKey = componentName + ':' + propName;
|
|
if (
|
|
!manualPropTypeCallCache[cacheKey] &&
|
|
// Avoid spamming the console because they are often not actionable except for lib authors
|
|
manualPropTypeWarningCount < 3
|
|
) {
|
|
warning(
|
|
false,
|
|
'You are manually calling a React.PropTypes validation ' +
|
|
'function for the `%s` prop on `%s`. This is deprecated ' +
|
|
'and will throw in the standalone `prop-types` package. ' +
|
|
'You may be seeing this warning due to a third-party PropTypes ' +
|
|
'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',
|
|
propFullName,
|
|
componentName
|
|
);
|
|
manualPropTypeCallCache[cacheKey] = true;
|
|
manualPropTypeWarningCount++;
|
|
}
|
|
}
|
|
}
|
|
if (props[propName] == null) {
|
|
if (isRequired) {
|
|
if (props[propName] === null) {
|
|
return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
|
|
}
|
|
return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
|
|
}
|
|
return null;
|
|
} else {
|
|
return validate(props, propName, componentName, location, propFullName);
|
|
}
|
|
}
|
|
|
|
var chainedCheckType = checkType.bind(null, false);
|
|
chainedCheckType.isRequired = checkType.bind(null, true);
|
|
|
|
return chainedCheckType;
|
|
}
|
|
|
|
function createPrimitiveTypeChecker(expectedType) {
|
|
function validate(props, propName, componentName, location, propFullName, secret) {
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== expectedType) {
|
|
// `propValue` being instance of, say, date/regexp, pass the 'object'
|
|
// check, but we can offer a more precise error message here rather than
|
|
// 'of type `object`'.
|
|
var preciseType = getPreciseType(propValue);
|
|
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createAnyTypeChecker() {
|
|
return createChainableTypeChecker(emptyFunction.thatReturnsNull);
|
|
}
|
|
|
|
function createArrayOfTypeChecker(typeChecker) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (typeof typeChecker !== 'function') {
|
|
return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
|
|
}
|
|
var propValue = props[propName];
|
|
if (!Array.isArray(propValue)) {
|
|
var propType = getPropType(propValue);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
|
|
}
|
|
for (var i = 0; i < propValue.length; i++) {
|
|
var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
|
|
if (error instanceof Error) {
|
|
return error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createElementTypeChecker() {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
if (!isValidElement(propValue)) {
|
|
var propType = getPropType(propValue);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createInstanceTypeChecker(expectedClass) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (!(props[propName] instanceof expectedClass)) {
|
|
var expectedClassName = expectedClass.name || ANONYMOUS;
|
|
var actualClassName = getClassName(props[propName]);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createEnumTypeChecker(expectedValues) {
|
|
if (!Array.isArray(expectedValues)) {
|
|
true ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
|
|
return emptyFunction.thatReturnsNull;
|
|
}
|
|
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
for (var i = 0; i < expectedValues.length; i++) {
|
|
if (is(propValue, expectedValues[i])) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var valuesString = JSON.stringify(expectedValues);
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createObjectOfTypeChecker(typeChecker) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (typeof typeChecker !== 'function') {
|
|
return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
|
|
}
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== 'object') {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
|
|
}
|
|
for (var key in propValue) {
|
|
if (propValue.hasOwnProperty(key)) {
|
|
var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
|
|
if (error instanceof Error) {
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createUnionTypeChecker(arrayOfTypeCheckers) {
|
|
if (!Array.isArray(arrayOfTypeCheckers)) {
|
|
true ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
|
|
return emptyFunction.thatReturnsNull;
|
|
}
|
|
|
|
for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
|
|
var checker = arrayOfTypeCheckers[i];
|
|
if (typeof checker !== 'function') {
|
|
warning(
|
|
false,
|
|
'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
|
|
'received %s at index %s.',
|
|
getPostfixForTypeWarning(checker),
|
|
i
|
|
);
|
|
return emptyFunction.thatReturnsNull;
|
|
}
|
|
}
|
|
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
|
|
var checker = arrayOfTypeCheckers[i];
|
|
if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createNodeChecker() {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
if (!isNode(props[propName])) {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createShapeTypeChecker(shapeTypes) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== 'object') {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
|
|
}
|
|
for (var key in shapeTypes) {
|
|
var checker = shapeTypes[key];
|
|
if (!checker) {
|
|
continue;
|
|
}
|
|
var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
|
|
if (error) {
|
|
return error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function createStrictShapeTypeChecker(shapeTypes) {
|
|
function validate(props, propName, componentName, location, propFullName) {
|
|
var propValue = props[propName];
|
|
var propType = getPropType(propValue);
|
|
if (propType !== 'object') {
|
|
return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
|
|
}
|
|
// We need to check all keys in case some are required but missing from
|
|
// props.
|
|
var allKeys = assign({}, props[propName], shapeTypes);
|
|
for (var key in allKeys) {
|
|
var checker = shapeTypes[key];
|
|
if (!checker) {
|
|
return new PropTypeError(
|
|
'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
|
|
'\nBad object: ' + JSON.stringify(props[propName], null, ' ') +
|
|
'\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')
|
|
);
|
|
}
|
|
var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
|
|
if (error) {
|
|
return error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
return createChainableTypeChecker(validate);
|
|
}
|
|
|
|
function isNode(propValue) {
|
|
switch (typeof propValue) {
|
|
case 'number':
|
|
case 'string':
|
|
case 'undefined':
|
|
return true;
|
|
case 'boolean':
|
|
return !propValue;
|
|
case 'object':
|
|
if (Array.isArray(propValue)) {
|
|
return propValue.every(isNode);
|
|
}
|
|
if (propValue === null || isValidElement(propValue)) {
|
|
return true;
|
|
}
|
|
|
|
var iteratorFn = getIteratorFn(propValue);
|
|
if (iteratorFn) {
|
|
var iterator = iteratorFn.call(propValue);
|
|
var step;
|
|
if (iteratorFn !== propValue.entries) {
|
|
while (!(step = iterator.next()).done) {
|
|
if (!isNode(step.value)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
// Iterator will provide entry [k,v] tuples rather than values.
|
|
while (!(step = iterator.next()).done) {
|
|
var entry = step.value;
|
|
if (entry) {
|
|
if (!isNode(entry[1])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function isSymbol(propType, propValue) {
|
|
// Native Symbol.
|
|
if (propType === 'symbol') {
|
|
return true;
|
|
}
|
|
|
|
// 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
|
|
if (propValue['@@toStringTag'] === 'Symbol') {
|
|
return true;
|
|
}
|
|
|
|
// Fallback for non-spec compliant Symbols which are polyfilled.
|
|
if (typeof Symbol === 'function' && propValue instanceof Symbol) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Equivalent of `typeof` but with special handling for array and regexp.
|
|
function getPropType(propValue) {
|
|
var propType = typeof propValue;
|
|
if (Array.isArray(propValue)) {
|
|
return 'array';
|
|
}
|
|
if (propValue instanceof RegExp) {
|
|
// Old webkits (at least until Android 4.0) return 'function' rather than
|
|
// 'object' for typeof a RegExp. We'll normalize this here so that /bla/
|
|
// passes PropTypes.object.
|
|
return 'object';
|
|
}
|
|
if (isSymbol(propType, propValue)) {
|
|
return 'symbol';
|
|
}
|
|
return propType;
|
|
}
|
|
|
|
// This handles more types than `getPropType`. Only used for error messages.
|
|
// See `createPrimitiveTypeChecker`.
|
|
function getPreciseType(propValue) {
|
|
if (typeof propValue === 'undefined' || propValue === null) {
|
|
return '' + propValue;
|
|
}
|
|
var propType = getPropType(propValue);
|
|
if (propType === 'object') {
|
|
if (propValue instanceof Date) {
|
|
return 'date';
|
|
} else if (propValue instanceof RegExp) {
|
|
return 'regexp';
|
|
}
|
|
}
|
|
return propType;
|
|
}
|
|
|
|
// Returns a string that is postfixed to a warning about an invalid type.
|
|
// For example, "undefined" or "of type array"
|
|
function getPostfixForTypeWarning(value) {
|
|
var type = getPreciseType(value);
|
|
switch (type) {
|
|
case 'array':
|
|
case 'object':
|
|
return 'an ' + type;
|
|
case 'boolean':
|
|
case 'date':
|
|
case 'regexp':
|
|
return 'a ' + type;
|
|
default:
|
|
return type;
|
|
}
|
|
}
|
|
|
|
// Returns class name of the object, if any.
|
|
function getClassName(propValue) {
|
|
if (!propValue.constructor || !propValue.constructor.name) {
|
|
return ANONYMOUS;
|
|
}
|
|
return propValue.constructor.name;
|
|
}
|
|
|
|
ReactPropTypes.checkPropTypes = checkPropTypes;
|
|
ReactPropTypes.PropTypes = ReactPropTypes;
|
|
|
|
return ReactPropTypes;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, exports) {
|
|
|
|
"use strict";
|
|
|
|
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
*
|
|
*/
|
|
|
|
function makeEmptyFunction(arg) {
|
|
return function () {
|
|
return arg;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* This function accepts and discards inputs; it has no side effects. This is
|
|
* primarily useful idiomatically for overridable function endpoints which
|
|
* always need to be callable, since JS lacks a null-call idiom ala Cocoa.
|
|
*/
|
|
var emptyFunction = function emptyFunction() {};
|
|
|
|
emptyFunction.thatReturns = makeEmptyFunction;
|
|
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
|
|
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
|
|
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
|
|
emptyFunction.thatReturnsThis = function () {
|
|
return this;
|
|
};
|
|
emptyFunction.thatReturnsArgument = function (arg) {
|
|
return arg;
|
|
};
|
|
|
|
module.exports = emptyFunction;
|
|
|
|
/***/ }),
|
|
/* 7 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* Use invariant() to assert state which your program assumes to be true.
|
|
*
|
|
* Provide sprintf-style format (only %s is supported) and arguments
|
|
* to provide information about what broke and what you were
|
|
* expecting.
|
|
*
|
|
* The invariant message will be stripped in production, but the invariant
|
|
* will remain to ensure logic does not differ in production.
|
|
*/
|
|
|
|
var validateFormat = function validateFormat(format) {};
|
|
|
|
if (true) {
|
|
validateFormat = function validateFormat(format) {
|
|
if (format === undefined) {
|
|
throw new Error('invariant requires an error message argument');
|
|
}
|
|
};
|
|
}
|
|
|
|
function invariant(condition, format, a, b, c, d, e, f) {
|
|
validateFormat(format);
|
|
|
|
if (!condition) {
|
|
var error;
|
|
if (format === undefined) {
|
|
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];
|
|
var argIndex = 0;
|
|
error = new Error(format.replace(/%s/g, function () {
|
|
return args[argIndex++];
|
|
}));
|
|
error.name = 'Invariant Violation';
|
|
}
|
|
|
|
error.framesToPop = 1; // we don't care about invariant's own frame
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
module.exports = invariant;
|
|
|
|
/***/ }),
|
|
/* 8 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright (c) 2014-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var emptyFunction = __webpack_require__(6);
|
|
|
|
/**
|
|
* Similar to invariant but only logs a warning if the condition is not met.
|
|
* This can be used to log issues in development environments in critical
|
|
* paths. Removing the logging code for production environments will keep the
|
|
* same logic and follow the same code paths.
|
|
*/
|
|
|
|
var warning = emptyFunction;
|
|
|
|
if (true) {
|
|
var printWarning = function printWarning(format) {
|
|
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
var argIndex = 0;
|
|
var message = 'Warning: ' + format.replace(/%s/g, function () {
|
|
return args[argIndex++];
|
|
});
|
|
if (typeof console !== 'undefined') {
|
|
console.error(message);
|
|
}
|
|
try {
|
|
// --- Welcome to debugging React ---
|
|
// This error was thrown as a convenience so that you can use this stack
|
|
// to find the callsite that caused this warning to fire.
|
|
throw new Error(message);
|
|
} catch (x) {}
|
|
};
|
|
|
|
warning = function warning(condition, format) {
|
|
if (format === undefined) {
|
|
throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
|
|
}
|
|
|
|
if (format.indexOf('Failed Composite propType: ') === 0) {
|
|
return; // Ignore CompositeComponent proptype check.
|
|
}
|
|
|
|
if (!condition) {
|
|
for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
|
|
args[_key2 - 2] = arguments[_key2];
|
|
}
|
|
|
|
printWarning.apply(undefined, [format].concat(args));
|
|
}
|
|
};
|
|
}
|
|
|
|
module.exports = warning;
|
|
|
|
/***/ }),
|
|
/* 9 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/*
|
|
object-assign
|
|
(c) Sindre Sorhus
|
|
@license MIT
|
|
*/
|
|
|
|
'use strict';
|
|
/* eslint-disable no-unused-vars */
|
|
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
|
|
|
|
function toObject(val) {
|
|
if (val === null || val === undefined) {
|
|
throw new TypeError('Object.assign cannot be called with null or undefined');
|
|
}
|
|
|
|
return Object(val);
|
|
}
|
|
|
|
function shouldUseNative() {
|
|
try {
|
|
if (!Object.assign) {
|
|
return false;
|
|
}
|
|
|
|
// Detect buggy property enumeration order in older V8 versions.
|
|
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
|
|
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
|
|
test1[5] = 'de';
|
|
if (Object.getOwnPropertyNames(test1)[0] === '5') {
|
|
return false;
|
|
}
|
|
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
|
|
var test2 = {};
|
|
for (var i = 0; i < 10; i++) {
|
|
test2['_' + String.fromCharCode(i)] = i;
|
|
}
|
|
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
|
|
return test2[n];
|
|
});
|
|
if (order2.join('') !== '0123456789') {
|
|
return false;
|
|
}
|
|
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
|
|
var test3 = {};
|
|
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
|
|
test3[letter] = letter;
|
|
});
|
|
if (Object.keys(Object.assign({}, test3)).join('') !==
|
|
'abcdefghijklmnopqrst') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
} catch (err) {
|
|
// We don't expect any of the above to throw, but better to be safe.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
|
|
var from;
|
|
var to = toObject(target);
|
|
var symbols;
|
|
|
|
for (var s = 1; s < arguments.length; s++) {
|
|
from = Object(arguments[s]);
|
|
|
|
for (var key in from) {
|
|
if (hasOwnProperty.call(from, key)) {
|
|
to[key] = from[key];
|
|
}
|
|
}
|
|
|
|
if (getOwnPropertySymbols) {
|
|
symbols = getOwnPropertySymbols(from);
|
|
for (var i = 0; i < symbols.length; i++) {
|
|
if (propIsEnumerable.call(from, symbols[i])) {
|
|
to[symbols[i]] = from[symbols[i]];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return to;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 10 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
|
|
|
|
module.exports = ReactPropTypesSecret;
|
|
|
|
|
|
/***/ }),
|
|
/* 11 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright (c) 2013-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
if (true) {
|
|
var invariant = __webpack_require__(7);
|
|
var warning = __webpack_require__(8);
|
|
var ReactPropTypesSecret = __webpack_require__(10);
|
|
var loggedTypeFailures = {};
|
|
}
|
|
|
|
/**
|
|
* Assert that the values match with the type specs.
|
|
* Error messages are memorized and will only be shown once.
|
|
*
|
|
* @param {object} typeSpecs Map of name to a ReactPropType
|
|
* @param {object} values Runtime values that need to be type-checked
|
|
* @param {string} location e.g. "prop", "context", "child context"
|
|
* @param {string} componentName Name of the component for error messages.
|
|
* @param {?Function} getStack Returns the component stack.
|
|
* @private
|
|
*/
|
|
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
|
|
if (true) {
|
|
for (var typeSpecName in typeSpecs) {
|
|
if (typeSpecs.hasOwnProperty(typeSpecName)) {
|
|
var error;
|
|
// Prop type validation may throw. In case they do, we don't want to
|
|
// fail the render phase where it didn't fail before. So we log it.
|
|
// After these have been cleaned up, we'll let them throw.
|
|
try {
|
|
// This is intentionally an invariant that gets caught. It's the same
|
|
// behavior as without this statement except with a better message.
|
|
invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);
|
|
error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
|
|
} catch (ex) {
|
|
error = ex;
|
|
}
|
|
warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);
|
|
if (error instanceof Error && !(error.message in loggedTypeFailures)) {
|
|
// Only monitor this failure once because there tends to be a lot of the
|
|
// same error.
|
|
loggedTypeFailures[error.message] = true;
|
|
|
|
var stack = getStack ? getStack() : '';
|
|
|
|
warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = checkPropTypes;
|
|
|
|
|
|
/***/ }),
|
|
/* 12 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = isFunction
|
|
|
|
var toString = Object.prototype.toString
|
|
|
|
function isFunction (fn) {
|
|
var string = toString.call(fn)
|
|
return string === '[object Function]' ||
|
|
(typeof fn === 'function' && string !== '[object RegExp]') ||
|
|
(typeof window !== 'undefined' &&
|
|
// IE8 and below
|
|
(fn === window.setTimeout ||
|
|
fn === window.alert ||
|
|
fn === window.confirm ||
|
|
fn === window.prompt))
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 13 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/*!
|
|
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
|
|
*
|
|
* Copyright (c) 2014-2017, Jon Schlinkert.
|
|
* Released under the MIT License.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var isObject = __webpack_require__(14);
|
|
|
|
function isObjectObject(o) {
|
|
return isObject(o) === true
|
|
&& Object.prototype.toString.call(o) === '[object Object]';
|
|
}
|
|
|
|
module.exports = function isPlainObject(o) {
|
|
var ctor,prot;
|
|
|
|
if (isObjectObject(o) === false) return false;
|
|
|
|
// If has modified constructor
|
|
ctor = o.constructor;
|
|
if (typeof ctor !== 'function') return false;
|
|
|
|
// If has modified prototype
|
|
prot = ctor.prototype;
|
|
if (isObjectObject(prot) === false) return false;
|
|
|
|
// If constructor does not have an Object-specific method
|
|
if (prot.hasOwnProperty('isPrototypeOf') === false) {
|
|
return false;
|
|
}
|
|
|
|
// Most likely a plain Object
|
|
return true;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 14 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/*!
|
|
* isobject <https://github.com/jonschlinkert/isobject>
|
|
*
|
|
* Copyright (c) 2014-2017, Jon Schlinkert.
|
|
* Released under the MIT License.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
module.exports = function isObject(val) {
|
|
return val != null && typeof val === 'object' && Array.isArray(val) === false;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 15 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = '__THEMING__';
|
|
|
|
/***/ }),
|
|
/* 16 */
|
|
/***/ (function(module, exports) {
|
|
|
|
function createBroadcast (initialState) {
|
|
var listeners = {};
|
|
var id = 1;
|
|
var _state = initialState;
|
|
|
|
function getState () {
|
|
return _state
|
|
}
|
|
|
|
function setState (state) {
|
|
_state = state;
|
|
var keys = Object.keys(listeners);
|
|
var i = 0;
|
|
var len = keys.length;
|
|
for (; i < len; i++) {
|
|
// if a listener gets unsubscribed during setState we just skip it
|
|
if (listeners[keys[i]]) { listeners[keys[i]](state); }
|
|
}
|
|
}
|
|
|
|
// subscribe to changes and return the subscriptionId
|
|
function subscribe (listener) {
|
|
if (typeof listener !== 'function') {
|
|
throw new Error('listener must be a function.')
|
|
}
|
|
var currentId = id;
|
|
listeners[currentId] = listener;
|
|
id += 1;
|
|
return currentId
|
|
}
|
|
|
|
// remove subscription by removing the listener function
|
|
function unsubscribe (id) {
|
|
listeners[id] = undefined;
|
|
}
|
|
|
|
return { getState: getState, setState: setState, subscribe: subscribe, unsubscribe: unsubscribe }
|
|
}
|
|
|
|
module.exports = createBroadcast;
|
|
|
|
|
|
/***/ }),
|
|
/* 17 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
exports.default = createWithTheme;
|
|
|
|
var _react = __webpack_require__(3);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _channel = __webpack_require__(15);
|
|
|
|
var _channel2 = _interopRequireDefault(_channel);
|
|
|
|
var _createThemeListener = __webpack_require__(18);
|
|
|
|
var _createThemeListener2 = _interopRequireDefault(_createThemeListener);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
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 && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { 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: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var getDisplayName = function getDisplayName(Component) {
|
|
return Component.displayName || Component.name || 'Component';
|
|
};
|
|
|
|
function createWithTheme() {
|
|
var CHANNEL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _channel2.default;
|
|
|
|
var themeListener = (0, _createThemeListener2.default)(CHANNEL);
|
|
return function (Component) {
|
|
var _class, _temp;
|
|
|
|
return _temp = _class = function (_React$Component) {
|
|
_inherits(WithTheme, _React$Component);
|
|
|
|
function WithTheme(props, context) {
|
|
_classCallCheck(this, WithTheme);
|
|
|
|
var _this = _possibleConstructorReturn(this, (WithTheme.__proto__ || Object.getPrototypeOf(WithTheme)).call(this, props, context));
|
|
|
|
_this.state = { theme: themeListener.initial(context) };
|
|
_this.setTheme = function (theme) {
|
|
return _this.setState({ theme: theme });
|
|
};
|
|
return _this;
|
|
}
|
|
|
|
_createClass(WithTheme, [{
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
this.unsubscribe = themeListener.subscribe(this.context, this.setTheme);
|
|
}
|
|
}, {
|
|
key: 'componentWillUnmount',
|
|
value: function componentWillUnmount() {
|
|
if (typeof this.unsubscribe === 'function') {
|
|
this.unsubscribe();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var theme = this.state.theme;
|
|
|
|
|
|
return _react2.default.createElement(Component, _extends({ theme: theme }, this.props));
|
|
}
|
|
}]);
|
|
|
|
return WithTheme;
|
|
}(_react2.default.Component), _class.displayName = 'WithTheme(' + getDisplayName(Component) + ')', _class.contextTypes = themeListener.contextTypes, _temp;
|
|
};
|
|
}
|
|
|
|
/***/ }),
|
|
/* 18 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = createThemeListener;
|
|
|
|
var _propTypes = __webpack_require__(4);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _channel = __webpack_require__(15);
|
|
|
|
var _channel2 = _interopRequireDefault(_channel);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
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; }
|
|
|
|
function createThemeListener() {
|
|
var CHANNEL = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _channel2.default;
|
|
|
|
var contextTypes = _defineProperty({}, CHANNEL, _propTypes2.default.object.isRequired);
|
|
|
|
function initial(context) {
|
|
if (!context[CHANNEL]) {
|
|
throw new Error('[' + this.displayName + '] Please use ThemeProvider to be able to use WithTheme');
|
|
}
|
|
|
|
return context[CHANNEL].getState();
|
|
}
|
|
|
|
function subscribe(context, cb) {
|
|
if (context[CHANNEL]) {
|
|
return context[CHANNEL].subscribe(cb);
|
|
}
|
|
}
|
|
|
|
function unsubscribe(context, subscriptionId) {
|
|
if (context[CHANNEL]) {
|
|
context[CHANNEL].unsubscribe(subscriptionId);
|
|
}
|
|
}
|
|
|
|
return {
|
|
contextTypes: contextTypes,
|
|
initial: initial,
|
|
subscribe: subscribe,
|
|
unsubscribe: unsubscribe
|
|
};
|
|
}
|
|
|
|
/***/ }),
|
|
/* 19 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _react = __webpack_require__(3);
|
|
|
|
var _propTypes = __webpack_require__(4);
|
|
|
|
var _jss = __webpack_require__(20);
|
|
|
|
var _ns = __webpack_require__(75);
|
|
|
|
var ns = _interopRequireWildcard(_ns);
|
|
|
|
var _contextTypes = __webpack_require__(76);
|
|
|
|
var _contextTypes2 = _interopRequireDefault(_contextTypes);
|
|
|
|
var _propTypes2 = __webpack_require__(77);
|
|
|
|
var _propTypes3 = _interopRequireDefault(_propTypes2);
|
|
|
|
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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
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; }
|
|
|
|
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 && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { 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: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var JssProvider = function (_Component) {
|
|
_inherits(JssProvider, _Component);
|
|
|
|
function JssProvider() {
|
|
_classCallCheck(this, JssProvider);
|
|
|
|
return _possibleConstructorReturn(this, (JssProvider.__proto__ || Object.getPrototypeOf(JssProvider)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass(JssProvider, [{
|
|
key: 'getChildContext',
|
|
|
|
|
|
// JssProvider can be nested. We allow to overwrite any context prop at any level.
|
|
// 1. Check if there is a value passed over props.
|
|
// 2. If value was passed, we set it on the child context.
|
|
// 3. If value was not passed, we proxy parent context (default context behaviour).
|
|
value: function getChildContext() {
|
|
var _props = this.props,
|
|
registry = _props.registry,
|
|
classNamePrefix = _props.classNamePrefix,
|
|
localJss = _props.jss,
|
|
generateClassName = _props.generateClassName,
|
|
disableStylesGeneration = _props.disableStylesGeneration;
|
|
|
|
var sheetOptions = this.context[ns.sheetOptions] || {};
|
|
var context = _defineProperty({}, ns.sheetOptions, sheetOptions);
|
|
|
|
if (registry) {
|
|
context[ns.sheetsRegistry] = registry;
|
|
// This way we identify a new request on the server, because user will create
|
|
// a new Registry instance for each.
|
|
if (registry !== this.registry) {
|
|
// We reset managers because we have to regenerate all sheets for the new request.
|
|
this.managers = {};
|
|
this.registry = registry;
|
|
}
|
|
}
|
|
|
|
// Make sure we don't loose managers when JssProvider is used inside of a stateful
|
|
// component which decides to rerender.
|
|
context[ns.managers] = this.managers;
|
|
|
|
if (generateClassName) {
|
|
sheetOptions.generateClassName = generateClassName;
|
|
} else if (!sheetOptions.generateClassName) {
|
|
if (!this.generateClassName) {
|
|
var createGenerateClassName = _jss.createGenerateClassNameDefault;
|
|
if (localJss && localJss.options.createGenerateClassName) {
|
|
createGenerateClassName = localJss.options.createGenerateClassName;
|
|
}
|
|
// Make sure we don't loose the generator when JssProvider is used inside of a stateful
|
|
// component which decides to rerender.
|
|
this.generateClassName = createGenerateClassName();
|
|
}
|
|
|
|
sheetOptions.generateClassName = this.generateClassName;
|
|
}
|
|
|
|
if (classNamePrefix) sheetOptions.classNamePrefix = classNamePrefix;
|
|
if (localJss) context[ns.jss] = localJss;
|
|
if (disableStylesGeneration !== undefined) {
|
|
sheetOptions.disableStylesGeneration = disableStylesGeneration;
|
|
}
|
|
|
|
return context;
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
return _react.Children.only(this.props.children);
|
|
}
|
|
}]);
|
|
|
|
return JssProvider;
|
|
}(_react.Component);
|
|
|
|
JssProvider.propTypes = _extends({}, _propTypes3['default'], {
|
|
generateClassName: _propTypes.func,
|
|
classNamePrefix: _propTypes.string,
|
|
disableStylesGeneration: _propTypes.bool,
|
|
children: _propTypes.node.isRequired
|
|
});
|
|
JssProvider.childContextTypes = _contextTypes2['default'];
|
|
JssProvider.contextTypes = _contextTypes2['default'];
|
|
exports['default'] = JssProvider;
|
|
|
|
/***/ }),
|
|
/* 20 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.createGenerateClassNameDefault = exports.SheetsManager = exports.getDynamicStyles = exports.SheetsRegistry = undefined;
|
|
|
|
var _jss = __webpack_require__(21);
|
|
|
|
Object.defineProperty(exports, 'SheetsRegistry', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _jss.SheetsRegistry;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'getDynamicStyles', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _jss.getDynamicStyles;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'SheetsManager', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _jss.SheetsManager;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, 'createGenerateClassNameDefault', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _jss.createGenerateClassName;
|
|
}
|
|
});
|
|
|
|
var _jssPresetDefault = __webpack_require__(55);
|
|
|
|
var _jssPresetDefault2 = _interopRequireDefault(_jssPresetDefault);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
exports['default'] = (0, _jss.create)((0, _jssPresetDefault2['default'])());
|
|
|
|
/***/ }),
|
|
/* 21 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.create = exports.createGenerateClassName = exports.sheets = exports.RuleList = exports.SheetsManager = exports.SheetsRegistry = exports.toCssValue = exports.getDynamicStyles = undefined;
|
|
|
|
var _getDynamicStyles = __webpack_require__(22);
|
|
|
|
Object.defineProperty(exports, 'getDynamicStyles', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_getDynamicStyles)['default'];
|
|
}
|
|
});
|
|
|
|
var _toCssValue = __webpack_require__(23);
|
|
|
|
Object.defineProperty(exports, 'toCssValue', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_toCssValue)['default'];
|
|
}
|
|
});
|
|
|
|
var _SheetsRegistry = __webpack_require__(24);
|
|
|
|
Object.defineProperty(exports, 'SheetsRegistry', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_SheetsRegistry)['default'];
|
|
}
|
|
});
|
|
|
|
var _SheetsManager = __webpack_require__(25);
|
|
|
|
Object.defineProperty(exports, 'SheetsManager', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_SheetsManager)['default'];
|
|
}
|
|
});
|
|
|
|
var _RuleList = __webpack_require__(27);
|
|
|
|
Object.defineProperty(exports, 'RuleList', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_RuleList)['default'];
|
|
}
|
|
});
|
|
|
|
var _sheets = __webpack_require__(38);
|
|
|
|
Object.defineProperty(exports, 'sheets', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_sheets)['default'];
|
|
}
|
|
});
|
|
|
|
var _createGenerateClassName = __webpack_require__(39);
|
|
|
|
Object.defineProperty(exports, 'createGenerateClassName', {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _interopRequireDefault(_createGenerateClassName)['default'];
|
|
}
|
|
});
|
|
|
|
var _Jss = __webpack_require__(42);
|
|
|
|
var _Jss2 = _interopRequireDefault(_Jss);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* Creates a new instance of Jss.
|
|
*/
|
|
var create = exports.create = function create(options) {
|
|
return new _Jss2['default'](options);
|
|
};
|
|
|
|
/**
|
|
* A global Jss instance.
|
|
*/
|
|
exports['default'] = create();
|
|
|
|
/***/ }),
|
|
/* 22 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
exports['default'] = getDynamicStyles;
|
|
/**
|
|
* Extracts a styles object with only props that contain function values.
|
|
*/
|
|
function getDynamicStyles(styles) {
|
|
var to = null;
|
|
|
|
for (var key in styles) {
|
|
var value = styles[key];
|
|
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
|
|
|
|
if (type === 'function') {
|
|
if (!to) to = {};
|
|
to[key] = value;
|
|
} else if (type === 'object' && value !== null && !Array.isArray(value)) {
|
|
var extracted = getDynamicStyles(value);
|
|
if (extracted) {
|
|
if (!to) to = {};
|
|
to[key] = extracted;
|
|
}
|
|
}
|
|
}
|
|
|
|
return to;
|
|
}
|
|
|
|
/***/ }),
|
|
/* 23 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = toCssValue;
|
|
var join = function join(value, by) {
|
|
var result = '';
|
|
for (var i = 0; i < value.length; i++) {
|
|
// Remove !important from the value, it will be readded later.
|
|
if (value[i] === '!important') break;
|
|
if (result) result += by;
|
|
result += value[i];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Converts array values to string.
|
|
*
|
|
* `margin: [['5px', '10px']]` > `margin: 5px 10px;`
|
|
* `border: ['1px', '2px']` > `border: 1px, 2px;`
|
|
* `margin: [['5px', '10px'], '!important']` > `margin: 5px 10px !important;`
|
|
* `color: ['red', !important]` > `color: red !important;`
|
|
*/
|
|
function toCssValue(value) {
|
|
var ignoreImportant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
|
|
if (!Array.isArray(value)) return value;
|
|
|
|
var cssValue = '';
|
|
|
|
// Support space separated values via `[['5px', '10px']]`.
|
|
if (Array.isArray(value[0])) {
|
|
for (var i = 0; i < value.length; i++) {
|
|
if (value[i] === '!important') break;
|
|
if (cssValue) cssValue += ', ';
|
|
cssValue += join(value[i], ' ');
|
|
}
|
|
} else cssValue = join(value, ', ');
|
|
|
|
// Add !important, because it was ignored.
|
|
if (!ignoreImportant && value[value.length - 1] === '!important') {
|
|
cssValue += ' !important';
|
|
}
|
|
|
|
return cssValue;
|
|
}
|
|
|
|
/***/ }),
|
|
/* 24 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/**
|
|
* Sheets registry to access them all at one place.
|
|
*/
|
|
var SheetsRegistry = function () {
|
|
function SheetsRegistry() {
|
|
_classCallCheck(this, SheetsRegistry);
|
|
|
|
this.registry = [];
|
|
}
|
|
|
|
_createClass(SheetsRegistry, [{
|
|
key: 'add',
|
|
|
|
|
|
/**
|
|
* Register a Style Sheet.
|
|
*/
|
|
value: function add(sheet) {
|
|
var registry = this.registry;
|
|
var index = sheet.options.index;
|
|
|
|
|
|
if (registry.indexOf(sheet) !== -1) return;
|
|
|
|
if (registry.length === 0 || index >= this.index) {
|
|
registry.push(sheet);
|
|
return;
|
|
}
|
|
|
|
// Find a position.
|
|
for (var i = 0; i < registry.length; i++) {
|
|
if (registry[i].options.index > index) {
|
|
registry.splice(i, 0, sheet);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reset the registry.
|
|
*/
|
|
|
|
}, {
|
|
key: 'reset',
|
|
value: function reset() {
|
|
this.registry = [];
|
|
}
|
|
|
|
/**
|
|
* Remove a Style Sheet.
|
|
*/
|
|
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove(sheet) {
|
|
var index = this.registry.indexOf(sheet);
|
|
this.registry.splice(index, 1);
|
|
}
|
|
|
|
/**
|
|
* Convert all attached sheets to a CSS string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
return this.registry.filter(function (sheet) {
|
|
return sheet.attached;
|
|
}).map(function (sheet) {
|
|
return sheet.toString(options);
|
|
}).join('\n');
|
|
}
|
|
}, {
|
|
key: 'index',
|
|
|
|
|
|
/**
|
|
* Current highest index number.
|
|
*/
|
|
get: function get() {
|
|
return this.registry.length === 0 ? 0 : this.registry[this.registry.length - 1].options.index;
|
|
}
|
|
}]);
|
|
|
|
return SheetsRegistry;
|
|
}();
|
|
|
|
exports['default'] = SheetsRegistry;
|
|
|
|
/***/ }),
|
|
/* 25 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/**
|
|
* SheetsManager is like a WeakMap which is designed to count StyleSheet
|
|
* instances and attach/detach automatically.
|
|
*/
|
|
var SheetsManager = function () {
|
|
function SheetsManager() {
|
|
_classCallCheck(this, SheetsManager);
|
|
|
|
this.sheets = [];
|
|
this.refs = [];
|
|
this.keys = [];
|
|
}
|
|
|
|
_createClass(SheetsManager, [{
|
|
key: 'get',
|
|
value: function get(key) {
|
|
var index = this.keys.indexOf(key);
|
|
return this.sheets[index];
|
|
}
|
|
}, {
|
|
key: 'add',
|
|
value: function add(key, sheet) {
|
|
var sheets = this.sheets,
|
|
refs = this.refs,
|
|
keys = this.keys;
|
|
|
|
var index = sheets.indexOf(sheet);
|
|
|
|
if (index !== -1) return index;
|
|
|
|
sheets.push(sheet);
|
|
refs.push(0);
|
|
keys.push(key);
|
|
|
|
return sheets.length - 1;
|
|
}
|
|
}, {
|
|
key: 'manage',
|
|
value: function manage(key) {
|
|
var index = this.keys.indexOf(key);
|
|
var sheet = this.sheets[index];
|
|
if (this.refs[index] === 0) sheet.attach();
|
|
this.refs[index]++;
|
|
if (!this.keys[index]) this.keys.splice(index, 0, key);
|
|
return sheet;
|
|
}
|
|
}, {
|
|
key: 'unmanage',
|
|
value: function unmanage(key) {
|
|
var index = this.keys.indexOf(key);
|
|
if (index === -1) {
|
|
// eslint-ignore-next-line no-console
|
|
(0, _warning2['default'])(false, "SheetsManager: can't find sheet to unmanage");
|
|
return;
|
|
}
|
|
if (this.refs[index] > 0) {
|
|
this.refs[index]--;
|
|
if (this.refs[index] === 0) this.sheets[index].detach();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'size',
|
|
get: function get() {
|
|
return this.keys.length;
|
|
}
|
|
}]);
|
|
|
|
return SheetsManager;
|
|
}();
|
|
|
|
exports['default'] = SheetsManager;
|
|
|
|
/***/ }),
|
|
/* 26 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright 2014-2015, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* Similar to invariant but only logs a warning if the condition is not met.
|
|
* This can be used to log issues in development environments in critical
|
|
* paths. Removing the logging code for production environments will keep the
|
|
* same logic and follow the same code paths.
|
|
*/
|
|
|
|
var warning = function() {};
|
|
|
|
if (true) {
|
|
warning = function(condition, format, args) {
|
|
var len = arguments.length;
|
|
args = new Array(len > 2 ? len - 2 : 0);
|
|
for (var key = 2; key < len; key++) {
|
|
args[key - 2] = arguments[key];
|
|
}
|
|
if (format === undefined) {
|
|
throw new Error(
|
|
'`warning(condition, format, ...args)` requires a warning ' +
|
|
'message argument'
|
|
);
|
|
}
|
|
|
|
if (format.length < 10 || (/^[s\W]*$/).test(format)) {
|
|
throw new Error(
|
|
'The warning format should be able to uniquely identify this ' +
|
|
'warning. Please, use a more descriptive format than: ' + format
|
|
);
|
|
}
|
|
|
|
if (!condition) {
|
|
var argIndex = 0;
|
|
var message = 'Warning: ' +
|
|
format.replace(/%s/g, function() {
|
|
return args[argIndex++];
|
|
});
|
|
if (typeof console !== 'undefined') {
|
|
console.error(message);
|
|
}
|
|
try {
|
|
// This error was thrown as a convenience so that you can use this stack
|
|
// to find the callsite that caused this warning to fire.
|
|
throw new Error(message);
|
|
} catch(x) {}
|
|
}
|
|
};
|
|
}
|
|
|
|
module.exports = warning;
|
|
|
|
|
|
/***/ }),
|
|
/* 27 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _createRule = __webpack_require__(28);
|
|
|
|
var _createRule2 = _interopRequireDefault(_createRule);
|
|
|
|
var _linkRule = __webpack_require__(36);
|
|
|
|
var _linkRule2 = _interopRequireDefault(_linkRule);
|
|
|
|
var _StyleRule = __webpack_require__(29);
|
|
|
|
var _StyleRule2 = _interopRequireDefault(_StyleRule);
|
|
|
|
var _escape = __webpack_require__(37);
|
|
|
|
var _escape2 = _interopRequireDefault(_escape);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/**
|
|
* Contains rules objects and allows adding/removing etc.
|
|
* Is used for e.g. by `StyleSheet` or `ConditionalRule`.
|
|
*/
|
|
var RuleList = function () {
|
|
|
|
// Original styles object.
|
|
function RuleList(options) {
|
|
_classCallCheck(this, RuleList);
|
|
|
|
this.map = {};
|
|
this.raw = {};
|
|
this.index = [];
|
|
|
|
this.options = options;
|
|
this.classes = options.classes;
|
|
}
|
|
|
|
/**
|
|
* Create and register rule.
|
|
*
|
|
* Will not render after Style Sheet was rendered the first time.
|
|
*/
|
|
|
|
|
|
// Used to ensure correct rules order.
|
|
|
|
// Rules registry for access by .get() method.
|
|
// It contains the same rule registered by name and by selector.
|
|
|
|
|
|
_createClass(RuleList, [{
|
|
key: 'add',
|
|
value: function add(name, decl, options) {
|
|
var _options = this.options,
|
|
parent = _options.parent,
|
|
sheet = _options.sheet,
|
|
jss = _options.jss,
|
|
Renderer = _options.Renderer,
|
|
generateClassName = _options.generateClassName;
|
|
|
|
|
|
options = _extends({
|
|
classes: this.classes,
|
|
parent: parent,
|
|
sheet: sheet,
|
|
jss: jss,
|
|
Renderer: Renderer,
|
|
generateClassName: generateClassName
|
|
}, options);
|
|
|
|
if (!options.selector && this.classes[name]) {
|
|
options.selector = '.' + (0, _escape2['default'])(this.classes[name]);
|
|
}
|
|
|
|
this.raw[name] = decl;
|
|
|
|
var rule = (0, _createRule2['default'])(name, decl, options);
|
|
|
|
var className = void 0;
|
|
|
|
if (!options.selector && rule instanceof _StyleRule2['default']) {
|
|
className = generateClassName(rule, sheet);
|
|
rule.selector = '.' + (0, _escape2['default'])(className);
|
|
}
|
|
|
|
this.register(rule, className);
|
|
|
|
var index = options.index === undefined ? this.index.length : options.index;
|
|
this.index.splice(index, 0, rule);
|
|
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Get a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'get',
|
|
value: function get(name) {
|
|
return this.map[name];
|
|
}
|
|
|
|
/**
|
|
* Delete a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove(rule) {
|
|
this.unregister(rule);
|
|
this.index.splice(this.indexOf(rule), 1);
|
|
}
|
|
|
|
/**
|
|
* Get index of a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'indexOf',
|
|
value: function indexOf(rule) {
|
|
return this.index.indexOf(rule);
|
|
}
|
|
|
|
/**
|
|
* Run `onProcessRule()` plugins on every rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'process',
|
|
value: function process() {
|
|
var plugins = this.options.jss.plugins;
|
|
// We need to clone array because if we modify the index somewhere else during a loop
|
|
// we end up with very hard-to-track-down side effects.
|
|
|
|
this.index.slice(0).forEach(plugins.onProcessRule, plugins);
|
|
}
|
|
|
|
/**
|
|
* Register a rule in `.map` and `.classes` maps.
|
|
*/
|
|
|
|
}, {
|
|
key: 'register',
|
|
value: function register(rule, className) {
|
|
this.map[rule.key] = rule;
|
|
if (rule instanceof _StyleRule2['default']) {
|
|
this.map[rule.selector] = rule;
|
|
if (className) this.classes[rule.key] = className;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unregister a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'unregister',
|
|
value: function unregister(rule) {
|
|
delete this.map[rule.key];
|
|
if (rule instanceof _StyleRule2['default']) {
|
|
delete this.map[rule.selector];
|
|
delete this.classes[rule.key];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update the function values with a new data.
|
|
*/
|
|
|
|
}, {
|
|
key: 'update',
|
|
value: function update(name, data) {
|
|
var _options2 = this.options,
|
|
plugins = _options2.jss.plugins,
|
|
sheet = _options2.sheet;
|
|
|
|
if (typeof name === 'string') {
|
|
plugins.onUpdate(data, this.get(name), sheet);
|
|
return;
|
|
}
|
|
|
|
for (var index = 0; index < this.index.length; index++) {
|
|
plugins.onUpdate(name, this.index[index], sheet);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Link renderable rules with CSSRuleList.
|
|
*/
|
|
|
|
}, {
|
|
key: 'link',
|
|
value: function link(cssRules) {
|
|
var map = this.options.sheet.renderer.getUnescapedKeysMap(this.index);
|
|
|
|
for (var i = 0; i < cssRules.length; i++) {
|
|
var cssRule = cssRules[i];
|
|
var _key = this.options.sheet.renderer.getKey(cssRule);
|
|
if (map[_key]) _key = map[_key];
|
|
var rule = this.map[_key];
|
|
if (rule) (0, _linkRule2['default'])(rule, cssRule);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert rules to a CSS string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
var str = '';
|
|
var sheet = this.options.sheet;
|
|
|
|
var link = sheet ? sheet.options.link : false;
|
|
|
|
for (var index = 0; index < this.index.length; index++) {
|
|
var rule = this.index[index];
|
|
var css = rule.toString(options);
|
|
|
|
// No need to render an empty rule.
|
|
if (!css && !link) continue;
|
|
|
|
if (str) str += '\n';
|
|
str += css;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
}]);
|
|
|
|
return RuleList;
|
|
}();
|
|
|
|
exports['default'] = RuleList;
|
|
|
|
/***/ }),
|
|
/* 28 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = createRule;
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
var _StyleRule = __webpack_require__(29);
|
|
|
|
var _StyleRule2 = _interopRequireDefault(_StyleRule);
|
|
|
|
var _cloneStyle = __webpack_require__(31);
|
|
|
|
var _cloneStyle2 = _interopRequireDefault(_cloneStyle);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* Create a rule instance.
|
|
*/
|
|
function createRule() {
|
|
var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'unnamed';
|
|
var decl = arguments[1];
|
|
var options = arguments[2];
|
|
var jss = options.jss;
|
|
|
|
var declCopy = (0, _cloneStyle2['default'])(decl);
|
|
|
|
var rule = jss.plugins.onCreateRule(name, declCopy, options);
|
|
if (rule) return rule;
|
|
|
|
// It is an at-rule and it has no instance.
|
|
if (name[0] === '@') {
|
|
(0, _warning2['default'])(false, '[JSS] Unknown at-rule %s', name);
|
|
}
|
|
|
|
return new _StyleRule2['default'](name, declCopy, options);
|
|
}
|
|
|
|
/***/ }),
|
|
/* 29 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
var _toCss = __webpack_require__(30);
|
|
|
|
var _toCss2 = _interopRequireDefault(_toCss);
|
|
|
|
var _toCssValue = __webpack_require__(23);
|
|
|
|
var _toCssValue2 = _interopRequireDefault(_toCssValue);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var StyleRule = function () {
|
|
function StyleRule(key, style, options) {
|
|
_classCallCheck(this, StyleRule);
|
|
|
|
this.type = 'style';
|
|
this.isProcessed = false;
|
|
var sheet = options.sheet,
|
|
Renderer = options.Renderer,
|
|
selector = options.selector;
|
|
|
|
this.key = key;
|
|
this.options = options;
|
|
this.style = style;
|
|
if (selector) this.selectorText = selector;
|
|
this.renderer = sheet ? sheet.renderer : new Renderer();
|
|
}
|
|
|
|
/**
|
|
* Set selector string.
|
|
* Attention: use this with caution. Most browsers didn't implement
|
|
* selectorText setter, so this may result in rerendering of entire Style Sheet.
|
|
*/
|
|
|
|
|
|
_createClass(StyleRule, [{
|
|
key: 'prop',
|
|
|
|
|
|
/**
|
|
* Get or set a style property.
|
|
*/
|
|
value: function prop(name, value) {
|
|
// It's a getter.
|
|
if (value === undefined) return this.style[name];
|
|
|
|
// Don't do anything if the value has not changed.
|
|
if (this.style[name] === value) return this;
|
|
|
|
value = this.options.jss.plugins.onChangeValue(value, name, this);
|
|
|
|
var isEmpty = value == null || value === false;
|
|
var isDefined = name in this.style;
|
|
|
|
// Value is empty and wasn't defined before.
|
|
if (isEmpty && !isDefined) return this;
|
|
|
|
// We are going to remove this value.
|
|
var remove = isEmpty && isDefined;
|
|
|
|
if (remove) delete this.style[name];else this.style[name] = value;
|
|
|
|
// Renderable is defined if StyleSheet option `link` is true.
|
|
if (this.renderable) {
|
|
if (remove) this.renderer.removeProperty(this.renderable, name);else this.renderer.setProperty(this.renderable, name, value);
|
|
return this;
|
|
}
|
|
|
|
var sheet = this.options.sheet;
|
|
|
|
if (sheet && sheet.attached) {
|
|
(0, _warning2['default'])(false, 'Rule is not linked. Missing sheet option "link: true".');
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Apply rule to an element inline.
|
|
*/
|
|
|
|
}, {
|
|
key: 'applyTo',
|
|
value: function applyTo(renderable) {
|
|
var json = this.toJSON();
|
|
for (var prop in json) {
|
|
this.renderer.setProperty(renderable, prop, json[prop]);
|
|
}return this;
|
|
}
|
|
|
|
/**
|
|
* Returns JSON representation of the rule.
|
|
* Fallbacks are not supported.
|
|
* Useful for inline styles.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toJSON',
|
|
value: function toJSON() {
|
|
var json = {};
|
|
for (var prop in this.style) {
|
|
var value = this.style[prop];
|
|
if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) !== 'object') json[prop] = value;else if (Array.isArray(value)) json[prop] = (0, _toCssValue2['default'])(value);
|
|
}
|
|
return json;
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
var sheet = this.options.sheet;
|
|
|
|
var link = sheet ? sheet.options.link : false;
|
|
var opts = link ? _extends({}, options, { allowEmpty: true }) : options;
|
|
return (0, _toCss2['default'])(this.selector, this.style, opts);
|
|
}
|
|
}, {
|
|
key: 'selector',
|
|
set: function set(selector) {
|
|
if (selector === this.selectorText) return;
|
|
|
|
this.selectorText = selector;
|
|
|
|
if (!this.renderable) return;
|
|
|
|
var hasChanged = this.renderer.setSelector(this.renderable, selector);
|
|
|
|
// If selector setter is not implemented, rerender the rule.
|
|
if (!hasChanged && this.renderable) {
|
|
var renderable = this.renderer.replaceRule(this.renderable, this);
|
|
if (renderable) this.renderable = renderable;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get selector string.
|
|
*/
|
|
,
|
|
get: function get() {
|
|
return this.selectorText;
|
|
}
|
|
}]);
|
|
|
|
return StyleRule;
|
|
}();
|
|
|
|
exports['default'] = StyleRule;
|
|
|
|
/***/ }),
|
|
/* 30 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = toCss;
|
|
|
|
var _toCssValue = __webpack_require__(23);
|
|
|
|
var _toCssValue2 = _interopRequireDefault(_toCssValue);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* Indent a string.
|
|
* http://jsperf.com/array-join-vs-for
|
|
*/
|
|
function indentStr(str, indent) {
|
|
var result = '';
|
|
for (var index = 0; index < indent; index++) {
|
|
result += ' ';
|
|
}return result + str;
|
|
}
|
|
|
|
/**
|
|
* Converts a Rule to CSS string.
|
|
*/
|
|
|
|
function toCss(selector, style) {
|
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
|
|
var result = '';
|
|
|
|
if (!style) return result;
|
|
|
|
var _options$indent = options.indent,
|
|
indent = _options$indent === undefined ? 0 : _options$indent;
|
|
var fallbacks = style.fallbacks;
|
|
|
|
|
|
indent++;
|
|
|
|
// Apply fallbacks first.
|
|
if (fallbacks) {
|
|
// Array syntax {fallbacks: [{prop: value}]}
|
|
if (Array.isArray(fallbacks)) {
|
|
for (var index = 0; index < fallbacks.length; index++) {
|
|
var fallback = fallbacks[index];
|
|
for (var prop in fallback) {
|
|
var value = fallback[prop];
|
|
if (value != null) {
|
|
result += '\n' + indentStr(prop + ': ' + (0, _toCssValue2['default'])(value) + ';', indent);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Object syntax {fallbacks: {prop: value}}
|
|
for (var _prop in fallbacks) {
|
|
var _value = fallbacks[_prop];
|
|
if (_value != null) {
|
|
result += '\n' + indentStr(_prop + ': ' + (0, _toCssValue2['default'])(_value) + ';', indent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var _prop2 in style) {
|
|
var _value2 = style[_prop2];
|
|
if (_value2 != null && _prop2 !== 'fallbacks') {
|
|
result += '\n' + indentStr(_prop2 + ': ' + (0, _toCssValue2['default'])(_value2) + ';', indent);
|
|
}
|
|
}
|
|
|
|
// Allow empty style in this case, because properties will be added dynamically.
|
|
if (!result && !options.allowEmpty) return result;
|
|
|
|
indent--;
|
|
result = indentStr(selector + ' {' + result + '\n', indent) + indentStr('}', indent);
|
|
|
|
return result;
|
|
}
|
|
|
|
/***/ }),
|
|
/* 31 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
exports['default'] = cloneStyle;
|
|
|
|
var _isObservable = __webpack_require__(32);
|
|
|
|
var _isObservable2 = _interopRequireDefault(_isObservable);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var isArray = Array.isArray;
|
|
function cloneStyle(style) {
|
|
// Support empty values in case user ends up with them by accident.
|
|
if (style == null) return style;
|
|
|
|
// Support string value for SimpleRule.
|
|
var typeOfStyle = typeof style === 'undefined' ? 'undefined' : _typeof(style);
|
|
|
|
if (typeOfStyle === 'string' || typeOfStyle === 'number' || typeOfStyle === 'function') {
|
|
return style;
|
|
}
|
|
|
|
// Support array for FontFaceRule.
|
|
if (isArray(style)) return style.map(cloneStyle);
|
|
|
|
// Support Observable styles. Observables are immutable, so we don't need to
|
|
// copy them.
|
|
if ((0, _isObservable2['default'])(style)) return style;
|
|
|
|
var newStyle = {};
|
|
for (var name in style) {
|
|
var value = style[name];
|
|
if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
|
|
newStyle[name] = cloneStyle(value);
|
|
continue;
|
|
}
|
|
newStyle[name] = value;
|
|
}
|
|
|
|
return newStyle;
|
|
}
|
|
|
|
/***/ }),
|
|
/* 32 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _symbolObservable = __webpack_require__(33);
|
|
|
|
var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
exports['default'] = function (value) {
|
|
return value && value[_symbolObservable2['default']] && value === value[_symbolObservable2['default']]();
|
|
};
|
|
|
|
/***/ }),
|
|
/* 33 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(global, module) {'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _ponyfill = __webpack_require__(35);
|
|
|
|
var _ponyfill2 = _interopRequireDefault(_ponyfill);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var root; /* global window */
|
|
|
|
|
|
if (typeof self !== 'undefined') {
|
|
root = self;
|
|
} else if (typeof window !== 'undefined') {
|
|
root = window;
|
|
} else if (typeof global !== 'undefined') {
|
|
root = global;
|
|
} else if (true) {
|
|
root = module;
|
|
} else {
|
|
root = Function('return this')();
|
|
}
|
|
|
|
var result = (0, _ponyfill2['default'])(root);
|
|
exports['default'] = result;
|
|
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(34)(module)))
|
|
|
|
/***/ }),
|
|
/* 34 */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = function(module) {
|
|
if(!module.webpackPolyfill) {
|
|
module.deprecate = function() {};
|
|
module.paths = [];
|
|
// module.parent = undefined by default
|
|
module.children = [];
|
|
module.webpackPolyfill = 1;
|
|
}
|
|
return module;
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 35 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = symbolObservablePonyfill;
|
|
function symbolObservablePonyfill(root) {
|
|
var result;
|
|
var _Symbol = root.Symbol;
|
|
|
|
if (typeof _Symbol === 'function') {
|
|
if (_Symbol.observable) {
|
|
result = _Symbol.observable;
|
|
} else {
|
|
result = _Symbol('observable');
|
|
_Symbol.observable = result;
|
|
}
|
|
} else {
|
|
result = '@@observable';
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 36 */
|
|
/***/ (function(module, exports) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports["default"] = linkRule;
|
|
/**
|
|
* Link rule with CSSStyleRule and nested rules with corresponding nested cssRules if both exists.
|
|
*/
|
|
function linkRule(rule, cssRule) {
|
|
rule.renderable = cssRule;
|
|
if (rule.rules && cssRule.cssRules) rule.rules.link(cssRule.cssRules);
|
|
}
|
|
|
|
/***/ }),
|
|
/* 37 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var CSS = global.CSS;
|
|
|
|
var env = ("development");
|
|
|
|
var escapeRegex = /([[\].#*$><+~=|^:(),"'`])/g;
|
|
|
|
exports['default'] = function (str) {
|
|
// We don't need to escape it in production, because we are not using user's
|
|
// input for selectors, we are generating a valid selector.
|
|
if (env === 'production') return str;
|
|
|
|
if (!CSS || !CSS.escape) {
|
|
return str.replace(escapeRegex, '\\$1');
|
|
}
|
|
|
|
return CSS.escape(str);
|
|
};
|
|
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
|
|
|
|
/***/ }),
|
|
/* 38 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _SheetsRegistry = __webpack_require__(24);
|
|
|
|
var _SheetsRegistry2 = _interopRequireDefault(_SheetsRegistry);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* This is a global sheets registry. Only DomRenderer will add sheets to it.
|
|
* On the server one should use an own SheetsRegistry instance and add the
|
|
* sheets to it, because you need to make sure to create a new registry for
|
|
* each request in order to not leak sheets across requests.
|
|
*/
|
|
exports['default'] = new _SheetsRegistry2['default']();
|
|
|
|
/***/ }),
|
|
/* 39 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
var _StyleSheet = __webpack_require__(40);
|
|
|
|
var _StyleSheet2 = _interopRequireDefault(_StyleSheet);
|
|
|
|
var _moduleId = __webpack_require__(41);
|
|
|
|
var _moduleId2 = _interopRequireDefault(_moduleId);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var maxRules = 1e10;
|
|
|
|
|
|
var env = ("development");
|
|
|
|
/**
|
|
* Returns a function which generates unique class names based on counters.
|
|
* When new generator function is created, rule counter is reseted.
|
|
* We need to reset the rule counter for SSR for each request.
|
|
*/
|
|
|
|
exports['default'] = function () {
|
|
var ruleCounter = 0;
|
|
var defaultPrefix = env === 'production' ? 'c' : '';
|
|
|
|
return function (rule, sheet) {
|
|
ruleCounter += 1;
|
|
|
|
if (ruleCounter > maxRules) {
|
|
(0, _warning2['default'])(false, '[JSS] You might have a memory leak. Rule counter is at %s.', ruleCounter);
|
|
}
|
|
|
|
var prefix = defaultPrefix;
|
|
var jssId = '';
|
|
|
|
if (sheet) {
|
|
prefix = sheet.options.classNamePrefix || defaultPrefix;
|
|
if (sheet.options.jss.id != null) jssId += sheet.options.jss.id;
|
|
}
|
|
|
|
if (env === 'production') {
|
|
return '' + prefix + _moduleId2['default'] + jssId + ruleCounter;
|
|
}
|
|
|
|
return prefix + rule.key + '-' + _moduleId2['default'] + (jssId && '-' + jssId) + '-' + ruleCounter;
|
|
};
|
|
};
|
|
|
|
/***/ }),
|
|
/* 40 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _linkRule = __webpack_require__(36);
|
|
|
|
var _linkRule2 = _interopRequireDefault(_linkRule);
|
|
|
|
var _RuleList = __webpack_require__(27);
|
|
|
|
var _RuleList2 = _interopRequireDefault(_RuleList);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var StyleSheet = function () {
|
|
function StyleSheet(styles, options) {
|
|
_classCallCheck(this, StyleSheet);
|
|
|
|
this.attached = false;
|
|
this.deployed = false;
|
|
this.linked = false;
|
|
this.classes = {};
|
|
this.options = _extends({}, options, {
|
|
sheet: this,
|
|
parent: this,
|
|
classes: this.classes
|
|
});
|
|
this.renderer = new options.Renderer(this);
|
|
this.rules = new _RuleList2['default'](this.options);
|
|
|
|
for (var name in styles) {
|
|
this.rules.add(name, styles[name]);
|
|
}
|
|
|
|
this.rules.process();
|
|
}
|
|
|
|
/**
|
|
* Attach renderable to the render tree.
|
|
*/
|
|
|
|
|
|
_createClass(StyleSheet, [{
|
|
key: 'attach',
|
|
value: function attach() {
|
|
if (this.attached) return this;
|
|
if (!this.deployed) this.deploy();
|
|
this.renderer.attach();
|
|
if (!this.linked && this.options.link) this.link();
|
|
this.attached = true;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Remove renderable from render tree.
|
|
*/
|
|
|
|
}, {
|
|
key: 'detach',
|
|
value: function detach() {
|
|
if (!this.attached) return this;
|
|
this.renderer.detach();
|
|
this.attached = false;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Add a rule to the current stylesheet.
|
|
* Will insert a rule also after the stylesheet has been rendered first time.
|
|
*/
|
|
|
|
}, {
|
|
key: 'addRule',
|
|
value: function addRule(name, decl, options) {
|
|
var queue = this.queue;
|
|
|
|
// Plugins can create rules.
|
|
// In order to preserve the right order, we need to queue all `.addRule` calls,
|
|
// which happen after the first `rules.add()` call.
|
|
|
|
if (this.attached && !queue) this.queue = [];
|
|
|
|
var rule = this.rules.add(name, decl, options);
|
|
this.options.jss.plugins.onProcessRule(rule);
|
|
|
|
if (this.attached) {
|
|
if (!this.deployed) return rule;
|
|
// Don't insert rule directly if there is no stringified version yet.
|
|
// It will be inserted all together when .attach is called.
|
|
if (queue) queue.push(rule);else {
|
|
this.insertRule(rule);
|
|
if (this.queue) {
|
|
this.queue.forEach(this.insertRule, this);
|
|
this.queue = undefined;
|
|
}
|
|
}
|
|
return rule;
|
|
}
|
|
|
|
// We can't add rules to a detached style node.
|
|
// We will redeploy the sheet once user will attach it.
|
|
this.deployed = false;
|
|
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Insert rule into the StyleSheet
|
|
*/
|
|
|
|
}, {
|
|
key: 'insertRule',
|
|
value: function insertRule(rule) {
|
|
var renderable = this.renderer.insertRule(rule);
|
|
if (renderable && this.options.link) (0, _linkRule2['default'])(rule, renderable);
|
|
}
|
|
|
|
/**
|
|
* Create and add rules.
|
|
* Will render also after Style Sheet was rendered the first time.
|
|
*/
|
|
|
|
}, {
|
|
key: 'addRules',
|
|
value: function addRules(styles, options) {
|
|
var added = [];
|
|
for (var name in styles) {
|
|
added.push(this.addRule(name, styles[name], options));
|
|
}
|
|
return added;
|
|
}
|
|
|
|
/**
|
|
* Get a rule by name.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getRule',
|
|
value: function getRule(name) {
|
|
return this.rules.get(name);
|
|
}
|
|
|
|
/**
|
|
* Delete a rule by name.
|
|
* Returns `true`: if rule has been deleted from the DOM.
|
|
*/
|
|
|
|
}, {
|
|
key: 'deleteRule',
|
|
value: function deleteRule(name) {
|
|
var rule = this.rules.get(name);
|
|
|
|
if (!rule) return false;
|
|
|
|
this.rules.remove(rule);
|
|
|
|
if (this.attached && rule.renderable) {
|
|
return this.renderer.deleteRule(rule.renderable);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get index of a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'indexOf',
|
|
value: function indexOf(rule) {
|
|
return this.rules.indexOf(rule);
|
|
}
|
|
|
|
/**
|
|
* Deploy pure CSS string to a renderable.
|
|
*/
|
|
|
|
}, {
|
|
key: 'deploy',
|
|
value: function deploy() {
|
|
this.renderer.deploy();
|
|
this.deployed = true;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Link renderable CSS rules from sheet with their corresponding models.
|
|
*/
|
|
|
|
}, {
|
|
key: 'link',
|
|
value: function link() {
|
|
var cssRules = this.renderer.getRules();
|
|
|
|
// Is undefined when VirtualRenderer is used.
|
|
if (cssRules) this.rules.link(cssRules);
|
|
this.linked = true;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Update the function values with a new data.
|
|
*/
|
|
|
|
}, {
|
|
key: 'update',
|
|
value: function update(name, data) {
|
|
this.rules.update(name, data);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Convert rules to a CSS string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
return this.rules.toString(options);
|
|
}
|
|
}]);
|
|
|
|
return StyleSheet;
|
|
}();
|
|
|
|
exports['default'] = StyleSheet;
|
|
|
|
/***/ }),
|
|
/* 41 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var ns = '2f1acc6c3a606b082e5eef5e54414ffb';
|
|
if (global[ns] == null) global[ns] = 0;
|
|
|
|
// Bundle may contain multiple JSS versions at the same time. In order to identify
|
|
// the current version with just one short number and use it for classes generation
|
|
// we use a counter. Also it is more accurate, because user can manually reevaluate
|
|
// the module.
|
|
exports['default'] = global[ns]++;
|
|
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
|
|
|
|
/***/ }),
|
|
/* 42 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _isInBrowser = __webpack_require__(43);
|
|
|
|
var _isInBrowser2 = _interopRequireDefault(_isInBrowser);
|
|
|
|
var _StyleSheet = __webpack_require__(40);
|
|
|
|
var _StyleSheet2 = _interopRequireDefault(_StyleSheet);
|
|
|
|
var _PluginsRegistry = __webpack_require__(44);
|
|
|
|
var _PluginsRegistry2 = _interopRequireDefault(_PluginsRegistry);
|
|
|
|
var _rules = __webpack_require__(45);
|
|
|
|
var _rules2 = _interopRequireDefault(_rules);
|
|
|
|
var _observables = __webpack_require__(51);
|
|
|
|
var _observables2 = _interopRequireDefault(_observables);
|
|
|
|
var _functions = __webpack_require__(52);
|
|
|
|
var _functions2 = _interopRequireDefault(_functions);
|
|
|
|
var _sheets = __webpack_require__(38);
|
|
|
|
var _sheets2 = _interopRequireDefault(_sheets);
|
|
|
|
var _StyleRule = __webpack_require__(29);
|
|
|
|
var _StyleRule2 = _interopRequireDefault(_StyleRule);
|
|
|
|
var _createGenerateClassName = __webpack_require__(39);
|
|
|
|
var _createGenerateClassName2 = _interopRequireDefault(_createGenerateClassName);
|
|
|
|
var _createRule2 = __webpack_require__(28);
|
|
|
|
var _createRule3 = _interopRequireDefault(_createRule2);
|
|
|
|
var _DomRenderer = __webpack_require__(53);
|
|
|
|
var _DomRenderer2 = _interopRequireDefault(_DomRenderer);
|
|
|
|
var _VirtualRenderer = __webpack_require__(54);
|
|
|
|
var _VirtualRenderer2 = _interopRequireDefault(_VirtualRenderer);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var defaultPlugins = _rules2['default'].concat([_observables2['default'], _functions2['default']]);
|
|
|
|
var instanceCounter = 0;
|
|
|
|
var Jss = function () {
|
|
function Jss(options) {
|
|
_classCallCheck(this, Jss);
|
|
|
|
this.id = instanceCounter++;
|
|
this.version = "9.8.1";
|
|
this.plugins = new _PluginsRegistry2['default']();
|
|
this.options = {
|
|
createGenerateClassName: _createGenerateClassName2['default'],
|
|
Renderer: _isInBrowser2['default'] ? _DomRenderer2['default'] : _VirtualRenderer2['default'],
|
|
plugins: []
|
|
};
|
|
this.generateClassName = (0, _createGenerateClassName2['default'])();
|
|
|
|
// eslint-disable-next-line prefer-spread
|
|
this.use.apply(this, defaultPlugins);
|
|
this.setup(options);
|
|
}
|
|
|
|
_createClass(Jss, [{
|
|
key: 'setup',
|
|
value: function setup() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
if (options.createGenerateClassName) {
|
|
this.options.createGenerateClassName = options.createGenerateClassName;
|
|
// $FlowFixMe
|
|
this.generateClassName = options.createGenerateClassName();
|
|
}
|
|
|
|
if (options.insertionPoint != null) this.options.insertionPoint = options.insertionPoint;
|
|
if (options.virtual || options.Renderer) {
|
|
this.options.Renderer = options.Renderer || (options.virtual ? _VirtualRenderer2['default'] : _DomRenderer2['default']);
|
|
}
|
|
|
|
// eslint-disable-next-line prefer-spread
|
|
if (options.plugins) this.use.apply(this, options.plugins);
|
|
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Create a Style Sheet.
|
|
*/
|
|
|
|
}, {
|
|
key: 'createStyleSheet',
|
|
value: function createStyleSheet(styles) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
var index = options.index;
|
|
if (typeof index !== 'number') {
|
|
index = _sheets2['default'].index === 0 ? 0 : _sheets2['default'].index + 1;
|
|
}
|
|
var sheet = new _StyleSheet2['default'](styles, _extends({}, options, {
|
|
jss: this,
|
|
generateClassName: options.generateClassName || this.generateClassName,
|
|
insertionPoint: this.options.insertionPoint,
|
|
Renderer: this.options.Renderer,
|
|
index: index
|
|
}));
|
|
this.plugins.onProcessSheet(sheet);
|
|
|
|
return sheet;
|
|
}
|
|
|
|
/**
|
|
* Detach the Style Sheet and remove it from the registry.
|
|
*/
|
|
|
|
}, {
|
|
key: 'removeStyleSheet',
|
|
value: function removeStyleSheet(sheet) {
|
|
sheet.detach();
|
|
_sheets2['default'].remove(sheet);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Create a rule without a Style Sheet.
|
|
*/
|
|
|
|
}, {
|
|
key: 'createRule',
|
|
value: function createRule(name) {
|
|
var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
|
|
// Enable rule without name for inline styles.
|
|
if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
|
|
options = style;
|
|
style = name;
|
|
name = undefined;
|
|
}
|
|
|
|
// Cast from RuleFactoryOptions to RuleOptions
|
|
// https://stackoverflow.com/questions/41328728/force-casting-in-flow
|
|
var ruleOptions = options;
|
|
|
|
ruleOptions.jss = this;
|
|
ruleOptions.Renderer = this.options.Renderer;
|
|
if (!ruleOptions.generateClassName) ruleOptions.generateClassName = this.generateClassName;
|
|
if (!ruleOptions.classes) ruleOptions.classes = {};
|
|
var rule = (0, _createRule3['default'])(name, style, ruleOptions);
|
|
|
|
if (!ruleOptions.selector && rule instanceof _StyleRule2['default']) {
|
|
rule.selector = '.' + ruleOptions.generateClassName(rule);
|
|
}
|
|
|
|
this.plugins.onProcessRule(rule);
|
|
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Register plugin. Passed function will be invoked with a rule instance.
|
|
*/
|
|
|
|
}, {
|
|
key: 'use',
|
|
value: function use() {
|
|
var _this = this;
|
|
|
|
for (var _len = arguments.length, plugins = Array(_len), _key = 0; _key < _len; _key++) {
|
|
plugins[_key] = arguments[_key];
|
|
}
|
|
|
|
plugins.forEach(function (plugin) {
|
|
// Avoids applying same plugin twice, at least based on ref.
|
|
if (_this.options.plugins.indexOf(plugin) === -1) {
|
|
_this.options.plugins.push(plugin);
|
|
_this.plugins.use(plugin);
|
|
}
|
|
});
|
|
|
|
return this;
|
|
}
|
|
}]);
|
|
|
|
return Jss;
|
|
}();
|
|
|
|
exports['default'] = Jss;
|
|
|
|
/***/ }),
|
|
/* 43 */
|
|
/***/ (function(module, exports) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
var isBrowser = exports.isBrowser = (typeof window === "undefined" ? "undefined" : _typeof(window)) === "object" && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object' && document.nodeType === 9;
|
|
|
|
exports.default = isBrowser;
|
|
|
|
/***/ }),
|
|
/* 44 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var PluginsRegistry = function () {
|
|
function PluginsRegistry() {
|
|
_classCallCheck(this, PluginsRegistry);
|
|
|
|
this.hooks = {
|
|
onCreateRule: [],
|
|
onProcessRule: [],
|
|
onProcessStyle: [],
|
|
onProcessSheet: [],
|
|
onChangeValue: [],
|
|
onUpdate: []
|
|
|
|
/**
|
|
* Call `onCreateRule` hooks and return an object if returned by a hook.
|
|
*/
|
|
};
|
|
}
|
|
|
|
_createClass(PluginsRegistry, [{
|
|
key: 'onCreateRule',
|
|
value: function onCreateRule(name, decl, options) {
|
|
for (var i = 0; i < this.hooks.onCreateRule.length; i++) {
|
|
var rule = this.hooks.onCreateRule[i](name, decl, options);
|
|
if (rule) return rule;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Call `onProcessRule` hooks.
|
|
*/
|
|
|
|
}, {
|
|
key: 'onProcessRule',
|
|
value: function onProcessRule(rule) {
|
|
if (rule.isProcessed) return;
|
|
var sheet = rule.options.sheet;
|
|
|
|
for (var i = 0; i < this.hooks.onProcessRule.length; i++) {
|
|
this.hooks.onProcessRule[i](rule, sheet);
|
|
}
|
|
|
|
// $FlowFixMe
|
|
if (rule.style) this.onProcessStyle(rule.style, rule, sheet);
|
|
|
|
rule.isProcessed = true;
|
|
}
|
|
|
|
/**
|
|
* Call `onProcessStyle` hooks.
|
|
*/
|
|
|
|
}, {
|
|
key: 'onProcessStyle',
|
|
value: function onProcessStyle(style, rule, sheet) {
|
|
var nextStyle = style;
|
|
|
|
for (var i = 0; i < this.hooks.onProcessStyle.length; i++) {
|
|
nextStyle = this.hooks.onProcessStyle[i](nextStyle, rule, sheet);
|
|
// $FlowFixMe
|
|
rule.style = nextStyle;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call `onProcessSheet` hooks.
|
|
*/
|
|
|
|
}, {
|
|
key: 'onProcessSheet',
|
|
value: function onProcessSheet(sheet) {
|
|
for (var i = 0; i < this.hooks.onProcessSheet.length; i++) {
|
|
this.hooks.onProcessSheet[i](sheet);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call `onUpdate` hooks.
|
|
*/
|
|
|
|
}, {
|
|
key: 'onUpdate',
|
|
value: function onUpdate(data, rule, sheet) {
|
|
for (var i = 0; i < this.hooks.onUpdate.length; i++) {
|
|
this.hooks.onUpdate[i](data, rule, sheet);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Call `onChangeValue` hooks.
|
|
*/
|
|
|
|
}, {
|
|
key: 'onChangeValue',
|
|
value: function onChangeValue(value, prop, rule) {
|
|
var processedValue = value;
|
|
for (var i = 0; i < this.hooks.onChangeValue.length; i++) {
|
|
processedValue = this.hooks.onChangeValue[i](processedValue, prop, rule);
|
|
}
|
|
return processedValue;
|
|
}
|
|
|
|
/**
|
|
* Register a plugin.
|
|
* If function is passed, it is a shortcut for `{onProcessRule}`.
|
|
*/
|
|
|
|
}, {
|
|
key: 'use',
|
|
value: function use(plugin) {
|
|
for (var name in plugin) {
|
|
if (this.hooks[name]) this.hooks[name].push(plugin[name]);else (0, _warning2['default'])(false, '[JSS] Unknown hook "%s".', name);
|
|
}
|
|
}
|
|
}]);
|
|
|
|
return PluginsRegistry;
|
|
}();
|
|
|
|
exports['default'] = PluginsRegistry;
|
|
|
|
/***/ }),
|
|
/* 45 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _SimpleRule = __webpack_require__(46);
|
|
|
|
var _SimpleRule2 = _interopRequireDefault(_SimpleRule);
|
|
|
|
var _KeyframesRule = __webpack_require__(47);
|
|
|
|
var _KeyframesRule2 = _interopRequireDefault(_KeyframesRule);
|
|
|
|
var _ConditionalRule = __webpack_require__(48);
|
|
|
|
var _ConditionalRule2 = _interopRequireDefault(_ConditionalRule);
|
|
|
|
var _FontFaceRule = __webpack_require__(49);
|
|
|
|
var _FontFaceRule2 = _interopRequireDefault(_FontFaceRule);
|
|
|
|
var _ViewportRule = __webpack_require__(50);
|
|
|
|
var _ViewportRule2 = _interopRequireDefault(_ViewportRule);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var classes = {
|
|
'@charset': _SimpleRule2['default'],
|
|
'@import': _SimpleRule2['default'],
|
|
'@namespace': _SimpleRule2['default'],
|
|
'@keyframes': _KeyframesRule2['default'],
|
|
'@media': _ConditionalRule2['default'],
|
|
'@supports': _ConditionalRule2['default'],
|
|
'@font-face': _FontFaceRule2['default'],
|
|
'@viewport': _ViewportRule2['default'],
|
|
'@-ms-viewport': _ViewportRule2['default']
|
|
|
|
/**
|
|
* Generate plugins which will register all rules.
|
|
*/
|
|
};
|
|
exports['default'] = Object.keys(classes).map(function (key) {
|
|
// https://jsperf.com/indexof-vs-substr-vs-regex-at-the-beginning-3
|
|
var re = new RegExp('^' + key);
|
|
var onCreateRule = function onCreateRule(name, decl, options) {
|
|
return re.test(name) ? new classes[key](name, decl, options) : null;
|
|
};
|
|
return { onCreateRule: onCreateRule };
|
|
});
|
|
|
|
/***/ }),
|
|
/* 46 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var SimpleRule = function () {
|
|
function SimpleRule(key, value, options) {
|
|
_classCallCheck(this, SimpleRule);
|
|
|
|
this.type = 'simple';
|
|
this.isProcessed = false;
|
|
|
|
this.key = key;
|
|
this.value = value;
|
|
this.options = options;
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
// eslint-disable-next-line no-unused-vars
|
|
|
|
|
|
_createClass(SimpleRule, [{
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
if (Array.isArray(this.value)) {
|
|
var str = '';
|
|
for (var index = 0; index < this.value.length; index++) {
|
|
str += this.key + ' ' + this.value[index] + ';';
|
|
if (this.value[index + 1]) str += '\n';
|
|
}
|
|
return str;
|
|
}
|
|
|
|
return this.key + ' ' + this.value + ';';
|
|
}
|
|
}]);
|
|
|
|
return SimpleRule;
|
|
}();
|
|
|
|
exports['default'] = SimpleRule;
|
|
|
|
/***/ }),
|
|
/* 47 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _RuleList = __webpack_require__(27);
|
|
|
|
var _RuleList2 = _interopRequireDefault(_RuleList);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/**
|
|
* Rule for @keyframes
|
|
*/
|
|
var KeyframesRule = function () {
|
|
function KeyframesRule(key, frames, options) {
|
|
_classCallCheck(this, KeyframesRule);
|
|
|
|
this.type = 'keyframes';
|
|
this.isProcessed = false;
|
|
|
|
this.key = key;
|
|
this.options = options;
|
|
this.rules = new _RuleList2['default'](_extends({}, options, { parent: this }));
|
|
|
|
for (var name in frames) {
|
|
this.rules.add(name, frames[name], _extends({}, this.options, {
|
|
parent: this,
|
|
selector: name
|
|
}));
|
|
}
|
|
|
|
this.rules.process();
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
|
|
|
|
_createClass(KeyframesRule, [{
|
|
key: 'toString',
|
|
value: function toString() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { indent: 1 };
|
|
|
|
var inner = this.rules.toString(options);
|
|
if (inner) inner += '\n';
|
|
return this.key + ' {\n' + inner + '}';
|
|
}
|
|
}]);
|
|
|
|
return KeyframesRule;
|
|
}();
|
|
|
|
exports['default'] = KeyframesRule;
|
|
|
|
/***/ }),
|
|
/* 48 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _RuleList = __webpack_require__(27);
|
|
|
|
var _RuleList2 = _interopRequireDefault(_RuleList);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/**
|
|
* Conditional rule for @media, @supports
|
|
*/
|
|
var ConditionalRule = function () {
|
|
function ConditionalRule(key, styles, options) {
|
|
_classCallCheck(this, ConditionalRule);
|
|
|
|
this.type = 'conditional';
|
|
this.isProcessed = false;
|
|
|
|
this.key = key;
|
|
this.options = options;
|
|
this.rules = new _RuleList2['default'](_extends({}, options, { parent: this }));
|
|
|
|
for (var name in styles) {
|
|
this.rules.add(name, styles[name]);
|
|
}
|
|
|
|
this.rules.process();
|
|
}
|
|
|
|
/**
|
|
* Get a rule.
|
|
*/
|
|
|
|
|
|
_createClass(ConditionalRule, [{
|
|
key: 'getRule',
|
|
value: function getRule(name) {
|
|
return this.rules.get(name);
|
|
}
|
|
|
|
/**
|
|
* Get index of a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'indexOf',
|
|
value: function indexOf(rule) {
|
|
return this.rules.indexOf(rule);
|
|
}
|
|
|
|
/**
|
|
* Create and register rule, run plugins.
|
|
*/
|
|
|
|
}, {
|
|
key: 'addRule',
|
|
value: function addRule(name, style, options) {
|
|
var rule = this.rules.add(name, style, options);
|
|
this.options.jss.plugins.onProcessRule(rule);
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { indent: 1 };
|
|
|
|
var inner = this.rules.toString(options);
|
|
return inner ? this.key + ' {\n' + inner + '\n}' : '';
|
|
}
|
|
}]);
|
|
|
|
return ConditionalRule;
|
|
}();
|
|
|
|
exports['default'] = ConditionalRule;
|
|
|
|
/***/ }),
|
|
/* 49 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _toCss = __webpack_require__(30);
|
|
|
|
var _toCss2 = _interopRequireDefault(_toCss);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var FontFaceRule = function () {
|
|
function FontFaceRule(key, style, options) {
|
|
_classCallCheck(this, FontFaceRule);
|
|
|
|
this.type = 'font-face';
|
|
this.isProcessed = false;
|
|
|
|
this.key = key;
|
|
this.style = style;
|
|
this.options = options;
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
|
|
|
|
_createClass(FontFaceRule, [{
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
if (Array.isArray(this.style)) {
|
|
var str = '';
|
|
for (var index = 0; index < this.style.length; index++) {
|
|
str += (0, _toCss2['default'])(this.key, this.style[index]);
|
|
if (this.style[index + 1]) str += '\n';
|
|
}
|
|
return str;
|
|
}
|
|
|
|
return (0, _toCss2['default'])(this.key, this.style, options);
|
|
}
|
|
}]);
|
|
|
|
return FontFaceRule;
|
|
}();
|
|
|
|
exports['default'] = FontFaceRule;
|
|
|
|
/***/ }),
|
|
/* 50 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _toCss = __webpack_require__(30);
|
|
|
|
var _toCss2 = _interopRequireDefault(_toCss);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var ViewportRule = function () {
|
|
function ViewportRule(key, style, options) {
|
|
_classCallCheck(this, ViewportRule);
|
|
|
|
this.type = 'viewport';
|
|
this.isProcessed = false;
|
|
|
|
this.key = key;
|
|
this.style = style;
|
|
this.options = options;
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
|
|
|
|
_createClass(ViewportRule, [{
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
return (0, _toCss2['default'])(this.key, this.style, options);
|
|
}
|
|
}]);
|
|
|
|
return ViewportRule;
|
|
}();
|
|
|
|
exports['default'] = ViewportRule;
|
|
|
|
/***/ }),
|
|
/* 51 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _StyleRule = __webpack_require__(29);
|
|
|
|
var _StyleRule2 = _interopRequireDefault(_StyleRule);
|
|
|
|
var _createRule = __webpack_require__(28);
|
|
|
|
var _createRule2 = _interopRequireDefault(_createRule);
|
|
|
|
var _isObservable = __webpack_require__(32);
|
|
|
|
var _isObservable2 = _interopRequireDefault(_isObservable);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
exports['default'] = {
|
|
onCreateRule: function onCreateRule(name, decl, options) {
|
|
if (!(0, _isObservable2['default'])(decl)) return null;
|
|
|
|
// Cast `decl` to `Observable`, since it passed the type guard.
|
|
var style$ = decl;
|
|
|
|
var rule = (0, _createRule2['default'])(name, {}, options);
|
|
|
|
// TODO
|
|
// Call `stream.subscribe()` returns a subscription, which should be explicitly
|
|
// unsubscribed from when we know this sheet is no longer needed.
|
|
style$.subscribe(function (style) {
|
|
for (var prop in style) {
|
|
rule.prop(prop, style[prop]);
|
|
}
|
|
});
|
|
|
|
return rule;
|
|
},
|
|
onProcessRule: function onProcessRule(rule) {
|
|
if (!(rule instanceof _StyleRule2['default'])) return;
|
|
var styleRule = rule;
|
|
var style = styleRule.style;
|
|
|
|
var _loop = function _loop(prop) {
|
|
var value = style[prop];
|
|
if (!(0, _isObservable2['default'])(value)) return 'continue';
|
|
delete style[prop];
|
|
value.subscribe({
|
|
next: function next(nextValue) {
|
|
styleRule.prop(prop, nextValue);
|
|
}
|
|
});
|
|
};
|
|
|
|
for (var prop in style) {
|
|
var _ret = _loop(prop);
|
|
|
|
if (_ret === 'continue') continue;
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 52 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _RuleList = __webpack_require__(27);
|
|
|
|
var _RuleList2 = _interopRequireDefault(_RuleList);
|
|
|
|
var _StyleRule = __webpack_require__(29);
|
|
|
|
var _StyleRule2 = _interopRequireDefault(_StyleRule);
|
|
|
|
var _createRule = __webpack_require__(28);
|
|
|
|
var _createRule2 = _interopRequireDefault(_createRule);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
// A symbol replacement.
|
|
var now = Date.now();
|
|
|
|
var fnValuesNs = 'fnValues' + now;
|
|
var fnStyleNs = 'fnStyle' + ++now;
|
|
|
|
exports['default'] = {
|
|
onCreateRule: function onCreateRule(name, decl, options) {
|
|
if (typeof decl !== 'function') return null;
|
|
var rule = (0, _createRule2['default'])(name, {}, options);
|
|
rule[fnStyleNs] = decl;
|
|
return rule;
|
|
},
|
|
onProcessStyle: function onProcessStyle(style, rule) {
|
|
var fn = {};
|
|
for (var prop in style) {
|
|
var value = style[prop];
|
|
if (typeof value !== 'function') continue;
|
|
delete style[prop];
|
|
fn[prop] = value;
|
|
}
|
|
rule = rule;
|
|
rule[fnValuesNs] = fn;
|
|
return style;
|
|
},
|
|
onUpdate: function onUpdate(data, rule) {
|
|
// It is a rules container like for e.g. ConditionalRule.
|
|
if (rule.rules instanceof _RuleList2['default']) {
|
|
rule.rules.update(data);
|
|
return;
|
|
}
|
|
if (!(rule instanceof _StyleRule2['default'])) return;
|
|
|
|
rule = rule;
|
|
|
|
// If we have a fn values map, it is a rule with function values.
|
|
if (rule[fnValuesNs]) {
|
|
for (var prop in rule[fnValuesNs]) {
|
|
rule.prop(prop, rule[fnValuesNs][prop](data));
|
|
}
|
|
}
|
|
|
|
rule = rule;
|
|
|
|
var fnStyle = rule[fnStyleNs];
|
|
|
|
// If we have a style function, the entire rule is dynamic and style object
|
|
// will be returned from that function.
|
|
if (fnStyle) {
|
|
var style = fnStyle(data);
|
|
for (var _prop in style) {
|
|
rule.prop(_prop, style[_prop]);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 53 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
var _sheets = __webpack_require__(38);
|
|
|
|
var _sheets2 = _interopRequireDefault(_sheets);
|
|
|
|
var _StyleRule = __webpack_require__(29);
|
|
|
|
var _StyleRule2 = _interopRequireDefault(_StyleRule);
|
|
|
|
var _toCssValue = __webpack_require__(23);
|
|
|
|
var _toCssValue2 = _interopRequireDefault(_toCssValue);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/**
|
|
* Cache the value from the first time a function is called.
|
|
*/
|
|
var memoize = function memoize(fn) {
|
|
var value = void 0;
|
|
return function () {
|
|
if (!value) value = fn();
|
|
return value;
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Get a style property value.
|
|
*/
|
|
function getPropertyValue(cssRule, prop) {
|
|
try {
|
|
return cssRule.style.getPropertyValue(prop);
|
|
} catch (err) {
|
|
// IE may throw if property is unknown.
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set a style property.
|
|
*/
|
|
function setProperty(cssRule, prop, value) {
|
|
try {
|
|
var cssValue = value;
|
|
|
|
if (Array.isArray(value)) {
|
|
cssValue = (0, _toCssValue2['default'])(value, true);
|
|
|
|
if (value[value.length - 1] === '!important') {
|
|
cssRule.style.setProperty(prop, cssValue, 'important');
|
|
return true;
|
|
}
|
|
}
|
|
|
|
cssRule.style.setProperty(prop, cssValue);
|
|
} catch (err) {
|
|
// IE may throw if property is unknown.
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove a style property.
|
|
*/
|
|
function removeProperty(cssRule, prop) {
|
|
try {
|
|
cssRule.style.removeProperty(prop);
|
|
} catch (err) {
|
|
(0, _warning2['default'])(false, '[JSS] DOMException "%s" was thrown. Tried to remove property "%s".', err.message, prop);
|
|
}
|
|
}
|
|
|
|
var CSSRuleTypes = {
|
|
STYLE_RULE: 1,
|
|
KEYFRAMES_RULE: 7
|
|
|
|
/**
|
|
* Get the CSS Rule key.
|
|
*/
|
|
|
|
};var getKey = function () {
|
|
var extractKey = function extractKey(cssText) {
|
|
var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
return cssText.substr(from, cssText.indexOf('{') - 1);
|
|
};
|
|
|
|
return function (cssRule) {
|
|
if (cssRule.type === CSSRuleTypes.STYLE_RULE) return cssRule.selectorText;
|
|
if (cssRule.type === CSSRuleTypes.KEYFRAMES_RULE) {
|
|
var name = cssRule.name;
|
|
|
|
if (name) return '@keyframes ' + name;
|
|
|
|
// There is no rule.name in the following browsers:
|
|
// - IE 9
|
|
// - Safari 7.1.8
|
|
// - Mobile Safari 9.0.0
|
|
var cssText = cssRule.cssText;
|
|
|
|
return '@' + extractKey(cssText, cssText.indexOf('keyframes'));
|
|
}
|
|
|
|
// Conditionals.
|
|
return extractKey(cssRule.cssText);
|
|
};
|
|
}();
|
|
|
|
/**
|
|
* Set the selector.
|
|
*/
|
|
function setSelector(cssRule, selectorText) {
|
|
cssRule.selectorText = selectorText;
|
|
|
|
// Return false if setter was not successful.
|
|
// Currently works in chrome only.
|
|
return cssRule.selectorText === selectorText;
|
|
}
|
|
|
|
/**
|
|
* Gets the `head` element upon the first call and caches it.
|
|
*/
|
|
var getHead = memoize(function () {
|
|
return document.head || document.getElementsByTagName('head')[0];
|
|
});
|
|
|
|
/**
|
|
* Gets a map of rule keys, where the property is an unescaped key and value
|
|
* is a potentially escaped one.
|
|
* It is used to identify CSS rules and the corresponding JSS rules. As an identifier
|
|
* for CSSStyleRule we normally use `selectorText`. Though if original selector text
|
|
* contains escaped code points e.g. `:not(#\\20)`, CSSOM will compile it to `:not(# )`
|
|
* and so CSS rule's `selectorText` won't match JSS rule selector.
|
|
*
|
|
* https://www.w3.org/International/questions/qa-escapes#cssescapes
|
|
*/
|
|
var getUnescapedKeysMap = function () {
|
|
var style = void 0;
|
|
var isAttached = false;
|
|
|
|
return function (rules) {
|
|
var map = {};
|
|
// https://github.com/facebook/flow/issues/2696
|
|
if (!style) style = document.createElement('style');
|
|
for (var i = 0; i < rules.length; i++) {
|
|
var rule = rules[i];
|
|
if (!(rule instanceof _StyleRule2['default'])) continue;
|
|
var selector = rule.selector;
|
|
// Only unescape selector over CSSOM if it contains a back slash.
|
|
|
|
if (selector && selector.indexOf('\\') !== -1) {
|
|
// Lazilly attach when needed.
|
|
if (!isAttached) {
|
|
getHead().appendChild(style);
|
|
isAttached = true;
|
|
}
|
|
style.textContent = selector + ' {}';
|
|
var _style = style,
|
|
sheet = _style.sheet;
|
|
|
|
if (sheet) {
|
|
var cssRules = sheet.cssRules;
|
|
|
|
if (cssRules) map[cssRules[0].selectorText] = rule.key;
|
|
}
|
|
}
|
|
}
|
|
if (isAttached) {
|
|
getHead().removeChild(style);
|
|
isAttached = false;
|
|
}
|
|
return map;
|
|
};
|
|
}();
|
|
|
|
/**
|
|
* Find attached sheet with an index higher than the passed one.
|
|
*/
|
|
function findHigherSheet(registry, options) {
|
|
for (var i = 0; i < registry.length; i++) {
|
|
var sheet = registry[i];
|
|
if (sheet.attached && sheet.options.index > options.index && sheet.options.insertionPoint === options.insertionPoint) {
|
|
return sheet;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Find attached sheet with the highest index.
|
|
*/
|
|
function findHighestSheet(registry, options) {
|
|
for (var i = registry.length - 1; i >= 0; i--) {
|
|
var sheet = registry[i];
|
|
if (sheet.attached && sheet.options.insertionPoint === options.insertionPoint) {
|
|
return sheet;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Find a comment with "jss" inside.
|
|
*/
|
|
function findCommentNode(text) {
|
|
var head = getHead();
|
|
for (var i = 0; i < head.childNodes.length; i++) {
|
|
var node = head.childNodes[i];
|
|
if (node.nodeType === 8 && node.nodeValue.trim() === text) {
|
|
return node;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Find a node before which we can insert the sheet.
|
|
*/
|
|
function findPrevNode(options) {
|
|
var registry = _sheets2['default'].registry;
|
|
|
|
|
|
if (registry.length > 0) {
|
|
// Try to insert before the next higher sheet.
|
|
var sheet = findHigherSheet(registry, options);
|
|
if (sheet) return sheet.renderer.element;
|
|
|
|
// Otherwise insert after the last attached.
|
|
sheet = findHighestSheet(registry, options);
|
|
if (sheet) return sheet.renderer.element.nextElementSibling;
|
|
}
|
|
|
|
// Try to find a comment placeholder if registry is empty.
|
|
var insertionPoint = options.insertionPoint;
|
|
|
|
if (insertionPoint && typeof insertionPoint === 'string') {
|
|
var comment = findCommentNode(insertionPoint);
|
|
if (comment) return comment.nextSibling;
|
|
// If user specifies an insertion point and it can't be found in the document -
|
|
// bad specificity issues may appear.
|
|
(0, _warning2['default'])(insertionPoint === 'jss', '[JSS] Insertion point "%s" not found.', insertionPoint);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Insert style element into the DOM.
|
|
*/
|
|
function insertStyle(style, options) {
|
|
var insertionPoint = options.insertionPoint;
|
|
|
|
var prevNode = findPrevNode(options);
|
|
|
|
if (prevNode) {
|
|
var parentNode = prevNode.parentNode;
|
|
|
|
if (parentNode) parentNode.insertBefore(style, prevNode);
|
|
return;
|
|
}
|
|
|
|
// Works with iframes and any node types.
|
|
if (insertionPoint && typeof insertionPoint.nodeType === 'number') {
|
|
// https://stackoverflow.com/questions/41328728/force-casting-in-flow
|
|
var insertionPointElement = insertionPoint;
|
|
var _parentNode = insertionPointElement.parentNode;
|
|
|
|
if (_parentNode) _parentNode.insertBefore(style, insertionPointElement.nextSibling);else (0, _warning2['default'])(false, '[JSS] Insertion point is not in the DOM.');
|
|
return;
|
|
}
|
|
|
|
getHead().insertBefore(style, prevNode);
|
|
}
|
|
|
|
/**
|
|
* Read jss nonce setting from the page if the user has set it.
|
|
*/
|
|
var getNonce = memoize(function () {
|
|
var node = document.querySelector('meta[property="csp-nonce"]');
|
|
return node ? node.getAttribute('content') : null;
|
|
});
|
|
|
|
var DomRenderer = function () {
|
|
function DomRenderer(sheet) {
|
|
_classCallCheck(this, DomRenderer);
|
|
|
|
this.getPropertyValue = getPropertyValue;
|
|
this.setProperty = setProperty;
|
|
this.removeProperty = removeProperty;
|
|
this.setSelector = setSelector;
|
|
this.getKey = getKey;
|
|
this.getUnescapedKeysMap = getUnescapedKeysMap;
|
|
this.hasInsertedRules = false;
|
|
|
|
// There is no sheet when the renderer is used from a standalone StyleRule.
|
|
if (sheet) _sheets2['default'].add(sheet);
|
|
|
|
this.sheet = sheet;
|
|
|
|
var _ref = this.sheet ? this.sheet.options : {},
|
|
media = _ref.media,
|
|
meta = _ref.meta,
|
|
element = _ref.element;
|
|
|
|
this.element = element || document.createElement('style');
|
|
this.element.type = 'text/css';
|
|
this.element.setAttribute('data-jss', '');
|
|
if (media) this.element.setAttribute('media', media);
|
|
if (meta) this.element.setAttribute('data-meta', meta);
|
|
var nonce = getNonce();
|
|
if (nonce) this.element.setAttribute('nonce', nonce);
|
|
}
|
|
|
|
/**
|
|
* Insert style element into render tree.
|
|
*/
|
|
|
|
|
|
// HTMLStyleElement needs fixing https://github.com/facebook/flow/issues/2696
|
|
|
|
|
|
_createClass(DomRenderer, [{
|
|
key: 'attach',
|
|
value: function attach() {
|
|
// In the case the element node is external and it is already in the DOM.
|
|
if (this.element.parentNode || !this.sheet) return;
|
|
|
|
// When rules are inserted using `insertRule` API, after `sheet.detach().attach()`
|
|
// browsers remove those rules.
|
|
// TODO figure out if its a bug and if it is known.
|
|
// Workaround is to redeploy the sheet before attaching as a string.
|
|
if (this.hasInsertedRules) {
|
|
this.deploy();
|
|
this.hasInsertedRules = false;
|
|
}
|
|
|
|
insertStyle(this.element, this.sheet.options);
|
|
}
|
|
|
|
/**
|
|
* Remove style element from render tree.
|
|
*/
|
|
|
|
}, {
|
|
key: 'detach',
|
|
value: function detach() {
|
|
this.element.parentNode.removeChild(this.element);
|
|
}
|
|
|
|
/**
|
|
* Inject CSS string into element.
|
|
*/
|
|
|
|
}, {
|
|
key: 'deploy',
|
|
value: function deploy() {
|
|
if (!this.sheet) return;
|
|
this.element.textContent = '\n' + this.sheet.toString() + '\n';
|
|
}
|
|
|
|
/**
|
|
* Insert a rule into element.
|
|
*/
|
|
|
|
}, {
|
|
key: 'insertRule',
|
|
value: function insertRule(rule, index) {
|
|
var sheet = this.element.sheet;
|
|
var cssRules = sheet.cssRules;
|
|
|
|
var str = rule.toString();
|
|
if (!index) index = cssRules.length;
|
|
|
|
if (!str) return false;
|
|
|
|
try {
|
|
sheet.insertRule(str, index);
|
|
} catch (err) {
|
|
(0, _warning2['default'])(false, '[JSS] Can not insert an unsupported rule \n\r%s', rule);
|
|
return false;
|
|
}
|
|
this.hasInsertedRules = true;
|
|
|
|
return cssRules[index];
|
|
}
|
|
|
|
/**
|
|
* Delete a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'deleteRule',
|
|
value: function deleteRule(cssRule) {
|
|
var sheet = this.element.sheet;
|
|
|
|
var index = this.indexOf(cssRule);
|
|
if (index === -1) return false;
|
|
sheet.deleteRule(index);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get index of a CSS Rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'indexOf',
|
|
value: function indexOf(cssRule) {
|
|
var cssRules = this.element.sheet.cssRules;
|
|
|
|
for (var _index = 0; _index < cssRules.length; _index++) {
|
|
if (cssRule === cssRules[_index]) return _index;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Generate a new CSS rule and replace the existing one.
|
|
*/
|
|
|
|
}, {
|
|
key: 'replaceRule',
|
|
value: function replaceRule(cssRule, rule) {
|
|
var index = this.indexOf(cssRule);
|
|
var newCssRule = this.insertRule(rule, index);
|
|
this.element.sheet.deleteRule(index);
|
|
return newCssRule;
|
|
}
|
|
|
|
/**
|
|
* Get all rules elements.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getRules',
|
|
value: function getRules() {
|
|
return this.element.sheet.cssRules;
|
|
}
|
|
}]);
|
|
|
|
return DomRenderer;
|
|
}();
|
|
|
|
exports['default'] = DomRenderer;
|
|
|
|
/***/ }),
|
|
/* 54 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/* eslint-disable class-methods-use-this */
|
|
|
|
/**
|
|
* Rendering backend to do nothing in nodejs.
|
|
*/
|
|
var VirtualRenderer = function () {
|
|
function VirtualRenderer() {
|
|
_classCallCheck(this, VirtualRenderer);
|
|
}
|
|
|
|
_createClass(VirtualRenderer, [{
|
|
key: 'setProperty',
|
|
value: function setProperty() {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: 'getPropertyValue',
|
|
value: function getPropertyValue() {
|
|
return '';
|
|
}
|
|
}, {
|
|
key: 'removeProperty',
|
|
value: function removeProperty() {}
|
|
}, {
|
|
key: 'setSelector',
|
|
value: function setSelector() {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: 'getKey',
|
|
value: function getKey() {
|
|
return '';
|
|
}
|
|
}, {
|
|
key: 'attach',
|
|
value: function attach() {}
|
|
}, {
|
|
key: 'detach',
|
|
value: function detach() {}
|
|
}, {
|
|
key: 'deploy',
|
|
value: function deploy() {}
|
|
}, {
|
|
key: 'insertRule',
|
|
value: function insertRule() {
|
|
return false;
|
|
}
|
|
}, {
|
|
key: 'deleteRule',
|
|
value: function deleteRule() {
|
|
return true;
|
|
}
|
|
}, {
|
|
key: 'replaceRule',
|
|
value: function replaceRule() {
|
|
return false;
|
|
}
|
|
}, {
|
|
key: 'getRules',
|
|
value: function getRules() {}
|
|
}, {
|
|
key: 'indexOf',
|
|
value: function indexOf() {
|
|
return -1;
|
|
}
|
|
}]);
|
|
|
|
return VirtualRenderer;
|
|
}();
|
|
|
|
exports['default'] = VirtualRenderer;
|
|
|
|
/***/ }),
|
|
/* 55 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _jssTemplate = __webpack_require__(56);
|
|
|
|
var _jssTemplate2 = _interopRequireDefault(_jssTemplate);
|
|
|
|
var _jssGlobal = __webpack_require__(58);
|
|
|
|
var _jssGlobal2 = _interopRequireDefault(_jssGlobal);
|
|
|
|
var _jssExtend = __webpack_require__(59);
|
|
|
|
var _jssExtend2 = _interopRequireDefault(_jssExtend);
|
|
|
|
var _jssNested = __webpack_require__(60);
|
|
|
|
var _jssNested2 = _interopRequireDefault(_jssNested);
|
|
|
|
var _jssCompose = __webpack_require__(61);
|
|
|
|
var _jssCompose2 = _interopRequireDefault(_jssCompose);
|
|
|
|
var _jssCamelCase = __webpack_require__(62);
|
|
|
|
var _jssCamelCase2 = _interopRequireDefault(_jssCamelCase);
|
|
|
|
var _jssDefaultUnit = __webpack_require__(64);
|
|
|
|
var _jssDefaultUnit2 = _interopRequireDefault(_jssDefaultUnit);
|
|
|
|
var _jssExpand = __webpack_require__(66);
|
|
|
|
var _jssExpand2 = _interopRequireDefault(_jssExpand);
|
|
|
|
var _jssVendorPrefixer = __webpack_require__(68);
|
|
|
|
var _jssVendorPrefixer2 = _interopRequireDefault(_jssVendorPrefixer);
|
|
|
|
var _jssPropsSort = __webpack_require__(74);
|
|
|
|
var _jssPropsSort2 = _interopRequireDefault(_jssPropsSort);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = function () {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
return {
|
|
plugins: [(0, _jssTemplate2.default)(options.template), (0, _jssGlobal2.default)(options.global), (0, _jssExtend2.default)(options.extend), (0, _jssNested2.default)(options.nested), (0, _jssCompose2.default)(options.compose), (0, _jssCamelCase2.default)(options.camelCase), (0, _jssDefaultUnit2.default)(options.defaultUnit), (0, _jssExpand2.default)(options.expand), (0, _jssVendorPrefixer2.default)(options.vendorPrefixer), (0, _jssPropsSort2.default)(options.propsSort)]
|
|
};
|
|
};
|
|
|
|
/***/ }),
|
|
/* 56 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _parse = __webpack_require__(57);
|
|
|
|
var _parse2 = _interopRequireDefault(_parse);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var onProcessRule = function onProcessRule(rule) {
|
|
if (typeof rule.style === 'string') {
|
|
rule.style = (0, _parse2['default'])(rule.style);
|
|
}
|
|
};
|
|
|
|
exports['default'] = function () {
|
|
return { onProcessRule: onProcessRule };
|
|
};
|
|
|
|
/***/ }),
|
|
/* 57 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var semiWithNl = /;\n/;
|
|
|
|
/**
|
|
* Naive CSS parser.
|
|
* - Supports only rule body (no selectors)
|
|
* - Requires semicolon and new line after the value (except of last line)
|
|
* - No nested rules support
|
|
*/
|
|
|
|
exports['default'] = function (cssText) {
|
|
var style = {};
|
|
var split = cssText.split(semiWithNl);
|
|
for (var i = 0; i < split.length; i++) {
|
|
var decl = (split[i] || '').trim();
|
|
|
|
if (!decl) continue;
|
|
var colonIndex = decl.indexOf(':');
|
|
if (colonIndex === -1) {
|
|
(0, _warning2['default'])(false, 'Malformed CSS string "%s"', decl);
|
|
continue;
|
|
}
|
|
var prop = decl.substr(0, colonIndex).trim();
|
|
var value = decl.substr(colonIndex + 1).trim();
|
|
style[prop] = value;
|
|
}
|
|
return style;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 58 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
exports['default'] = jssGlobal;
|
|
|
|
var _jss = __webpack_require__(21);
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var propKey = '@global';
|
|
var prefixKey = '@global ';
|
|
|
|
var GlobalContainerRule = function () {
|
|
function GlobalContainerRule(key, styles, options) {
|
|
_classCallCheck(this, GlobalContainerRule);
|
|
|
|
this.type = 'global';
|
|
|
|
this.key = key;
|
|
this.options = options;
|
|
this.rules = new _jss.RuleList(_extends({}, options, {
|
|
parent: this
|
|
}));
|
|
|
|
for (var selector in styles) {
|
|
this.rules.add(selector, styles[selector], { selector: selector });
|
|
}
|
|
|
|
this.rules.process();
|
|
}
|
|
|
|
/**
|
|
* Get a rule.
|
|
*/
|
|
|
|
|
|
_createClass(GlobalContainerRule, [{
|
|
key: 'getRule',
|
|
value: function getRule(name) {
|
|
return this.rules.get(name);
|
|
}
|
|
|
|
/**
|
|
* Create and register rule, run plugins.
|
|
*/
|
|
|
|
}, {
|
|
key: 'addRule',
|
|
value: function addRule(name, style, options) {
|
|
var rule = this.rules.add(name, style, options);
|
|
this.options.jss.plugins.onProcessRule(rule);
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Get index of a rule.
|
|
*/
|
|
|
|
}, {
|
|
key: 'indexOf',
|
|
value: function indexOf(rule) {
|
|
return this.rules.indexOf(rule);
|
|
}
|
|
|
|
/**
|
|
* Generates a CSS string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString() {
|
|
return this.rules.toString();
|
|
}
|
|
}]);
|
|
|
|
return GlobalContainerRule;
|
|
}();
|
|
|
|
var GlobalPrefixedRule = function () {
|
|
function GlobalPrefixedRule(name, style, options) {
|
|
_classCallCheck(this, GlobalPrefixedRule);
|
|
|
|
this.name = name;
|
|
this.options = options;
|
|
var selector = name.substr(prefixKey.length);
|
|
this.rule = options.jss.createRule(selector, style, _extends({}, options, {
|
|
parent: this,
|
|
selector: selector
|
|
}));
|
|
}
|
|
|
|
_createClass(GlobalPrefixedRule, [{
|
|
key: 'toString',
|
|
value: function toString(options) {
|
|
return this.rule.toString(options);
|
|
}
|
|
}]);
|
|
|
|
return GlobalPrefixedRule;
|
|
}();
|
|
|
|
var separatorRegExp = /\s*,\s*/g;
|
|
|
|
function addScope(selector, scope) {
|
|
var parts = selector.split(separatorRegExp);
|
|
var scoped = '';
|
|
for (var i = 0; i < parts.length; i++) {
|
|
scoped += scope + ' ' + parts[i].trim();
|
|
if (parts[i + 1]) scoped += ', ';
|
|
}
|
|
return scoped;
|
|
}
|
|
|
|
function handleNestedGlobalContainerRule(rule) {
|
|
var options = rule.options,
|
|
style = rule.style;
|
|
|
|
var rules = style[propKey];
|
|
|
|
if (!rules) return;
|
|
|
|
for (var name in rules) {
|
|
options.sheet.addRule(name, rules[name], _extends({}, options, {
|
|
selector: addScope(name, rule.selector)
|
|
}));
|
|
}
|
|
|
|
delete style[propKey];
|
|
}
|
|
|
|
function handlePrefixedGlobalRule(rule) {
|
|
var options = rule.options,
|
|
style = rule.style;
|
|
|
|
for (var prop in style) {
|
|
if (prop.substr(0, propKey.length) !== propKey) continue;
|
|
|
|
var selector = addScope(prop.substr(propKey.length), rule.selector);
|
|
options.sheet.addRule(selector, style[prop], _extends({}, options, {
|
|
selector: selector
|
|
}));
|
|
delete style[prop];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert nested rules to separate, remove them from original styles.
|
|
*
|
|
* @param {Rule} rule
|
|
* @api public
|
|
*/
|
|
function jssGlobal() {
|
|
function onCreateRule(name, styles, options) {
|
|
if (name === propKey) {
|
|
return new GlobalContainerRule(name, styles, options);
|
|
}
|
|
|
|
if (name[0] === '@' && name.substr(0, prefixKey.length) === prefixKey) {
|
|
return new GlobalPrefixedRule(name, styles, options);
|
|
}
|
|
|
|
var parent = options.parent;
|
|
|
|
|
|
if (parent) {
|
|
if (parent.type === 'global' || parent.options.parent.type === 'global') {
|
|
options.global = true;
|
|
}
|
|
}
|
|
|
|
if (options.global) options.selector = name;
|
|
|
|
return null;
|
|
}
|
|
|
|
function onProcessRule(rule) {
|
|
if (rule.type !== 'style') return;
|
|
|
|
handleNestedGlobalContainerRule(rule);
|
|
handlePrefixedGlobalRule(rule);
|
|
}
|
|
|
|
return { onCreateRule: onCreateRule, onProcessRule: onProcessRule };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 59 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
exports['default'] = jssExtend;
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var isObject = function isObject(obj) {
|
|
return obj && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && !Array.isArray(obj);
|
|
};
|
|
var valueNs = 'extendCurrValue' + Date.now();
|
|
|
|
function mergeExtend(style, rule, sheet, newStyle) {
|
|
var extendType = _typeof(style.extend);
|
|
// Extend using a rule name.
|
|
if (extendType === 'string') {
|
|
if (!sheet) return;
|
|
var refRule = sheet.getRule(style.extend);
|
|
if (!refRule) return;
|
|
if (refRule === rule) {
|
|
(0, _warning2['default'])(false, '[JSS] A rule tries to extend itself \r\n%s', rule);
|
|
return;
|
|
}
|
|
var parent = refRule.options.parent;
|
|
|
|
if (parent) {
|
|
var originalStyle = parent.rules.raw[style.extend];
|
|
extend(originalStyle, rule, sheet, newStyle);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Extend using an array of objects.
|
|
if (Array.isArray(style.extend)) {
|
|
for (var index = 0; index < style.extend.length; index++) {
|
|
extend(style.extend[index], rule, sheet, newStyle);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Extend is a style object.
|
|
for (var prop in style.extend) {
|
|
if (prop === 'extend') {
|
|
extend(style.extend.extend, rule, sheet, newStyle);
|
|
continue;
|
|
}
|
|
if (isObject(style.extend[prop])) {
|
|
if (!(prop in newStyle)) newStyle[prop] = {};
|
|
extend(style.extend[prop], rule, sheet, newStyle[prop]);
|
|
continue;
|
|
}
|
|
newStyle[prop] = style.extend[prop];
|
|
}
|
|
}
|
|
|
|
function mergeRest(style, rule, sheet, newStyle) {
|
|
// Copy base style.
|
|
for (var prop in style) {
|
|
if (prop === 'extend') continue;
|
|
if (isObject(newStyle[prop]) && isObject(style[prop])) {
|
|
extend(style[prop], rule, sheet, newStyle[prop]);
|
|
continue;
|
|
}
|
|
|
|
if (isObject(style[prop])) {
|
|
newStyle[prop] = extend(style[prop], rule, sheet);
|
|
continue;
|
|
}
|
|
|
|
newStyle[prop] = style[prop];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Recursively extend styles.
|
|
*/
|
|
function extend(style, rule, sheet) {
|
|
var newStyle = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
|
|
|
mergeExtend(style, rule, sheet, newStyle);
|
|
mergeRest(style, rule, sheet, newStyle);
|
|
return newStyle;
|
|
}
|
|
|
|
/**
|
|
* Handle `extend` property.
|
|
*
|
|
* @param {Rule} rule
|
|
* @api public
|
|
*/
|
|
function jssExtend() {
|
|
function onProcessStyle(style, rule, sheet) {
|
|
if ('extend' in style) return extend(style, rule, sheet);
|
|
return style;
|
|
}
|
|
|
|
function onChangeValue(value, prop, rule) {
|
|
if (prop !== 'extend') return value;
|
|
|
|
// Value is empty, remove properties set previously.
|
|
if (value == null || value === false) {
|
|
for (var key in rule[valueNs]) {
|
|
rule.prop(key, null);
|
|
}
|
|
rule[valueNs] = null;
|
|
return null;
|
|
}
|
|
|
|
for (var _key in value) {
|
|
rule.prop(_key, value[_key]);
|
|
}
|
|
rule[valueNs] = value;
|
|
|
|
// Make sure we don't set the value in the core.
|
|
return null;
|
|
}
|
|
|
|
return { onProcessStyle: onProcessStyle, onChangeValue: onChangeValue };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 60 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
exports.default = jssNested;
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
var separatorRegExp = /\s*,\s*/g;
|
|
var parentRegExp = /&/g;
|
|
var refRegExp = /\$([\w-]+)/g;
|
|
|
|
/**
|
|
* Convert nested rules to separate, remove them from original styles.
|
|
*
|
|
* @param {Rule} rule
|
|
* @api public
|
|
*/
|
|
function jssNested() {
|
|
// Get a function to be used for $ref replacement.
|
|
function getReplaceRef(container) {
|
|
return function (match, key) {
|
|
var rule = container.getRule(key);
|
|
if (rule) return rule.selector;
|
|
(0, _warning2.default)(false, '[JSS] Could not find the referenced rule %s in %s.', key, container.options.meta || container);
|
|
return key;
|
|
};
|
|
}
|
|
|
|
var hasAnd = function hasAnd(str) {
|
|
return str.indexOf('&') !== -1;
|
|
};
|
|
|
|
function replaceParentRefs(nestedProp, parentProp) {
|
|
var parentSelectors = parentProp.split(separatorRegExp);
|
|
var nestedSelectors = nestedProp.split(separatorRegExp);
|
|
|
|
var result = '';
|
|
|
|
for (var i = 0; i < parentSelectors.length; i++) {
|
|
var parent = parentSelectors[i];
|
|
|
|
for (var j = 0; j < nestedSelectors.length; j++) {
|
|
var nested = nestedSelectors[j];
|
|
if (result) result += ', ';
|
|
// Replace all & by the parent or prefix & with the parent.
|
|
result += hasAnd(nested) ? nested.replace(parentRegExp, parent) : parent + ' ' + nested;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function getOptions(rule, container, options) {
|
|
// Options has been already created, now we only increase index.
|
|
if (options) return _extends({}, options, { index: options.index + 1 });
|
|
|
|
var nestingLevel = rule.options.nestingLevel;
|
|
|
|
nestingLevel = nestingLevel === undefined ? 1 : nestingLevel + 1;
|
|
|
|
return _extends({}, rule.options, {
|
|
nestingLevel: nestingLevel,
|
|
index: container.indexOf(rule) + 1
|
|
});
|
|
}
|
|
|
|
function onProcessStyle(style, rule) {
|
|
if (rule.type !== 'style') return style;
|
|
var container = rule.options.parent;
|
|
var options = void 0;
|
|
var replaceRef = void 0;
|
|
for (var prop in style) {
|
|
var isNested = hasAnd(prop);
|
|
var isNestedConditional = prop[0] === '@';
|
|
|
|
if (!isNested && !isNestedConditional) continue;
|
|
|
|
options = getOptions(rule, container, options);
|
|
|
|
if (isNested) {
|
|
var selector = replaceParentRefs(prop, rule.selector
|
|
// Lazily create the ref replacer function just once for
|
|
// all nested rules within the sheet.
|
|
);if (!replaceRef) replaceRef = getReplaceRef(container
|
|
// Replace all $refs.
|
|
);selector = selector.replace(refRegExp, replaceRef);
|
|
|
|
container.addRule(selector, style[prop], _extends({}, options, { selector: selector }));
|
|
} else if (isNestedConditional) {
|
|
container
|
|
// Place conditional right after the parent rule to ensure right ordering.
|
|
.addRule(prop, null, options).addRule(rule.key, style[prop], { selector: rule.selector });
|
|
}
|
|
|
|
delete style[prop];
|
|
}
|
|
|
|
return style;
|
|
}
|
|
|
|
return { onProcessStyle: onProcessStyle };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 61 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = jssCompose;
|
|
|
|
var _warning = __webpack_require__(26);
|
|
|
|
var _warning2 = _interopRequireDefault(_warning);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/**
|
|
* Set selector.
|
|
*
|
|
* @param {Object} original rule
|
|
* @param {String} className class string
|
|
* @return {Boolean} flag, indicating function was successfull or not
|
|
*/
|
|
function registerClass(rule, className) {
|
|
// Skip falsy values
|
|
if (!className) return true;
|
|
|
|
// Support array of class names `{composes: ['foo', 'bar']}`
|
|
if (Array.isArray(className)) {
|
|
for (var index = 0; index < className.length; index++) {
|
|
var isSetted = registerClass(rule, className[index]);
|
|
if (!isSetted) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Support space separated class names `{composes: 'foo bar'}`
|
|
if (className.indexOf(' ') > -1) {
|
|
return registerClass(rule, className.split(' '));
|
|
}
|
|
|
|
var parent = rule.options.parent;
|
|
|
|
// It is a ref to a local rule.
|
|
|
|
if (className[0] === '$') {
|
|
var refRule = parent.getRule(className.substr(1));
|
|
|
|
if (!refRule) {
|
|
(0, _warning2.default)(false, '[JSS] Referenced rule is not defined. \r\n%s', rule);
|
|
return false;
|
|
}
|
|
|
|
if (refRule === rule) {
|
|
(0, _warning2.default)(false, '[JSS] Cyclic composition detected. \r\n%s', rule);
|
|
return false;
|
|
}
|
|
|
|
parent.classes[rule.key] += ' ' + parent.classes[refRule.key];
|
|
|
|
return true;
|
|
}
|
|
|
|
rule.options.parent.classes[rule.key] += ' ' + className;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Convert compose property to additional class, remove property from original styles.
|
|
*
|
|
* @param {Rule} rule
|
|
* @api public
|
|
*/
|
|
function jssCompose() {
|
|
function onProcessStyle(style, rule) {
|
|
if (!style.composes) return style;
|
|
registerClass(rule, style.composes);
|
|
// Remove composes property to prevent infinite loop.
|
|
delete style.composes;
|
|
return style;
|
|
}
|
|
return { onProcessStyle: onProcessStyle };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 62 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = camelCase;
|
|
|
|
var _hyphenateStyleName = __webpack_require__(63);
|
|
|
|
var _hyphenateStyleName2 = _interopRequireDefault(_hyphenateStyleName);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* Convert camel cased property names to dash separated.
|
|
*
|
|
* @param {Object} style
|
|
* @return {Object}
|
|
*/
|
|
function convertCase(style) {
|
|
var converted = {};
|
|
|
|
for (var prop in style) {
|
|
converted[(0, _hyphenateStyleName2['default'])(prop)] = style[prop];
|
|
}
|
|
|
|
if (style.fallbacks) {
|
|
if (Array.isArray(style.fallbacks)) converted.fallbacks = style.fallbacks.map(convertCase);else converted.fallbacks = convertCase(style.fallbacks);
|
|
}
|
|
|
|
return converted;
|
|
}
|
|
|
|
/**
|
|
* Allow camel cased property names by converting them back to dasherized.
|
|
*
|
|
* @param {Rule} rule
|
|
*/
|
|
function camelCase() {
|
|
function onProcessStyle(style) {
|
|
if (Array.isArray(style)) {
|
|
// Handle rules like @font-face, which can have multiple styles in an array
|
|
for (var index = 0; index < style.length; index++) {
|
|
style[index] = convertCase(style[index]);
|
|
}
|
|
return style;
|
|
}
|
|
|
|
return convertCase(style);
|
|
}
|
|
|
|
function onChangeValue(value, prop, rule) {
|
|
var hyphenatedProp = (0, _hyphenateStyleName2['default'])(prop);
|
|
|
|
// There was no camel case in place
|
|
if (prop === hyphenatedProp) return value;
|
|
|
|
rule.prop(hyphenatedProp, value);
|
|
|
|
// Core will ignore that property value we set the proper one above.
|
|
return null;
|
|
}
|
|
|
|
return { onProcessStyle: onProcessStyle, onChangeValue: onChangeValue };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 63 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
var uppercasePattern = /[A-Z]/g;
|
|
var msPattern = /^ms-/;
|
|
var cache = {};
|
|
|
|
function hyphenateStyleName(string) {
|
|
return string in cache
|
|
? cache[string]
|
|
: cache[string] = string
|
|
.replace(uppercasePattern, '-$&')
|
|
.toLowerCase()
|
|
.replace(msPattern, '-ms-');
|
|
}
|
|
|
|
module.exports = hyphenateStyleName;
|
|
|
|
|
|
/***/ }),
|
|
/* 64 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
exports['default'] = defaultUnit;
|
|
|
|
var _defaultUnits = __webpack_require__(65);
|
|
|
|
var _defaultUnits2 = _interopRequireDefault(_defaultUnits);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* Clones the object and adds a camel cased property version.
|
|
*/
|
|
function addCamelCasedVersion(obj) {
|
|
var regExp = /(-[a-z])/g;
|
|
var replace = function replace(str) {
|
|
return str[1].toUpperCase();
|
|
};
|
|
var newObj = {};
|
|
for (var key in obj) {
|
|
newObj[key] = obj[key];
|
|
newObj[key.replace(regExp, replace)] = obj[key];
|
|
}
|
|
return newObj;
|
|
}
|
|
|
|
var units = addCamelCasedVersion(_defaultUnits2['default']);
|
|
|
|
/**
|
|
* Recursive deep style passing function
|
|
*
|
|
* @param {String} current property
|
|
* @param {(Object|Array|Number|String)} property value
|
|
* @param {Object} options
|
|
* @return {(Object|Array|Number|String)} resulting value
|
|
*/
|
|
function iterate(prop, value, options) {
|
|
if (!value) return value;
|
|
|
|
var convertedValue = value;
|
|
|
|
var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
|
|
if (type === 'object' && Array.isArray(value)) type = 'array';
|
|
|
|
switch (type) {
|
|
case 'object':
|
|
if (prop === 'fallbacks') {
|
|
for (var innerProp in value) {
|
|
value[innerProp] = iterate(innerProp, value[innerProp], options);
|
|
}
|
|
break;
|
|
}
|
|
for (var _innerProp in value) {
|
|
value[_innerProp] = iterate(prop + '-' + _innerProp, value[_innerProp], options);
|
|
}
|
|
break;
|
|
case 'array':
|
|
for (var i = 0; i < value.length; i++) {
|
|
value[i] = iterate(prop, value[i], options);
|
|
}
|
|
break;
|
|
case 'number':
|
|
if (value !== 0) {
|
|
convertedValue = value + (options[prop] || units[prop] || '');
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return convertedValue;
|
|
}
|
|
|
|
/**
|
|
* Add unit to numeric values.
|
|
*/
|
|
function defaultUnit() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
var camelCasedOptions = addCamelCasedVersion(options);
|
|
|
|
function onProcessStyle(style, rule) {
|
|
if (rule.type !== 'style') return style;
|
|
|
|
for (var prop in style) {
|
|
style[prop] = iterate(prop, style[prop], camelCasedOptions);
|
|
}
|
|
|
|
return style;
|
|
}
|
|
|
|
function onChangeValue(value, prop) {
|
|
return iterate(prop, value, camelCasedOptions);
|
|
}
|
|
|
|
return { onProcessStyle: onProcessStyle, onChangeValue: onChangeValue };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 65 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
/**
|
|
* Generated jss-default-unit CSS property units
|
|
*
|
|
* @type object
|
|
*/
|
|
exports['default'] = {
|
|
'animation-delay': 'ms',
|
|
'animation-duration': 'ms',
|
|
'background-position': 'px',
|
|
'background-position-x': 'px',
|
|
'background-position-y': 'px',
|
|
'background-size': 'px',
|
|
border: 'px',
|
|
'border-bottom': 'px',
|
|
'border-bottom-left-radius': 'px',
|
|
'border-bottom-right-radius': 'px',
|
|
'border-bottom-width': 'px',
|
|
'border-left': 'px',
|
|
'border-left-width': 'px',
|
|
'border-radius': 'px',
|
|
'border-right': 'px',
|
|
'border-right-width': 'px',
|
|
'border-spacing': 'px',
|
|
'border-top': 'px',
|
|
'border-top-left-radius': 'px',
|
|
'border-top-right-radius': 'px',
|
|
'border-top-width': 'px',
|
|
'border-width': 'px',
|
|
'border-after-width': 'px',
|
|
'border-before-width': 'px',
|
|
'border-end-width': 'px',
|
|
'border-horizontal-spacing': 'px',
|
|
'border-start-width': 'px',
|
|
'border-vertical-spacing': 'px',
|
|
bottom: 'px',
|
|
'box-shadow': 'px',
|
|
'column-gap': 'px',
|
|
'column-rule': 'px',
|
|
'column-rule-width': 'px',
|
|
'column-width': 'px',
|
|
'flex-basis': 'px',
|
|
'font-size': 'px',
|
|
'font-size-delta': 'px',
|
|
height: 'px',
|
|
left: 'px',
|
|
'letter-spacing': 'px',
|
|
'logical-height': 'px',
|
|
'logical-width': 'px',
|
|
margin: 'px',
|
|
'margin-after': 'px',
|
|
'margin-before': 'px',
|
|
'margin-bottom': 'px',
|
|
'margin-left': 'px',
|
|
'margin-right': 'px',
|
|
'margin-top': 'px',
|
|
'max-height': 'px',
|
|
'max-width': 'px',
|
|
'margin-end': 'px',
|
|
'margin-start': 'px',
|
|
'mask-position-x': 'px',
|
|
'mask-position-y': 'px',
|
|
'mask-size': 'px',
|
|
'max-logical-height': 'px',
|
|
'max-logical-width': 'px',
|
|
'min-height': 'px',
|
|
'min-width': 'px',
|
|
'min-logical-height': 'px',
|
|
'min-logical-width': 'px',
|
|
motion: 'px',
|
|
'motion-offset': 'px',
|
|
outline: 'px',
|
|
'outline-offset': 'px',
|
|
'outline-width': 'px',
|
|
padding: 'px',
|
|
'padding-bottom': 'px',
|
|
'padding-left': 'px',
|
|
'padding-right': 'px',
|
|
'padding-top': 'px',
|
|
'padding-after': 'px',
|
|
'padding-before': 'px',
|
|
'padding-end': 'px',
|
|
'padding-start': 'px',
|
|
'perspective-origin-x': '%',
|
|
'perspective-origin-y': '%',
|
|
perspective: 'px',
|
|
right: 'px',
|
|
'shape-margin': 'px',
|
|
size: 'px',
|
|
'text-indent': 'px',
|
|
'text-stroke': 'px',
|
|
'text-stroke-width': 'px',
|
|
top: 'px',
|
|
'transform-origin': '%',
|
|
'transform-origin-x': '%',
|
|
'transform-origin-y': '%',
|
|
'transform-origin-z': '%',
|
|
'transition-delay': 'ms',
|
|
'transition-duration': 'ms',
|
|
'vertical-align': 'px',
|
|
width: 'px',
|
|
'word-spacing': 'px',
|
|
// Not existing properties.
|
|
// Used to avoid issues with jss-expand intergration.
|
|
'box-shadow-x': 'px',
|
|
'box-shadow-y': 'px',
|
|
'box-shadow-blur': 'px',
|
|
'box-shadow-spread': 'px',
|
|
'font-line-height': 'px',
|
|
'text-shadow-x': 'px',
|
|
'text-shadow-y': 'px',
|
|
'text-shadow-blur': 'px'
|
|
};
|
|
|
|
/***/ }),
|
|
/* 66 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
exports.default = jssExpand;
|
|
|
|
var _props = __webpack_require__(67);
|
|
|
|
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; }
|
|
|
|
/**
|
|
* Map values by given prop.
|
|
*
|
|
* @param {Array} array of values
|
|
* @param {String} original property
|
|
* @param {String} original rule
|
|
* @return {String} mapped values
|
|
*/
|
|
function mapValuesByProp(value, prop, rule) {
|
|
return value.map(function (item) {
|
|
return objectToString(item, prop, rule);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Convert array to string.
|
|
*
|
|
* @param {Array} array of values
|
|
* @param {String} original property
|
|
* @param {Object} sheme, for converting arrays in strings
|
|
* @param {Object} original rule
|
|
* @return {String} converted string
|
|
*/
|
|
function arrayToString(value, prop, scheme, rule) {
|
|
if (scheme[prop] == null) return value.join(',');
|
|
if (value.length === 0) return '';
|
|
if (Array.isArray(value[0])) return arrayToString(value[0], prop, scheme);
|
|
if (_typeof(value[0]) === 'object') {
|
|
return mapValuesByProp(value, prop, rule);
|
|
}
|
|
return value.join(' ');
|
|
}
|
|
|
|
/**
|
|
* Convert object to string.
|
|
*
|
|
* @param {Object} object of values
|
|
* @param {String} original property
|
|
* @param {Object} original rule
|
|
* @param {Boolean} is fallback prop
|
|
* @return {String} converted string
|
|
*/
|
|
function objectToString(value, prop, rule, isFallback) {
|
|
if (!(_props.propObj[prop] || _props.customPropObj[prop])) return '';
|
|
|
|
var result = [];
|
|
|
|
// Check if exists any non-standart property
|
|
if (_props.customPropObj[prop]) {
|
|
value = customPropsToStyle(value, rule, _props.customPropObj[prop], isFallback);
|
|
}
|
|
|
|
// Pass throught all standart props
|
|
if (Object.keys(value).length) {
|
|
for (var baseProp in _props.propObj[prop]) {
|
|
if (value[baseProp]) {
|
|
if (Array.isArray(value[baseProp])) {
|
|
result.push(arrayToString(value[baseProp], baseProp, _props.propArrayInObj));
|
|
} else result.push(value[baseProp]);
|
|
continue;
|
|
}
|
|
|
|
// Add default value from props config.
|
|
if (_props.propObj[prop][baseProp] != null) {
|
|
result.push(_props.propObj[prop][baseProp]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result.join(' ');
|
|
}
|
|
|
|
/**
|
|
* Convert custom properties values to styles adding them to rule directly
|
|
*
|
|
* @param {Object} object of values
|
|
* @param {Object} original rule
|
|
* @param {String} property, that contain partial custom properties
|
|
* @param {Boolean} is fallback prop
|
|
* @return {Object} value without custom properties, that was already added to rule
|
|
*/
|
|
function customPropsToStyle(value, rule, customProps, isFallback) {
|
|
for (var prop in customProps) {
|
|
var propName = customProps[prop];
|
|
|
|
// If current property doesn't exist already in rule - add new one
|
|
if (typeof value[prop] !== 'undefined' && (isFallback || !rule.prop(propName))) {
|
|
var appendedValue = styleDetector(_defineProperty({}, propName, value[prop]), rule)[propName];
|
|
|
|
// Add style directly in rule
|
|
if (isFallback) rule.style.fallbacks[propName] = appendedValue;else rule.style[propName] = appendedValue;
|
|
}
|
|
// Delete converted property to avoid double converting
|
|
delete value[prop];
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Detect if a style needs to be converted.
|
|
*
|
|
* @param {Object} style
|
|
* @param {Object} rule
|
|
* @param {Boolean} is fallback prop
|
|
* @return {Object} convertedStyle
|
|
*/
|
|
function styleDetector(style, rule, isFallback) {
|
|
for (var prop in style) {
|
|
var value = style[prop];
|
|
|
|
if (Array.isArray(value)) {
|
|
// Check double arrays to avoid recursion.
|
|
if (!Array.isArray(value[0])) {
|
|
if (prop === 'fallbacks') {
|
|
for (var index = 0; index < style.fallbacks.length; index++) {
|
|
style.fallbacks[index] = styleDetector(style.fallbacks[index], rule, true);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
style[prop] = arrayToString(value, prop, _props.propArray);
|
|
// Avoid creating properties with empty values
|
|
if (!style[prop]) delete style[prop];
|
|
}
|
|
} else if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
|
|
if (prop === 'fallbacks') {
|
|
style.fallbacks = styleDetector(style.fallbacks, rule, true);
|
|
continue;
|
|
}
|
|
|
|
style[prop] = objectToString(value, prop, rule, isFallback);
|
|
// Avoid creating properties with empty values
|
|
if (!style[prop]) delete style[prop];
|
|
}
|
|
|
|
// Maybe a computed value resulting in an empty string
|
|
else if (style[prop] === '') delete style[prop];
|
|
}
|
|
|
|
return style;
|
|
}
|
|
|
|
/**
|
|
* Adds possibility to write expanded styles.
|
|
*
|
|
* @param {Rule} rule
|
|
* @api public
|
|
*/
|
|
function jssExpand() {
|
|
function onProcessStyle(style, rule) {
|
|
if (!style || rule.type !== 'style') return style;
|
|
|
|
if (Array.isArray(style)) {
|
|
// Pass rules one by one and reformat them
|
|
for (var index = 0; index < style.length; index++) {
|
|
style[index] = styleDetector(style[index], rule);
|
|
}
|
|
return style;
|
|
}
|
|
|
|
return styleDetector(style, rule);
|
|
}
|
|
|
|
return { onProcessStyle: onProcessStyle };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 67 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
/**
|
|
* A scheme for converting properties from array to regular style.
|
|
* All properties listed below will be transformed to a string separated by space.
|
|
*/
|
|
var propArray = exports.propArray = {
|
|
'background-size': true,
|
|
'background-position': true,
|
|
border: true,
|
|
'border-bottom': true,
|
|
'border-left': true,
|
|
'border-top': true,
|
|
'border-right': true,
|
|
'border-radius': true,
|
|
'border-image': true,
|
|
'box-shadow': true,
|
|
flex: true,
|
|
margin: true,
|
|
padding: true,
|
|
outline: true,
|
|
'transform-origin': true,
|
|
transform: true,
|
|
transition: true
|
|
|
|
/**
|
|
* A scheme for converting arrays to regular styles inside of objects.
|
|
* For e.g.: "{position: [0, 0]}" => "background-position: 0 0;".
|
|
*/
|
|
};var propArrayInObj = exports.propArrayInObj = {
|
|
position: true, // background-position
|
|
size: true // background-size
|
|
|
|
|
|
/**
|
|
* A scheme for parsing and building correct styles from passed objects.
|
|
*/
|
|
};var propObj = exports.propObj = {
|
|
padding: {
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0
|
|
},
|
|
margin: {
|
|
top: 0,
|
|
right: 0,
|
|
bottom: 0,
|
|
left: 0
|
|
},
|
|
background: {
|
|
attachment: null,
|
|
color: null,
|
|
image: null,
|
|
position: null,
|
|
repeat: null
|
|
},
|
|
border: {
|
|
width: null,
|
|
style: null,
|
|
color: null
|
|
},
|
|
'border-top': {
|
|
width: null,
|
|
style: null,
|
|
color: null
|
|
},
|
|
'border-right': {
|
|
width: null,
|
|
style: null,
|
|
color: null
|
|
},
|
|
'border-bottom': {
|
|
width: null,
|
|
style: null,
|
|
color: null
|
|
},
|
|
'border-left': {
|
|
width: null,
|
|
style: null,
|
|
color: null
|
|
},
|
|
outline: {
|
|
width: null,
|
|
style: null,
|
|
color: null
|
|
},
|
|
'list-style': {
|
|
type: null,
|
|
position: null,
|
|
image: null
|
|
},
|
|
transition: {
|
|
property: null,
|
|
duration: null,
|
|
'timing-function': null,
|
|
timingFunction: null, // Needed for avoiding comilation issues with jss-camel-case
|
|
delay: null
|
|
},
|
|
animation: {
|
|
name: null,
|
|
duration: null,
|
|
'timing-function': null,
|
|
timingFunction: null, // Needed to avoid compilation issues with jss-camel-case
|
|
delay: null,
|
|
'iteration-count': null,
|
|
iterationCount: null, // Needed to avoid compilation issues with jss-camel-case
|
|
direction: null,
|
|
'fill-mode': null,
|
|
fillMode: null, // Needed to avoid compilation issues with jss-camel-case
|
|
'play-state': null,
|
|
playState: null // Needed to avoid compilation issues with jss-camel-case
|
|
},
|
|
'box-shadow': {
|
|
x: 0,
|
|
y: 0,
|
|
blur: 0,
|
|
spread: 0,
|
|
color: null,
|
|
inset: null
|
|
},
|
|
'text-shadow': {
|
|
x: 0,
|
|
y: 0,
|
|
blur: null,
|
|
color: null
|
|
}
|
|
|
|
/**
|
|
* A scheme for converting non-standart properties inside object.
|
|
* For e.g.: include 'border-radius' property inside 'border' object.
|
|
*/
|
|
};var customPropObj = exports.customPropObj = {
|
|
border: {
|
|
radius: 'border-radius',
|
|
image: 'border-image'
|
|
},
|
|
background: {
|
|
size: 'background-size',
|
|
image: 'background-image'
|
|
},
|
|
font: {
|
|
style: 'font-style',
|
|
variant: 'font-variant',
|
|
weight: 'font-weight',
|
|
stretch: 'font-stretch',
|
|
size: 'font-size',
|
|
family: 'font-family',
|
|
lineHeight: 'line-height', // Needed to avoid compilation issues with jss-camel-case
|
|
'line-height': 'line-height'
|
|
},
|
|
flex: {
|
|
grow: 'flex-grow',
|
|
basis: 'flex-basis',
|
|
direction: 'flex-direction',
|
|
wrap: 'flex-wrap',
|
|
flow: 'flex-flow',
|
|
shrink: 'flex-shrink'
|
|
},
|
|
align: {
|
|
self: 'align-self',
|
|
items: 'align-items',
|
|
content: 'align-content'
|
|
}
|
|
};
|
|
|
|
/***/ }),
|
|
/* 68 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = jssVendorPrefixer;
|
|
|
|
var _cssVendor = __webpack_require__(69);
|
|
|
|
var vendor = _interopRequireWildcard(_cssVendor);
|
|
|
|
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)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
/**
|
|
* Add vendor prefix to a property name when needed.
|
|
*
|
|
* @param {Rule} rule
|
|
* @api public
|
|
*/
|
|
function jssVendorPrefixer() {
|
|
function onProcessRule(rule) {
|
|
if (rule.type === 'keyframes') {
|
|
rule.key = '@' + vendor.prefix.css + rule.key.substr(1);
|
|
}
|
|
}
|
|
|
|
function onProcessStyle(style, rule) {
|
|
if (rule.type !== 'style') return style;
|
|
|
|
for (var prop in style) {
|
|
var value = style[prop];
|
|
|
|
var changeProp = false;
|
|
var supportedProp = vendor.supportedProperty(prop);
|
|
if (supportedProp && supportedProp !== prop) changeProp = true;
|
|
|
|
var changeValue = false;
|
|
var supportedValue = vendor.supportedValue(supportedProp, value);
|
|
if (supportedValue && supportedValue !== value) changeValue = true;
|
|
|
|
if (changeProp || changeValue) {
|
|
if (changeProp) delete style[prop];
|
|
style[supportedProp || prop] = supportedValue || value;
|
|
}
|
|
}
|
|
|
|
return style;
|
|
}
|
|
|
|
function onChangeValue(value, prop) {
|
|
return vendor.supportedValue(prop, value);
|
|
}
|
|
|
|
return { onProcessRule: onProcessRule, onProcessStyle: onProcessStyle, onChangeValue: onChangeValue };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 69 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.supportedValue = exports.supportedProperty = exports.prefix = undefined;
|
|
|
|
var _prefix = __webpack_require__(70);
|
|
|
|
var _prefix2 = _interopRequireDefault(_prefix);
|
|
|
|
var _supportedProperty = __webpack_require__(71);
|
|
|
|
var _supportedProperty2 = _interopRequireDefault(_supportedProperty);
|
|
|
|
var _supportedValue = __webpack_require__(73);
|
|
|
|
var _supportedValue2 = _interopRequireDefault(_supportedValue);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
exports['default'] = {
|
|
prefix: _prefix2['default'],
|
|
supportedProperty: _supportedProperty2['default'],
|
|
supportedValue: _supportedValue2['default']
|
|
}; /**
|
|
* CSS Vendor prefix detection and property feature testing.
|
|
*
|
|
* @copyright Oleg Slobodskoi 2015
|
|
* @website https://github.com/jsstyles/css-vendor
|
|
* @license MIT
|
|
*/
|
|
|
|
exports.prefix = _prefix2['default'];
|
|
exports.supportedProperty = _supportedProperty2['default'];
|
|
exports.supportedValue = _supportedValue2['default'];
|
|
|
|
/***/ }),
|
|
/* 70 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _isInBrowser = __webpack_require__(43);
|
|
|
|
var _isInBrowser2 = _interopRequireDefault(_isInBrowser);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var js = ''; /**
|
|
* Export javascript style and css style vendor prefixes.
|
|
* Based on "transform" support test.
|
|
*/
|
|
|
|
var css = '';
|
|
|
|
// We should not do anything if required serverside.
|
|
if (_isInBrowser2['default']) {
|
|
// Order matters. We need to check Webkit the last one because
|
|
// other vendors use to add Webkit prefixes to some properties
|
|
var jsCssMap = {
|
|
Moz: '-moz-',
|
|
// IE did it wrong again ...
|
|
ms: '-ms-',
|
|
O: '-o-',
|
|
Webkit: '-webkit-'
|
|
};
|
|
var style = document.createElement('p').style;
|
|
var testProp = 'Transform';
|
|
|
|
for (var key in jsCssMap) {
|
|
if (key + testProp in style) {
|
|
js = key;
|
|
css = jsCssMap[key];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vendor prefix string for the current browser.
|
|
*
|
|
* @type {{js: String, css: String}}
|
|
* @api public
|
|
*/
|
|
exports['default'] = { js: js, css: css };
|
|
|
|
/***/ }),
|
|
/* 71 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = supportedProperty;
|
|
|
|
var _isInBrowser = __webpack_require__(43);
|
|
|
|
var _isInBrowser2 = _interopRequireDefault(_isInBrowser);
|
|
|
|
var _prefix = __webpack_require__(70);
|
|
|
|
var _prefix2 = _interopRequireDefault(_prefix);
|
|
|
|
var _camelize = __webpack_require__(72);
|
|
|
|
var _camelize2 = _interopRequireDefault(_camelize);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var el = void 0;
|
|
var cache = {};
|
|
|
|
if (_isInBrowser2['default']) {
|
|
el = document.createElement('p');
|
|
|
|
/**
|
|
* We test every property on vendor prefix requirement.
|
|
* Once tested, result is cached. It gives us up to 70% perf boost.
|
|
* http://jsperf.com/element-style-object-access-vs-plain-object
|
|
*
|
|
* Prefill cache with known css properties to reduce amount of
|
|
* properties we need to feature test at runtime.
|
|
* http://davidwalsh.name/vendor-prefix
|
|
*/
|
|
var computed = window.getComputedStyle(document.documentElement, '');
|
|
for (var key in computed) {
|
|
if (!isNaN(key)) cache[computed[key]] = computed[key];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test if a property is supported, returns supported property with vendor
|
|
* prefix if required. Returns `false` if not supported.
|
|
*
|
|
* @param {String} prop dash separated
|
|
* @return {String|Boolean}
|
|
* @api public
|
|
*/
|
|
function supportedProperty(prop) {
|
|
// For server-side rendering.
|
|
if (!el) return prop;
|
|
|
|
// We have not tested this prop yet, lets do the test.
|
|
if (cache[prop] != null) return cache[prop];
|
|
|
|
// Camelization is required because we can't test using
|
|
// css syntax for e.g. in FF.
|
|
// Test if property is supported as it is.
|
|
if ((0, _camelize2['default'])(prop) in el.style) {
|
|
cache[prop] = prop;
|
|
}
|
|
// Test if property is supported with vendor prefix.
|
|
else if (_prefix2['default'].js + (0, _camelize2['default'])('-' + prop) in el.style) {
|
|
cache[prop] = _prefix2['default'].css + prop;
|
|
} else {
|
|
cache[prop] = false;
|
|
}
|
|
|
|
return cache[prop];
|
|
}
|
|
|
|
/***/ }),
|
|
/* 72 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = camelize;
|
|
var regExp = /[-\s]+(.)?/g;
|
|
|
|
/**
|
|
* Convert dash separated strings to camel cased.
|
|
*
|
|
* @param {String} str
|
|
* @return {String}
|
|
*/
|
|
function camelize(str) {
|
|
return str.replace(regExp, toUpper);
|
|
}
|
|
|
|
function toUpper(match, c) {
|
|
return c ? c.toUpperCase() : '';
|
|
}
|
|
|
|
/***/ }),
|
|
/* 73 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = supportedValue;
|
|
|
|
var _isInBrowser = __webpack_require__(43);
|
|
|
|
var _isInBrowser2 = _interopRequireDefault(_isInBrowser);
|
|
|
|
var _prefix = __webpack_require__(70);
|
|
|
|
var _prefix2 = _interopRequireDefault(_prefix);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var cache = {};
|
|
var el = void 0;
|
|
|
|
if (_isInBrowser2['default']) el = document.createElement('p');
|
|
|
|
/**
|
|
* Returns prefixed value if needed. Returns `false` if value is not supported.
|
|
*
|
|
* @param {String} property
|
|
* @param {String} value
|
|
* @return {String|Boolean}
|
|
* @api public
|
|
*/
|
|
function supportedValue(property, value) {
|
|
// For server-side rendering.
|
|
if (!el) return value;
|
|
|
|
// It is a string or a number as a string like '1'.
|
|
// We want only prefixable values here.
|
|
if (typeof value !== 'string' || !isNaN(parseInt(value, 10))) return value;
|
|
|
|
var cacheKey = property + value;
|
|
|
|
if (cache[cacheKey] != null) return cache[cacheKey];
|
|
|
|
// IE can even throw an error in some cases, for e.g. style.content = 'bar'
|
|
try {
|
|
// Test value as it is.
|
|
el.style[property] = value;
|
|
} catch (err) {
|
|
cache[cacheKey] = false;
|
|
return false;
|
|
}
|
|
|
|
// Value is supported as it is.
|
|
if (el.style[property] !== '') {
|
|
cache[cacheKey] = value;
|
|
} else {
|
|
// Test value with vendor prefix.
|
|
value = _prefix2['default'].css + value;
|
|
|
|
// Hardcode test to convert "flex" to "-ms-flexbox" for IE10.
|
|
if (value === '-ms-flex') value = '-ms-flexbox';
|
|
|
|
el.style[property] = value;
|
|
|
|
// Value is supported with vendor prefix.
|
|
if (el.style[property] !== '') cache[cacheKey] = value;
|
|
}
|
|
|
|
if (!cache[cacheKey]) cache[cacheKey] = false;
|
|
|
|
// Reset style value.
|
|
el.style[property] = '';
|
|
|
|
return cache[cacheKey];
|
|
}
|
|
|
|
/***/ }),
|
|
/* 74 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = jssPropsSort;
|
|
/**
|
|
* Sort props by length.
|
|
*/
|
|
function jssPropsSort() {
|
|
function sort(prop0, prop1) {
|
|
return prop0.length - prop1.length;
|
|
}
|
|
|
|
function onProcessStyle(style, rule) {
|
|
if (rule.type !== 'style') return style;
|
|
|
|
var newStyle = {};
|
|
var props = Object.keys(style).sort(sort);
|
|
for (var prop in props) {
|
|
newStyle[props[prop]] = style[props[prop]];
|
|
}
|
|
return newStyle;
|
|
}
|
|
|
|
return { onProcessStyle: onProcessStyle };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 75 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
/**
|
|
* Namespaces to avoid conflicts on the context.
|
|
*/
|
|
var jss = exports.jss = '64a55d578f856d258dc345b094a2a2b3';
|
|
var sheetsRegistry = exports.sheetsRegistry = 'd4bd0baacbc52bbd48bbb9eb24344ecd';
|
|
var managers = exports.managers = 'b768b78919504fba9de2c03545c5cd3a';
|
|
var sheetOptions = exports.sheetOptions = '6fc570d6bd61383819d0f9e7407c452d';
|
|
|
|
/***/ }),
|
|
/* 76 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _ns$jss$ns$sheetOptio;
|
|
|
|
var _propTypes = __webpack_require__(4);
|
|
|
|
var _ns = __webpack_require__(75);
|
|
|
|
var ns = _interopRequireWildcard(_ns);
|
|
|
|
var _propTypes2 = __webpack_require__(77);
|
|
|
|
var _propTypes3 = _interopRequireDefault(_propTypes2);
|
|
|
|
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)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
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; }
|
|
|
|
exports['default'] = (_ns$jss$ns$sheetOptio = {}, _defineProperty(_ns$jss$ns$sheetOptio, ns.jss, _propTypes3['default'].jss), _defineProperty(_ns$jss$ns$sheetOptio, ns.sheetOptions, _propTypes.object), _defineProperty(_ns$jss$ns$sheetOptio, ns.sheetsRegistry, _propTypes3['default'].registry), _defineProperty(_ns$jss$ns$sheetOptio, ns.managers, _propTypes.object), _ns$jss$ns$sheetOptio);
|
|
|
|
/***/ }),
|
|
/* 77 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _propTypes = __webpack_require__(4);
|
|
|
|
exports['default'] = {
|
|
jss: (0, _propTypes.shape)({
|
|
options: (0, _propTypes.shape)({
|
|
createGenerateClassName: _propTypes.func.isRequired
|
|
}).isRequired,
|
|
createStyleSheet: _propTypes.func.isRequired,
|
|
removeStyleSheet: _propTypes.func.isRequired
|
|
}),
|
|
registry: (0, _propTypes.shape)({
|
|
add: _propTypes.func.isRequired,
|
|
toString: _propTypes.func.isRequired
|
|
})
|
|
};
|
|
|
|
/***/ }),
|
|
/* 78 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports['default'] = injectSheet;
|
|
|
|
var _hoistNonReactStatics = __webpack_require__(79);
|
|
|
|
var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
|
|
|
|
var _createHoc = __webpack_require__(80);
|
|
|
|
var _createHoc2 = _interopRequireDefault(_createHoc);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
/**
|
|
* Global index counter to preserve source order.
|
|
* As we create the style sheet during componentWillMount lifecycle,
|
|
* children are handled after the parents, so the order of style elements would
|
|
* be parent->child. It is a problem though when a parent passes a className
|
|
* which needs to override any childs styles. StyleSheet of the child has a higher
|
|
* specificity, because of the source order.
|
|
* So our solution is to render sheets them in the reverse order child->sheet, so
|
|
* that parent has a higher specificity.
|
|
*
|
|
* @type {Number}
|
|
*/
|
|
var indexCounter = -100000;
|
|
|
|
var NoRenderer = function NoRenderer(_ref) {
|
|
var children = _ref.children;
|
|
return children || null;
|
|
};
|
|
|
|
/**
|
|
* HOC creator function that wrapps the user component.
|
|
*
|
|
* `injectSheet(styles, [options])(Component)`
|
|
*
|
|
* @api public
|
|
*/
|
|
function injectSheet(stylesOrSheet) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
if (options.index === undefined) {
|
|
options.index = indexCounter++;
|
|
}
|
|
return function () {
|
|
var InnerComponent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : NoRenderer;
|
|
|
|
var Jss = (0, _createHoc2['default'])(stylesOrSheet, InnerComponent, options);
|
|
return (0, _hoistNonReactStatics2['default'])(Jss, InnerComponent, { inner: true });
|
|
};
|
|
}
|
|
|
|
/***/ }),
|
|
/* 79 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright 2015, Yahoo! Inc.
|
|
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
|
|
*/
|
|
(function (global, factory) {
|
|
true ? module.exports = factory() :
|
|
typeof define === 'function' && define.amd ? define(factory) :
|
|
(global.hoistNonReactStatics = factory());
|
|
}(this, (function () {
|
|
'use strict';
|
|
|
|
var REACT_STATICS = {
|
|
childContextTypes: true,
|
|
contextTypes: true,
|
|
defaultProps: true,
|
|
displayName: true,
|
|
getDefaultProps: true,
|
|
getDerivedStateFromProps: true,
|
|
mixins: true,
|
|
propTypes: true,
|
|
type: true
|
|
};
|
|
|
|
var KNOWN_STATICS = {
|
|
name: true,
|
|
length: true,
|
|
prototype: true,
|
|
caller: true,
|
|
callee: true,
|
|
arguments: true,
|
|
arity: true
|
|
};
|
|
|
|
var defineProperty = Object.defineProperty;
|
|
var getOwnPropertyNames = Object.getOwnPropertyNames;
|
|
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var getPrototypeOf = Object.getPrototypeOf;
|
|
var objectPrototype = getPrototypeOf && getPrototypeOf(Object);
|
|
|
|
return function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
|
|
if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components
|
|
|
|
if (objectPrototype) {
|
|
var inheritedComponent = getPrototypeOf(sourceComponent);
|
|
if (inheritedComponent && inheritedComponent !== objectPrototype) {
|
|
hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
|
|
}
|
|
}
|
|
|
|
var keys = getOwnPropertyNames(sourceComponent);
|
|
|
|
if (getOwnPropertySymbols) {
|
|
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
|
|
}
|
|
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {
|
|
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
|
|
try { // Avoid failures from read-only properties
|
|
defineProperty(targetComponent, key, descriptor);
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
|
|
return targetComponent;
|
|
}
|
|
|
|
return targetComponent;
|
|
};
|
|
})));
|
|
|
|
|
|
/***/ }),
|
|
/* 80 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _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; };
|
|
|
|
var _react = __webpack_require__(3);
|
|
|
|
var _react2 = _interopRequireDefault(_react);
|
|
|
|
var _propTypes = __webpack_require__(4);
|
|
|
|
var _propTypes2 = _interopRequireDefault(_propTypes);
|
|
|
|
var _theming = __webpack_require__(1);
|
|
|
|
var _theming2 = _interopRequireDefault(_theming);
|
|
|
|
var _jss = __webpack_require__(20);
|
|
|
|
var _jss2 = _interopRequireDefault(_jss);
|
|
|
|
var _compose = __webpack_require__(81);
|
|
|
|
var _compose2 = _interopRequireDefault(_compose);
|
|
|
|
var _getDisplayName = __webpack_require__(82);
|
|
|
|
var _getDisplayName2 = _interopRequireDefault(_getDisplayName);
|
|
|
|
var _ns = __webpack_require__(75);
|
|
|
|
var ns = _interopRequireWildcard(_ns);
|
|
|
|
var _contextTypes = __webpack_require__(76);
|
|
|
|
var _contextTypes2 = _interopRequireDefault(_contextTypes);
|
|
|
|
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)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
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 && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { 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: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
|
|
|
|
var env = ("development");
|
|
|
|
// Like a Symbol
|
|
var dynamicStylesNs = Math.random();
|
|
|
|
/*
|
|
* # Use cases
|
|
*
|
|
* - Unthemed component accepts styles object
|
|
* - Themed component accepts styles creator function which takes theme as a single argument
|
|
* - Multiple instances will re-use the same static sheet via sheets manager
|
|
* - Sheet manager identifies static sheets by theme as a key
|
|
* - For unthemed components theme is an empty object
|
|
* - The very first instance will add static sheet to sheets manager
|
|
* - Every further instances will get that static sheet from sheet manager
|
|
* - Every mount of every instance will call method `sheetsManager.manage`,
|
|
* thus incrementing reference counter.
|
|
* - Every unmount of every instance will call method `sheetsManager.unmanage`,
|
|
* thus decrementing reference counter.
|
|
* - `sheetsManager.unmanage` under the hood will detach static sheet once reference
|
|
* counter is zero.
|
|
* - Dynamic styles are not shared between instances
|
|
*
|
|
*/
|
|
|
|
var getStyles = function getStyles(stylesOrCreator, theme) {
|
|
if (typeof stylesOrCreator !== 'function') {
|
|
return stylesOrCreator;
|
|
}
|
|
return stylesOrCreator(theme);
|
|
};
|
|
|
|
// Returns an object with array property as a key and true as a value.
|
|
var toMap = function toMap(arr) {
|
|
return arr.reduce(function (map, prop) {
|
|
map[prop] = true;
|
|
return map;
|
|
}, {});
|
|
};
|
|
|
|
var defaultInjectProps = {
|
|
sheet: false,
|
|
classes: true,
|
|
theme: true
|
|
};
|
|
|
|
var managersCounter = 0;
|
|
|
|
/**
|
|
* Wrap a Component into a JSS Container Component.
|
|
*
|
|
* @param {Object|Function} stylesOrCreator
|
|
* @param {Component} InnerComponent
|
|
* @param {Object} [options]
|
|
* @return {Component}
|
|
*/
|
|
|
|
exports['default'] = function (stylesOrCreator, InnerComponent) {
|
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
|
|
var isThemingEnabled = typeof stylesOrCreator === 'function';
|
|
|
|
var _options$theming = options.theming,
|
|
theming = _options$theming === undefined ? _theming2['default'] : _options$theming,
|
|
inject = options.inject,
|
|
optionsJss = options.jss,
|
|
sheetOptions = _objectWithoutProperties(options, ['theming', 'inject', 'jss']);
|
|
|
|
var injectMap = inject ? toMap(inject) : defaultInjectProps;
|
|
var themeListener = theming.themeListener;
|
|
|
|
var displayName = (0, _getDisplayName2['default'])(InnerComponent);
|
|
var defaultClassNamePrefix = env === 'production' ? undefined : displayName + '-';
|
|
var noTheme = {};
|
|
var managerId = managersCounter++;
|
|
var manager = new _jss.SheetsManager();
|
|
var defaultProps = _extends({}, InnerComponent.defaultProps);
|
|
delete defaultProps.classes;
|
|
|
|
var Jss = function (_Component) {
|
|
_inherits(Jss, _Component);
|
|
|
|
function Jss(props, context) {
|
|
_classCallCheck(this, Jss);
|
|
|
|
var _this = _possibleConstructorReturn(this, (Jss.__proto__ || Object.getPrototypeOf(Jss)).call(this, props, context));
|
|
|
|
_initialiseProps.call(_this);
|
|
|
|
var theme = isThemingEnabled ? themeListener.initial(context) : noTheme;
|
|
|
|
_this.state = _this.createState({ theme: theme }, props);
|
|
return _this;
|
|
}
|
|
|
|
_createClass(Jss, [{
|
|
key: 'componentWillMount',
|
|
value: function componentWillMount() {
|
|
this.manage(this.state);
|
|
}
|
|
}, {
|
|
key: 'componentDidMount',
|
|
value: function componentDidMount() {
|
|
if (isThemingEnabled) {
|
|
this.unsubscribeId = themeListener.subscribe(this.context, this.setTheme);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'componentWillReceiveProps',
|
|
value: function componentWillReceiveProps(nextProps, nextContext) {
|
|
this.context = nextContext;
|
|
var dynamicSheet = this.state.dynamicSheet;
|
|
|
|
if (dynamicSheet) dynamicSheet.update(nextProps);
|
|
}
|
|
}, {
|
|
key: 'componentWillUpdate',
|
|
value: function componentWillUpdate(nextProps, nextState) {
|
|
if (isThemingEnabled && this.state.theme !== nextState.theme) {
|
|
var newState = this.createState(nextState, nextProps);
|
|
this.manage(newState);
|
|
this.manager.unmanage(this.state.theme);
|
|
this.setState(newState);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'componentDidUpdate',
|
|
value: function componentDidUpdate(prevProps, prevState) {
|
|
// We remove previous dynamicSheet only after new one was created to avoid FOUC.
|
|
if (prevState.dynamicSheet !== this.state.dynamicSheet) {
|
|
this.jss.removeStyleSheet(prevState.dynamicSheet);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'componentWillUnmount',
|
|
value: function componentWillUnmount() {
|
|
if (this.unsubscribeId) {
|
|
themeListener.unsubscribe(this.context, this.unsubscribeId);
|
|
}
|
|
|
|
this.manager.unmanage(this.state.theme);
|
|
if (this.state.dynamicSheet) {
|
|
this.state.dynamicSheet.detach();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'createState',
|
|
value: function createState(_ref, _ref2) {
|
|
var theme = _ref.theme,
|
|
dynamicSheet = _ref.dynamicSheet;
|
|
var userClasses = _ref2.classes;
|
|
|
|
var contextSheetOptions = this.context[ns.sheetOptions];
|
|
if (contextSheetOptions && contextSheetOptions.disableStylesGeneration) {
|
|
return { theme: theme, dynamicSheet: dynamicSheet, classes: {} };
|
|
}
|
|
|
|
var classNamePrefix = defaultClassNamePrefix;
|
|
var staticSheet = this.manager.get(theme);
|
|
|
|
if (contextSheetOptions && contextSheetOptions.classNamePrefix) {
|
|
classNamePrefix = contextSheetOptions.classNamePrefix + classNamePrefix;
|
|
}
|
|
|
|
if (!staticSheet) {
|
|
var styles = getStyles(stylesOrCreator, theme);
|
|
staticSheet = this.jss.createStyleSheet(styles, _extends({}, sheetOptions, contextSheetOptions, {
|
|
meta: displayName + ', ' + (isThemingEnabled ? 'Themed' : 'Unthemed') + ', Static',
|
|
classNamePrefix: classNamePrefix
|
|
}));
|
|
this.manager.add(theme, staticSheet);
|
|
staticSheet[dynamicStylesNs] = (0, _jss.getDynamicStyles)(styles);
|
|
}
|
|
|
|
var dynamicStyles = staticSheet[dynamicStylesNs];
|
|
|
|
if (dynamicStyles) {
|
|
dynamicSheet = this.jss.createStyleSheet(dynamicStyles, _extends({}, sheetOptions, contextSheetOptions, {
|
|
meta: displayName + ', ' + (isThemingEnabled ? 'Themed' : 'Unthemed') + ', Dynamic',
|
|
classNamePrefix: classNamePrefix,
|
|
link: true
|
|
}));
|
|
}
|
|
|
|
var defaultClasses = InnerComponent.defaultProps ? InnerComponent.defaultProps.classes : {};
|
|
var jssClasses = dynamicSheet ? (0, _compose2['default'])(staticSheet.classes, dynamicSheet.classes) : staticSheet.classes;
|
|
var classes = _extends({}, defaultClasses, jssClasses, userClasses);
|
|
|
|
return { theme: theme, dynamicSheet: dynamicSheet, classes: classes };
|
|
}
|
|
}, {
|
|
key: 'manage',
|
|
value: function manage(_ref3) {
|
|
var theme = _ref3.theme,
|
|
dynamicSheet = _ref3.dynamicSheet;
|
|
|
|
var contextSheetOptions = this.context[ns.sheetOptions];
|
|
if (contextSheetOptions && contextSheetOptions.disableStylesGeneration) {
|
|
return;
|
|
}
|
|
var registry = this.context[ns.sheetsRegistry];
|
|
|
|
var staticSheet = this.manager.manage(theme);
|
|
if (registry) registry.add(staticSheet);
|
|
|
|
if (dynamicSheet) {
|
|
dynamicSheet.update(this.props).attach();
|
|
if (registry) registry.add(dynamicSheet);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'render',
|
|
value: function render() {
|
|
var _state = this.state,
|
|
theme = _state.theme,
|
|
dynamicSheet = _state.dynamicSheet,
|
|
classes = _state.classes;
|
|
|
|
var _props = this.props,
|
|
innerRef = _props.innerRef,
|
|
props = _objectWithoutProperties(_props, ['innerRef']);
|
|
|
|
var sheet = dynamicSheet || this.manager.get(theme);
|
|
|
|
if (injectMap.sheet && !props.sheet) props.sheet = sheet;
|
|
if (isThemingEnabled && injectMap.theme && !props.theme) props.theme = theme;
|
|
|
|
// We have merged classes already.
|
|
if (injectMap.classes) props.classes = classes;
|
|
|
|
return _react2['default'].createElement(InnerComponent, _extends({ ref: innerRef }, props));
|
|
}
|
|
}, {
|
|
key: 'jss',
|
|
get: function get() {
|
|
return this.context[ns.jss] || optionsJss || _jss2['default'];
|
|
}
|
|
}, {
|
|
key: 'manager',
|
|
get: function get() {
|
|
var managers = this.context[ns.managers];
|
|
|
|
// If `managers` map is present in the context, we use it in order to
|
|
// let JssProvider reset them when new response has to render server-side.
|
|
if (managers) {
|
|
if (!managers[managerId]) {
|
|
managers[managerId] = new _jss.SheetsManager();
|
|
}
|
|
return managers[managerId];
|
|
}
|
|
|
|
return manager;
|
|
}
|
|
}]);
|
|
|
|
return Jss;
|
|
}(_react.Component);
|
|
|
|
Jss.displayName = 'Jss(' + displayName + ')';
|
|
Jss.InnerComponent = InnerComponent;
|
|
Jss.contextTypes = _extends({}, _contextTypes2['default'], isThemingEnabled && themeListener.contextTypes);
|
|
Jss.propTypes = {
|
|
innerRef: _propTypes2['default'].func
|
|
};
|
|
Jss.defaultProps = defaultProps;
|
|
|
|
var _initialiseProps = function _initialiseProps() {
|
|
var _this2 = this;
|
|
|
|
this.setTheme = function (theme) {
|
|
return _this2.setState({ theme: theme });
|
|
};
|
|
};
|
|
|
|
return Jss;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 81 */
|
|
/***/ (function(module, exports) {
|
|
|
|
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _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; };
|
|
|
|
/**
|
|
* Adds `composes` property to each top level rule
|
|
* in order to have a composed class name for dynamic style sheets.
|
|
*
|
|
* It relies on jss-compose and jss-extend plugins.
|
|
*
|
|
* Example:
|
|
* classes: {left: 'a', button: 'b'}
|
|
* styles: {button: {height: () => { ... }}}
|
|
* composed: {
|
|
* button: {
|
|
* composes: 'b',
|
|
* height: () => { ... }
|
|
* },
|
|
* left: {
|
|
* composes: 'a'
|
|
* }
|
|
* }
|
|
*
|
|
* @param {Object} classes static classes map
|
|
* @param {Object} styles dynamic styles object without static properties
|
|
* @return {Object|null}
|
|
*/
|
|
exports["default"] = function (staticClasses, dynamicClasses) {
|
|
var combinedClasses = _extends({}, staticClasses);
|
|
|
|
for (var name in dynamicClasses) {
|
|
combinedClasses[name] = staticClasses[name] ? staticClasses[name] + " " + dynamicClasses[name] : dynamicClasses[name];
|
|
}
|
|
|
|
return combinedClasses;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 82 */
|
|
/***/ (function(module, exports) {
|
|
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
exports['default'] = function (Component) {
|
|
return Component.displayName || Component.name || 'Component';
|
|
};
|
|
|
|
/***/ })
|
|
/******/ ])
|
|
});
|
|
;
|
|
//# sourceMappingURL=react-jss.js.map
|