@builder.io/mitosis 0.0.56-97 → 0.0.56

package/dist/src/parsers/jsx/element-parser.js

@@ -0,0 +1,243 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsxElementToJson = void 0;
+var babel = __importStar(require("@babel/core"));
+var generator_1 = __importDefault(require("@babel/generator"));
+var nullable_1 = require("../../helpers/nullable");
+var create_mitosis_node_1 = require("../../helpers/create-mitosis-node");
+var function_1 = require("fp-ts/lib/function");
+var types = babel.types;
+var getForArguments = function (params) {
+    var _a = params
+        .filter(function (param) { return types.isIdentifier(param); })
+        .map(function (param) { return param.name; })
+        .filter(nullable_1.checkIsDefined), forName = _a[0], indexName = _a[1], collectionName = _a[2];
+    return {
+        forName: forName,
+        collectionName: collectionName,
+        indexName: indexName,
+    };
+};
+/**
+ * Parses a JSX element into a MitosisNode.
+ */
+var jsxElementToJson = function (node) {
+    if (types.isJSXText(node)) {
+        return (0, create_mitosis_node_1.createMitosisNode)({
+            properties: {
+                _text: node.value,
+            },
+        });
+    }
+    if (types.isJSXExpressionContainer(node)) {
+        if (types.isJSXEmptyExpression(node.expression)) {
+            return null;
+        }
+        // foo.map -> <For each={foo}>...</For>
+        if (types.isCallExpression(node.expression) ||
+            types.isOptionalCallExpression(node.expression)) {
+            var callback = node.expression.arguments[0];
+            if (types.isArrowFunctionExpression(callback)) {
+                if (types.isIdentifier(callback.params[0])) {
+                    var forArguments = getForArguments(callback.params);
+                    return (0, create_mitosis_node_1.createMitosisNode)({
+                        name: 'For',
+                        bindings: {
+                            each: {
+                                code: (0, generator_1.default)(node.expression.callee)
+                                    .code // Remove .map or potentially ?.map
+                                    .replace(/\??\.map$/, ''),
+                            },
+                        },
+                        scope: forArguments,
+                        children: [(0, exports.jsxElementToJson)(callback.body)],
+                    });
+                }
+            }
+        }
+        // {foo && <div />} -> <Show when={foo}>...</Show>
+        if (types.isLogicalExpression(node.expression)) {
+            if (node.expression.operator === '&&') {
+                return (0, create_mitosis_node_1.createMitosisNode)({
+                    name: 'Show',
+                    bindings: {
+                        when: { code: (0, generator_1.default)(node.expression.left).code },
+                    },
+                    children: [(0, exports.jsxElementToJson)(node.expression.right)],
+                });
+            }
+            else {
+                // TODO: good warning system for unsupported operators
+            }
+        }
+        // {foo ? <div /> : <span />} -> <Show when={foo} else={<span />}>...</Show>
+        if (types.isConditionalExpression(node.expression)) {
+            return (0, create_mitosis_node_1.createMitosisNode)({
+                name: 'Show',
+                meta: {
+                    else: (0, exports.jsxElementToJson)(node.expression.alternate),
+                },
+                bindings: {
+                    when: { code: (0, generator_1.default)(node.expression.test).code },
+                },
+                children: [(0, exports.jsxElementToJson)(node.expression.consequent)],
+            });
+        }
+        // TODO: support {foo ? bar : baz}
+        return (0, create_mitosis_node_1.createMitosisNode)({
+            bindings: {
+                _text: { code: (0, generator_1.default)(node.expression).code },
+            },
+        });
+    }
+    if (types.isJSXFragment(node)) {
+        return (0, create_mitosis_node_1.createMitosisNode)({
+            name: 'Fragment',
+            children: node.children.map(exports.jsxElementToJson).filter(nullable_1.checkIsDefined),
+        });
+    }
+    // TODO: support spread attributes
+    if (types.isJSXSpreadChild(node)) {
+        return null;
+    }
+    var nodeName = (0, generator_1.default)(node.openingElement.name).code;
+    if (nodeName === 'Show') {
+        var whenAttr = node.openingElement.attributes.find(function (item) { return types.isJSXAttribute(item) && item.name.name === 'when'; });
+        var elseAttr = node.openingElement.attributes.find(function (item) { return types.isJSXAttribute(item) && item.name.name === 'else'; });
+        var whenValue = whenAttr && types.isJSXExpressionContainer(whenAttr.value)
+            ? (0, generator_1.default)(whenAttr.value.expression).code
+            : undefined;
+        var elseValue = elseAttr &&
+            types.isJSXExpressionContainer(elseAttr.value) &&
+            (0, exports.jsxElementToJson)(elseAttr.value.expression);
+        return (0, create_mitosis_node_1.createMitosisNode)({
+            name: 'Show',
+            meta: {
+                else: elseValue || undefined,
+            },
+            bindings: __assign({}, (whenValue ? { when: { code: whenValue } } : {})),
+            children: node.children.map(exports.jsxElementToJson).filter(nullable_1.checkIsDefined),
+        });
+    }
+    // <For ...> control flow component
+    if (nodeName === 'For') {
+        var child = node.children.find(function (item) {
+            return types.isJSXExpressionContainer(item);
+        });
+        if ((0, nullable_1.checkIsDefined)(child)) {
+            var childExpression = child.expression;
+            if (types.isArrowFunctionExpression(childExpression)) {
+                var forArguments = getForArguments(childExpression === null || childExpression === void 0 ? void 0 : childExpression.params);
+                var forCode = (0, function_1.pipe)(node.openingElement.attributes[0], function (attr) {
+                    if (types.isJSXAttribute(attr) && types.isJSXExpressionContainer(attr.value)) {
+                        return (0, generator_1.default)(attr.value.expression).code;
+                    }
+                    else {
+                        // TO-DO: is an empty string valid here?
+                        return '';
+                    }
+                });
+                return (0, create_mitosis_node_1.createMitosisNode)({
+                    name: 'For',
+                    bindings: {
+                        each: {
+                            code: forCode,
+                        },
+                    },
+                    scope: forArguments,
+                    children: [(0, exports.jsxElementToJson)(childExpression.body)],
+                });
+            }
+        }
+    }
+    return (0, create_mitosis_node_1.createMitosisNode)({
+        name: nodeName,
+        properties: node.openingElement.attributes.reduce(function (memo, item) {
+            if (types.isJSXAttribute(item)) {
+                var key = item.name.name;
+                var value = item.value;
+                if (types.isStringLiteral(value)) {
+                    memo[key] = value.value;
+                    return memo;
+                }
+                if (types.isJSXExpressionContainer(value) && types.isStringLiteral(value.expression)) {
+                    memo[key] = value.expression.value;
+                    return memo;
+                }
+            }
+            return memo;
+        }, {}),
+        bindings: node.openingElement.attributes.reduce(function (memo, item) {
+            if (types.isJSXAttribute(item)) {
+                var key = item.name.name;
+                var value = item.value;
+                if (types.isJSXExpressionContainer(value) && !types.isStringLiteral(value.expression)) {
+                    var expression = value.expression;
+                    if (types.isArrowFunctionExpression(expression)) {
+                        if (key.startsWith('on')) {
+                            memo[key] = {
+                                code: (0, generator_1.default)(expression.body).code,
+                                arguments: expression.params.map(function (node) { return node === null || node === void 0 ? void 0 : node.name; }),
+                            };
+                        }
+                        else {
+                            memo[key] = { code: (0, generator_1.default)(expression.body).code };
+                        }
+                    }
+                    else {
+                        memo[key] = { code: (0, generator_1.default)(expression).code };
+                    }
+                    return memo;
+                }
+            }
+            else if (types.isJSXSpreadAttribute(item)) {
+                // TODO: potentially like Vue store bindings and properties as array of key value pairs
+                // too so can do this accurately when order matters. Also tempting to not support spread,
+                // as some frameworks do not support it (e.g. Angular) tho Angular may be the only one
+                memo._spread = {
+                    code: types.stringLiteral((0, generator_1.default)(item.argument).code).value,
+                };
+            }
+            return memo;
+        }, {}),
+        children: node.children.map(exports.jsxElementToJson).filter(nullable_1.checkIsDefined),
+    });
+};
+exports.jsxElementToJson = jsxElementToJson;

package/dist/src/parsers/jsx/exports.d.ts

@@ -0,0 +1,3 @@
+import * as babel from '@babel/core';
+import { MitosisExport } from '../../types/mitosis-component';
+export declare const generateExports: (path: babel.NodePath<babel.types.Program>) => MitosisExport;

package/dist/src/parsers/jsx/exports.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExports = void 0;
+var babel = __importStar(require("@babel/core"));
+var generator_1 = __importDefault(require("@babel/generator"));
+var component_types_1 = require("./component-types");
+var helpers_1 = require("./helpers");
+var types = babel.types;
+var generateExports = function (path) {
+    var exportsOrLocalVariables = path.node.body.filter(function (statement) {
+        return !(0, helpers_1.isImportOrDefaultExport)(statement) &&
+            !(0, component_types_1.isTypeOrInterface)(statement) &&
+            !types.isExpressionStatement(statement);
+    });
+    return exportsOrLocalVariables.reduce(function (pre, node) {
+        var _a, _b;
+        var name, isFunction;
+        if (babel.types.isExportNamedDeclaration(node)) {
+            if (babel.types.isVariableDeclaration(node.declaration) &&
+                babel.types.isIdentifier(node.declaration.declarations[0].id)) {
+                name = node.declaration.declarations[0].id.name;
+                isFunction = babel.types.isFunction(node.declaration.declarations[0].init);
+            }
+            if (babel.types.isFunctionDeclaration(node.declaration)) {
+                name = (_a = node.declaration.id) === null || _a === void 0 ? void 0 : _a.name;
+                isFunction = true;
+            }
+        }
+        else {
+            if (babel.types.isVariableDeclaration(node) &&
+                babel.types.isIdentifier(node.declarations[0].id)) {
+                name = node.declarations[0].id.name;
+                isFunction = babel.types.isFunction(node.declarations[0].init);
+            }
+            if (babel.types.isFunctionDeclaration(node)) {
+                name = (_b = node.id) === null || _b === void 0 ? void 0 : _b.name;
+                isFunction = true;
+            }
+        }
+        if (name) {
+            pre[name] = {
+                code: (0, generator_1.default)(node).code,
+                isFunction: isFunction,
+            };
+        }
+        else {
+            console.warn('Could not parse export or variable: ignoring node', node);
+        }
+        return pre;
+    }, {});
+};
+exports.generateExports = generateExports;

package/dist/src/parsers/jsx/function-parser.d.ts

@@ -0,0 +1,7 @@
+import * as babel from '@babel/core';
+import { JSONOrNode } from '../../types/json';
+import { Context } from './types';
+/**
+ * Parses function declarations within the Mitosis copmonent's body to JSON
+ */
+export declare const componentFunctionToJson: (node: babel.types.FunctionDeclaration, context: Context) => JSONOrNode;

package/dist/src/parsers/jsx/function-parser.js

@@ -0,0 +1,291 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentFunctionToJson = void 0;
+var babel = __importStar(require("@babel/core"));
+var generator_1 = __importDefault(require("@babel/generator"));
+var trace_reference_to_module_path_1 = require("../../helpers/trace-reference-to-module-path");
+var create_mitosis_component_1 = require("../../helpers/create-mitosis-component");
+var get_bindings_1 = require("../../helpers/get-bindings");
+var hooks_1 = require("../../constants/hooks");
+var state_1 = require("./state");
+var helpers_1 = require("./helpers");
+var component_types_1 = require("./component-types");
+var element_parser_1 = require("./element-parser");
+var types = babel.types;
+/**
+ * Parses function declarations within the Mitosis copmonent's body to JSON
+ */
+var componentFunctionToJson = function (node, context) {
+    var _a, _b;
+    var hooks = {};
+    var state = {};
+    var accessedContext = {};
+    var setContext = {};
+    var refs = {};
+    for (var _i = 0, _c = node.body.body; _i < _c.length; _i++) {
+        var item = _c[_i];
+        if (types.isExpressionStatement(item)) {
+            var expression = item.expression;
+            if (types.isCallExpression(expression)) {
+                if (types.isIdentifier(expression.callee)) {
+                    if (expression.callee.name === 'setContext' ||
+                        expression.callee.name === 'provideContext') {
+                        var keyNode = expression.arguments[0];
+                        if (types.isIdentifier(keyNode)) {
+                            var key = keyNode.name;
+                            var keyPath = (0, trace_reference_to_module_path_1.traceReferenceToModulePath)(context.builder.component.imports, key);
+                            var valueNode = expression.arguments[1];
+                            if (valueNode) {
+                                if (types.isObjectExpression(valueNode)) {
+                                    var value = (0, state_1.parseStateObjectToMitosisState)(valueNode);
+                                    setContext[keyPath] = {
+                                        name: keyNode.name,
+                                        value: value,
+                                    };
+                                }
+                                else {
+                                    var ref = (0, generator_1.default)(valueNode).code;
+                                    setContext[keyPath] = {
+                                        name: keyNode.name,
+                                        ref: ref,
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    else if (expression.callee.name === 'onMount' ||
+                        expression.callee.name === 'useEffect') {
+                        var firstArg = expression.arguments[0];
+                        if (types.isFunctionExpression(firstArg) || types.isArrowFunctionExpression(firstArg)) {
+                            var code = (0, generator_1.default)(firstArg.body)
+                                .code.trim()
+                                // Remove arbitrary block wrapping if any
+                                // AKA
+                                //  { console.log('hi') } -> console.log('hi')
+                                .replace(/^{/, '')
+                                .replace(/}$/, '');
+                            // TODO: add arguments
+                            hooks.onMount = { code: code };
+                        }
+                    }
+                    else if (expression.callee.name === 'onUpdate') {
+                        var firstArg = expression.arguments[0];
+                        var secondArg = expression.arguments[1];
+                        if (types.isFunctionExpression(firstArg) || types.isArrowFunctionExpression(firstArg)) {
+                            var code = (0, generator_1.default)(firstArg.body)
+                                .code.trim()
+                                // Remove arbitrary block wrapping if any
+                                // AKA
+                                //  { console.log('hi') } -> console.log('hi')
+                                .replace(/^{/, '')
+                                .replace(/}$/, '');
+                            if (!secondArg ||
+                                (types.isArrayExpression(secondArg) && secondArg.elements.length > 0)) {
+                                var depsCode = secondArg ? (0, generator_1.default)(secondArg).code : '';
+                                hooks.onUpdate = __spreadArray(__spreadArray([], (hooks.onUpdate || []), true), [
+                                    {
+                                        code: code,
+                                        deps: depsCode,
+                                    },
+                                ], false);
+                            }
+                        }
+                    }
+                    else if (expression.callee.name === 'onUnMount') {
+                        var firstArg = expression.arguments[0];
+                        if (types.isFunctionExpression(firstArg) || types.isArrowFunctionExpression(firstArg)) {
+                            var code = (0, generator_1.default)(firstArg.body)
+                                .code.trim()
+                                // Remove arbitrary block wrapping if any
+                                // AKA
+                                //  { console.log('hi') } -> console.log('hi')
+                                .replace(/^{/, '')
+                                .replace(/}$/, '');
+                            hooks.onUnMount = { code: code };
+                        }
+                    }
+                    else if (expression.callee.name === 'onInit') {
+                        var firstArg = expression.arguments[0];
+                        if (types.isFunctionExpression(firstArg) || types.isArrowFunctionExpression(firstArg)) {
+                            var code = (0, generator_1.default)(firstArg.body)
+                                .code.trim()
+                                // Remove arbitrary block wrapping if any
+                                // AKA
+                                //  { console.log('hi') } -> console.log('hi')
+                                .replace(/^{/, '')
+                                .replace(/}$/, '');
+                            hooks.onInit = { code: code };
+                        }
+                    }
+                    else if (expression.callee.name === hooks_1.HOOKS.DEFAULT_PROPS) {
+                        var firstArg = expression.arguments[0];
+                        if (types.isObjectExpression(firstArg)) {
+                            var objectProperties = (_a = firstArg.properties) === null || _a === void 0 ? void 0 : _a.filter(function (i) {
+                                return types.isObjectProperty(i);
+                            });
+                            objectProperties === null || objectProperties === void 0 ? void 0 : objectProperties.forEach(function (i) {
+                                var _a;
+                                var _b, _c, _d;
+                                if ((_b = i.key) === null || _b === void 0 ? void 0 : _b.name) {
+                                    context.builder.component.defaultProps = __assign(__assign({}, ((_c = context.builder.component.defaultProps) !== null && _c !== void 0 ? _c : {})), (_a = {}, _a[(_d = i.key) === null || _d === void 0 ? void 0 : _d.name] = i.value.value, _a));
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        if (types.isFunctionDeclaration(item)) {
+            if (types.isIdentifier(item.id)) {
+                state[item.id.name] = {
+                    code: (0, generator_1.default)(item).code,
+                    type: 'function',
+                };
+            }
+        }
+        if (types.isVariableDeclaration(item)) {
+            var declaration = item.declarations[0];
+            var init = declaration.init;
+            if (types.isCallExpression(init)) {
+                // React format, like:
+                // const [foo, setFoo] = useState(...)
+                if (types.isArrayPattern(declaration.id)) {
+                    var varName = types.isIdentifier(declaration.id.elements[0]) && declaration.id.elements[0].name;
+                    if (varName) {
+                        var value = init.arguments[0];
+                        // Function as init, like:
+                        // useState(() => true)
+                        if (types.isArrowFunctionExpression(value)) {
+                            state[varName] = {
+                                code: (0, helpers_1.parseCodeJson)(value.body),
+                                type: 'function',
+                            };
+                        }
+                        else {
+                            // Value as init, like:
+                            // useState(true)
+                            state[varName] = {
+                                code: (0, helpers_1.parseCodeJson)(value),
+                                type: 'property',
+                            };
+                        }
+                    }
+                }
+                // Legacy format, like:
+                // const state = useStore({...})
+                else if (types.isIdentifier(init.callee)) {
+                    if (init.callee.name === hooks_1.HOOKS.STATE || init.callee.name === hooks_1.HOOKS.STORE) {
+                        var firstArg = init.arguments[0];
+                        if (types.isObjectExpression(firstArg)) {
+                            var useStoreState = (0, state_1.parseStateObjectToMitosisState)(firstArg);
+                            Object.assign(state, useStoreState);
+                        }
+                    }
+                    else if (init.callee.name === hooks_1.HOOKS.CONTEXT) {
+                        var firstArg = init.arguments[0];
+                        if (types.isVariableDeclarator(declaration) && types.isIdentifier(declaration.id)) {
+                            if (types.isIdentifier(firstArg)) {
+                                var varName = declaration.id.name;
+                                var name_1 = firstArg.name;
+                                accessedContext[varName] = {
+                                    name: name_1,
+                                    path: (0, trace_reference_to_module_path_1.traceReferenceToModulePath)(context.builder.component.imports, name_1),
+                                };
+                            }
+                            else {
+                                var varName = declaration.id.name;
+                                var name_2 = (0, generator_1.default)(firstArg).code;
+                                accessedContext[varName] = {
+                                    name: name_2,
+                                    path: '',
+                                };
+                            }
+                        }
+                    }
+                    else if (init.callee.name === hooks_1.HOOKS.REF) {
+                        if (types.isIdentifier(declaration.id)) {
+                            var firstArg = init.arguments[0];
+                            var varName = declaration.id.name;
+                            refs[varName] = {
+                                argument: (0, generator_1.default)(firstArg).code,
+                            };
+                            // Typescript Parameter
+                            if (types.isTSTypeParameterInstantiation(init.typeParameters)) {
+                                refs[varName].typeParameter = (0, generator_1.default)(init.typeParameters.params[0]).code;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    var theReturn = node.body.body.find(function (item) { return types.isReturnStatement(item); });
+    var children = [];
+    if (theReturn) {
+        var value = theReturn.argument;
+        if (types.isJSXElement(value) || types.isJSXFragment(value)) {
+            children.push((0, element_parser_1.jsxElementToJson)(value));
+        }
+    }
+    var localExports = context.builder.component.exports;
+    if (localExports) {
+        var bindingsCode_1 = (0, get_bindings_1.getBindingsCode)(children);
+        Object.keys(localExports).forEach(function (name) {
+            var found = bindingsCode_1.find(function (code) { return code.match(new RegExp("\\b".concat(name, "\\b"))); });
+            localExports[name].usedInLocal = Boolean(found);
+        });
+        context.builder.component.exports = localExports;
+    }
+    var propsTypeRef = (0, component_types_1.getPropsTypeRef)(node, context);
+    return (0, create_mitosis_component_1.createMitosisComponent)(__assign(__assign({}, context.builder.component), { name: (_b = node.id) === null || _b === void 0 ? void 0 : _b.name, state: state, children: children, refs: refs, hooks: hooks, context: {
+            get: accessedContext,
+            set: setContext,
+        }, propsTypeRef: propsTypeRef }));
+};
+exports.componentFunctionToJson = componentFunctionToJson;

package/dist/src/parsers/jsx/helpers.d.ts

@@ -1,3 +1,5 @@
+import * as babel from '@babel/core';
 export declare const selfClosingTags: Set<string>;
 export declare const uncapitalize: (str: string) => string;
 export declare const parseCodeJson: (node: babel.types.Node) => any;
+export declare const isImportOrDefaultExport: (node: babel.Node) => boolean;