test-renderer 0.11.0

package/dist/index.cjs

@@ -0,0 +1,868 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRoot: () => createRoot
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/renderer.ts
+var import_constants5 = require("react-reconciler/constants");
+
+// src/constants.ts
+var Tag = {
+  Container: "CONTAINER",
+  Instance: "INSTANCE",
+  Text: "TEXT"
+};
+var CONTAINER_TYPE = "";
+
+// src/query-all.ts
+function queryAll(element, predicate, options) {
+  var _a, _b;
+  const includeSelf = (_a = options == null ? void 0 : options.includeSelf) != null ? _a : false;
+  const matchDeepestOnly = (_b = options == null ? void 0 : options.matchDeepestOnly) != null ? _b : false;
+  const results = [];
+  const matchingDescendants = [];
+  element.children.forEach((child) => {
+    if (typeof child === "string") {
+      return;
+    }
+    matchingDescendants.push(...queryAll(child, predicate, __spreadProps(__spreadValues({}, options), { includeSelf: true })));
+  });
+  if (includeSelf && // When matchDeepestOnly = true: add current element only if no descendants match
+  (matchingDescendants.length === 0 || !matchDeepestOnly) && predicate(element)) {
+    results.push(element);
+  }
+  results.push(...matchingDescendants);
+  return results;
+}
+
+// src/render-to-json.ts
+function renderContainerToJson(instance) {
+  return {
+    type: CONTAINER_TYPE,
+    props: {},
+    children: renderChildrenToJson(instance.children),
+    $$typeof: /* @__PURE__ */ Symbol.for("react.test.json")
+  };
+}
+function renderInstanceToJson(instance) {
+  if (instance.isHidden) {
+    return null;
+  }
+  const _a = instance.props, { children: _children } = _a, restProps = __objRest(_a, ["children"]);
+  return {
+    type: instance.type,
+    props: restProps,
+    children: renderChildrenToJson(instance.children),
+    $$typeof: /* @__PURE__ */ Symbol.for("react.test.json")
+  };
+}
+function renderTextInstanceToJson(instance) {
+  if (instance.isHidden) {
+    return null;
+  }
+  return instance.text;
+}
+function renderChildrenToJson(children) {
+  const result = [];
+  for (const child of children) {
+    if (child.tag === Tag.Instance) {
+      const renderedChild = renderInstanceToJson(child);
+      if (renderedChild !== null) {
+        result.push(renderedChild);
+      }
+    } else {
+      const renderedChild = renderTextInstanceToJson(child);
+      if (renderedChild !== null) {
+        result.push(renderedChild);
+      }
+    }
+  }
+  return result;
+}
+
+// src/host-element.ts
+var instanceMap = /* @__PURE__ */ new WeakMap();
+var HostElement = class _HostElement {
+  constructor(instance) {
+    this.instance = instance;
+  }
+  /** The element type (e.g., "div", "span"). Empty string for container. */
+  get type() {
+    return this.instance.tag === Tag.Instance ? this.instance.type : CONTAINER_TYPE;
+  }
+  /** The element's props object. */
+  get props() {
+    return this.instance.tag === Tag.Instance ? this.instance.props : {};
+  }
+  /** The parent element, or null if this is the root container. */
+  get parent() {
+    const parentInstance = this.instance.parent;
+    if (parentInstance == null) {
+      return null;
+    }
+    return _HostElement.fromInstance(parentInstance);
+  }
+  /** Array of child nodes (elements and text strings). Hidden children are excluded. */
+  get children() {
+    const result = this.instance.children.filter((child) => !child.isHidden).map((child) => getHostNodeForInstance(child));
+    return result;
+  }
+  /**
+   * Access to the underlying React Fiber node. This is an unstable API that exposes
+   * internal react-reconciler structures which may change without warning in future
+   * React versions. Use with caution and only when absolutely necessary.
+   *
+   * @returns The Fiber node for this instance, or null if this is a container.
+   */
+  get unstable_fiber() {
+    return this.instance.tag === Tag.Instance ? this.instance.unstable_fiber : null;
+  }
+  /**
+   * Convert this element to a JSON representation suitable for snapshots.
+   *
+   * @returns JSON element or null if the element is hidden.
+   */
+  toJSON() {
+    return this.instance.tag === Tag.Container ? renderContainerToJson(this.instance) : renderInstanceToJson(this.instance);
+  }
+  /**
+   * Find all descendant elements matching the predicate.
+   *
+   * @param predicate - Function that returns true for matching elements.
+   * @param options - Optional query configuration.
+   * @returns Array of matching elements.
+   */
+  queryAll(predicate, options) {
+    return queryAll(this, predicate, options);
+  }
+  /** @internal */
+  static fromInstance(instance) {
+    const hostElement = instanceMap.get(instance);
+    if (hostElement) {
+      return hostElement;
+    }
+    const result = new _HostElement(instance);
+    instanceMap.set(instance, result);
+    return result;
+  }
+};
+function getHostNodeForInstance(instance) {
+  switch (instance.tag) {
+    case Tag.Text:
+      return instance.text;
+    case Tag.Instance:
+      return HostElement.fromInstance(instance);
+  }
+}
+
+// src/reconciler.ts
+var import_react_reconciler = __toESM(require("react-reconciler"), 1);
+var import_constants3 = require("react-reconciler/constants");
+
+// src/utils.ts
+function formatComponentList(names) {
+  if (names.length === 0) {
+    return "";
+  }
+  if (names.length === 1) {
+    return `<${names[0]}>`;
+  }
+  if (names.length === 2) {
+    return `<${names[0]}> or <${names[1]}>`;
+  }
+  const allButLast = names.slice(0, -1);
+  const last = names[names.length - 1];
+  return `${allButLast.map((name) => `<${name}>`).join(", ")}, or <${last}>`;
+}
+
+// src/reconciler.ts
+var nodeToInstanceMap = /* @__PURE__ */ new WeakMap();
+var currentUpdatePriority = import_constants3.NoEventPriority;
+var hostConfig = {
+  /**
+   * The reconciler has two modes: mutation mode and persistent mode. You must specify one of them.
+   *
+   * If your target platform is similar to the DOM and has methods similar to `appendChild`, `removeChild`,
+   * and so on, you'll want to use the **mutation mode**. This is the same mode used by React DOM, React ART,
+   * and the classic React Native renderer.
+   *
+   * ```js
+   * const HostConfig = {
+   *   // ...
+   *   supportsMutation: true,
+   *   // ...
+   * }
+   * ```
+   *
+   * Depending on the mode, the reconciler will call different methods on your host config.
+   * If you're not sure which one you want, you likely need the mutation mode.
+   */
+  supportsMutation: true,
+  /**
+   * The reconciler has two modes: mutation mode and persistent mode. You must specify one of them.
+   *
+   * If your target platform has immutable trees, you'll want the **persistent mode** instead. In that mode,
+   * existing nodes are never mutated, and instead every change clones the parent tree and then replaces
+   * the whole parent tree at the root. This is the node used by the new React Native renderer, codenamed "Fabric".
+   *
+   * ```js
+   * const HostConfig = {
+   *   // ...
+   *   supportsPersistence: true,
+   *   // ...
+   * }
+   * ```
+   *
+   * Depending on the mode, the reconciler will call different methods on your host config.
+   * If you're not sure which one you want, you likely need the mutation mode.
+   */
+  supportsPersistence: false,
+  /**
+   * #### `createInstance(type, props, rootContainer, hostContext, internalHandle)`
+   *
+   * This method should return a newly created node. For example, the DOM renderer would call
+   * `document.createElement(type)` here and then set the properties from `props`.
+   *
+   * You can use `rootContainer` to access the root container associated with that tree. For example,
+   * in the DOM renderer, this is useful to get the correct `document` reference that the root belongs to.
+   *
+   * The `hostContext` parameter lets you keep track of some information about your current place in
+   * the tree. To learn more about it, see `getChildHostContext` below.
+   *
+   * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its
+   * internal fields, be aware that it may change significantly between versions. You're taking on additional
+   * maintenance risk by reading from it, and giving up all guarantees if you write something to it.
+   *
+   * This method happens **in the render phase**. It can (and usually should) mutate the node it has
+   * just created before returning it, but it must not modify any other nodes. It must not register
+   * any event handlers on the parent tree. This is because an instance being created doesn't guarantee
+   * it would be placed in the tree — it could be left unused and later collected by GC. If you need to do
+   * something when an instance is definitely in the tree, look at `commitMount` instead.
+   */
+  createInstance(type, props, rootContainer, _hostContext, internalHandle) {
+    return {
+      tag: Tag.Instance,
+      type,
+      props,
+      isHidden: false,
+      children: [],
+      parent: null,
+      rootContainer,
+      unstable_fiber: internalHandle
+    };
+  },
+  /**
+   * #### `createTextInstance(text, rootContainer, hostContext, internalHandle)`
+   *
+   * Same as `createInstance`, but for text nodes. If your renderer doesn't support text nodes, you can
+   * throw here.
+   */
+  createTextInstance(text, rootContainer, hostContext, _internalHandle) {
+    if (rootContainer.config.textComponents && !hostContext.isInsideText) {
+      throw new Error(
+        `Invariant Violation: Text strings must be rendered within a ${formatComponentList(
+          rootContainer.config.textComponents
+        )} component. Detected attempt to render "${text}" string within a <${hostContext.type}> component.`
+      );
+    }
+    return {
+      tag: Tag.Text,
+      text,
+      parent: null,
+      isHidden: false
+    };
+  },
+  /**
+   * #### `appendInitialChild(parentInstance, child)`
+   *
+   * This method should mutate the `parentInstance` and add the child to its list of children.
+   * For example, in the DOM this would translate to a `parentInstance.appendChild(child)` call.
+   *
+   * This method happens **in the render phase**. It can mutate `parentInstance` and `child`, but it
+   * must not modify any other nodes. It's called while the tree is still being built up and not connected
+   * to the actual tree on the screen.
+   */
+  appendInitialChild: appendChild,
+  /**
+   * #### `finalizeInitialChildren(instance, type, props, rootContainer, hostContext)`
+   *
+   * In this method, you can perform some final mutations on the `instance`. Unlike with `createInstance`,
+   * by the time `finalizeInitialChildren` is called, all the initial children have already been added to
+   * the `instance`, but the instance itself has not yet been connected to the tree on the screen.
+   *
+   * This method happens **in the render phase**. It can mutate `instance`, but it must not modify any other
+   * nodes. It's called while the tree is still being built up and not connected to the actual tree on the screen.
+   *
+   * There is a second purpose to this method. It lets you specify whether there is some work that needs to
+   * happen when the node is connected to the tree on the screen. If you return `true`, the instance will
+   * receive a `commitMount` call later. See its documentation below.
+   *
+   * If you don't want to do anything here, you should return `false`.
+   */
+  finalizeInitialChildren(_instance, _type, _props, _rootContainer, _hostContext) {
+    return false;
+  },
+  /**
+   * #### `shouldSetTextContent(type, props)`
+   *
+   * Some target platforms support setting an instance's text content without manually creating a text node.
+   * For example, in the DOM, you can set `node.textContent` instead of creating a text node and appending it.
+   *
+   * If you return `true` from this method, React will assume that this node's children are text, and will
+   * not create nodes for them. It will instead rely on you to have filled that text during `createInstance`.
+   * This is a performance optimization. For example, the DOM renderer returns `true` only if `type` is a
+   * known text-only parent (like `'textarea'`) or if `props.children` has a `'string'` type. If you return `true`,
+   *  you will need to implement `resetTextContent` too.
+   *
+   * If you don't want to do anything here, you should return `false`.
+   * This method happens **in the render phase**. Do not mutate the tree from it.
+   */
+  shouldSetTextContent(_type, _props) {
+    return false;
+  },
+  setCurrentUpdatePriority(newPriority) {
+    currentUpdatePriority = newPriority;
+  },
+  getCurrentUpdatePriority() {
+    return currentUpdatePriority;
+  },
+  resolveUpdatePriority() {
+    return currentUpdatePriority || import_constants3.DefaultEventPriority;
+  },
+  shouldAttemptEagerTransition() {
+    return false;
+  },
+  /**
+   * #### `getRootHostContext(rootContainer)`
+   *
+   * This method lets you return the initial host context from the root of the tree. See `getChildHostContext`
+   * for the explanation of host context.
+   *
+   * If you don't intend to use host context, you can return `null`.
+   * This method happens **in the render phase**. Do not mutate the tree from it.
+   */
+  getRootHostContext(rootContainer) {
+    return {
+      type: "ROOT",
+      config: rootContainer.config,
+      isInsideText: false
+    };
+  },
+  /**
+   * #### `getChildHostContext(parentHostContext, type, rootContainer)`
+   *
+   * Host context lets you track some information about where you are in the tree so that it's available
+   * inside `createInstance` as the `hostContext` parameter. For example, the DOM renderer uses it to track
+   * whether it's inside an HTML or an SVG tree, because `createInstance` implementation needs to be
+   * different for them.
+   *
+   * If the node of this `type` does not influence the context you want to pass down, you can return
+   * `parentHostContext`. Alternatively, you can return any custom object representing the information
+   * you want to pass down.
+   *
+   * If you don't want to do anything here, return `parentHostContext`.
+   *
+   * This method happens **in the render phase**. Do not mutate the tree from it.
+   */
+  getChildHostContext(parentHostContext, type) {
+    var _a;
+    const isInsideText = Boolean((_a = parentHostContext.config.textComponents) == null ? void 0 : _a.includes(type));
+    return __spreadProps(__spreadValues({}, parentHostContext), { type, isInsideText });
+  },
+  /**
+   * #### `getPublicInstance(instance)`
+   *
+   * Determines what object gets exposed as a ref. You'll likely want to return the `instance` itself. But
+   * in some cases it might make sense to only expose some part of it.
+   *
+   * If you don't want to do anything here, return `instance`.
+   */
+  getPublicInstance(instance) {
+    switch (instance.tag) {
+      case Tag.Instance: {
+        const createNodeMock = instance.rootContainer.config.createNodeMock;
+        const mockNode = createNodeMock({
+          type: instance.type,
+          props: instance.props,
+          key: null
+        });
+        nodeToInstanceMap.set(mockNode, instance);
+        return mockNode;
+      }
+      default:
+        return instance;
+    }
+  },
+  /**
+   * #### `prepareForCommit(containerInfo)`
+   *
+   * This method lets you store some information before React starts making changes to the tree on
+   * the screen. For example, the DOM renderer stores the current text selection so that it can later
+   * restore it. This method is mirrored by `resetAfterCommit`.
+   *
+   * Even if you don't want to do anything here, you need to return `null` from it.
+   */
+  prepareForCommit(_containerInfo) {
+    return null;
+  },
+  /**
+   * #### `resetAfterCommit(containerInfo)`
+   *
+   * This method is called right after React has performed the tree mutations. You can use it to restore
+   * something you've stored in `prepareForCommit` — for example, text selection.
+   *
+   * You can leave it empty.
+   */
+  resetAfterCommit(_containerInfo) {
+  },
+  /**
+   * #### `preparePortalMount(containerInfo)`
+   *
+   * This method is called for a container that's used as a portal target. Usually you can leave it empty.
+   */
+  preparePortalMount(_containerInfo) {
+  },
+  /**
+   * #### `scheduleTimeout(fn, delay)`
+   *
+   * You can proxy this to `setTimeout` or its equivalent in your environment.
+   */
+  scheduleTimeout: setTimeout,
+  /**
+   * #### `cancelTimeout(id)`
+   *
+   * You can proxy this to `clearTimeout` or its equivalent in your environment.
+   */
+  cancelTimeout: clearTimeout,
+  /**
+   * #### `noTimeout`
+   *
+   * This is a property (not a function) that should be set to something that can never be a valid timeout ID.
+   * For example, you can set it to `-1`.
+   */
+  noTimeout: -1,
+  /**
+   * #### `supportsMicrotasks`
+   *
+   * Set this to `true` to indicate that your renderer supports `scheduleMicrotask`. We use microtasks as part
+   * of our discrete event implementation in React DOM. If you're not sure if your renderer should support this,
+   * you probably should. The option to not implement `scheduleMicrotask` exists so that platforms with more control
+   * over user events, like React Native, can choose to use a different mechanism.
+   */
+  supportsMicrotasks: true,
+  /**
+   * #### `scheduleMicrotask(fn)`
+   *
+   * Optional. You can proxy this to `queueMicrotask` or its equivalent in your environment.
+   */
+  scheduleMicrotask: queueMicrotask,
+  /**
+   * #### `isPrimaryRenderer`
+   *
+   * This is a property (not a function) that should be set to `true` if your renderer is the main one on the
+   * page. For example, if you're writing a renderer for the Terminal, it makes sense to set it to `true`, but
+   * if your renderer is used *on top of* React DOM or some other existing renderer, set it to `false`.
+   */
+  isPrimaryRenderer: true,
+  /**
+   * Whether the renderer shouldn't trigger missing `act()` warnings
+   */
+  warnsIfNotActing: true,
+  getInstanceFromNode(node) {
+    const instance = nodeToInstanceMap.get(node);
+    if (instance !== void 0) {
+      return instance.unstable_fiber;
+    }
+    return null;
+  },
+  beforeActiveInstanceBlur() {
+  },
+  afterActiveInstanceBlur() {
+  },
+  prepareScopeUpdate(scopeInstance, instance) {
+    nodeToInstanceMap.set(scopeInstance, instance);
+  },
+  getInstanceFromScope(scopeInstance) {
+    var _a;
+    return (_a = nodeToInstanceMap.get(scopeInstance)) != null ? _a : null;
+  },
+  detachDeletedInstance(_node) {
+  },
+  /**
+   * #### `appendChild(parentInstance, child)`
+   *
+   * This method should mutate the `parentInstance` and add the child to its list of children. For example,
+   * in the DOM this would translate to a `parentInstance.appendChild(child)` call.
+   *
+   * Although this method currently runs in the commit phase, you still should not mutate any other nodes
+   * in it. If you need to do some additional work when a node is definitely connected to the visible tree, look at `commitMount`.
+   */
+  appendChild,
+  /**
+   * #### `appendChildToContainer(container, child)`
+   *
+   * Same as `appendChild`, but for when a node is attached to the root container. This is useful if attaching
+   * to the root has a slightly different implementation, or if the root container nodes are of a different
+   * type than the rest of the tree.
+   */
+  appendChildToContainer: appendChild,
+  /**
+   * #### `insertBefore(parentInstance, child, beforeChild)`
+   *
+   * This method should mutate the `parentInstance` and place the `child` before `beforeChild` in the list of
+   * its children. For example, in the DOM this would translate to a `parentInstance.insertBefore(child, beforeChild)` call.
+   *
+   * Note that React uses this method both for insertions and for reordering nodes. Similar to DOM, it is expected
+   * that you can call `insertBefore` to reposition an existing child. Do not mutate any other parts of the tree from it.
+   */
+  insertBefore,
+  /**
+   * #### `insertInContainerBefore(container, child, beforeChild)
+   *
+   * Same as `insertBefore`, but for when a node is attached to the root container. This is useful if attaching
+   * to the root has a slightly different implementation, or if the root container nodes are of a different type
+   * than the rest of the tree.
+   */
+  insertInContainerBefore: insertBefore,
+  /**
+   * #### `removeChild(parentInstance, child)`
+   *
+   * This method should mutate the `parentInstance` to remove the `child` from the list of its children.
+   *
+   * React will only call it for the top-level node that is being removed. It is expected that garbage collection
+   * would take care of the whole subtree. You are not expected to traverse the child tree in it.
+   */
+  removeChild,
+  /**
+   * #### `removeChildFromContainer(container, child)`
+   *
+   * Same as `removeChild`, but for when a node is detached from the root container. This is useful if attaching
+   * to the root has a slightly different implementation, or if the root container nodes are of a different type
+   * than the rest of the tree.
+   */
+  removeChildFromContainer: removeChild,
+  /**
+   * #### `resetTextContent(instance)`
+   *
+   * If you returned `true` from `shouldSetTextContent` for the previous props, but returned `false` from
+   * `shouldSetTextContent` for the next props, React will call this method so that you can clear the text
+   * content you were managing manually. For example, in the DOM you could set `node.textContent = ''`.
+   *
+   * If you never return `true` from `shouldSetTextContent`, you can leave it empty.
+   */
+  resetTextContent(_instance) {
+  },
+  /**
+   * #### `commitTextUpdate(textInstance, prevText, nextText)`
+   *
+   * This method should mutate the `textInstance` and update its text content to `nextText`.
+   *
+   * Here, `textInstance` is a node created by `createTextInstance`.
+   */
+  commitTextUpdate(textInstance, _oldText, newText) {
+    textInstance.text = newText;
+  },
+  /**
+   * #### `commitMount(instance, type, props, internalHandle)`
+   *
+   * This method is only called if you returned `true` from `finalizeInitialChildren` for this instance.
+   *
+   * It lets you do some additional work after the node is actually attached to the tree on the screen for
+   * the first time. For example, the DOM renderer uses it to trigger focus on nodes with the `autoFocus` attribute.
+   *
+   * Note that `commitMount` does not mirror `removeChild` one to one because `removeChild` is only called for
+   * the top-level removed node. This is why ideally `commitMount` should not mutate any nodes other than the
+   * `instance` itself. For example, if it registers some events on some node above, it will be your responsibility
+   * to traverse the tree in `removeChild` and clean them up, which is not ideal.
+   *
+   * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal
+   * fields, be aware that it may change significantly between versions. You're taking on additional maintenance
+   * risk by reading from it, and giving up all guarantees if you write something to it.
+   *
+   * If you never return `true` from `finalizeInitialChildren`, you can leave it empty.
+   */
+  commitMount(_instance, _type, _props, _internalHandle) {
+  },
+  /**
+   * #### `commitUpdate(instance, type, prevProps, nextProps, internalHandle)`
+   *
+   * This method should mutate the `instance` according to the set of changes in `updatePayload`. Here, `updatePayload`
+   *  is the object that you've returned from `prepareUpdate` and has an arbitrary structure that makes sense for your
+   * renderer. For example, the DOM renderer returns an update payload like `[prop1, value1, prop2, value2, ...]` from
+   * `prepareUpdate`, and that structure gets passed into `commitUpdate`. Ideally, all the diffing and calculation
+   * should happen inside `prepareUpdate` so that `commitUpdate` can be fast and straightforward.
+   *
+   * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields,
+   *  be aware that it may change significantly between versions. You're taking on additional maintenance risk by
+   * reading from it, and giving up all guarantees if you write something to it.
+   */
+  // @ts-expect-error @types/react-reconciler types don't fully match react-reconciler's actual Flow types.
+  // Correctness is verified through tests.
+  commitUpdate(instance, type, _prevProps, nextProps, internalHandle) {
+    instance.type = type;
+    instance.props = nextProps;
+    instance.unstable_fiber = internalHandle;
+  },
+  /**
+   * #### `hideInstance(instance)`
+   *
+   * This method should make the `instance` invisible without removing it from the tree. For example, it can apply
+   * visual styling to hide it. It is used by Suspense to hide the tree while the fallback is visible.
+   */
+  hideInstance(instance) {
+    instance.isHidden = true;
+  },
+  /**
+   * #### `hideTextInstance(textInstance)`
+   *
+   * Same as `hideInstance`, but for nodes created by `createTextInstance`.
+   */
+  hideTextInstance(textInstance) {
+    textInstance.isHidden = true;
+  },
+  /**
+   * #### `unhideInstance(instance, props)`
+   *
+   * This method should make the `instance` visible, undoing what `hideInstance` did.
+   */
+  unhideInstance(instance, _props) {
+    instance.isHidden = false;
+  },
+  /**
+   * #### `unhideTextInstance(textInstance, text)`
+   *
+   * Same as `unhideInstance`, but for nodes created by `createTextInstance`.
+   */
+  unhideTextInstance(textInstance, _text) {
+    textInstance.isHidden = false;
+  },
+  /**
+   * #### `clearContainer(container)`
+   *
+   * This method should mutate the `container` root node and remove all children from it.
+   */
+  clearContainer(container) {
+    container.children.forEach((child) => {
+      child.parent = null;
+    });
+    container.children.splice(0);
+  },
+  /**
+   * #### `maySuspendCommit(type, props)`
+   *
+   * This method is called during render to determine if the Host Component type and props require
+   * some kind of loading process to complete before committing an update.
+   */
+  maySuspendCommit(_type, _props) {
+    return false;
+  },
+  /**
+   * #### `preloadInstance(type, props)`
+   *
+   * This method may be called during render if the Host Component type and props might suspend a commit.
+   * It can be used to initiate any work that might shorten the duration of a suspended commit.
+   */
+  preloadInstance(_type, _props) {
+    return true;
+  },
+  /**
+   * #### `startSuspendingCommit()`
+   *
+   * This method is called just before the commit phase. Use it to set up any necessary state while any Host
+   * Components that might suspend this commit are evaluated to determine if the commit must be suspended.
+   */
+  startSuspendingCommit() {
+  },
+  /**
+   * #### `suspendInstance(type, props)`
+   *
+   * This method is called after `startSuspendingCommit` for each Host Component that indicated it might
+   * suspend a commit.
+   */
+  suspendInstance() {
+  },
+  /**
+   * #### `waitForCommitToBeReady()`
+   *
+   * This method is called after all `suspendInstance` calls are complete.
+   *
+   * Return `null` if the commit can happen immediately.
+   * Return `(initiateCommit: Function) => Function` if the commit must be suspended. The argument to this
+   * callback will initiate the commit when called. The return value is a cancellation function that the
+   * Reconciler can use to abort the commit.
+   */
+  waitForCommitToBeReady() {
+    return null;
+  },
+  // -------------------
+  // Hydration Methods
+  //    (optional)
+  // You can optionally implement hydration to "attach" to the existing tree during the initial render instead
+  // of creating it from scratch. For example, the DOM renderer uses this to attach to an HTML markup.
+  //
+  // To support hydration, you need to declare `supportsHydration: true` and then implement the methods in
+  // the "Hydration" section [listed in this file](https://github.com/facebook/react/blob/master/packages/react-reconciler/src/forks/ReactFiberHostConfig.custom.js).
+  // File an issue if you need help.
+  // -------------------
+  supportsHydration: false,
+  NotPendingTransition: null,
+  resetFormInstance(_form) {
+  },
+  requestPostPaintCallback(_callback) {
+  }
+};
+var TestReconciler = (0, import_react_reconciler.default)(hostConfig);
+function appendChild(parentInstance, child) {
+  const index = parentInstance.children.indexOf(child);
+  if (index !== -1) {
+    parentInstance.children.splice(index, 1);
+  }
+  child.parent = parentInstance;
+  parentInstance.children.push(child);
+}
+function insertBefore(parentInstance, child, beforeChild) {
+  const index = parentInstance.children.indexOf(child);
+  if (index !== -1) {
+    parentInstance.children.splice(index, 1);
+  }
+  child.parent = parentInstance;
+  const beforeIndex = parentInstance.children.indexOf(beforeChild);
+  parentInstance.children.splice(beforeIndex, 0, child);
+}
+function removeChild(parentInstance, child) {
+  const index = parentInstance.children.indexOf(child);
+  parentInstance.children.splice(index, 1);
+  child.parent = null;
+}
+
+// src/renderer.ts
+var defaultCreateMockNode = () => ({});
+var defaultOnUncaughtError = (error, errorInfo) => {
+  console.error("Uncaught error:", error, errorInfo);
+};
+var defaultOnCaughtError = (error, errorInfo) => {
+  console.error("Caught error:", error, errorInfo);
+};
+var defaultOnRecoverableError = (error, errorInfo) => {
+  console.error("Recoverable error:", error, errorInfo);
+};
+function createRoot(options) {
+  var _a, _b, _c, _d, _e, _f;
+  let container = {
+    tag: Tag.Container,
+    parent: null,
+    children: [],
+    isHidden: false,
+    config: {
+      textComponents: options == null ? void 0 : options.textComponents,
+      createNodeMock: (_a = options == null ? void 0 : options.createNodeMock) != null ? _a : defaultCreateMockNode
+    }
+  };
+  let containerFiber = TestReconciler.createContainer(
+    container,
+    import_constants5.ConcurrentRoot,
+    null,
+    // hydrationCallbacks
+    (_b = options == null ? void 0 : options.isStrictMode) != null ? _b : false,
+    false,
+    // concurrentUpdatesByDefaultOverride
+    (_c = options == null ? void 0 : options.identifierPrefix) != null ? _c : "",
+    (_d = options == null ? void 0 : options.onUncaughtError) != null ? _d : defaultOnUncaughtError,
+    (_e = options == null ? void 0 : options.onCaughtError) != null ? _e : defaultOnCaughtError,
+    // @ts-expect-error @types/react-reconciler types don't include onRecoverableError parameter
+    // in the createContainer signature, but react-reconciler's actual Flow types do.
+    // Correctness is verified through tests.
+    (_f = options == null ? void 0 : options.onRecoverableError) != null ? _f : defaultOnRecoverableError,
+    null
+    // transitionCallbacks
+  );
+  const render = (element) => {
+    if (containerFiber == null) {
+      throw new Error("Cannot render after unmount");
+    }
+    TestReconciler.updateContainer(element, containerFiber, null, null);
+  };
+  const unmount = () => {
+    if (container == null) {
+      return;
+    }
+    TestReconciler.updateContainer(null, containerFiber, null, null);
+    containerFiber = null;
+    container = null;
+  };
+  return {
+    render,
+    unmount,
+    get container() {
+      if (container == null) {
+        throw new Error("Cannot access .container on unmounted test renderer");
+      }
+      return HostElement.fromInstance(container);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRoot
+});
+//# sourceMappingURL=index.cjs.map