[idea] Parse fenced code block metastrings as JSX props

[shawnbot]

I originally brought this up in #464 (comment) and again in system-ui/theme-ui#212 (comment), where it was suggested that I open a new issue. Here's the pitch:

Fenced code blocks should be able to specify "first-class" JSX props that get passed down to the MDX tag. Currently, everything after the language identifier is passed along via the metastring prop, which is then passed as key/value strings, so this:

```js live foo=bar
```

...produces a remark code node with properties: {live: true, foo: 'bar'}, which is great! However, the key/value parser doesn't support anything with strings, such as foo="bar baz". When you test this in the MDX playground:

```jsx live foo=1 bar="baz 2"
```

...it produces a node with properties: {live: true, foo: '1', bar": '"baz', '2"': true}, which is clearly not right. Rather than inventing a new parser for this, I think it would be best to just treat the metastring as JSX props and either parse them "properly" (i.e. with Babel) at build time or inline them directly in the resulting JSX during the HAST → JSX compilation phase. For instance, I would expect the above example to compile to:

<MDXTag tag="pre" className="language-jsx" live foo={1} bar="baz 2" />

Or, to prevent breakage of existing components, pass them in via a separate prop:

<MDXTag tag="pre" className="language-jsx"
  meta={{live: true, foo: '1', bar: 'baz 2'}} />

As a proof of concept, I've hacked together remark-fenced-props to show how at least the remark-level transformation of metastring → props could work. It's very much not production-ready or backward compatible with the key/value pair syntax, but it could easily be made so with a replacement like:

metastring.replace(/(\w+)=([^ ]+)/g, (_, key, value) => {
  return isNaN(value) ? `${key}="${value}"` : `${key}={${value}}`
})

Anyway, lmk what you think!

[RichiCoder1]

I just ran into this and assumed (wrongly) that this was how it worked. I'd love to see this and would also be willing to do the above PR.

[wooorm]

👋

Would this need to support expressions? Spread assignment expressions? Such as:

```js {...object} key={<h2>asdasd</h2>}
```

[shawnbot]

Would this need to support expressions? Spread assignment expressions? Such as:

IMO, yes. At the very least, that would mean not having to introduce some new/different syntax from the one you're using in the document already.

[wooorm]

Right, makes sense! Having JSX attributes instead of some other form of attributes too. I am worried that we’re adding another way to do things. Yes, this is nice:

```js live foo={1} bar="baz 2" {...object} key={<h2>asdasd</h2>}
console.log(1)
```

But you can already author as (or am I missing something? Do you need to get the <pre>/<code>?):

<MyCode live foo={1} bar="baz 2" {...object} key={<h2>asdasd</h2>}>

  ```js
  console.log(1)
  ```

</MyCode>

Meta string is a weird and intriguing thing! It’s the “hidden” place in Markdown.

[shawnbot]

@wooorm You're absolutely right: for anything more complicated than 1-2 props, just dropping into JSX makes a ton of sense. I guess I just figured that it would be simpler on the MDX side to inline the metastring as props and just let the JSX parser throw syntax errors, rather than relying on a completely separate key/value parser. 🤷

[wooorm]

rather than relying on a completely separate key/value parser. 🤷

It’s indeed a pretty weird key/value parser: splitting on spaces, then splitting on equals—not supporting quotes. Probably not how people expect it to be parsed.

[KutnerUri]

This is needed.
For example, I am trying to make the same 'live' preview, and I need to pass the scope to the Code component:

import { Button } from 'my-button'
const scope = { Button };

Try out this button!
    ```tsx live scope={scope}
    <Button>click me!</Button>
    ```

This is not possible with today's parser.

[wooorm]

@KutnerUri You can use a component for that now.

<MyComponent language="tsx" live scope={scope}>
   {"<Button>click me!</Button>"}
</MyComponent>