@trackunit/react-core-contexts-test 0.1.126 → 0.1.127

package/HookRenderer.esm.js

@@ -1,528 +1,16 @@
-import { g as getAugmentedNamespace, d as dom_esm, c as commonjsGlobal, _ as __awaiter, a as act$1, f as flushPromises } from './index.esm2.js';
+import { _ as __awaiter, f as flushPromises } from './index.esm2.js';
 import { jsx, Fragment } from 'react/jsx-runtime';
-import React__default from 'react';
-import ReactDOM from 'react-dom';
-import ReactDOMClient__default from 'react-dom/client';
-import testUtils__default from 'react-dom/test-utils';
-import 'util';
+import { act } from '@testing-library/react';
+import { renderHook } from '@testing-library/react/pure';
 import '@trackunit/react-core-hooks';
+import 'lodash';
 import 'react-router-dom';
+import '@apollo/client';
+import '@apollo/client/link/error';
+import '@apollo/client/testing';
 import '@trackunit/react-core-contexts-api';
-
-var pure$1 = {};
-
-var interopRequireDefault = {exports: {}};
-
-(function (module) {
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {
-    "default": obj
-  };
-}
-module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
-}(interopRequireDefault));
-
-var require$$4 = /*@__PURE__*/getAugmentedNamespace(dom_esm);
-
-var actCompat = {};
-
-Object.defineProperty(actCompat, "__esModule", {
-  value: true
-});
-actCompat.default = void 0;
-actCompat.getIsReactActEnvironment = getIsReactActEnvironment;
-actCompat.setReactActEnvironment = setIsReactActEnvironment;
-
-var testUtils = _interopRequireWildcard(testUtils__default);
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-const domAct = testUtils.act;
-
-function getGlobalThis() {
-  /* istanbul ignore else */
-  if (typeof globalThis !== 'undefined') {
-    return globalThis;
-  }
-  /* istanbul ignore next */
-
-
-  if (typeof self !== 'undefined') {
-    return self;
-  }
-  /* istanbul ignore next */
-
-
-  if (typeof window !== 'undefined') {
-    return window;
-  }
-  /* istanbul ignore next */
-
-
-  if (typeof commonjsGlobal !== 'undefined') {
-    return commonjsGlobal;
-  }
-  /* istanbul ignore next */
-
-
-  throw new Error('unable to locate global object');
-}
-
-function setIsReactActEnvironment(isReactActEnvironment) {
-  getGlobalThis().IS_REACT_ACT_ENVIRONMENT = isReactActEnvironment;
-}
-
-function getIsReactActEnvironment() {
-  return getGlobalThis().IS_REACT_ACT_ENVIRONMENT;
-}
-
-function withGlobalActEnvironment(actImplementation) {
-  return callback => {
-    const previousActEnvironment = getIsReactActEnvironment();
-    setIsReactActEnvironment(true);
-
-    try {
-      // The return value of `act` is always a thenable.
-      let callbackNeedsToBeAwaited = false;
-      const actResult = actImplementation(() => {
-        const result = callback();
-
-        if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
-          callbackNeedsToBeAwaited = true;
-        }
-
-        return result;
-      });
-
-      if (callbackNeedsToBeAwaited) {
-        const thenable = actResult;
-        return {
-          then: (resolve, reject) => {
-            thenable.then(returnValue => {
-              setIsReactActEnvironment(previousActEnvironment);
-              resolve(returnValue);
-            }, error => {
-              setIsReactActEnvironment(previousActEnvironment);
-              reject(error);
-            });
-          }
-        };
-      } else {
-        setIsReactActEnvironment(previousActEnvironment);
-        return actResult;
-      }
-    } catch (error) {
-      // Can't be a `finally {}` block since we don't know if we have to immediately restore IS_REACT_ACT_ENVIRONMENT
-      // or if we have to await the callback first.
-      setIsReactActEnvironment(previousActEnvironment);
-      throw error;
-    }
-  };
-}
-
-const act = withGlobalActEnvironment(domAct);
-var _default = act;
-/* eslint no-console:0 */
-
-actCompat.default = _default;
-
-var fireEvent$1 = {};
-
-Object.defineProperty(fireEvent$1, "__esModule", {
-  value: true
-});
-fireEvent$1.fireEvent = void 0;
-
-var _dom = require$$4;
-
-// react-testing-library's version of fireEvent will call
-// dom-testing-library's version of fireEvent. The reason
-// we make this distinction however is because we have
-// a few extra events that work a bit differently
-const fireEvent = (...args) => (0, _dom.fireEvent)(...args);
-
-fireEvent$1.fireEvent = fireEvent;
-Object.keys(_dom.fireEvent).forEach(key => {
-  fireEvent[key] = (...args) => _dom.fireEvent[key](...args);
-}); // React event system tracks native mouseOver/mouseOut events for
-// running onMouseEnter/onMouseLeave handlers
-// @link https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/react-dom/src/events/EnterLeaveEventPlugin.js#L24-L31
-
-const mouseEnter = fireEvent.mouseEnter;
-const mouseLeave = fireEvent.mouseLeave;
-
-fireEvent.mouseEnter = (...args) => {
-  mouseEnter(...args);
-  return fireEvent.mouseOver(...args);
-};
-
-fireEvent.mouseLeave = (...args) => {
-  mouseLeave(...args);
-  return fireEvent.mouseOut(...args);
-};
-
-const pointerEnter = fireEvent.pointerEnter;
-const pointerLeave = fireEvent.pointerLeave;
-
-fireEvent.pointerEnter = (...args) => {
-  pointerEnter(...args);
-  return fireEvent.pointerOver(...args);
-};
-
-fireEvent.pointerLeave = (...args) => {
-  pointerLeave(...args);
-  return fireEvent.pointerOut(...args);
-};
-
-const select = fireEvent.select;
-
-fireEvent.select = (node, init) => {
-  select(node, init); // React tracks this event only on focused inputs
-
-  node.focus(); // React creates this event when one of the following native events happens
-  // - contextMenu
-  // - mouseUp
-  // - dragEnd
-  // - keyUp
-  // - keyDown
-  // so we can use any here
-  // @link https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/react-dom/src/events/SelectEventPlugin.js#L203-L224
-
-  fireEvent.keyUp(node, init);
-}; // React event system tracks native focusout/focusin events for
-// running blur/focus handlers
-// @link https://github.com/facebook/react/pull/19186
-
-
-const blur = fireEvent.blur;
-const focus = fireEvent.focus;
-
-fireEvent.blur = (...args) => {
-  fireEvent.focusOut(...args);
-  return blur(...args);
-};
-
-fireEvent.focus = (...args) => {
-  fireEvent.focusIn(...args);
-  return focus(...args);
-};
-
-(function (exports) {
-
-var _interopRequireDefault = interopRequireDefault.exports;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  render: true,
-  renderHook: true,
-  cleanup: true,
-  act: true,
-  fireEvent: true
-};
-Object.defineProperty(exports, "act", {
-  enumerable: true,
-  get: function () {
-    return _actCompat.default;
-  }
-});
-exports.cleanup = cleanup;
-Object.defineProperty(exports, "fireEvent", {
-  enumerable: true,
-  get: function () {
-    return _fireEvent.fireEvent;
-  }
-});
-exports.render = render;
-exports.renderHook = renderHook;
-
-var React = _interopRequireWildcard(React__default);
-
-var _reactDom = _interopRequireDefault(ReactDOM);
-
-var ReactDOMClient = _interopRequireWildcard(ReactDOMClient__default);
-
-var _dom = require$$4;
-
-Object.keys(_dom).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _dom[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _dom[key];
-    }
-  });
-});
-
-var _actCompat = _interopRequireWildcard(actCompat);
-
-var _fireEvent = fireEvent$1;
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-(0, _dom.configure)({
-  unstable_advanceTimersWrapper: cb => {
-    return (0, _actCompat.default)(cb);
-  },
-  // We just want to run `waitFor` without IS_REACT_ACT_ENVIRONMENT
-  // But that's not necessarily how `asyncWrapper` is used since it's a public method.
-  // Let's just hope nobody else is using it.
-  asyncWrapper: async cb => {
-    const previousActEnvironment = (0, _actCompat.getIsReactActEnvironment)();
-    (0, _actCompat.setReactActEnvironment)(false);
-
-    try {
-      return await cb();
-    } finally {
-      (0, _actCompat.setReactActEnvironment)(previousActEnvironment);
-    }
-  },
-  eventWrapper: cb => {
-    let result;
-    (0, _actCompat.default)(() => {
-      result = cb();
-    });
-    return result;
-  }
-}); // Ideally we'd just use a WeakMap where containers are keys and roots are values.
-// We use two variables so that we can bail out in constant time when we render with a new container (most common use case)
-
-/**
- * @type {Set<import('react-dom').Container>}
- */
-
-const mountedContainers = new Set();
-/**
- * @type Array<{container: import('react-dom').Container, root: ReturnType<typeof createConcurrentRoot>}>
- */
-
-const mountedRootEntries = [];
-
-function createConcurrentRoot(container, {
-  hydrate,
-  ui,
-  wrapper: WrapperComponent
-}) {
-  let root;
-
-  if (hydrate) {
-    (0, _actCompat.default)(() => {
-      root = ReactDOMClient.hydrateRoot(container, WrapperComponent ? /*#__PURE__*/React.createElement(WrapperComponent, null, ui) : ui);
-    });
-  } else {
-    root = ReactDOMClient.createRoot(container);
-  }
-
-  return {
-    hydrate() {
-      /* istanbul ignore if */
-      if (!hydrate) {
-        throw new Error('Attempted to hydrate a non-hydrateable root. This is a bug in `@testing-library/react`.');
-      } // Nothing to do since hydration happens when creating the root object.
-
-    },
-
-    render(element) {
-      root.render(element);
-    },
-
-    unmount() {
-      root.unmount();
-    }
-
-  };
-}
-
-function createLegacyRoot(container) {
-  return {
-    hydrate(element) {
-      _reactDom.default.hydrate(element, container);
-    },
-
-    render(element) {
-      _reactDom.default.render(element, container);
-    },
-
-    unmount() {
-      _reactDom.default.unmountComponentAtNode(container);
-    }
-
-  };
-}
-
-function renderRoot(ui, {
-  baseElement,
-  container,
-  hydrate,
-  queries,
-  root,
-  wrapper: WrapperComponent
-}) {
-  const wrapUiIfNeeded = innerElement => WrapperComponent ? /*#__PURE__*/React.createElement(WrapperComponent, null, innerElement) : innerElement;
-
-  (0, _actCompat.default)(() => {
-    if (hydrate) {
-      root.hydrate(wrapUiIfNeeded(ui), container);
-    } else {
-      root.render(wrapUiIfNeeded(ui), container);
-    }
-  });
-  return {
-    container,
-    baseElement,
-    debug: (el = baseElement, maxLength, options) => Array.isArray(el) ? // eslint-disable-next-line no-console
-    el.forEach(e => console.log((0, _dom.prettyDOM)(e, maxLength, options))) : // eslint-disable-next-line no-console,
-    console.log((0, _dom.prettyDOM)(el, maxLength, options)),
-    unmount: () => {
-      (0, _actCompat.default)(() => {
-        root.unmount();
-      });
-    },
-    rerender: rerenderUi => {
-      renderRoot(wrapUiIfNeeded(rerenderUi), {
-        container,
-        baseElement,
-        root
-      }); // Intentionally do not return anything to avoid unnecessarily complicating the API.
-      // folks can use all the same utilities we return in the first place that are bound to the container
-    },
-    asFragment: () => {
-      /* istanbul ignore else (old jsdom limitation) */
-      if (typeof document.createRange === 'function') {
-        return document.createRange().createContextualFragment(container.innerHTML);
-      } else {
-        const template = document.createElement('template');
-        template.innerHTML = container.innerHTML;
-        return template.content;
-      }
-    },
-    ...(0, _dom.getQueriesForElement)(baseElement, queries)
-  };
-}
-
-function render(ui, {
-  container,
-  baseElement = container,
-  legacyRoot = false,
-  queries,
-  hydrate = false,
-  wrapper
-} = {}) {
-  if (!baseElement) {
-    // default to document.body instead of documentElement to avoid output of potentially-large
-    // head elements (such as JSS style blocks) in debug output
-    baseElement = document.body;
-  }
-
-  if (!container) {
-    container = baseElement.appendChild(document.createElement('div'));
-  }
-
-  let root; // eslint-disable-next-line no-negated-condition -- we want to map the evolution of this over time. The root is created first. Only later is it re-used so we don't want to read the case that happens later first.
-
-  if (!mountedContainers.has(container)) {
-    const createRootImpl = legacyRoot ? createLegacyRoot : createConcurrentRoot;
-    root = createRootImpl(container, {
-      hydrate,
-      ui,
-      wrapper
-    });
-    mountedRootEntries.push({
-      container,
-      root
-    }); // we'll add it to the mounted containers regardless of whether it's actually
-    // added to document.body so the cleanup method works regardless of whether
-    // they're passing us a custom container or not.
-
-    mountedContainers.add(container);
-  } else {
-    mountedRootEntries.forEach(rootEntry => {
-      // Else is unreachable since `mountedContainers` has the `container`.
-      // Only reachable if one would accidentally add the container to `mountedContainers` but not the root to `mountedRootEntries`
-
-      /* istanbul ignore else */
-      if (rootEntry.container === container) {
-        root = rootEntry.root;
-      }
-    });
-  }
-
-  return renderRoot(ui, {
-    container,
-    baseElement,
-    queries,
-    hydrate,
-    wrapper,
-    root
-  });
-}
-
-function cleanup() {
-  mountedRootEntries.forEach(({
-    root,
-    container
-  }) => {
-    (0, _actCompat.default)(() => {
-      root.unmount();
-    });
-
-    if (container.parentNode === document.body) {
-      document.body.removeChild(container);
-    }
-  });
-  mountedRootEntries.length = 0;
-  mountedContainers.clear();
-}
-
-function renderHook(renderCallback, options = {}) {
-  const {
-    initialProps,
-    ...renderOptions
-  } = options;
-  const result = /*#__PURE__*/React.createRef();
-
-  function TestComponent({
-    renderCallbackProps
-  }) {
-    const pendingResult = renderCallback(renderCallbackProps);
-    React.useEffect(() => {
-      result.current = pendingResult;
-    });
-    return null;
-  }
-
-  const {
-    rerender: baseRerender,
-    unmount
-  } = render( /*#__PURE__*/React.createElement(TestComponent, {
-    renderCallbackProps: initialProps
-  }), renderOptions);
-
-  function rerender(rerenderCallbackProps) {
-    return baseRerender( /*#__PURE__*/React.createElement(TestComponent, {
-      renderCallbackProps: rerenderCallbackProps
-    }));
-  }
-
-  return {
-    result,
-    rerender,
-    unmount
-  };
-} // just re-export everything from dom-testing-library
-
-/* eslint func-name-matching:0 */
-}(pure$1));
-
-// makes it so people can import from '@testing-library/react/pure'
-var pure = pure$1;
+import 'react';
+import 'graphql';
 
 /**
  * This is a wrapper around the react testing library renderHook function.
@@ -541,10 +29,10 @@ const reactHooksRenderHook = (callback, getMockedCompositionRoot) => __awaiter(v
     let renderedHook;
     // This is added here to make storybook work and to ensure the right act is loaded for hooks.
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    yield act$1(() => __awaiter(void 0, void 0, void 0, function* () {
-        renderedHook = yield pure.renderHook(callback, { wrapper });
+    yield act(() => __awaiter(void 0, void 0, void 0, function* () {
+        renderedHook = yield renderHook(callback, { wrapper });
     }));
-    yield act$1(() => __awaiter(void 0, void 0, void 0, function* () {
+    yield act(() => __awaiter(void 0, void 0, void 0, function* () {
         yield flushPromises();
     }));
     return renderedHook;

package/index.cjs.js

@@ -4,14 +4,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var index = require('./index.cjs2.js');
 require('react/jsx-runtime');
-require('react-dom/test-utils');
-require('react');
-require('react-dom');
-require('react-dom/client');
-require('util');
+require('@testing-library/react');
 require('@trackunit/react-core-hooks');
+require('lodash');
 require('react-router-dom');
+require('@apollo/client');
+require('@apollo/client/link/error');
+require('@apollo/client/testing');
 require('@trackunit/react-core-contexts-api');
+require('react');
+require('graphql');