react-dom-testing/lib/index.js

A minimal React DOM testing utility

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Ignore = exports.Simulate = exports.act = undefined;
exports.mount = mount;
exports.unmount = unmount;
exports.simulate = simulate;

var _testUtils = require("react-dom/test-utils");

Object.defineProperty(exports, "act", {
  enumerable: true,
  get: function get() {
    return _testUtils.act;
  }
});
Object.defineProperty(exports, "Simulate", {
  enumerable: true,
  get: function get() {
    return _testUtils.Simulate;
  }
});

var _Ignore = require("./Ignore");

Object.defineProperty(exports, "Ignore", {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_Ignore).default;
  }
});

var _domspace = require("domspace");

var _domspace2 = _interopRequireDefault(_domspace);

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

var createRoot = void 0;
try {
  var ReactDomClient = require("react-dom/client");
  createRoot = ReactDomClient.createRoot;
  global.IS_REACT_ACT_ENVIRONMENT = true;
} catch (e) {
  var ReactDom = require("react-dom");
  createRoot = function createRoot(container) {
    return {
      render: function render(element) {
        ReactDom.render(element, container);
      },
      unmount: function unmount() {
        ReactDom.unmountComponentAtNode(container);
      }
    };
  };
}

var getContainer = function getContainer(_ref) {
  var container = _ref.container;

  if (typeof container === "string") {
    return document.createElement(container);
  }

  if (container) {
    return container;
  }

  return document.createElement("div");
};

var rendered = new Set();

function mount(element) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var container = getContainer(options);

  var root = createRoot(container);
  rendered.add(root);

  if (_testUtils.act) {
    (0, _testUtils.act)(function () {
      root.render(element);
    });
  } else {
    root.render(element);
  }

  var childNodes = container.childNodes;

  if (childNodes.length === 0) {
    return null;
  } else if (childNodes.length === 1) {
    return childNodes[0];
  } else {
    var documentFragment = document.createDocumentFragment();

    for (var i = 0; i < childNodes.length; i += 1) {
      documentFragment.appendChild(childNodes[i].cloneNode(true));
    }

    return documentFragment;
  }
}

function unmount() {
  var _loop = function _loop(root) {
    if (_testUtils.act) {
      (0, _testUtils.act)(function () {
        root.unmount();
      });
    } else {
      root.unmount();
    }
  };

  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = rendered[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var root = _step.value;

      _loop(root);
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  rendered.clear();
}

function simulate(rootElement, events) {
  if (arguments.length !== 2) {
    throw new Error("simulate takes exactly two arguments");
  }

  [].concat(events).map(function (event) {
    return typeof event === "string" ? { type: event } : event;
  }).forEach(function (event) {
    var target = rootElement;

    if (!event.type) {
      throw new Error("All events must have a type");
    }

    if (event.target) {
      target = rootElement.querySelector(event.target);
      if (!target) {
        throw new Error("Could not trigger " + event.type + " on '" + event.target + "' in\n" + (0, _domspace2.default)(rootElement.cloneNode(true)).outerHTML);
      }
    }

    if (event.type === "change" && typeof event.value === "string") {
      target.value = event.value;
    }

    if (!_testUtils.Simulate[event.type]) {
      throw new Error("Event '" + event.type + "' is not supported by Simulate\nSee https://reactjs.org/docs/events.html#supported-events");
    }

    if (_testUtils.act) {
      (0, _testUtils.act)(function () {
        _testUtils.Simulate[event.type](target, event.data);
      });
    } else {
      _testUtils.Simulate[event.type](target, event.data);
    }
  });
}