@closeio/backbone-testing-library/dist/index.es.js

DOM testing utilities with API that mirrors React Testing Library

import { getQueriesForElement, prettyDOM } from '@testing-library/dom';
export * from '@testing-library/dom';

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

function _objectWithoutPropertiesLoose(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  return target;
}

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};

  var target = _objectWithoutPropertiesLoose(source, excluded);

  var key, i;

  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }

  return target;
}

if (typeof afterEach === 'function' && !process.env.RTL_SKIP_AUTO_CLEANUP) {
  afterEach(function () {
    cleanup();
  });
}

var mountedViews = new Set();

function render(View) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      container = _ref.container,
      _ref$baseElement = _ref.baseElement,
      baseElement = _ref$baseElement === void 0 ? container : _ref$baseElement,
      _ref$autoRender = _ref.autoRender,
      autoRender = _ref$autoRender === void 0 ? true : _ref$autoRender,
      options = _objectWithoutProperties(_ref, ["container", "baseElement", "autoRender"]);

  // Match react-testing-library's baseElement/container approach exactly:
  if (!baseElement) {
    baseElement = document.body;
  }

  if (!container) {
    container = baseElement.appendChild(document.createElement('div'));
  } // if no el is supplied BB will create one in _ensureElement


  var view = new View(options);
  container.appendChild(view.el);

  if (autoRender) {
    // sometimes you might not want to render immediately, eg. wrap render in act
    view.render();
  }

  mountedViews.add({
    view: view,
    container: container
  });
  return _objectSpread2({
    view: view,
    container: container,
    baseElement: baseElement,
    debug: function debug() {
      var debugEl = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : baseElement;
      var maxLength = arguments.length > 1 ? arguments[1] : undefined;
      var options = arguments.length > 2 ? arguments[2] : undefined;
      return console.log(prettyDOM(debugEl, maxLength, options));
    },
    unmount: function unmount() {
      return cleanupView(view);
    }
  }, getQueriesForElement(baseElement));
}

function cleanup() {
  mountedViews.forEach(cleanupView);
}

function cleanupView(viewData) {
  var view = viewData.view,
      container = viewData.container;
  view.remove();

  if (container.parentNode === document.body) {
    document.body.removeChild(container);
  }

  mountedViews.delete(viewData);
}

export { cleanup, render };
//# sourceMappingURL=index.es.js.map