239 lines
7.3 KiB
JavaScript
239 lines
7.3 KiB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["jssNested"] = factory();
|
|
else
|
|
root["jssNested"] = factory();
|
|
})(this, function() {
|
|
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 _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__(1);
|
|
|
|
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 };
|
|
}
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (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;
|
|
|
|
|
|
/***/ })
|
|
/******/ ])
|
|
});
|
|
;
|
|
//# sourceMappingURL=jss-nested.js.map
|