prejss/lib/create-async-adapter.js

Get the power of PostCSS with plugins in your JSS styles. 🎨 Just put CSS into JS and get it as JSS object.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extractExpressions = require('./extract-expressions');

var _extractExpressions2 = _interopRequireDefault(_extractExpressions);

var _restoreExpressions = require('./restore-expressions');

var _restoreExpressions2 = _interopRequireDefault(_restoreExpressions);

var _isPromise = require('./utils/is-promise');

var _isPromise2 = _interopRequireDefault(_isPromise);

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

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; }

exports.default = function (_ref) {
  var prepare = _ref.prepare,
      parse = _ref.parse,
      finalize = _ref.finalize,
      options = _objectWithoutProperties(_ref, ['prepare', 'parse', 'finalize']);

  var extractFunc = options.extractExpressions || _extractExpressions2.default;
  var restoreFunc = options.restoreExpressions || _restoreExpressions2.default;

  return function () {
    var _ref2 = _asyncToGenerator(function* (chunks) {
      for (var _len = arguments.length, variables = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        variables[_key - 1] = arguments[_key];
      }

      var _extractFunc = extractFunc.apply(undefined, [chunks].concat(variables)),
          rawStyles = _extractFunc.rawStyles,
          expressions = _extractFunc.expressions;

      var prepareResult = typeof prepare === 'function' ? prepare(rawStyles) : rawStyles;
      var prepared = void 0;
      if ((0, _isPromise2.default)(prepareResult)) {
        prepared = yield prepareResult();
      } else {
        prepared = prepareResult;
      }

      // throw error if parse() is not defined properly
      var parseResult = parse(prepared);
      var parsed = void 0;
      if ((0, _isPromise2.default)(parseResult)) {
        parsed = yield parseResult();
      } else {
        parsed = parseResult;
      }

      var finalParsed = restoreFunc(parsed, expressions);

      var finalizeResult = typeof finalize === 'function' ? finalize(finalParsed) : finalParsed;
      var finalized = void 0;
      if ((0, _isPromise2.default)(finalizeResult)) {
        finalized = yield finalizeResult();
      } else {
        finalized = finalizeResult;
      }

      return finalized;
    });

    return function (_x) {
      return _ref2.apply(this, arguments);
    };
  }();
};