@shopify/ui-extensions-server-kit 0.0.0-snapshot-20240814205424

package/node_modules/@shopify/react-testing/build/esnext/matchers/components.esnext

@@ -0,0 +1,41 @@
+import { matcherHint, RECEIVED_COLOR, EXPECTED_COLOR, printExpected } from 'jest-matcher-utils';
+import { assertIsNode, assertIsType, printType, diffs, pluralize } from './utilities.esnext';
+
+function toContainReactComponent(node, type, props) {
+  assertIsNode(node, {
+    expectation: 'toContainReactComponent',
+    isNot: this.isNot
+  });
+  assertIsType(type, {
+    expectation: 'toContainReactComponent',
+    isNot: this.isNot
+  });
+  const foundByType = node.findAll(type);
+  const foundByProps = props == null ? foundByType : foundByType.filter(element => Object.keys(props).every(key => this.equals(props[key], element.props[key])));
+  const pass = foundByProps.length > 0;
+  const message = pass ? () => `${matcherHint('.not.toContainReactComponent')}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `Not to contain component:\n  ${EXPECTED_COLOR(printType(type))}\n${props ? `With props matching:\n  ${printExpected(props)}\n` : ''}` + `But ${foundByProps.length} matching ${printType(type)} ${foundByProps.length === 1 ? 'elements were' : 'element was'} found.\n` : () => `${`${matcherHint('.toContainReactComponent')}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `To contain component:\n  ${EXPECTED_COLOR(printType(type))}\n${props ? `With props matching:\n  ${printExpected(props)}\n` : ''}`}${foundByType.length === 0 ? `But no matching ${printType(type)} elements were found.\n` : `But the ${foundByType.length === 1 ? 'found element has' : 'found elements have'} the following prop differences:\n\n${diffs(foundByType, props, this.expand)}`}`;
+  return {
+    pass,
+    message
+  };
+}
+function toContainReactComponentTimes(node, type, times, props) {
+  assertIsNode(node, {
+    expectation: 'toContainReactComponentTimes',
+    isNot: this.isNot
+  });
+  assertIsType(type, {
+    expectation: 'toContainReactComponent',
+    isNot: this.isNot
+  });
+  const foundByType = node.findAll(type);
+  const foundByProps = props == null ? foundByType : foundByType.filter(element => Object.keys(props).every(key => this.equals(props[key], element.props[key])));
+  const pass = foundByProps.length === times;
+  const message = pass ? () => [`${matcherHint('.not.toContainReactComponentTimes')}\n`, `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}`, `Not to contain component:\n  ${EXPECTED_COLOR(printType(type))}`, `${times} ${pluralize('time', times)}, but it did.`].join('\n') : () => [`${matcherHint('.toContainReactComponentTimes')}\n`, `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}`, `To contain component:\n  ${EXPECTED_COLOR(printType(type))}`, `${times} ${pluralize('time', times)}, but it was found ${foundByProps.length}.`].join('\n');
+  return {
+    pass,
+    message
+  };
+}
+
+export { toContainReactComponent, toContainReactComponentTimes };

package/node_modules/@shopify/react-testing/build/esnext/matchers/context.esnext

@@ -0,0 +1,21 @@
+import { matcherHint, RECEIVED_COLOR, EXPECTED_COLOR, printExpected } from 'jest-matcher-utils';
+import { assertIsNode, printType, diffs } from './utilities.esnext';
+
+function toProvideReactContext(node, Context, value) {
+  assertIsNode(node, {
+    expectation: 'toProvideReactContext',
+    isNot: this.isNot
+  });
+  const foundByType = node.findAll(Context.Provider);
+  const foundByValue = value == null ? foundByType : foundByType.filter(element => this.equals(value, element.prop('value')));
+  const pass = foundByValue.length > 0;
+  const message = pass ? () => `${matcherHint('.not.toProvideReactContext')}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `Not to contain context provider:\n  ${EXPECTED_COLOR(printType(Context.Provider))}\n${value ? `With value matching:\n  ${printExpected(value)}\n` : ''}` + `But ${foundByValue.length} matching ${printType(Context.Provider)}${foundByValue.length === 1 ? 's were' : ' was'} found.\n` : () => `${`${matcherHint('.toProvideReactContext')}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `To contain context provider:\n  ${EXPECTED_COLOR(printType(Context.Provider))}\n${value ? `With value matching:\n  ${printExpected(value)}\n` : ''}`}${foundByType.length === 0 ? `But no matching ${printType(Context.Provider)}s were found.\n` : `But the ${foundByType.length === 1 ? 'found provider has' : 'found provider have'} had different values:\n\n${diffs(foundByType, {
+    value
+  }, this.expand)}`}`;
+  return {
+    pass,
+    message
+  };
+}
+
+export { toProvideReactContext };

package/node_modules/@shopify/react-testing/build/esnext/matchers/index.esnext

@@ -0,0 +1,14 @@
+import { toHaveReactProps, toHaveReactDataProps } from './props.esnext';
+import { toContainReactComponent, toContainReactComponentTimes } from './components.esnext';
+import { toProvideReactContext } from './context.esnext';
+import { toContainReactText, toContainReactHtml } from './strings.esnext';
+
+expect.extend({
+  toHaveReactProps,
+  toHaveReactDataProps,
+  toContainReactComponent,
+  toContainReactComponentTimes,
+  toContainReactText,
+  toContainReactHtml,
+  toProvideReactContext
+});

package/node_modules/@shopify/react-testing/build/esnext/matchers/props.esnext

@@ -0,0 +1,33 @@
+import { matcherHint, RECEIVED_COLOR, printExpected, printReceived } from 'jest-matcher-utils';
+import { assertIsNode, diffPropsForNode } from './utilities.esnext';
+
+function toHaveReactProps(node, props) {
+  assertIsNode(node, {
+    expectation: 'toHaveReactProps',
+    isNot: this.isNot
+  });
+
+  if (props == null || typeof props !== 'object') {
+    return {
+      pass: false,
+      message: () => `You passed ${props == null ? String(props) : `a ${typeof props}`} as props, but it must be an object.`
+    };
+  }
+
+  const pass = Object.keys(props).every(key => this.equals(props[key], node.props[key]));
+  const message = pass ? () => `${matcherHint('.not.toHaveReactProps', node.toString())}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `Not to have props:\n  ${printExpected(props)}\n` + `Received:\n  ${printReceived(node.props)}\n` : () => {
+    const diffString = diffPropsForNode(node, props, {
+      expand: this.expand
+    });
+    return `${matcherHint('.toHaveReactProps', node.toString())}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `To have props:\n  ${printExpected(props)}\n` + `Received:\n  ${printReceived(node.props)}\n${diffString ? `Difference:\n${diffString}\n` : ''}`;
+  };
+  return {
+    pass,
+    message
+  };
+}
+function toHaveReactDataProps(node, data) {
+  return toHaveReactProps.call(this, node, data);
+}
+
+export { toHaveReactDataProps, toHaveReactProps };

package/node_modules/@shopify/react-testing/build/esnext/matchers/strings.esnext

@@ -0,0 +1,37 @@
+import { matcherHint, RECEIVED_COLOR, printExpected, INVERTED_COLOR, printReceived } from 'jest-matcher-utils';
+import { assertIsNode } from './utilities.esnext';
+
+function toContainReactText(node, text) {
+  assertIsNode(node, {
+    expectation: 'toContainReactText',
+    isNot: this.isNot
+  });
+  const nodeText = node.text();
+  const matchIndex = nodeText.indexOf(text);
+  const pass = matchIndex >= 0;
+  const message = pass ? () => `${matcherHint('.not.toContainReactText', node.toString())}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `Not to contain text:\n  ${printExpected(text)}\n` + `But it did:\n  ${printReceivedWithHighlight(nodeText, matchIndex, text.length)}\n` : () => `${matcherHint('.not.toContainReactText', node.toString())}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `With text content:\n  ${printReceived(nodeText)}\n` + `To contain string:\n  ${printExpected(text)}\n`;
+  return {
+    pass,
+    message
+  };
+}
+function toContainReactHtml(node, text) {
+  assertIsNode(node, {
+    expectation: 'toContainReactHtml',
+    isNot: this.isNot
+  });
+  const nodeHtml = node.html();
+  const matchIndex = nodeHtml.indexOf(text);
+  const pass = matchIndex >= 0;
+  const message = pass ? () => `${matcherHint('.not.toContainReactHtml', node.toString())}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `Not to contain HTML:\n  ${printExpected(text)}\n` + `But it did:\n  ${printReceivedWithHighlight(nodeHtml, matchIndex, text.length)}\n` : () => `${matcherHint('.not.toContainReactHtml', node.toString())}\n\n` + `Expected the React element:\n  ${RECEIVED_COLOR(node.toString())}\n` + `With HTML content:\n  ${printReceived(nodeHtml)}\n` + `To contain HTML:\n  ${printExpected(text)}\n`;
+  return {
+    pass,
+    message
+  };
+}
+
+function printReceivedWithHighlight(text, start, length) {
+  return RECEIVED_COLOR(`"${text.slice(0, start)}${INVERTED_COLOR(text.slice(start, start + length))}${text.slice(start + length)}"`);
+}
+
+export { toContainReactHtml, toContainReactText };

package/node_modules/@shopify/react-testing/build/esnext/matchers/utilities.esnext

@@ -0,0 +1,99 @@
+import { diff, matcherErrorMessage, matcherHint, RECEIVED_COLOR, printWithType, printReceived, printExpected } from 'jest-matcher-utils';
+import { Root } from '../root.esnext';
+import { Element } from '../element.esnext';
+
+function assertIsNode(node, {
+  expectation,
+  isNot
+}) {
+  if (node == null) {
+    throw new Error(matcherErrorMessage(matcherHint(`.${expectation}`, undefined, undefined, {
+      isNot
+    }), `${RECEIVED_COLOR('received')} value must be an @shopify/react-testing Root or Element object`, `Received ${RECEIVED_COLOR('null')}.\nThis usually means that your \`.findX\` method failed to find any matching elements.`));
+  }
+
+  if (Array.isArray(node) && node.length > 1 && (node[0] instanceof Root || node[0] instanceof Element)) {
+    throw new Error(matcherErrorMessage(matcherHint(`.${expectation}`, undefined, undefined, {
+      isNot
+    }), `${RECEIVED_COLOR('received')} value must be an @shopify/react-testing Root or Element object`, `Received an ${RECEIVED_COLOR('array of Root or Element objects')}.\nThis usually means that you passed in the result of \`.findAllX\`. Pass the result of \`.findX\` instead.`));
+  }
+
+  if (!(node instanceof Root) && !(node instanceof Element)) {
+    throw new Error(matcherErrorMessage(matcherHint(`.${expectation}`, undefined, undefined, {
+      isNot
+    }), `${RECEIVED_COLOR('received')} value must be an @shopify/react-testing Root or Element object`, printWithType('Received', node, printReceived)));
+  }
+}
+function assertIsType(type, {
+  expectation,
+  isNot
+}) {
+  if (type == null) {
+    throw new Error(matcherErrorMessage(matcherHint(`.${expectation}`, undefined, undefined, {
+      isNot
+    }), `${RECEIVED_COLOR('expected')} value must be a string or a valid React component.`, printWithType('Expected', type, printExpected)));
+  }
+}
+function diffs(element, props, expand) {
+  return element.reduce((diffs, element, index) => {
+    const separator = index === 0 ? '' : '\n\n';
+    return `${diffs}${separator}${normalizedDiff(element, props, {
+      expand,
+      showLegend: index === 0
+    })}`;
+  }, '');
+}
+
+function normalizedDiff(element, props, {
+  expand = false,
+  showLegend = false
+}) {
+  const result = diffPropsForNode(element, props, {
+    expand
+  }) || '';
+  return showLegend ? result : result.split('\n\n')[1];
+}
+
+function printType(type) {
+  if (typeof type === 'object' && '_context' in type) {
+    const context = type._context;
+    const componentName = type === context.Provider ? 'Provider' : 'Consumer';
+    const displayName = context.displayName || 'Context';
+    return `<${displayName}.${componentName} />`;
+  }
+
+  const displayName = typeof type === 'string' ? type : type.displayName || type.name || 'Component';
+  return `<${displayName} />`;
+}
+function diffPropsForNode(node, props, {
+  expand = false
+}) {
+  return diff(props, getObjectSubset(node.props, props), {
+    expand
+  });
+} // Original from https://github.com/facebook/jest/blob/master/packages/expect/src/utils.ts#L107
+
+function getObjectSubset(object, subset) {
+  if (Array.isArray(object)) {
+    if (Array.isArray(subset) && subset.length === object.length) {
+      return subset.map((sub, i) => getObjectSubset(object[i], sub));
+    }
+  } else if (object instanceof Date) {
+    return object;
+  } else if (typeof object === 'object' && object !== null && typeof subset === 'object' && subset !== null) {
+    const trimmed = {};
+    Object.keys(subset).filter(key => Reflect.has(object, key)).forEach(key => trimmed[key] = getObjectSubset(object[key], subset[key]));
+
+    if (Object.keys(trimmed).length > 0) {
+      return trimmed;
+    }
+  }
+
+  return object;
+}
+
+function pluralize(word, count) {
+  return count === 1 ? word : `${word}s`;
+}
+
+export { assertIsNode, assertIsType, diffPropsForNode, diffs, pluralize, printType };

package/node_modules/@shopify/react-testing/build/esnext/mount.esnext

@@ -0,0 +1,71 @@
+import { Root } from './root.esnext';
+export { Root } from './root.esnext';
+
+function mount(element) {
+  return new Root(element);
+}
+class CustomRoot extends Root {
+  constructor(tree, context, options) {
+    super(tree, options);
+    this.context = context;
+  }
+
+}
+function createMount({
+  render,
+  context: createContext = defaultContext,
+  afterMount = defaultAfterMount,
+  cleanup
+}) {
+  function mount(element, options = {}) {
+    const context = createContext(options);
+    const wrapper = new CustomRoot(element, context, {
+      render: element => render(element, context, options),
+      resolveRoot: root => root.find(element.type)
+    });
+
+    if (cleanup) {
+      const originalDestroy = wrapper.destroy.bind(wrapper);
+
+      wrapper.destroy = () => {
+        cleanup(wrapper, options);
+        originalDestroy();
+      };
+    }
+
+    const afterMountResult = afterMount(wrapper, options);
+    return afterMountResult != null && 'then' in afterMountResult ? afterMountResult.then(() => wrapper) : wrapper;
+  }
+
+  Reflect.defineProperty(mount, 'extend', {
+    writable: false,
+    value: ({
+      context: createAdditionalContext = defaultContext,
+      render: additionalRender,
+      afterMount: additionalAfterMount = defaultAfterMount
+    }) => {
+      return createMount({
+        context: options => ({ ...createContext(options),
+          ...createAdditionalContext(options)
+        }),
+        render: (element, context, options) => render(additionalRender(element, context, options), context, options),
+        afterMount: (wrapper, options) => {
+          const result = additionalAfterMount(wrapper, options);
+
+          const finalResult = () => afterMount(wrapper, options);
+
+          return result != null && 'then' in result ? result.then(finalResult) : finalResult();
+        }
+      });
+    }
+  });
+  return mount;
+}
+
+function defaultContext() {
+  return {};
+}
+
+function defaultAfterMount() {}
+
+export { CustomRoot, createMount, mount };

package/node_modules/@shopify/react-testing/build/esnext/root.esnext

@@ -0,0 +1,275 @@
+import React from 'react';
+import { render, unmountComponentAtNode } from 'react-dom';
+import { act } from 'react-dom/test-utils';
+import { TestWrapper } from './TestWrapper.esnext';
+import { Element } from './element.esnext';
+import { getInternals } from './compat.esnext';
+import { Tag } from './types.esnext';
+
+const {
+  findCurrentFiberUsingSlowPath
+} = require('react-reconciler/reflection');
+
+const connected = new Set();
+class Root {
+  get props() {
+    return this.withRoot(root => root.props);
+  }
+
+  get isDOM() {
+    return this.withRoot(root => root.isDOM);
+  }
+
+  get type() {
+    return this.withRoot(root => root.type);
+  }
+
+  get instance() {
+    return this.withRoot(root => root.instance);
+  }
+
+  get children() {
+    return this.withRoot(root => root.children);
+  }
+
+  get descendants() {
+    return this.withRoot(root => root.descendants);
+  }
+
+  get domNodes() {
+    return this.withRoot(root => root.domNodes);
+  }
+
+  get domNode() {
+    return this.withRoot(root => root.domNode);
+  }
+
+  get mounted() {
+    return this.wrapper != null;
+  }
+
+  constructor(tree, {
+    render = defaultRender,
+    resolveRoot = defaultResolveRoot
+  } = {}) {
+    this.tree = tree;
+    this.wrapper = null;
+    this.element = document.createElement('div');
+    this.root = null;
+    this.acting = false;
+    this.render = void 0;
+    this.resolveRoot = void 0;
+    this.render = render;
+    this.resolveRoot = resolveRoot;
+    this.mount();
+  }
+
+  act(action, {
+    update = true
+  } = {}) {
+    const updateWrapper = update ? this.update.bind(this) : noop;
+    let result;
+
+    if (this.acting) {
+      return action();
+    }
+
+    this.acting = true;
+
+    const afterResolve = () => {
+      updateWrapper();
+      this.acting = false;
+      return result;
+    };
+
+    const promise = act(() => {
+      result = action(); // This condition checks the returned value is an actual Promise and returns it
+      // to React’s `act()` call, otherwise we just want to return `undefined`
+
+      if (isPromise(result)) {
+        return result;
+      }
+
+      return undefined;
+    });
+
+    if (isPromise(result)) {
+      updateWrapper();
+      return Promise.resolve(promise).then(afterResolve);
+    }
+
+    return afterResolve();
+  }
+
+  html() {
+    return this.withRoot(root => root.html());
+  }
+
+  text() {
+    return this.withRoot(root => root.text());
+  }
+
+  is(type) {
+    return this.withRoot(root => root.is(type));
+  }
+
+  prop(key) {
+    return this.withRoot(root => root.prop(key));
+  }
+
+  data(key) {
+    return this.withRoot(root => root.data(key));
+  }
+
+  find(type, props) {
+    return this.withRoot(root => root.find(type, props));
+  }
+
+  findAll(type, props) {
+    return this.withRoot(root => root.findAll(type, props));
+  }
+
+  findWhere(predicate) {
+    return this.withRoot(root => root.findWhere(predicate));
+  }
+
+  findAllWhere(predicate) {
+    return this.withRoot(root => root.findAllWhere(predicate));
+  }
+
+  trigger(prop, ...args) {
+    return this.withRoot(root => root.trigger(prop, ...args));
+  }
+
+  triggerKeypath(keypath, ...args) {
+    return this.withRoot(root => root.triggerKeypath(keypath, ...args));
+  }
+
+  mount() {
+    if (this.mounted) {
+      throw new Error('Attempted to mount a node that was already mounted');
+    }
+
+    if (this.element.parentNode == null) {
+      document.body.appendChild(this.element);
+      connected.add(this);
+    }
+
+    this.act(() => {
+      render( /*#__PURE__*/React.createElement(TestWrapper, {
+        render: this.render,
+        ref: wrapper => {
+          this.wrapper = wrapper;
+        }
+      }, this.tree), this.element);
+    });
+  }
+
+  unmount() {
+    if (!this.mounted) {
+      throw new Error('You attempted to unmount a node that was already unmounted');
+    }
+
+    this.ensureRoot();
+    this.act(() => unmountComponentAtNode(this.element));
+  }
+
+  destroy() {
+    const {
+      element,
+      mounted
+    } = this;
+
+    if (mounted) {
+      this.unmount();
+    }
+
+    element.remove();
+    connected.delete(this);
+  }
+
+  setProps(props) {
+    this.ensureRoot();
+    this.act(() => this.wrapper.setProps(props));
+  }
+
+  forceUpdate() {
+    this.ensureRoot();
+    this.act(() => this.wrapper.forceUpdate());
+  }
+
+  debug(options) {
+    this.ensureRoot();
+    return this.root.debug(options);
+  }
+
+  toString() {
+    return this.withRoot(root => root.toString());
+  }
+
+  update() {
+    if (this.wrapper == null) {
+      this.root = null;
+    } else {
+      const rootFiber = getInternals(this.wrapper.rootRef);
+      const topElement = fiberToElement(findCurrentFiberUsingSlowPath(rootFiber), this);
+      this.root = this.resolveRoot(topElement);
+    }
+  }
+
+  ensureRoot() {
+    if (this.wrapper == null || this.root == null) {
+      throw new Error('Attempted to operate on a mounted tree, but the component is no longer mounted');
+    }
+  }
+
+  withRoot(withRoot) {
+    this.ensureRoot();
+    return withRoot(this.root);
+  }
+
+}
+
+function defaultResolveRoot(element) {
+  return element.children[0];
+}
+
+function defaultRender(element) {
+  return element;
+}
+
+function fiberToElement(node, root) {
+  if (node.tag === Tag.HostText) {
+    return node.memoizedProps;
+  }
+
+  const props = node.memoizedProps;
+  const children = childrenToTree(node.child, root);
+  return new Element({
+    tag: node.tag,
+    type: node.type,
+    props,
+    instance: node.stateNode
+  }, children, root);
+}
+
+function childrenToTree(fiber, root) {
+  let currentFiber = fiber;
+  const children = [];
+
+  while (currentFiber != null) {
+    const result = fiberToElement(currentFiber, root);
+    children.push(result);
+    currentFiber = currentFiber.sibling;
+  }
+
+  return children;
+}
+
+function isPromise(promise) {
+  return promise != null && typeof promise === 'object' && 'then' in promise;
+}
+
+function noop() {}
+
+export { Root, connected };

package/node_modules/@shopify/react-testing/build/esnext/toReactString.esnext

@@ -0,0 +1,80 @@
+import { stringify } from 'jest-matcher-utils';
+
+function toReactString(node, options = {}, level = 0) {
+  // if this is an array node then print all children at the current level
+  if (!node.type && node.children.length > 0) {
+    return node.children.map(child => toReactString(child, options, level)).join('\n');
+  }
+
+  const name = nodeName(node);
+  const indent = '  '.repeat(level);
+  const props = Object.keys(node.props) // we always filter out children no matter what, but unless allProps option
+  // is present we will also filter out insigificant props
+  .filter(key => options.allProps ? key !== 'children' : !/^(children|className)$|^(aria|data)-/.test(key)).reduce((list, key) => {
+    if (!key) {
+      return list;
+    }
+
+    const value = node.props[key];
+
+    if (value === undefined && !options.allProps) {
+      return list;
+    }
+
+    list.push(toPropString(key, value, options.verbosity));
+    return list;
+  }, []);
+  const hasChildren = node.children.length > 0 && !['svg'].includes(name);
+  const open = `${indent}<${name}${props.length > 0 ? ` ${props.join(' ')}` : ''}${hasChildren ? '>' : ' />'}`;
+
+  if (!hasChildren) {
+    return open;
+  }
+
+  const close = `${indent}</${name}>`;
+
+  if (options.depth != null && level >= options.depth) {
+    return [open, `${indent}  {/* <${node.children.length} child${node.children.length === 1 ? '' : 'ren'}... /> */}`, close].join('\n');
+  }
+
+  return [open, ...node.children.map(child => toReactString(child, options, level + 1)), close].join('\n');
+}
+function toPropString(key, value, verbosity = 1) {
+  if (value === undefined) {
+    return `${key}={undefined}`;
+  }
+
+  if (value === null) {
+    return `${key}={null}`;
+  }
+
+  if (typeof value === 'string') {
+    return `${key}="${value}"`;
+  }
+
+  if (typeof value === 'boolean' && value) {
+    return value ? `${key}` : `${key}={false}`;
+  }
+
+  if (value instanceof Array) {
+    return `${key}={${stringify(value, verbosity + 1)}}`;
+  }
+
+  return `${key}={${stringify(value, verbosity)}}`;
+}
+function nodeName({
+  type
+}) {
+  if (type && typeof type === 'object' && '_context' in type) {
+    const context = type._context;
+    return `${context.displayName || 'Context'}.${type === context.Provider ? 'Provider' : 'Consumer'}`;
+  }
+
+  if (type == null) {
+    return 'Node';
+  }
+
+  return typeof type === 'string' ? type : type.displayName || type.name || 'Component';
+}
+
+export { nodeName, toPropString, toReactString };