Issue 1:
Note from maintainers:

We know this is an issue and we know exactly what set of problem can be solved. We want this too but it is a hard problem with our current architecture. Additional comments expressing desire for this feature are not helpful. Feel free to subscribe to the issue (there's button in the right hand column) but do not comment unless you are adding value to the discussion. "Me too" and "+1" are not valuable, nor are use cases that have already been written in the comments (e.g., we know that you can't put <tr> or <dd> elements with a <div>).

Consider the following:

var ManagePost = React.createClass({

render: function() {
var posts = this.props.posts

var something;
var somethingelse;

var row = posts.map(function(post){
return(
<div>
<div className="col-md-8">
</div>
<div className="cold-md-4">
</div>
</div>
)
});

return (
{row}
);
}

});

If you remove the <div></div> in the map, you get the following error: Adjacent XJS elements must be wrapped in an enclosing tag

it isn't till I re-add the surrounding, and rather pointless, divs that it compiles with out issue. I am running 0.11.1

Is this being addressed? It adds extra, and again - IMO - useless and pointless html to the page, that while harming nothing - looks messy and unprofessional. Maybe I am just doing something wrong, please enlighten me if I am.

Issue 2:
I have a setup where log entries are written and stored in markdown plain text. Come time to render these in the browser, they're run through a markdown to HTML converter, and that gets rendered by the browser. In React, despite the fact that the code never works with HTML except at the very last step (edits occur on plain text, saving occurs on plain text, plain text in the props/state, etc) the only way to get this data loaded in is by using the cumbersome dangerouslySetInnerHTML attribute, even though this HTML is not human-generated in any way, and isn't "dynamic" in the traditional sense; it's just the snapshot HTML representation of my text, in the same way that the HTML that React generates is simply a snapshot representation of my component.

var MarkDown = React.createClass({
render: function() {
// completely transient data; It has no meaning outside of the render function
var html = markdown.toHTML(this.props.text);
return <div className="post" dangerouslySetInnerHTML={{__html: html }}</div>;
}
});

Is there something available that doesn't "lie" about what is being done in this scenario, like a way to tell React that there are additional safe processors available, such as:

React.registerContentTransformer("markdown", markdown.toHTML);

var MarkDown = React.createClass({
render: function() {
return <div className="post">{markdown: this.props.text}</div>;
}
});

(or whatever syntax would work that makes it explicit we're not working with human-generated dynamic HTML content, but with rigidly transformed, syntactically-correct-unless-the-transformer-has-bugs output)

edit: to further explain the motivation for this question/request, the dangerouslySetInnerHTML mechanism is great and we definitely need it for user-generated HTML strings. However, there should also be a way to extend the mechanism that exists inside the render function for transforming data that isn't HTML but can be snapshot-serialized to HTML (like React components themselves). An additional API for telling the JSX transformer that there are additional transformers available that can be used exclusively during render() using special curly bracket syntax would be close to ideal.

People would still need to use dangerouslySetInnerHTML for regular HTML string data, but people who have data that isn't HTML at all, merely transiently transformable into HTML form, should not need to say "this HTML is dangerous"; it's only as dangerous as the transformer makes it, putting it on part with the JSX transformer itself (bugs notwithstanding, the resulting HTML should always be well formed and legal)