@superinterface/react 3.5.2 → 3.5.4

package/dist/index.js

@@ -912,7 +912,147 @@ import { useState as useState2, useEffect as useEffect2, useMemo as useMemo8 } f
 import { compile } from "@mdx-js/mdx";
 import { MDXProvider, useMDXComponents } from "@mdx-js/react";
 import * as runtime from "react/jsx-runtime";
-import recmaMdxEscapeMissingComponents from "recma-mdx-escape-missing-components";
+// src/lib/recma/recmaFallbackComponentPlugin.ts
+import { visit, CONTINUE, SKIP } from "estree-util-visit";
+var recmaFallbackComponentPlugin = function() {
+    return function(tree) {
+        visit(tree, function(node) {
+            if (node.type === "VariableDeclaration" && node.kind === "const") {
+                var varDecl = node;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = varDecl.declarations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var declarator = _step.value;
+                        var _declarator_init, _declarator_init1;
+                        if (declarator.id.type === "ObjectPattern" && ((_declarator_init = declarator.init) === null || _declarator_init === void 0 ? void 0 : _declarator_init.type) === "Identifier" && declarator.init.name === "_components" || declarator.id.type === "ObjectPattern" && ((_declarator_init1 = declarator.init) === null || _declarator_init1 === void 0 ? void 0 : _declarator_init1.type) === "ObjectExpression") {
+                            varDecl.kind = "let";
+                            return SKIP;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            return CONTINUE;
+        });
+        visit(tree, function(node) {
+            var _node_id;
+            if (node.type === "FunctionDeclaration" && ((_node_id = node.id) === null || _node_id === void 0 ? void 0 : _node_id.type) === "Identifier" && node.id.name === "_missingMdxReference") {
+                var funcNode = node;
+                funcNode.body = {
+                    type: "BlockStatement",
+                    body: [
+                        {
+                            type: "IfStatement",
+                            test: {
+                                type: "Identifier",
+                                name: "component"
+                            },
+                            consequent: {
+                                type: "ReturnStatement",
+                                argument: {
+                                    type: "FunctionExpression",
+                                    id: null,
+                                    params: [
+                                        {
+                                            type: "Identifier",
+                                            name: "props"
+                                        }
+                                    ],
+                                    body: {
+                                        type: "BlockStatement",
+                                        body: [
+                                            {
+                                                type: "ReturnStatement",
+                                                argument: {
+                                                    type: "BinaryExpression",
+                                                    operator: "+",
+                                                    left: {
+                                                        type: "BinaryExpression",
+                                                        operator: "+",
+                                                        left: {
+                                                            type: "Literal",
+                                                            value: "<"
+                                                        },
+                                                        right: {
+                                                            type: "Identifier",
+                                                            name: "id"
+                                                        }
+                                                    },
+                                                    right: {
+                                                        type: "BinaryExpression",
+                                                        operator: "+",
+                                                        left: {
+                                                            type: "Literal",
+                                                            value: "></"
+                                                        },
+                                                        right: {
+                                                            type: "BinaryExpression",
+                                                            operator: "+",
+                                                            left: {
+                                                                type: "Identifier",
+                                                                name: "id"
+                                                            },
+                                                            right: {
+                                                                type: "Literal",
+                                                                value: ">"
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        ]
+                                    },
+                                    generator: false,
+                                    async: false
+                                }
+                            },
+                            alternate: null
+                        }
+                    ]
+                };
+                return SKIP;
+            }
+            return CONTINUE;
+        });
+        visit(tree, function(node) {
+            if (node.type === "IfStatement") {
+                var ifNode = node;
+                if (ifNode.test.type === "UnaryExpression" && ifNode.test.operator === "!" && ifNode.test.argument.type === "Identifier") {
+                    var componentName = ifNode.test.argument.name;
+                    if (ifNode.consequent.type === "ExpressionStatement" && ifNode.consequent.expression.type === "CallExpression" && ifNode.consequent.expression.callee.type === "Identifier" && ifNode.consequent.expression.callee.name === "_missingMdxReference") {
+                        var assignmentExpr = {
+                            type: "AssignmentExpression",
+                            operator: "=",
+                            left: {
+                                type: "Identifier",
+                                name: componentName
+                            },
+                            right: ifNode.consequent.expression
+                        };
+                        ifNode.consequent = {
+                            type: "ExpressionStatement",
+                            expression: assignmentExpr
+                        };
+                        return SKIP;
+                    }
+                }
+            }
+            return CONTINUE;
+        });
+    };
+};
 // src/hooks/markdown/useMarkdownContext/index.ts
 import { useContext as useContext5 } from "react";
 // src/contexts/markdown/MarkdownContext/index.ts
@@ -2789,7 +2929,7 @@ var TextContent = function(param) {
                                     outputFormat: "function-body",
                                     remarkPlugins: remarkPlugins,
                                     recmaPlugins: [
-                                        recmaMdxEscapeMissingComponents
+                                        recmaFallbackComponentPlugin
                                     ],
                                     providerImportSource: "@mdx-js/react"
                                 })