jest-fela-bindings/es/createAsyncSnapshotFactory.js

Abstract Fela bindings for Jest

import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import { renderToString } from 'fela-tools';
import { formatCSS, formatHTML } from './utils';

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

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

      return _regeneratorRuntime.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;
  }();
}