@shopify/ui-extensions-server-kit 5.3.1 → 5.4.1

package/node_modules/@testing-library/react/dist/@testing-library/react.pure.esm.js

@@ -0,0 +1,461 @@
+import * as React from 'react';
+import ReactDOM from 'react-dom';
+import * as ReactDOMClient from 'react-dom/client';
+import { fireEvent as fireEvent$1, getConfig as getConfig$1, configure as configure$1, prettyDOM, getQueriesForElement } from '@testing-library/dom';
+export * from '@testing-library/dom';
+import * as DeprecatedReactTestUtils from 'react-dom/test-utils';
+
+const reactAct = typeof React.act === 'function' ? React.act : DeprecatedReactTestUtils.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 global !== 'undefined') {
+    return global;
+  }
+  /* 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(reactAct);
+
+/* eslint no-console:0 */
+
+// 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) => fireEvent$1(...args);
+Object.keys(fireEvent$1).forEach(key => {
+  fireEvent[key] = (...args) => fireEvent$1[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);
+};
+
+let configForRTL = {
+  reactStrictMode: false
+};
+function getConfig() {
+  return {
+    ...getConfig$1(),
+    ...configForRTL
+  };
+}
+function configure(newConfig) {
+  if (typeof newConfig === 'function') {
+    // Pass the existing config out to the provided function
+    // and accept a delta in return
+    newConfig = newConfig(getConfig());
+  }
+  const {
+    reactStrictMode,
+    ...configForDTL
+  } = newConfig;
+  configure$1(configForDTL);
+  configForRTL = {
+    ...configForRTL,
+    reactStrictMode
+  };
+}
+
+function jestFakeTimersAreEnabled() {
+  /* istanbul ignore else */
+  if (typeof jest !== 'undefined' && jest !== null) {
+    return (
+      // legacy timers
+      setTimeout._isMockFunction === true ||
+      // modern timers
+      // eslint-disable-next-line prefer-object-has-own -- No Object.hasOwn in all target environments we support.
+      Object.prototype.hasOwnProperty.call(setTimeout, 'clock')
+    );
+  } // istanbul ignore next
+
+  return false;
+}
+configure$1({
+  unstable_advanceTimersWrapper: cb => {
+    return act(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 = getIsReactActEnvironment();
+    setIsReactActEnvironment(false);
+    try {
+      const result = await cb();
+      // Drain microtask queue.
+      // Otherwise we'll restore the previous act() environment, before we resolve the `waitFor` call.
+      // The caller would have no chance to wrap the in-flight Promises in `act()`
+      await new Promise(resolve => {
+        setTimeout(() => {
+          resolve();
+        }, 0);
+        if (jestFakeTimersAreEnabled()) {
+          jest.advanceTimersByTime(0);
+        }
+      });
+      return result;
+    } finally {
+      setIsReactActEnvironment(previousActEnvironment);
+    }
+  },
+  eventWrapper: cb => {
+    let result;
+    act(() => {
+      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 strictModeIfNeeded(innerElement, reactStrictMode) {
+  return reactStrictMode ?? getConfig().reactStrictMode ? /*#__PURE__*/React.createElement(React.StrictMode, null, innerElement) : innerElement;
+}
+function wrapUiIfNeeded(innerElement, wrapperComponent) {
+  return wrapperComponent ? /*#__PURE__*/React.createElement(wrapperComponent, null, innerElement) : innerElement;
+}
+function createConcurrentRoot(container, {
+  hydrate,
+  onCaughtError,
+  onRecoverableError,
+  ui,
+  wrapper: WrapperComponent,
+  reactStrictMode
+}) {
+  let root;
+  if (hydrate) {
+    act(() => {
+      root = ReactDOMClient.hydrateRoot(container, strictModeIfNeeded(wrapUiIfNeeded(ui, WrapperComponent), reactStrictMode), {
+        onCaughtError,
+        onRecoverableError
+      });
+    });
+  } else {
+    root = ReactDOMClient.createRoot(container, {
+      onCaughtError,
+      onRecoverableError
+    });
+  }
+  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.hydrate(element, container);
+    },
+    render(element) {
+      ReactDOM.render(element, container);
+    },
+    unmount() {
+      ReactDOM.unmountComponentAtNode(container);
+    }
+  };
+}
+function renderRoot(ui, {
+  baseElement,
+  container,
+  hydrate,
+  queries,
+  root,
+  wrapper: WrapperComponent,
+  reactStrictMode
+}) {
+  act(() => {
+    if (hydrate) {
+      root.hydrate(strictModeIfNeeded(wrapUiIfNeeded(ui, WrapperComponent), reactStrictMode), container);
+    } else {
+      root.render(strictModeIfNeeded(wrapUiIfNeeded(ui, WrapperComponent), reactStrictMode), container);
+    }
+  });
+  return {
+    container,
+    baseElement,
+    debug: (el = baseElement, maxLength, options) => Array.isArray(el) ?
+    // eslint-disable-next-line no-console
+    el.forEach(e => console.log(prettyDOM(e, maxLength, options))) :
+    // eslint-disable-next-line no-console,
+    console.log(prettyDOM(el, maxLength, options)),
+    unmount: () => {
+      act(() => {
+        root.unmount();
+      });
+    },
+    rerender: rerenderUi => {
+      renderRoot(rerenderUi, {
+        container,
+        baseElement,
+        root,
+        wrapper: WrapperComponent,
+        reactStrictMode
+      });
+      // 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;
+      }
+    },
+    ...getQueriesForElement(baseElement, queries)
+  };
+}
+function render(ui, {
+  container,
+  baseElement = container,
+  legacyRoot = false,
+  onCaughtError,
+  onUncaughtError,
+  onRecoverableError,
+  queries,
+  hydrate = false,
+  wrapper,
+  reactStrictMode
+} = {}) {
+  if (onUncaughtError !== undefined) {
+    throw new Error('onUncaughtError is not supported. The `render` call will already throw on uncaught errors.');
+  }
+  if (legacyRoot && typeof ReactDOM.render !== 'function') {
+    const error = new Error('`legacyRoot: true` is not supported in this version of React. ' + 'If your app runs React 19 or later, you should remove this flag. ' + 'If your app runs React 18 or earlier, visit https://react.dev/blog/2022/03/08/react-18-upgrade-guide for upgrade instructions.');
+    Error.captureStackTrace(error, render);
+    throw error;
+  }
+  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,
+      onCaughtError,
+      onRecoverableError,
+      ui,
+      wrapper,
+      reactStrictMode
+    });
+    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,
+    reactStrictMode
+  });
+}
+function cleanup() {
+  mountedRootEntries.forEach(({
+    root,
+    container
+  }) => {
+    act(() => {
+      root.unmount();
+    });
+    if (container.parentNode === document.body) {
+      document.body.removeChild(container);
+    }
+  });
+  mountedRootEntries.length = 0;
+  mountedContainers.clear();
+}
+function renderHook(renderCallback, options = {}) {
+  const {
+    initialProps,
+    ...renderOptions
+  } = options;
+  if (renderOptions.legacyRoot && typeof ReactDOM.render !== 'function') {
+    const error = new Error('`legacyRoot: true` is not supported in this version of React. ' + 'If your app runs React 19 or later, you should remove this flag. ' + 'If your app runs React 18 or earlier, visit https://react.dev/blog/2022/03/08/react-18-upgrade-guide for upgrade instructions.');
+    Error.captureStackTrace(error, renderHook);
+    throw error;
+  }
+  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
+  };
+}
+
+/* eslint func-name-matching:0 */
+
+export { act, cleanup, configure, fireEvent, getConfig, render, renderHook };