@shopify/ui-extensions-server-kit 0.0.0-nightly-20250605112924

package/node_modules/@shopify/react-testing/build/cjs/mount.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('./_virtual/_rollupPluginBabelHelpers.js');
+var root = require('./root.js');
+
+function mount(element) {
+  return new root.Root(element);
+}
+class CustomRoot extends root.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 => _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, 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() {}
+
+exports.Root = root.Root;
+exports.CustomRoot = CustomRoot;
+exports.createMount = createMount;
+exports.mount = mount;

package/node_modules/@shopify/react-testing/build/cjs/root.js

@@ -0,0 +1,284 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var reactDom = require('react-dom');
+var testUtils = require('react-dom/test-utils');
+var TestWrapper = require('./TestWrapper.js');
+var element = require('./element.js');
+var compat = require('./compat.js');
+var types = require('./types.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+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 = testUtils.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(() => {
+      reactDom.render( /*#__PURE__*/React__default["default"].createElement(TestWrapper.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(() => reactDom.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 = compat.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 === types.Tag.HostText) {
+    return node.memoizedProps;
+  }
+
+  const props = node.memoizedProps;
+  const children = childrenToTree(node.child, root);
+  return new element.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() {}
+
+exports.Root = Root;
+exports.connected = connected;

package/node_modules/@shopify/react-testing/build/cjs/toReactString.js

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jestMatcherUtils = require('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}={${jestMatcherUtils.stringify(value, verbosity + 1)}}`;
+  }
+
+  return `${key}={${jestMatcherUtils.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';
+}
+
+exports.nodeName = nodeName;
+exports.toPropString = toPropString;
+exports.toReactString = toReactString;

package/node_modules/@shopify/react-testing/build/cjs/types.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// https://github.com/facebook/react/blob/master/packages/shared/ReactWorkTag.js
+exports.Tag = void 0;
+
+(function (Tag) {
+  Tag[Tag["FunctionComponent"] = 0] = "FunctionComponent";
+  Tag[Tag["ClassComponent"] = 1] = "ClassComponent";
+  Tag[Tag["IndeterminateComponent"] = 2] = "IndeterminateComponent";
+  Tag[Tag["HostRoot"] = 3] = "HostRoot";
+  Tag[Tag["HostPortal"] = 4] = "HostPortal";
+  Tag[Tag["HostComponent"] = 5] = "HostComponent";
+  Tag[Tag["HostText"] = 6] = "HostText";
+  Tag[Tag["Fragment"] = 7] = "Fragment";
+  Tag[Tag["Mode"] = 8] = "Mode";
+  Tag[Tag["ContextConsumer"] = 9] = "ContextConsumer";
+  Tag[Tag["ContextProvider"] = 10] = "ContextProvider";
+  Tag[Tag["ForwardRef"] = 11] = "ForwardRef";
+  Tag[Tag["Profiler"] = 12] = "Profiler";
+  Tag[Tag["SuspenseComponent"] = 13] = "SuspenseComponent";
+  Tag[Tag["MemoComponent"] = 14] = "MemoComponent";
+  Tag[Tag["SimpleMemoComponent"] = 15] = "SimpleMemoComponent";
+  Tag[Tag["LazyComponent"] = 16] = "LazyComponent";
+  Tag[Tag["IncompleteClassComponent"] = 17] = "IncompleteClassComponent";
+  Tag[Tag["DehydratedSuspenseComponent"] = 18] = "DehydratedSuspenseComponent";
+})(exports.Tag || (exports.Tag = {}));

package/node_modules/@shopify/react-testing/build/esm/TestWrapper.mjs

@@ -0,0 +1,44 @@
+import React from 'react';
+
+class TestWrapper extends React.Component {
+  constructor(...args) {
+    super(...args);
+    this.state = {};
+    this.rootRef = null;
+
+    this.setRef = ref => {
+      this.rootRef = ref;
+    };
+  }
+
+  // eslint-disable-next-line @shopify/react-prefer-private-members
+  setProps(props) {
+    this.setState({
+      props
+    });
+  }
+
+  render() {
+    const {
+      props
+    } = this.state;
+    const {
+      children,
+      render
+    } = this.props;
+    const rootElement = props ? /*#__PURE__*/React.cloneElement(children, props) : children;
+    return render( /*#__PURE__*/React.createElement(TestInnerWrapper, {
+      ref: this.setRef
+    }, rootElement));
+  }
+
+}
+
+class TestInnerWrapper extends React.Component {
+  render() {
+    return this.props.children;
+  }
+
+}
+
+export { TestWrapper };

package/node_modules/@shopify/react-testing/build/esm/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,42 @@
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    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 = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+
+  return target;
+}
+
+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;
+}
+
+export { _defineProperty as defineProperty, _objectSpread2 as objectSpread2 };

package/node_modules/@shopify/react-testing/build/esm/compat.mjs

@@ -0,0 +1,10 @@
+function getInternals(instance) {
+  // In React 17+ _reactInternalFiber was renamed to _reactInternals. As such we need to handle both APIs to maintain support.
+  if ('_reactInternalFiber' in instance) {
+    return instance._reactInternalFiber;
+  }
+
+  return instance._reactInternals;
+}
+
+export { getInternals };

package/node_modules/@shopify/react-testing/build/esm/destroy.mjs

@@ -0,0 +1,9 @@
+import { connected } from './root.mjs';
+
+function destroyAll() {
+  for (const wrapper of [...connected]) {
+    wrapper.destroy();
+  }
+}
+
+export { destroyAll };