{"version":3,"sources":["../src/ReactSixteenAdapter.js"],"names":["is164","TestUtils","Simulate","touchStart","is165","auxClick","is166","React","unstable_AsyncMode","is168","act","hasShouldComponentUpdateBug","semver","satisfies","testRendererVersion","FiberTags","nodeAndSiblingsArray","nodeWithSibling","array","node","push","sibling","flatten","arr","result","stack","i","length","n","pop","el","Array","isArray","nodeTypeFromType","type","Portal","isMemo","Memo","isLazy","Lazy","unmemoType","elementToTree","children","containerInfo","props","nodeType","key","ref","instance","rendered","toTree","vnode","tag","HostRoot","childrenToTree","child","HostPortal","stateNode","memoizedProps","ClassComponent","FunctionalComponent","MemoClass","elementType","MemoSFC","renderedNodes","map","HostComponent","HostText","Fragment","Mode","ContextProvider","ContextConsumer","Profiler","ForwardRef","pendingProps","Suspense","Error","nodeToHostNode","_node","mapper","item","ReactDOM","findDOMNode","replaceLazyWithFallback","fallback","eventOptions","animation","pointerEvents","getEmptyStateValue","EmptyState","Component","testRenderer","ShallowRenderer","render","createElement","_instance","state","wrapAct","fn","returnVal","getProviderDefaultValue","Provider","_context","_defaultValue","_currentValue","makeFakeElement","$$typeof","Element","isStateful","prototype","isReactComponent","__reactAutoBindPairs","ReactSixteenAdapter","lifecycles","options","enableComponentDidUpdateOnSetState","legacyContextMode","componentDidUpdate","onSetState","getDerivedStateFromProps","getSnapshotBeforeUpdate","setState","skipsComponentDidUpdateOnNullish","getChildContext","calledByRenderer","getDerivedStateFromError","TypeError","attachTo","hydrateIn","wrappingComponentProps","domNode","global","document","adapter","context","callback","wrapperProps","refProp","ReactWrapperComponent","wrappedEl","hydrate","setChildProps","unmount","unmountComponentAtNode","getNode","isCustomComponent","_reactInternalFiber","simulateError","nodeHierarchy","rootNode","error","isErrorBoundary","elInstance","componentDidCatch","find","catchingInstance","catchingType","displayNameOfNode","undefined","simulateEvent","event","mock","mappedEvent","eventFn","batchedUpdates","getWrappingComponentRenderer","inst","getMountWrapperInstance","wrapInvoke","renderer","suspenseFallback","isDOM","cachedNode","lastComponent","wrappedComponent","sentinel","wrapPureComponent","compare","RangeError","shouldComponentUpdate","nextProps","isPureReactComponent","memoized","prevProps","shouldUpdate","args","defaultProps","displayName","wrapFunctionalComponent","unmaskedContext","providerValues","Map","set","value","MockProvider","getProviderFromConsumer","has","get","MockConsumer","renderedEl","FakeSuspenseWrapper","contextTypes","InnerComp","emptyStateValue","Object","defineProperty","configurable","enumerable","writable","output","getRenderOutput","concat","handler","checkPropTypes","typeSpecs","values","location","hierarchy","childContextTypes","ContextWrapper","ReactDOMServer","renderToStaticMarkup","mode","EnzymeAdapter","MODES","MOUNT","createMountRenderer","SHALLOW","createShallowRenderer","STRING","createStringRenderer","element","matchingType","supportsArray","nodes","ConcurrentMode","AsyncMode","NaN","StrictMode","$$typeofType","nodeName","name","object","fragment","fakeElement","isValidElement","Consumer","RootFinder","module","exports"],"mappings":"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","file":"ReactSixteenAdapter.js","sourcesContent":["/* eslint no-use-before-define: 0 */\nimport React from 'react';\nimport ReactDOM from 'react-dom';\n// eslint-disable-next-line import/no-unresolved\nimport ReactDOMServer from 'react-dom/server';\n// eslint-disable-next-line import/no-unresolved\nimport ShallowRenderer from 'react-test-renderer/shallow';\nimport { version as testRendererVersion } from 'react-test-renderer/package.json';\n// eslint-disable-next-line import/no-unresolved\nimport TestUtils from 'react-dom/test-utils';\nimport semver from 'semver';\nimport checkPropTypes from 'prop-types/checkPropTypes';\nimport has from 'has';\nimport {\n  AsyncMode,\n  ConcurrentMode,\n  ContextConsumer,\n  ContextProvider,\n  Element,\n  ForwardRef,\n  Fragment,\n  isContextConsumer,\n  isContextProvider,\n  isElement,\n  isForwardRef,\n  isPortal,\n  isSuspense,\n  isValidElementType,\n  Lazy,\n  Memo,\n  Portal,\n  Profiler,\n  StrictMode,\n  Suspense,\n} from 'react-is';\nimport { EnzymeAdapter } from 'enzyme';\nimport { typeOfNode } from 'enzyme/build/Utils';\nimport shallowEqual from 'enzyme-shallow-equal';\nimport {\n  displayNameOfNode,\n  elementToTree as utilElementToTree,\n  nodeTypeFromType as utilNodeTypeFromType,\n  mapNativeEventNames,\n  propFromEvent,\n  assertDomAvailable,\n  withSetStateAllowed,\n  createRenderWrapper,\n  createMountWrapper,\n  propsWithKeysAndRef,\n  ensureKeyOrUndefined,\n  simulateError,\n  wrap,\n  getMaskedContext,\n  getComponentStack,\n  RootFinder,\n  getNodeFromRootFinder,\n  wrapWithWrappingComponent,\n  getWrappingComponentMountRenderer,\n  compareNodeTypeOf,\n} from 'enzyme-adapter-utils';\nimport findCurrentFiberUsingSlowPath from './findCurrentFiberUsingSlowPath';\nimport detectFiberTags from './detectFiberTags';\n\nconst is164 = !!TestUtils.Simulate.touchStart; // 16.4+\nconst is165 = !!TestUtils.Simulate.auxClick; // 16.5+\nconst is166 = is165 && !React.unstable_AsyncMode; // 16.6+\nconst is168 = is166 && typeof TestUtils.act === 'function';\n\nconst hasShouldComponentUpdateBug = semver.satisfies(testRendererVersion, '< 16.8');\n\n// Lazily populated if DOM is available.\nlet FiberTags = null;\n\nfunction nodeAndSiblingsArray(nodeWithSibling) {\n  const array = [];\n  let node = nodeWithSibling;\n  while (node != null) {\n    array.push(node);\n    node = node.sibling;\n  }\n  return array;\n}\n\nfunction flatten(arr) {\n  const result = [];\n  const stack = [{ i: 0, array: arr }];\n  while (stack.length) {\n    const n = stack.pop();\n    while (n.i < n.array.length) {\n      const el = n.array[n.i];\n      n.i += 1;\n      if (Array.isArray(el)) {\n        stack.push(n);\n        stack.push({ i: 0, array: el });\n        break;\n      }\n      result.push(el);\n    }\n  }\n  return result;\n}\n\nfunction nodeTypeFromType(type) {\n  if (type === Portal) {\n    return 'portal';\n  }\n\n  return utilNodeTypeFromType(type);\n}\n\nfunction isMemo(type) {\n  return compareNodeTypeOf(type, Memo);\n}\n\nfunction isLazy(type) {\n  return compareNodeTypeOf(type, Lazy);\n}\n\nfunction unmemoType(type) {\n  return isMemo(type) ? type.type : type;\n}\n\nfunction elementToTree(el) {\n  if (!isPortal(el)) {\n    return utilElementToTree(el, elementToTree);\n  }\n\n  const { children, containerInfo } = el;\n  const props = { children, containerInfo };\n\n  return {\n    nodeType: 'portal',\n    type: Portal,\n    props,\n    key: ensureKeyOrUndefined(el.key),\n    ref: el.ref || null,\n    instance: null,\n    rendered: elementToTree(el.children),\n  };\n}\n\nfunction toTree(vnode) {\n  if (vnode == null) {\n    return null;\n  }\n  // TODO(lmr): I'm not really sure I understand whether or not this is what\n  // i should be doing, or if this is a hack for something i'm doing wrong\n  // somewhere else. Should talk to sebastian about this perhaps\n  const node = findCurrentFiberUsingSlowPath(vnode);\n  switch (node.tag) {\n    case FiberTags.HostRoot:\n      return childrenToTree(node.child);\n    case FiberTags.HostPortal: {\n      const {\n        stateNode: { containerInfo },\n        memoizedProps: children,\n      } = node;\n      const props = { containerInfo, children };\n      return {\n        nodeType: 'portal',\n        type: Portal,\n        props,\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: null,\n        rendered: childrenToTree(node.child),\n      };\n    }\n    case FiberTags.ClassComponent:\n      return {\n        nodeType: 'class',\n        type: node.type,\n        props: { ...node.memoizedProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: node.stateNode,\n        rendered: childrenToTree(node.child),\n      };\n    case FiberTags.FunctionalComponent:\n      return {\n        nodeType: 'function',\n        type: node.type,\n        props: { ...node.memoizedProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: null,\n        rendered: childrenToTree(node.child),\n      };\n    case FiberTags.MemoClass:\n      return {\n        nodeType: 'class',\n        type: node.elementType.type,\n        props: { ...node.memoizedProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: node.stateNode,\n        rendered: childrenToTree(node.child.child),\n      };\n    case FiberTags.MemoSFC: {\n      let renderedNodes = flatten(nodeAndSiblingsArray(node.child).map(toTree));\n      if (renderedNodes.length === 0) {\n        renderedNodes = [node.memoizedProps.children];\n      }\n      return {\n        nodeType: 'function',\n        type: node.elementType,\n        props: { ...node.memoizedProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: null,\n        rendered: renderedNodes,\n      };\n    }\n    case FiberTags.HostComponent: {\n      let renderedNodes = flatten(nodeAndSiblingsArray(node.child).map(toTree));\n      if (renderedNodes.length === 0) {\n        renderedNodes = [node.memoizedProps.children];\n      }\n      return {\n        nodeType: 'host',\n        type: node.type,\n        props: { ...node.memoizedProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: node.stateNode,\n        rendered: renderedNodes,\n      };\n    }\n    case FiberTags.HostText:\n      return node.memoizedProps;\n    case FiberTags.Fragment:\n    case FiberTags.Mode:\n    case FiberTags.ContextProvider:\n    case FiberTags.ContextConsumer:\n      return childrenToTree(node.child);\n    case FiberTags.Profiler:\n    case FiberTags.ForwardRef: {\n      return {\n        nodeType: 'function',\n        type: node.type,\n        props: { ...node.pendingProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: null,\n        rendered: childrenToTree(node.child),\n      };\n    }\n    case FiberTags.Suspense: {\n      return {\n        nodeType: 'function',\n        type: Suspense,\n        props: { ...node.memoizedProps },\n        key: ensureKeyOrUndefined(node.key),\n        ref: node.ref,\n        instance: null,\n        rendered: childrenToTree(node.child),\n      };\n    }\n    case FiberTags.Lazy:\n      return childrenToTree(node.child);\n    default:\n      throw new Error(`Enzyme Internal Error: unknown node with tag ${node.tag}`);\n  }\n}\n\nfunction childrenToTree(node) {\n  if (!node) {\n    return null;\n  }\n  const children = nodeAndSiblingsArray(node);\n  if (children.length === 0) {\n    return null;\n  }\n  if (children.length === 1) {\n    return toTree(children[0]);\n  }\n  return flatten(children.map(toTree));\n}\n\nfunction nodeToHostNode(_node) {\n  // NOTE(lmr): node could be a function component\n  // which wont have an instance prop, but we can get the\n  // host node associated with its return value at that point.\n  // Although this breaks down if the return value is an array,\n  // as is possible with React 16.\n  let node = _node;\n  while (node && !Array.isArray(node) && node.instance === null) {\n    node = node.rendered;\n  }\n  // if the SFC returned null effectively, there is no host node.\n  if (!node) {\n    return null;\n  }\n\n  const mapper = (item) => {\n    if (item && item.instance) return ReactDOM.findDOMNode(item.instance);\n    return null;\n  };\n  if (Array.isArray(node)) {\n    return node.map(mapper);\n  }\n  if (Array.isArray(node.rendered) && node.nodeType === 'class') {\n    return node.rendered.map(mapper);\n  }\n  return mapper(node);\n}\n\nfunction replaceLazyWithFallback(node, fallback) {\n  if (!node) {\n    return null;\n  }\n  if (Array.isArray(node)) {\n    return node.map((el) => replaceLazyWithFallback(el, fallback));\n  }\n  if (isLazy(node.type)) {\n    return fallback;\n  }\n  return {\n    ...node,\n    props: {\n      ...node.props,\n      children: replaceLazyWithFallback(node.props.children, fallback),\n    },\n  };\n}\n\nconst eventOptions = {\n  animation: true,\n  pointerEvents: is164,\n  auxClick: is165,\n};\n\nfunction getEmptyStateValue() {\n  // this handles a bug in React 16.0 - 16.2\n  // see https://github.com/facebook/react/commit/39be83565c65f9c522150e52375167568a2a1459\n  // also see https://github.com/facebook/react/pull/11965\n\n  // eslint-disable-next-line react/prefer-stateless-function\n  class EmptyState extends React.Component {\n    render() {\n      return null;\n    }\n  }\n  const testRenderer = new ShallowRenderer();\n  testRenderer.render(React.createElement(EmptyState));\n  return testRenderer._instance.state;\n}\n\nfunction wrapAct(fn) {\n  if (!is168) {\n    return fn();\n  }\n  let returnVal;\n  TestUtils.act(() => { returnVal = fn(); });\n  return returnVal;\n}\n\nfunction getProviderDefaultValue(Provider) {\n  // React stores references to the Provider's defaultValue differently across versions.\n  if ('_defaultValue' in Provider._context) {\n    return Provider._context._defaultValue;\n  }\n  if ('_currentValue' in Provider._context) {\n    return Provider._context._currentValue;\n  }\n  throw new Error('Enzyme Internal Error: can’t figure out how to get Provider’s default value');\n}\n\nfunction makeFakeElement(type) {\n  return { $$typeof: Element, type };\n}\n\nfunction isStateful(Component) {\n  return Component.prototype && (\n    Component.prototype.isReactComponent\n    || Array.isArray(Component.__reactAutoBindPairs) // fallback for createClass components\n  );\n}\n\nclass ReactSixteenAdapter extends EnzymeAdapter {\n  constructor() {\n    super();\n    const { lifecycles } = this.options;\n    this.options = {\n      ...this.options,\n      enableComponentDidUpdateOnSetState: true, // TODO: remove, semver-major\n      legacyContextMode: 'parent',\n      lifecycles: {\n        ...lifecycles,\n        componentDidUpdate: {\n          onSetState: true,\n        },\n        getDerivedStateFromProps: {\n          hasShouldComponentUpdateBug,\n        },\n        getSnapshotBeforeUpdate: true,\n        setState: {\n          skipsComponentDidUpdateOnNullish: true,\n        },\n        getChildContext: {\n          calledByRenderer: false,\n        },\n        getDerivedStateFromError: is166,\n      },\n    };\n  }\n\n  createMountRenderer(options) {\n    assertDomAvailable('mount');\n    if (has(options, 'suspenseFallback')) {\n      throw new TypeError('`suspenseFallback` is not supported by the `mount` renderer');\n    }\n    if (FiberTags === null) {\n      // Requires DOM.\n      FiberTags = detectFiberTags();\n    }\n    const { attachTo, hydrateIn, wrappingComponentProps } = options;\n    const domNode = hydrateIn || attachTo || global.document.createElement('div');\n    let instance = null;\n    const adapter = this;\n    return {\n      render(el, context, callback) {\n        return wrapAct(() => {\n          if (instance === null) {\n            const { type, props, ref } = el;\n            const wrapperProps = {\n              Component: type,\n              props,\n              wrappingComponentProps,\n              context,\n              ...(ref && { refProp: ref }),\n            };\n            const ReactWrapperComponent = createMountWrapper(el, { ...options, adapter });\n            const wrappedEl = React.createElement(ReactWrapperComponent, wrapperProps);\n            instance = hydrateIn\n              ? ReactDOM.hydrate(wrappedEl, domNode)\n              : ReactDOM.render(wrappedEl, domNode);\n            if (typeof callback === 'function') {\n              callback();\n            }\n          } else {\n            instance.setChildProps(el.props, context, callback);\n          }\n        });\n      },\n      unmount() {\n        ReactDOM.unmountComponentAtNode(domNode);\n        instance = null;\n      },\n      getNode() {\n        if (!instance) {\n          return null;\n        }\n        return getNodeFromRootFinder(\n          adapter.isCustomComponent,\n          toTree(instance._reactInternalFiber),\n          options,\n        );\n      },\n      simulateError(nodeHierarchy, rootNode, error) {\n        const isErrorBoundary = ({ instance: elInstance, type }) => {\n          if (is166 && type && type.getDerivedStateFromError) {\n            return true;\n          }\n          return elInstance && elInstance.componentDidCatch;\n        };\n\n        const {\n          instance: catchingInstance,\n          type: catchingType,\n        } = nodeHierarchy.find(isErrorBoundary) || {};\n\n        simulateError(\n          error,\n          catchingInstance,\n          rootNode,\n          nodeHierarchy,\n          nodeTypeFromType,\n          adapter.displayNameOfNode,\n          is166 ? catchingType : undefined,\n        );\n      },\n      simulateEvent(node, event, mock) {\n        const mappedEvent = mapNativeEventNames(event, eventOptions);\n        const eventFn = TestUtils.Simulate[mappedEvent];\n        if (!eventFn) {\n          throw new TypeError(`ReactWrapper::simulate() event '${event}' does not exist`);\n        }\n        wrapAct(() => {\n          eventFn(adapter.nodeToHostNode(node), mock);\n        });\n      },\n      batchedUpdates(fn) {\n        return fn();\n        // return ReactDOM.unstable_batchedUpdates(fn);\n      },\n      getWrappingComponentRenderer() {\n        return {\n          ...this,\n          ...getWrappingComponentMountRenderer({\n            toTree: (inst) => toTree(inst._reactInternalFiber),\n            getMountWrapperInstance: () => instance,\n          }),\n        };\n      },\n      ...(is168 && { wrapInvoke: wrapAct }),\n    };\n  }\n\n  createShallowRenderer(options = {}) {\n    const adapter = this;\n    const renderer = new ShallowRenderer();\n    const { suspenseFallback } = options;\n    if (typeof suspenseFallback !== 'undefined' && typeof suspenseFallback !== 'boolean') {\n      throw TypeError('`options.suspenseFallback` should be boolean or undefined');\n    }\n    let isDOM = false;\n    let cachedNode = null;\n\n    let lastComponent = null;\n    let wrappedComponent = null;\n    const sentinel = {};\n\n    // wrap memo components with a PureComponent, or a class component with sCU\n    const wrapPureComponent = (Component, compare) => {\n      if (!is166) {\n        throw new RangeError('this function should not be called in React < 16.6. Please report this!');\n      }\n      if (lastComponent !== Component) {\n        if (isStateful(Component)) {\n          wrappedComponent = class extends Component {}; // eslint-disable-line react/prefer-stateless-function\n          if (compare) {\n            wrappedComponent.prototype.shouldComponentUpdate = (nextProps) => !compare(this.props, nextProps);\n          } else {\n            wrappedComponent.prototype.isPureReactComponent = true;\n          }\n        } else {\n          let memoized = sentinel;\n          let prevProps;\n          wrappedComponent = function (props, ...args) {\n            const shouldUpdate = memoized === sentinel || (compare\n              ? !compare(prevProps, props)\n              : !shallowEqual(prevProps, props)\n            );\n            if (shouldUpdate) {\n              memoized = Component({ ...Component.defaultProps, ...props }, ...args);\n              prevProps = props;\n            }\n            return memoized;\n          };\n        }\n        Object.assign(\n          wrappedComponent,\n          Component,\n          { displayName: adapter.displayNameOfNode({ type: Component }) },\n        );\n        lastComponent = Component;\n      }\n      return wrappedComponent;\n    };\n\n    // Wrap functional components on versions prior to 16.5,\n    // to avoid inadvertently pass a `this` instance to it.\n    const wrapFunctionalComponent = (Component) => {\n      if (is166 && has(Component, 'defaultProps')) {\n        if (lastComponent !== Component) {\n          wrappedComponent = Object.assign(\n            // eslint-disable-next-line new-cap\n            (props, ...args) => Component({ ...Component.defaultProps, ...props }, ...args),\n            Component,\n            { displayName: adapter.displayNameOfNode({ type: Component }) },\n          );\n          lastComponent = Component;\n        }\n        return wrappedComponent;\n      }\n      if (is165) {\n        return Component;\n      }\n\n      if (lastComponent !== Component) {\n        wrappedComponent = Object.assign(\n          (...args) => Component(...args), // eslint-disable-line new-cap\n          Component,\n        );\n        lastComponent = Component;\n      }\n      return wrappedComponent;\n    };\n\n    return {\n      render(el, unmaskedContext, {\n        providerValues = new Map(),\n      } = {}) {\n        cachedNode = el;\n        /* eslint consistent-return: 0 */\n        if (typeof el.type === 'string') {\n          isDOM = true;\n        } else if (isContextProvider(el)) {\n          providerValues.set(el.type, el.props.value);\n          const MockProvider = Object.assign(\n            (props) => props.children,\n            el.type,\n          );\n          return withSetStateAllowed(() => renderer.render({ ...el, type: MockProvider }));\n        } else if (isContextConsumer(el)) {\n          const Provider = adapter.getProviderFromConsumer(el.type);\n          const value = providerValues.has(Provider)\n            ? providerValues.get(Provider)\n            : getProviderDefaultValue(Provider);\n          const MockConsumer = Object.assign(\n            (props) => props.children(value),\n            el.type,\n          );\n          return withSetStateAllowed(() => renderer.render({ ...el, type: MockConsumer }));\n        } else {\n          isDOM = false;\n          let renderedEl = el;\n          if (isLazy(renderedEl)) {\n            throw TypeError('`React.lazy` is not supported by shallow rendering.');\n          }\n          if (isSuspense(renderedEl)) {\n            let { children } = renderedEl.props;\n            if (suspenseFallback) {\n              const { fallback } = renderedEl.props;\n              children = replaceLazyWithFallback(children, fallback);\n            }\n            const FakeSuspenseWrapper = () => children;\n            renderedEl = React.createElement(FakeSuspenseWrapper, null, children);\n          }\n          const { type: Component } = renderedEl;\n\n          const context = getMaskedContext(Component.contextTypes, unmaskedContext);\n\n          if (isMemo(el.type)) {\n            const { type: InnerComp, compare } = el.type;\n\n            return withSetStateAllowed(() => renderer.render(\n              { ...el, type: wrapPureComponent(InnerComp, compare) },\n              context,\n            ));\n          }\n\n          if (!isStateful(Component) && typeof Component === 'function') {\n            return withSetStateAllowed(() => renderer.render(\n              { ...renderedEl, type: wrapFunctionalComponent(Component) },\n              context,\n            ));\n          }\n\n          if (isStateful) {\n            // fix react bug; see implementation of `getEmptyStateValue`\n            const emptyStateValue = getEmptyStateValue();\n            if (emptyStateValue) {\n              Object.defineProperty(Component.prototype, 'state', {\n                configurable: true,\n                enumerable: true,\n                get() {\n                  return null;\n                },\n                set(value) {\n                  if (value !== emptyStateValue) {\n                    Object.defineProperty(this, 'state', {\n                      configurable: true,\n                      enumerable: true,\n                      value,\n                      writable: true,\n                    });\n                  }\n                  return true;\n                },\n              });\n            }\n          }\n          return withSetStateAllowed(() => renderer.render(renderedEl, context));\n        }\n      },\n      unmount() {\n        renderer.unmount();\n      },\n      getNode() {\n        if (isDOM) {\n          return elementToTree(cachedNode);\n        }\n        const output = renderer.getRenderOutput();\n        return {\n          nodeType: nodeTypeFromType(cachedNode.type),\n          type: cachedNode.type,\n          props: cachedNode.props,\n          key: ensureKeyOrUndefined(cachedNode.key),\n          ref: cachedNode.ref,\n          instance: renderer._instance,\n          rendered: Array.isArray(output)\n            ? flatten(output).map((el) => elementToTree(el))\n            : elementToTree(output),\n        };\n      },\n      simulateError(nodeHierarchy, rootNode, error) {\n        simulateError(\n          error,\n          renderer._instance,\n          cachedNode,\n          nodeHierarchy.concat(cachedNode),\n          nodeTypeFromType,\n          adapter.displayNameOfNode,\n          is166 ? cachedNode.type : undefined,\n        );\n      },\n      simulateEvent(node, event, ...args) {\n        const handler = node.props[propFromEvent(event, eventOptions)];\n        if (handler) {\n          withSetStateAllowed(() => {\n            // TODO(lmr): create/use synthetic events\n            // TODO(lmr): emulate React's event propagation\n            // ReactDOM.unstable_batchedUpdates(() => {\n            handler(...args);\n            // });\n          });\n        }\n      },\n      batchedUpdates(fn) {\n        return fn();\n        // return ReactDOM.unstable_batchedUpdates(fn);\n      },\n      checkPropTypes(typeSpecs, values, location, hierarchy) {\n        return checkPropTypes(\n          typeSpecs,\n          values,\n          location,\n          displayNameOfNode(cachedNode),\n          () => getComponentStack(hierarchy.concat([cachedNode])),\n        );\n      },\n    };\n  }\n\n  createStringRenderer(options) {\n    if (has(options, 'suspenseFallback')) {\n      throw new TypeError('`suspenseFallback` should not be specified in options of string renderer');\n    }\n    return {\n      render(el, context) {\n        if (options.context && (el.type.contextTypes || options.childContextTypes)) {\n          const childContextTypes = {\n            ...(el.type.contextTypes || {}),\n            ...options.childContextTypes,\n          };\n          const ContextWrapper = createRenderWrapper(el, context, childContextTypes);\n          return ReactDOMServer.renderToStaticMarkup(React.createElement(ContextWrapper));\n        }\n        return ReactDOMServer.renderToStaticMarkup(el);\n      },\n    };\n  }\n\n  // Provided a bag of options, return an `EnzymeRenderer`. Some options can be implementation\n  // specific, like `attach` etc. for React, but not part of this interface explicitly.\n  // eslint-disable-next-line class-methods-use-this\n  createRenderer(options) {\n    switch (options.mode) {\n      case EnzymeAdapter.MODES.MOUNT: return this.createMountRenderer(options);\n      case EnzymeAdapter.MODES.SHALLOW: return this.createShallowRenderer(options);\n      case EnzymeAdapter.MODES.STRING: return this.createStringRenderer(options);\n      default:\n        throw new Error(`Enzyme Internal Error: Unrecognized mode: ${options.mode}`);\n    }\n  }\n\n  wrap(element) {\n    return wrap(element);\n  }\n\n  // converts an RSTNode to the corresponding JSX Pragma Element. This will be needed\n  // in order to implement the `Wrapper.mount()` and `Wrapper.shallow()` methods, but should\n  // be pretty straightforward for people to implement.\n  // eslint-disable-next-line class-methods-use-this\n  nodeToElement(node) {\n    if (!node || typeof node !== 'object') return null;\n    const { type } = node;\n    return React.createElement(unmemoType(type), propsWithKeysAndRef(node));\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  matchesElementType(node, matchingType) {\n    if (!node) {\n      return node;\n    }\n    const { type } = node;\n    return unmemoType(type) === unmemoType(matchingType);\n  }\n\n  elementToNode(element) {\n    return elementToTree(element);\n  }\n\n  nodeToHostNode(node, supportsArray = false) {\n    const nodes = nodeToHostNode(node);\n    if (Array.isArray(nodes) && !supportsArray) {\n      return nodes[0];\n    }\n    return nodes;\n  }\n\n  displayNameOfNode(node) {\n    if (!node) return null;\n    const { type, $$typeof } = node;\n\n    const nodeType = type || $$typeof;\n\n    // newer node types may be undefined, so only test if the nodeType exists\n    if (nodeType) {\n      switch (nodeType) {\n        case (is166 ? ConcurrentMode : AsyncMode) || NaN: return is166 ? 'ConcurrentMode' : 'AsyncMode';\n        case Fragment || NaN: return 'Fragment';\n        case StrictMode || NaN: return 'StrictMode';\n        case Profiler || NaN: return 'Profiler';\n        case Portal || NaN: return 'Portal';\n        case Suspense || NaN: return 'Suspense';\n        default:\n      }\n    }\n\n    const $$typeofType = type && type.$$typeof;\n\n    switch ($$typeofType) {\n      case ContextConsumer || NaN: return 'ContextConsumer';\n      case ContextProvider || NaN: return 'ContextProvider';\n      case Memo || NaN: {\n        const nodeName = displayNameOfNode(node);\n        return typeof nodeName === 'string' ? nodeName : `Memo(${displayNameOfNode(type)})`;\n      }\n      case ForwardRef || NaN: {\n        if (type.displayName) {\n          return type.displayName;\n        }\n        const name = displayNameOfNode({ type: type.render });\n        return name ? `ForwardRef(${name})` : 'ForwardRef';\n      }\n      case Lazy || NaN: {\n        return 'lazy';\n      }\n      default: return displayNameOfNode(node);\n    }\n  }\n\n  isValidElement(element) {\n    return isElement(element);\n  }\n\n  isValidElementType(object) {\n    return !!object && isValidElementType(object);\n  }\n\n  isFragment(fragment) {\n    return typeOfNode(fragment) === Fragment;\n  }\n\n  isCustomComponent(type) {\n    const fakeElement = makeFakeElement(type);\n    return !!type && (\n      typeof type === 'function'\n      || isForwardRef(fakeElement)\n      || isContextProvider(fakeElement)\n      || isContextConsumer(fakeElement)\n      || isSuspense(fakeElement)\n    );\n  }\n\n  isContextConsumer(type) {\n    return !!type && isContextConsumer(makeFakeElement(type));\n  }\n\n  isCustomComponentElement(inst) {\n    if (!inst || !this.isValidElement(inst)) {\n      return false;\n    }\n    return this.isCustomComponent(inst.type);\n  }\n\n  getProviderFromConsumer(Consumer) {\n    // React stores references to the Provider on a Consumer differently across versions.\n    if (Consumer) {\n      let Provider;\n      if (Consumer._context) { // check this first, to avoid a deprecation warning\n        ({ Provider } = Consumer._context);\n      } else if (Consumer.Provider) {\n        ({ Provider } = Consumer);\n      }\n      if (Provider) {\n        return Provider;\n      }\n    }\n    throw new Error('Enzyme Internal Error: can’t figure out how to get Provider from Consumer');\n  }\n\n  createElement(...args) {\n    return React.createElement(...args);\n  }\n\n  wrapWithWrappingComponent(node, options) {\n    return {\n      RootFinder,\n      node: wrapWithWrappingComponent(React.createElement, node, options),\n    };\n  }\n}\n\nmodule.exports = ReactSixteenAdapter;\n"]}