@builder.io/mitosis 0.4.0 → 0.4.2

package/dist/src/parsers/builder/helpers.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapBuilderContentStateToMitosisState = void 0;
-var lodash_1 = require("lodash");
-var patterns_1 = require("../../helpers/patterns");
-var __DO_NOT_USE_FUNCTION_LITERAL_PREFIX = "@builder.io/mitosis/function:";
-var __DO_NOT_USE_METHOD_LITERAL_PREFIX = "@builder.io/mitosis/method:";
+const lodash_1 = require("lodash");
+const patterns_1 = require("../../helpers/patterns");
+const __DO_NOT_USE_FUNCTION_LITERAL_PREFIX = `@builder.io/mitosis/function:`;
+const __DO_NOT_USE_METHOD_LITERAL_PREFIX = `@builder.io/mitosis/method:`;
 /**
  * Maps the Builder State format to the Mitosis State format.
  */
-var mapJsonToStateValue = function (value) {
+const mapJsonToStateValue = (value) => {
     if (typeof value === 'string') {
         if (value.startsWith(__DO_NOT_USE_FUNCTION_LITERAL_PREFIX)) {
             return { type: 'function', code: value.replace(__DO_NOT_USE_FUNCTION_LITERAL_PREFIX, '') };
         }
         else if (value.startsWith(__DO_NOT_USE_METHOD_LITERAL_PREFIX)) {
-            var strippedValue = value.replace(__DO_NOT_USE_METHOD_LITERAL_PREFIX, '');
-            var isGet = Boolean(strippedValue.match(patterns_1.GETTER));
-            var type = isGet ? 'getter' : 'method';
-            return { type: type, code: strippedValue };
+            const strippedValue = value.replace(__DO_NOT_USE_METHOD_LITERAL_PREFIX, '');
+            const isGet = Boolean(strippedValue.match(patterns_1.GETTER));
+            const type = isGet ? 'getter' : 'method';
+            return { type, code: strippedValue };
         }
     }
     return { type: 'property', code: JSON.stringify(value), propertyType: 'normal' };
 };
-var mapBuilderContentStateToMitosisState = function (value) { return (0, lodash_1.mapValues)(value, mapJsonToStateValue); };
+const mapBuilderContentStateToMitosisState = (value) => (0, lodash_1.mapValues)(value, mapJsonToStateValue);
 exports.mapBuilderContentStateToMitosisState = mapBuilderContentStateToMitosisState;

package/dist/src/parsers/context.js

@@ -24,40 +24,38 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseContext = void 0;
-var babel = __importStar(require("@babel/core"));
-var create_mitosis_context_1 = require("../helpers/create-mitosis-context");
-var state_1 = require("./jsx/state");
-var types = babel.types;
-var tsPreset = require('@babel/preset-typescript');
+const babel = __importStar(require("@babel/core"));
+const create_mitosis_context_1 = require("../helpers/create-mitosis-context");
+const state_1 = require("./jsx/state");
+const { types } = babel;
+const tsPreset = require('@babel/preset-typescript');
 function parseContext(code, options) {
-    var found = false;
-    var context = (0, create_mitosis_context_1.createMitosisContext)({ name: options.name });
+    let found = false;
+    const context = (0, create_mitosis_context_1.createMitosisContext)({ name: options.name });
     babel.transform(code, {
         configFile: false,
         babelrc: false,
         presets: [[tsPreset, { isTSX: true, allExtensions: true }]],
         plugins: [
-            function () { return ({
+            () => ({
                 visitor: {
-                    Program: function (path) {
-                        for (var _i = 0, _a = path.node.body; _i < _a.length; _i++) {
-                            var item = _a[_i];
+                    Program(path) {
+                        for (const item of path.node.body) {
                             if (types.isExportDefaultDeclaration(item)) {
-                                var expression = item.declaration;
+                                const expression = item.declaration;
                                 if (types.isCallExpression(expression)) {
                                     if (types.isIdentifier(expression.callee) &&
                                         expression.callee.name === 'createContext') {
-                                        var _b = expression.arguments, firstArg = _b[0], secondArg = _b[1];
+                                        const [firstArg, secondArg] = expression.arguments;
                                         if (types.isObjectExpression(firstArg)) {
                                             // TODO: support non object values by parsing any node type
                                             // like the logic within each property value of parseStateObject
                                             context.value = (0, state_1.parseStateObjectToMitosisState)(firstArg);
                                             if (types.isObjectExpression(secondArg)) {
-                                                for (var _c = 0, _d = secondArg.properties; _c < _d.length; _c++) {
-                                                    var prop = _d[_c];
+                                                for (const prop of secondArg.properties) {
                                                     if (!types.isProperty(prop) || !types.isIdentifier(prop.key))
                                                         continue;
-                                                    var isReactive = prop.key.name === 'reactive';
+                                                    const isReactive = prop.key.name === 'reactive';
                                                     if (isReactive &&
                                                         types.isBooleanLiteral(prop.value) &&
                                                         prop.value.value) {
@@ -73,7 +71,7 @@ function parseContext(code, options) {
                         }
                     },
                 },
-            }); },
+            }),
         ],
     });
     if (!found) {

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

@@ -24,10 +24,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.jsonToAst = void 0;
-var babel = __importStar(require("@babel/core"));
-var types = babel.types;
-var arrayToAst = function (array) { return types.arrayExpression(array.map(exports.jsonToAst)); };
-var jsonToAst = function (json) {
+const babel = __importStar(require("@babel/core"));
+const { types } = babel;
+const arrayToAst = (array) => types.arrayExpression(array.map(exports.jsonToAst));
+const jsonToAst = (json) => {
     if (types.isNode(json)) {
         if (types.isJSXText(json)) {
             return types.stringLiteral(json.value);
@@ -54,21 +54,21 @@ var jsonToAst = function (json) {
     }
 };
 exports.jsonToAst = jsonToAst;
-var jsonObjectToAst = function (json) {
+const jsonObjectToAst = (json) => {
     if (!json) {
         // TO-DO: This looks concerning...
         return json;
     }
-    var properties = [];
-    for (var key in json) {
-        var value = json[key];
+    const properties = [];
+    for (const key in json) {
+        const value = json[key];
         if (value === undefined) {
             continue;
         }
-        var keyAst = types.stringLiteral(key);
-        var valueAst = (0, exports.jsonToAst)(value);
+        const keyAst = types.stringLiteral(key);
+        const valueAst = (0, exports.jsonToAst)(value);
         properties.push(types.objectProperty(keyAst, valueAst));
     }
-    var newNode = types.objectExpression(properties);
+    const newNode = types.objectExpression(properties);
     return newNode;
 };

package/dist/src/parsers/jsx/component-types.js

@@ -22,41 +22,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.collectTypes = exports.isTypeOrInterface = exports.getPropsTypeRef = void 0;
-var babel = __importStar(require("@babel/core"));
-var generator_1 = __importDefault(require("@babel/generator"));
-var types = babel.types;
-var getPropsTypeRef = function (node, context) {
+const babel = __importStar(require("@babel/core"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const { types } = babel;
+const getPropsTypeRef = (node, context) => {
     var _a;
-    var param = node.params[0];
+    const param = node.params[0];
     // TODO: component function params name must be props
     if (babel.types.isIdentifier(param) &&
         param.name === 'props' &&
         babel.types.isTSTypeAnnotation(param.typeAnnotation)) {
-        var paramIdentifier = babel.types.variableDeclaration('let', [
+        const paramIdentifier = babel.types.variableDeclaration('let', [
             babel.types.variableDeclarator(param),
         ]);
-        var generatedTypes = (0, generator_1.default)(paramIdentifier)
+        const generatedTypes = (0, generator_1.default)(paramIdentifier)
             .code.replace(/^let\sprops:\s+/, '')
             .replace(/;/g, '');
         if (generatedTypes.startsWith('{')) {
-            var propsTypeRef = "".concat((_a = node.id) === null || _a === void 0 ? void 0 : _a.name, "Props");
-            context.builder.component.types = __spreadArray(__spreadArray([], (context.builder.component.types || []), true), [
-                "export interface ".concat(propsTypeRef, " ").concat(generatedTypes),
-            ], false);
+            const propsTypeRef = `${(_a = node.id) === null || _a === void 0 ? void 0 : _a.name}Props`;
+            context.builder.component.types = [
+                ...(context.builder.component.types || []),
+                `export interface ${propsTypeRef} ${generatedTypes}`,
+            ];
             return propsTypeRef;
         }
         return generatedTypes;
@@ -64,28 +56,26 @@ var getPropsTypeRef = function (node, context) {
     return undefined;
 };
 exports.getPropsTypeRef = getPropsTypeRef;
-var isTypeImport = function (node) {
+const isTypeImport = (node) => {
     var _a;
     return types.isImportDeclaration(node) &&
         node.importKind === 'type' &&
         // Babel adds an implicit JSX type import that we don't want
         ((_a = node.specifiers[0]) === null || _a === void 0 ? void 0 : _a.local.name) !== 'JSX';
 };
-var isTypeOrInterface = function (node) {
-    return types.isTSTypeAliasDeclaration(node) ||
-        types.isTSInterfaceDeclaration(node) ||
-        (types.isExportNamedDeclaration(node) && types.isTSTypeAliasDeclaration(node.declaration)) ||
-        (types.isExportNamedDeclaration(node) && types.isTSInterfaceDeclaration(node.declaration));
-};
+const isTypeOrInterface = (node) => types.isTSTypeAliasDeclaration(node) ||
+    types.isTSInterfaceDeclaration(node) ||
+    (types.isExportNamedDeclaration(node) && types.isTSTypeAliasDeclaration(node.declaration)) ||
+    (types.isExportNamedDeclaration(node) && types.isTSInterfaceDeclaration(node.declaration));
 exports.isTypeOrInterface = isTypeOrInterface;
-var getTypesFromNode = function (node, context) {
-    var typeStr = (0, generator_1.default)(node).code;
-    var _a = context.builder.component.types, types = _a === void 0 ? [] : _a;
+const getTypesFromNode = (node, context) => {
+    const typeStr = (0, generator_1.default)(node).code;
+    const { types = [] } = context.builder.component;
     types.push(typeStr);
     context.builder.component.types = types.filter(Boolean);
 };
-var collectTypes = function (path, context) {
-    var node = path.node;
+const collectTypes = (path, context) => {
+    const { node } = path;
     getTypesFromNode(node, context);
     path.remove();
 };

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

@@ -27,14 +27,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractContextComponents = void 0;
-var babel = __importStar(require("@babel/core"));
-var legacy_1 = __importDefault(require("neotraverse/legacy"));
-var create_mitosis_node_1 = require("../../helpers/create-mitosis-node");
-var is_mitosis_node_1 = require("../../helpers/is-mitosis-node");
-var trace_reference_to_module_path_1 = require("../../helpers/trace-reference-to-module-path");
-var state_1 = require("./state");
-var expressionToNode = function (str) {
-    var code = "export default ".concat(str);
+const babel = __importStar(require("@babel/core"));
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const create_mitosis_node_1 = require("../../helpers/create-mitosis-node");
+const is_mitosis_node_1 = require("../../helpers/is-mitosis-node");
+const trace_reference_to_module_path_1 = require("../../helpers/trace-reference-to-module-path");
+const state_1 = require("./state");
+const expressionToNode = (str) => {
+    const code = `export default ${str}`;
     return babel.parse(code).program.body[0].declaration;
 };
 /**
@@ -46,11 +46,11 @@ function extractContextComponents(json) {
         var _a, _b;
         if ((0, is_mitosis_node_1.isMitosisNode)(item)) {
             if (item.name.endsWith('.Provider')) {
-                var value = (_b = (_a = item.bindings) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.code;
-                var name_1 = item.name.split('.')[0];
-                var refPath = (0, trace_reference_to_module_path_1.traceReferenceToModulePath)(json.imports, name_1);
+                const value = (_b = (_a = item.bindings) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.code;
+                const name = item.name.split('.')[0];
+                const refPath = (0, trace_reference_to_module_path_1.traceReferenceToModulePath)(json.imports, name);
                 json.context.set[refPath] = {
-                    name: name_1,
+                    name,
                     value: value
                         ? (0, state_1.parseStateObjectToMitosisState)(expressionToNode(value))
                         : undefined,

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

@@ -1,15 +1,4 @@
 "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);
@@ -38,29 +27,29 @@ var __importDefault = (this && this.__importDefault) || function (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 function_1 = require("fp-ts/lib/function");
-var bindings_1 = require("../../helpers/bindings");
-var create_mitosis_node_1 = require("../../helpers/create-mitosis-node");
-var nullable_1 = require("../../helpers/nullable");
-var helpers_1 = require("./helpers");
-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];
+const babel = __importStar(require("@babel/core"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const function_1 = require("fp-ts/lib/function");
+const bindings_1 = require("../../helpers/bindings");
+const create_mitosis_node_1 = require("../../helpers/create-mitosis-node");
+const nullable_1 = require("../../helpers/nullable");
+const helpers_1 = require("./helpers");
+const { types } = babel;
+const getForArguments = (params) => {
+    const [forName, indexName, collectionName] = params
+        .filter((param) => types.isIdentifier(param))
+        .map((param) => param.name)
+        .filter(nullable_1.checkIsDefined);
     return {
-        forName: forName,
-        collectionName: collectionName,
-        indexName: indexName,
+        forName,
+        collectionName,
+        indexName,
     };
 };
 /**
  * Parses a JSX element into a MitosisNode.
  */
-var jsxElementToJson = function (node) {
+const jsxElementToJson = (node) => {
     if (types.isJSXText(node)) {
         return (0, create_mitosis_node_1.createMitosisNode)({
             properties: {
@@ -75,10 +64,10 @@ var jsxElementToJson = function (node) {
         return (0, exports.jsxElementToJson)(node.expression);
     }
     if (types.isCallExpression(node) || types.isOptionalCallExpression(node)) {
-        var callback = node.arguments[0];
+        const callback = node.arguments[0];
         if (types.isArrowFunctionExpression(callback)) {
             if (types.isIdentifier(callback.params[0])) {
-                var forArguments = getForArguments(callback.params);
+                const forArguments = getForArguments(callback.params);
                 return (0, create_mitosis_node_1.createMitosisNode)({
                     name: 'For',
                     bindings: {
@@ -111,7 +100,7 @@ var jsxElementToJson = function (node) {
     }
     else if (types.isConditionalExpression(node)) {
         // {foo ? <div /> : <span />} -> <Show when={foo} else={<span />}>...</Show>
-        var child = (0, exports.jsxElementToJson)(node.consequent);
+        const child = (0, exports.jsxElementToJson)(node.consequent);
         return (0, create_mitosis_node_1.createMitosisNode)({
             name: 'Show',
             meta: {
@@ -157,14 +146,14 @@ var jsxElementToJson = function (node) {
             },
         });
     }
-    var nodeName = (0, generator_1.default)(node.openingElement.name).code;
+    const 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)
+        const whenAttr = node.openingElement.attributes.find((item) => types.isJSXAttribute(item) && item.name.name === 'when');
+        const elseAttr = node.openingElement.attributes.find((item) => types.isJSXAttribute(item) && item.name.name === 'else');
+        const whenValue = whenAttr && types.isJSXExpressionContainer(whenAttr.value)
             ? (0, generator_1.default)(whenAttr.value.expression).code
             : undefined;
-        var elseValue = elseAttr &&
+        const elseValue = elseAttr &&
             types.isJSXExpressionContainer(elseAttr.value) &&
             (0, exports.jsxElementToJson)(elseAttr.value.expression);
         return (0, create_mitosis_node_1.createMitosisNode)({
@@ -172,20 +161,20 @@ var jsxElementToJson = function (node) {
             meta: {
                 else: elseValue || undefined,
             },
-            bindings: __assign({}, (whenValue ? { when: (0, bindings_1.createSingleBinding)({ code: whenValue }) } : {})),
+            bindings: {
+                ...(whenValue ? { when: (0, bindings_1.createSingleBinding)({ 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);
-        });
+        const child = node.children.find((item) => types.isJSXExpressionContainer(item));
         if ((0, nullable_1.checkIsDefined)(child)) {
-            var childExpression = child.expression;
+            const 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) {
+                const forArguments = getForArguments(childExpression === null || childExpression === void 0 ? void 0 : childExpression.params);
+                const forCode = (0, function_1.pipe)(node.openingElement.attributes[0], (attr) => {
                     if (types.isJSXAttribute(attr) && types.isJSXExpressionContainer(attr.value)) {
                         return (0, generator_1.default)(attr.value.expression).code;
                     }
@@ -210,10 +199,10 @@ var jsxElementToJson = function (node) {
     // const properties: MitosisNode['properties'] = {}
     // const bindings: MitosisNode['bindings'] = {}
     // const slots: MitosisNode['slots'] = {}
-    var _a = node.openingElement.attributes.reduce(function (memo, item) {
+    const { bindings, properties, slots } = node.openingElement.attributes.reduce((memo, item) => {
         if (types.isJSXAttribute(item)) {
-            var key = (0, helpers_1.transformAttributeName)(item.name.name);
-            var value = item.value;
+            const key = (0, helpers_1.transformAttributeName)(item.name.name);
+            const value = item.value;
             // <Foo myProp />
             if (value === null) {
                 memo.bindings[key] = (0, bindings_1.createSingleBinding)({ code: 'true' });
@@ -226,15 +215,15 @@ var jsxElementToJson = function (node) {
             }
             if (!types.isJSXExpressionContainer(value))
                 return memo;
-            var expression = value.expression;
+            const { expression } = value;
             if (types.isStringLiteral(expression)) {
                 // <Foo myProp={"hello"} />
                 memo.properties[key] = expression.value;
             }
             else if (types.isArrowFunctionExpression(expression)) {
                 // <Foo myProp={() => {}} />
-                var args = key.startsWith('on')
-                    ? expression.params.map(function (node) { return node === null || node === void 0 ? void 0 : node.name; })
+                const args = key.startsWith('on')
+                    ? expression.params.map((node) => node === null || node === void 0 ? void 0 : node.name)
                     : [];
                 memo.bindings[key] = (0, bindings_1.createSingleBinding)({
                     code: (0, generator_1.default)(expression.body).code,
@@ -243,7 +232,7 @@ var jsxElementToJson = function (node) {
             }
             else if (types.isJSXElement(expression)) {
                 // <Foo myProp={<MoreMitosisNode><div /></MoreMitosisNode>} />
-                var slotNode = (0, exports.jsxElementToJson)(expression);
+                const slotNode = (0, exports.jsxElementToJson)(expression);
                 if (!slotNode)
                     return memo;
                 memo.slots[key] = [slotNode];
@@ -259,7 +248,7 @@ var jsxElementToJson = function (node) {
             // 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
-            var key = (0, generator_1.default)(item.argument).code;
+            const { code: key } = (0, generator_1.default)(item.argument);
             memo.bindings[key] = {
                 code: types.stringLiteral((0, generator_1.default)(item.argument).code).value,
                 type: 'spread',
@@ -271,11 +260,11 @@ var jsxElementToJson = function (node) {
         bindings: {},
         properties: {},
         slots: {},
-    }), bindings = _a.bindings, properties = _a.properties, slots = _a.slots;
+    });
     return (0, create_mitosis_node_1.createMitosisNode)({
         name: nodeName,
-        properties: properties,
-        bindings: bindings,
+        properties,
+        bindings,
         children: node.children.map(exports.jsxElementToJson).filter(nullable_1.checkIsDefined),
         slots: Object.keys(slots).length > 0 ? slots : undefined,
     });

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

@@ -27,20 +27,18 @@ var __importDefault = (this && this.__importDefault) || function (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) {
+const babel = __importStar(require("@babel/core"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const component_types_1 = require("./component-types");
+const helpers_1 = require("./helpers");
+const { types } = babel;
+const generateExports = (path) => {
+    const exportsOrLocalVariables = path.node.body.filter((statement) => !(0, helpers_1.isImportOrDefaultExport)(statement) &&
+        !(0, component_types_1.isTypeOrInterface)(statement) &&
+        !types.isExpressionStatement(statement));
+    return exportsOrLocalVariables.reduce((pre, node) => {
         var _a, _b;
-        var name, isFunction;
+        let name, isFunction;
         if (babel.types.isExportNamedDeclaration(node)) {
             if (babel.types.isVariableDeclaration(node.declaration) &&
                 babel.types.isIdentifier(node.declaration.declarations[0].id)) {
@@ -66,7 +64,7 @@ var generateExports = function (path) {
         if (name) {
             pre[name] = {
                 code: (0, generator_1.default)(node).code,
-                isFunction: isFunction,
+                isFunction,
             };
         }
         else {