export function jsxWithValidation()

in packages/react/src/ReactElementValidator.js [284:418]

• 114 lines of code
• 27 McCabe index (conditional complexity)

export function jsxWithValidation(
  type,
  props,
  key,
  isStaticChildren,
  source,
  self,
) {
  if (__DEV__) {
    const validType = isValidElementType(type);

    // We warn in this case but don't throw. We expect the element creation to
    // succeed and there will likely be errors in render.
    if (!validType) {
      let info = '';
      if (
        type === undefined ||
        (typeof type === 'object' &&
          type !== null &&
          Object.keys(type).length === 0)
      ) {
        info +=
          ' You likely forgot to export your component from the file ' +
          "it's defined in, or you might have mixed up default and named imports.";
      }

      const sourceInfo = getSourceInfoErrorAddendum(source);
      if (sourceInfo) {
        info += sourceInfo;
      } else {
        info += getDeclarationErrorAddendum();
      }

      let typeString;
      if (type === null) {
        typeString = 'null';
      } else if (isArray(type)) {
        typeString = 'array';
      } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
        typeString = `<${getComponentNameFromType(type.type) || 'Unknown'} />`;
        info =
          ' Did you accidentally export a JSX literal instead of a component?';
      } else {
        typeString = typeof type;
      }

      if (__DEV__) {
        console.error(
          'React.jsx: type is invalid -- expected a string (for ' +
            'built-in components) or a class/function (for composite ' +
            'components) but got: %s.%s',
          typeString,
          info,
        );
      }
    }

    const element = jsxDEV(type, props, key, source, self);

    // The result can be nullish if a mock or a custom function is used.
    // TODO: Drop this when these are no longer allowed as the type argument.
    if (element == null) {
      return element;
    }

    // Skip key warning if the type isn't valid since our key validation logic
    // doesn't expect a non-string/function type and can throw confusing errors.
    // We don't want exception behavior to differ between dev and prod.
    // (Rendering will throw with a helpful message and as soon as the type is
    // fixed, the key warnings will appear.)

    if (validType) {
      const children = props.children;
      if (children !== undefined) {
        if (isStaticChildren) {
          if (isArray(children)) {
            for (let i = 0; i < children.length; i++) {
              validateChildKeys(children[i], type);
            }

            if (Object.freeze) {
              Object.freeze(children);
            }
          } else {
            if (__DEV__) {
              console.error(
                'React.jsx: Static children should always be an array. ' +
                  'You are likely explicitly calling React.jsxs or React.jsxDEV. ' +
                  'Use the Babel transform instead.',
              );
            }
          }
        } else {
          validateChildKeys(children, type);
        }
      }
    }

    if (warnAboutSpreadingKeyToJSX) {
      if (hasOwnProperty.call(props, 'key')) {
        const componentName = getComponentNameFromType(type);
        const keys = Object.keys(props).filter(k => k !== 'key');
        const beforeExample =
          keys.length > 0
            ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}'
            : '{key: someKey}';
        if (!didWarnAboutKeySpread[componentName + beforeExample]) {
          const afterExample =
            keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}';
          console.error(
            'A props object containing a "key" prop is being spread into JSX:\n' +
              '  let props = %s;\n' +
              '  <%s {...props} />\n' +
              'React keys must be passed directly to JSX without using spread:\n' +
              '  let props = %s;\n' +
              '  <%s key={someKey} {...props} />',
            beforeExample,
            componentName,
            afterExample,
            componentName,
          );
          didWarnAboutKeySpread[componentName + beforeExample] = true;
        }
      }
    }

    if (type === REACT_FRAGMENT_TYPE) {
      validateFragmentProps(element);
    } else {
      validatePropTypes(element);
    }

    return element;
  }
}