react-inline-for-rix-loader/lib/transformStyleSheetObjectIntoSpecification.js

for developing webpack rix-loader, folk from https://github.com/martinandert/react-inline

'use strict';

var _interopRequireDefault = require('babel-runtime/helpers/interop-require-default')['default'];

exports.__esModule = true;
exports['default'] = transformStyleSheetObjectIntoSpecification;

var _assert = require('assert');

var _assert2 = _interopRequireDefault(_assert);

var _foreach = require('foreach');

var _foreach2 = _interopRequireDefault(_foreach);

var _utilsSplitSelector = require('./utils/splitSelector');

var _utilsSplitSelector2 = _interopRequireDefault(_utilsSplitSelector);

var isMediaQueryDeclaration = /^@/;
var hasAttachedSelector = /[^:\[]+[:\[]/;
var isStandaloneSelector = /^[:\[]/;
var isValidStyleName = /^.-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/;

function transformStyleSheetObjectIntoSpecification(content) {
  assertPlainObject(content);

  var styles = {};

  _foreach2['default'](content, function (value, key) {
    if (isMediaQueryDeclaration.test(key)) {
      processMediaQuery(styles, key.substring(1), value);
    } else if (isStandaloneSelector.test(key)) {
      _assert2['default'](false, 'stand-alone selectors are not allowed at the top-level');
    } else if (hasAttachedSelector.test(key)) {
      var _splitSelector = _utilsSplitSelector2['default'](key);

      var styleName = _splitSelector[0];
      var selectorName = _splitSelector[1];

      processStyleAndSelector(styles, styleName, selectorName, value);
    } else {
      processStyle(styles, key, value);
    }
  });

  return styles;
}

function processMediaQuery(styles, mediaQueryName, content) {
  assertPlainObject(content);

  _foreach2['default'](content, function (value, key) {
    if (isMediaQueryDeclaration.test(key)) {
      _assert2['default'](false, 'media queries cannot be nested into each other');
    } else if (isStandaloneSelector.test(key)) {
      _assert2['default'](false, 'stand-alone selectors are not allowed in top-level media queries');
    } else if (hasAttachedSelector.test(key)) {
      var _splitSelector2 = _utilsSplitSelector2['default'](key);

      var styleName = _splitSelector2[0];
      var selectorName = _splitSelector2[1];

      processStyleAndMediaQueryAndSelector(styles, styleName, mediaQueryName, selectorName, value);
    } else {
      processStyleAndMediaQuery(styles, key, mediaQueryName, value);
    }
  });
}

function processStyle(styles, styleName, content) {
  assertPlainObject(content);

  var style = initStyleSpec(styles, styleName);

  _foreach2['default'](content, function (value, key) {
    if (isMediaQueryDeclaration.test(key)) {
      processStyleAndMediaQuery(styles, styleName, key.substring(1), value);
    } else if (isStandaloneSelector.test(key)) {
      processStyleAndSelector(styles, styleName, key, value);
    } else if (hasAttachedSelector.test(key)) {
      _assert2['default'](false, 'styles cannot be nested into each other');
    } else {
      processRule(style.rules, key, value);
    }
  });
}

function processStyleAndMediaQuery(styles, styleName, mediaQueryName, content) {
  assertPlainObject(content);

  var style = initStyleSpec(styles, styleName);
  var mediaQuery = initMediaQuerySpec(style.mediaQueries, mediaQueryName);

  _foreach2['default'](content, function (value, key) {
    if (isMediaQueryDeclaration.test(key)) {
      _assert2['default'](false, 'media queries cannot be nested into each other');
    } else if (isStandaloneSelector.test(key)) {
      processStyleAndMediaQueryAndSelector(styles, styleName, mediaQueryName, key, value);
    } else if (hasAttachedSelector.test(key)) {
      _assert2['default'](false, 'styles cannot be nested into each other');
    } else {
      processRule(mediaQuery.rules, key, value);
    }
  });
}

function processStyleAndSelector(styles, styleName, selectorName, content) {
  assertPlainObject(content);

  var style = initStyleSpec(styles, styleName);
  var selector = initSelectorSpec(style.selectors, selectorName);

  _foreach2['default'](content, function (value, key) {
    if (isMediaQueryDeclaration.test(key)) {
      _assert2['default'](false, 'media queries cannot be nested into selectors');
    } else if (isStandaloneSelector.test(key)) {
      processStyleAndSelector(styles, styleName, selectorName + key, value);
    } else if (hasAttachedSelector.test(key)) {
      _assert2['default'](false, 'styles cannot be nested into each other');
    } else {
      processRule(selector.rules, key, value);
    }
  });
}

function processStyleAndMediaQueryAndSelector(styles, styleName, mediaQueryName, selectorName, content) {
  _assert2['default'](isPlainObject(content), 'style value must be a plain object');

  var style = initStyleSpec(styles, styleName);
  var mediaQuery = initMediaQuerySpec(style.mediaQueries, mediaQueryName);
  var selector = initSelectorSpec(mediaQuery.selectors, selectorName);

  _foreach2['default'](content, function (value, key) {
    if (isMediaQueryDeclaration.test(key)) {
      _assert2['default'](false, 'media queries cannot be nested into each other');
    } else if (isStandaloneSelector.test(key)) {
      processStyleAndMediaQueryAndSelector(styles, styleName, mediaQueryName, selectorName + key, value);
    } else if (hasAttachedSelector.test(key)) {
      _assert2['default'](false, 'styles cannot be nested into each other');
    } else {
      processRule(selector.rules, key, value);
    }
  });
}

function processRule(rules, key, value) {
  _assert2['default'](typeof value === 'string' || typeof value === 'number', 'value must be a number or a string');
  rules[key] = value;
}

function initStyleSpec(styles, name) {
  _assert2['default'](isValidStyleName.test(name), 'style name is invalid');

  styles[name] = styles[name] || { rules: {}, selectors: {}, mediaQueries: {} };
  return styles[name];
}

function initMediaQuerySpec(mediaQueries, name) {
  mediaQueries[name] = mediaQueries[name] || { rules: {}, selectors: {} };
  return mediaQueries[name];
}

function initSelectorSpec(selectors, name) {
  selectors[name] = selectors[name] || { rules: {} };
  return selectors[name];
}

function isPlainObject(obj) {
  return Object.prototype.toString.call(obj) === '[object Object]';
}

function assertPlainObject(content) {
  _assert2['default'](isPlainObject(content), 'value must be a plain object');
}
module.exports = exports['default'];