jest-fela-bindings/lib/createAsyncSnapshotFactory.js

Abstract Fela bindings for Jest

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = createSnapshotFactory;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _felaTools = require("fela-tools");

var _utils = require("./utils");

function getFormattedOutput(renderer, markup) {
  return "".concat((0, _utils.formatCSS)((0, _felaTools.renderToString)(renderer)), "\n\n").concat((0, _utils.formatHTML)(markup));
}

function createSnapshotFactory(createElement, renderHandler, defaultRenderer, defaultRendererProvider, defaultThemeProvider) {
  return /*#__PURE__*/function () {
    var _createSnapshot = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(component) {
      var theme,
          renderer,
          RendererProvider,
          ThemeProvider,
          markup,
          createRoot,
          div,
          root,
          _markup,
          _div,
          _markup2,
          _args = arguments;

      return _regenerator["default"].wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              theme = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
              renderer = _args.length > 2 && _args[2] !== undefined ? _args[2] : defaultRenderer;
              RendererProvider = _args.length > 3 && _args[3] !== undefined ? _args[3] : defaultRendererProvider;
              ThemeProvider = _args.length > 4 && _args[4] !== undefined ? _args[4] : defaultThemeProvider;
              // reset renderer to have a clean setup
              renderer.clear(); // Node environment

              if (!(typeof window === 'undefined')) {
                _context.next = 8;
                break;
              }

              markup = renderHandler.renderToStaticMarkup(createElement(RendererProvider, {
                renderer: renderer
              }, createElement(ThemeProvider, {
                theme: theme
              }, component)));
              return _context.abrupt("return", getFormattedOutput(renderer, markup));

            case 8:
              // async createRoot, JSDOM
              createRoot = renderHandler.createRoot;

              if (!createRoot.createRoot) {
                _context.next = 16;
                break;
              }

              div = document.createElement('div');
              root = createRoot.createRoot(div);
              _context.next = 14;
              return new Promise(function (resolve) {
                root.render(createElement(RendererProvider, {
                  renderer: renderer
                }, createElement(ThemeProvider, {
                  theme: theme
                }, createElement(createRoot.CallbackWrapper, {
                  callback: function callback() {
                    return resolve(div.innerHTML);
                  }
                }, component))));
              });

            case 14:
              _markup = _context.sent;
              return _context.abrupt("return", getFormattedOutput(renderer, _markup));

            case 16:
              if (!renderHandler.render) {
                _context.next = 22;
                break;
              }

              _div = document.createElement('div');
              _context.next = 20;
              return new Promise(function (resolve) {
                renderHandler.render(createElement(RendererProvider, {
                  renderer: renderer
                }, createElement(ThemeProvider, {
                  theme: theme
                }, component)), _div, function () {
                  return resolve(_div.innerHTML);
                });
              });

            case 20:
              _markup2 = _context.sent;
              return _context.abrupt("return", getFormattedOutput(renderer, _markup2));

            case 22:
              return _context.abrupt("return", '');

            case 23:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

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

    return createSnapshot;
  }();
}