31
votes

I'm building a React Component for rendering an HTML form and I'm finding the need to recursively iterate through all children of my parent Form component in order to add extra props to only children components of a certain Type.

An example (in JSX):

<Form>
    <p>Personal Information</p>
    <Input name="first_name" />
    <Input name="last_name" />
    <Input name="email" />
    <Label>
        Enter Your Birthday
        <Input name="birthday" type="date" />
    </Label>
</Form>

In this example, I'm using React.Children.map inside my Form component, and then inside the map function I'm checking the child's "type" and the child's "type.displayName" to determine what element I'm dealing with (either a native HTML element or a ReactElement):

var newChildren = React.Children.map(this.props.children, function(child) {
    if (is.inArray(child.type.displayName, supportedInputTypes)) {
      var extraChildProps = {
        alertColor: this.props.alertColor,
        displayErrors: this.state.displayErrors
      }
      return React.cloneElement(child, extraChildProps);
    } else {
      return child;
    }
  }.bind(this));

My problem is that React.Children.map only shallowly iterates through this.props.children, and I would like it to also check children of children of children, etc. I need to add props to only my Input components so that they know when to display errors, and which color the error message should be displayed, etc. In the example above, the birthday input does not receive the necessary props, because it is wrapped in a Label component.

Any plan for React.Children.map to have a "recursive" mode or any other utility out there that can accomplish what I'm trying to do?

At the end of the day, I would like to write a single function that maps through each and every child (even nested ones) in order to perform an operation on it (in this case cloning).

5
I figured out a way to work around the specific problem I was trying to solve, so I no longer need to implement this specific recursive iteration feature, but it would be really cool to hear of potential ways to solve this problem from others who may have encountered this need. - eriklharper
This is the kind of problem you solve by avoiding the problem. Using React.Children.map at all is a red flag that you're doing something complicated and confusing. - Brigand
Agreed. I see that using higher-order components and/or mixins (temporarily) and/or something like a global flux store is the way to prevent having to use this method. In my specific use case it was the Formsy.Mixin that came to my rescue as I was able to determine when to "displayErrors" simply by calling the Formsy mixin function isFormSubmitted() which solved my problem without having to clone children with extra props. - eriklharper
@FakeRainBrigand if you want to always write a bunch of boilerplate code to inject value, onChange, and validation props to your form controls, by all means do it. But one day I got tired of doing that, figured out how to inject them all using recursive cloning, turned it into a library (github.com/jedwards1211/react-bind-data), created another library to get rid of all the redux boilerplate (github.com/jedwards1211/react-bind-data-redux), and sped up my development time dramatically. Recursive cloning is really the only way to do this right now. - Andy

5 Answers

41
votes

While not baked into React, this is certainly possible:

import React from "react";

function recursiveMap(children, fn) {
  return React.Children.map(children, child => {
    if (!React.isValidElement(child)) {
      return child;
    }

    if (child.props.children) {
      child = React.cloneElement(child, {
        children: recursiveMap(child.props.children, fn)
      });
    }

    return fn(child);
  });
}

If you'd like to avoid copy / pasting the above you can also use this npm package I authored.

8
votes

I've made a small library to deal with the Children structure. You can check it here:

https://github.com/fernandopasik/react-children-utilities

In your case you can use the method deepMap:

import React from 'react';
import Children from 'react-children-utilities';

var newChildren = Children.deepMap(this.props.children, function(child) {
    if (is.inArray(child.type.displayName, supportedInputTypes)) {
      var extraChildProps = {
        alertColor: this.props.alertColor,
        displayErrors: this.state.displayErrors
      }
      return React.cloneElement(child, extraChildProps);
    } else {
      return child;
    }
}.bind(this));
4
votes

This thread actually misses the right answer:

const mapRecursive = (children, callback) => (
  React.Children.map(
    children,
    child => (
      child.props.children
        ? [callback(child), mapRecursive(child.props.children, callback)]
        : callback(child)
    ),
  )
);
3
votes

If you're looking to push props into a set of children under your component "automatically", you can also use context. This allows you to "give" properties, functions, etc. to child components by providing them from the parent with childContextTypes and getChildContext(), and having the child "request" them with contextTypes.

1
votes

Short answer to this is that its not currently possible as of React 0.14. As FakeRainBrigand mentioned, its more than likely a code smell anyway, so it should prompt a reevaluation of your implementation.