recma-mdx-import-react

This package is a unified (recma) plugin that ensures getting React from argument[0] and inject it as property into the imported components in the compiled source.

unified is a project that transforms content with abstract syntax trees (ASTs) using the new parser micromark. recma adds support for producing a javascript code by transforming esast which stands for Ecma Script Abstract Syntax Tree (AST) that is used in production of compiled source for the MDX.

When should I use this?

If you are using MDX, and want to import a React component dynamically into MDX, you should use recma-mdx-import-react, otherwise imported component throws an error React/jsx/jsxs is null. The recma-mdx-import-react ensures the runtime props {React, jsx, jsxs, jsxDev, Fragment} is available in the imported React components (as runtimeProps). You can set the options to define which runtime prop is going to be available.

It is a fix for the issues

The tool you use should insert React instance into function construction arguments to get it in the compiled source !

next-mdx-remote-client provides the React instance available in the compiled source.
next-mdx-remote doesn't provide the React instance; and it doesn't support import either.
@mdx-js/mdx doesn't provide the React instance yet in the runtime options.

Installation

This package is suitable for ESM only. In Node.js (version 18+), install with npm:

npm install recma-mdx-import-react

yarn add recma-mdx-import-react

Usage

Say we have the following file, example.mdx,

import Test from "./context/Test.mjs"

Hello world !

<Test source={source} />

And our module, example.js, looks as follows:

import { read } from "to-vfile";
import { compile } from "@mdx-js/mdx";
import recmaMdxImportReact from "recma-mdx-import-react";

main();

async function main() {
  const source = await read("example.mdx");

  const compiledSource = await compile(source, {
    recmaPlugins: [recmaMdxImportReact],
  });

  return String(compiledSource);
}

Now, running node example.js produces the compiled source like below:

// ...
+ const React = arguments[0].React;
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
// ...
const {default: Test} = await import(_resolveDynamicMdxSpecifier("./context/Test.mjs"));
function _createMdxContent(props) {
  // ...
  return _jsxs(_Fragment, {
    // ...
-   _jsx(Test, { source: source })
+   _jsx(Test, { runtimeProps: { React }, source: source })
    // ...
  })
}

Options

All options are optional and has default values.

export type ImportReactOptions = {
  arguments?: string[]; // default is ["React"]
  runtimeProps?: ("React" | "jsx-runtime" | "jsx-dev-runtime" | [string, string])[]; // default is ["React"]
};

arguments

It is an array option to get arguments from arguments[0] in the compiled source.

The default is ["React"].

use(recmaMdxImportReact, { arguments: ["Preact"] } as ImportReactOptions);

Now the statement will be const Preact = arguments[0].Preact; in the compiled source.

runtimeProps

It is an array of ("React" | "jsx-runtime" | "jsx-dev-runtime" | [string, string]) option to inject runtimeProps into the imported components in the compiled source.

The default is ["React"].

use(recmaMdxImportReact, { runtimeProps: ["React", "jsx-runtime"] } as ImportReactOptions);

Now, React and jsx-runtime as { runtimeProps: { React, jsx: _jsx, jsxs: _jsxs, Fragment }} will be provided to the imported React components in the compiled source.

Syntax tree

This plugin only modifies the ESAST (Ecma Script Abstract Syntax Tree) as explained.

Types

This package is fully typed with TypeScript. The plugin options is exported as ImportReactOptions.

Compatibility

This plugin works with unified version 6+. It is compatible with mdx version 3+.

Security

Use of recma-mdx-import-react does not involve user content so there are no openings for cross-site scripting (XSS) attacks.

My Plugins

I like to contribute the Unified / Remark / MDX ecosystem, so I recommend you to have a look my plugins.

My Remark Plugins

remark-flexible-code-titles – Remark plugin to add titles or/and containers for the code blocks with customizable properties
remark-flexible-containers – Remark plugin to add custom containers with customizable properties in markdown
remark-ins – Remark plugin to add ins element in markdown
remark-flexible-paragraphs – Remark plugin to add custom paragraphs with customizable properties in markdown
remark-flexible-markers – Remark plugin to add custom mark element with customizable properties in markdown
remark-flexible-toc – Remark plugin to expose the table of contents via vfile.data or via an option reference
remark-mdx-remove-esm – Remark plugin to remove import and/or export statements (mdxjsEsm)

My Rehype Plugins

rehype-pre-language – Rehype plugin to add language information as a property to pre element
rehype-highlight-code-lines – Rehype plugin to add line numbers to code blocks and allow highlighting of desired code lines
rehype-code-meta – Rehype plugin to copy code.data.meta to code.properties.metastring

My Recma Plugins

recma-mdx-escape-missing-components – Recma plugin to set the default value () => null for the Components in MDX in case of missing or not provided so as not to throw an error
recma-mdx-change-props – Recma plugin to change the props parameter into the _props in the function _createMdxContent(props) {/* */} in the compiled source in order to be able to use {props.foo} like expressions. It is useful for the next-mdx-remote or next-mdx-remote-client users in nextjs applications.
recma-mdx-change-imports – Recma plugin to convert import declarations for assets and media with relative links into variable declarations with string URLs, enabling direct asset URL resolution in compiled MDX.
recma-mdx-import-media – Recma plugin to turn media relative paths into import declarations for both markdown and html syntax in MDX.
recma-mdx-import-react – Recma plugin to ensure getting React instance from the arguments and to make the runtime props {React, jsx, jsxs, jsxDev, Fragment} is available in the dynamically imported components in the compiled source of MDX.