@builder.io/mitosis 0.0.115-7 → 0.0.115

package/dist/src/generators/qwik/helpers/state.js

@@ -82,7 +82,14 @@ var checkIsObjectWithCodeBlock = function (obj) {
     return typeof obj == 'object' && (obj === null || obj === void 0 ? void 0 : obj.code) && typeof obj.code === 'string';
 };
 function getLexicalScopeVars(component) {
-    return __spreadArray(__spreadArray(['props', 'state'], Object.keys(component.refs), true), Object.keys(component.context.get), true);
+    return __spreadArray(__spreadArray(__spreadArray([
+        'props',
+        'state'
+    ], Object.keys(component.refs), true), Object.keys(component.context.get), true), Object.keys(component.state).filter(function (key) {
+        var _a;
+        var stateType = (_a = component.state[key]) === null || _a === void 0 ? void 0 : _a.type;
+        return stateType === 'getter' || stateType === 'function';
+    }), true);
 }
 exports.getLexicalScopeVars = getLexicalScopeVars;
 function rewriteCodeExpr(component, methodMap, lexicalArgs, replace) {

package/dist/src/generators/rsc.js

@@ -89,7 +89,6 @@ var componentToRsc = function (_options) {
         var component = _a.component, path = _a.path;
         if (!(0, nullable_1.checkIsDefined)((_c = (_b = component.meta.useMetadata) === null || _b === void 0 ? void 0 : _b.rsc) === null || _c === void 0 ? void 0 : _c.componentType) &&
             checkIfIsRsc(component)) {
-            console.log('comp type is not defined. setting as RSC: ', component.name);
             component.meta.useMetadata = __assign(__assign({}, component.meta.useMetadata), { rsc: __assign(__assign({}, (_d = component.meta.useMetadata) === null || _d === void 0 ? void 0 : _d.rsc), { componentType: 'server' }) });
         }
         var isRSC = ((_f = (_e = component.meta.useMetadata) === null || _e === void 0 ? void 0 : _e.rsc) === null || _f === void 0 ? void 0 : _f.componentType) === 'server';

package/dist/src/generators/svelte/blocks.js

@@ -125,18 +125,20 @@ var getTagName = function (_a) {
     }
     return json.name;
 };
-var stringifyBinding = function (options) {
+var stringifyBinding = function (node, options) {
     return function (_a) {
         var key = _a[0], binding = _a[1];
         if (key === 'innerHTML' || !binding) {
             return '';
         }
         var code = binding.code, _b = binding.arguments, cusArgs = _b === void 0 ? ['event'] : _b, type = binding.type;
+        var isValidHtmlTag = html_tags_2.VALID_HTML_TAGS.includes(node.name);
         if (type === 'spread') {
             var spreadValue = key === 'props' ? '$$props' : code;
             return " {...".concat(spreadValue, "} ");
         }
-        else if (key.startsWith('on')) {
+        else if (key.startsWith('on') && isValidHtmlTag) {
+            // handle html native on[event] props
             var event_1 = key.replace('on', '').toLowerCase();
             // TODO: handle quotes in event handler values
             var valueWithoutBlock = (0, remove_surrounding_block_1.removeSurroundingBlock)(code);
@@ -147,6 +149,16 @@ var stringifyBinding = function (options) {
                 return " on:".concat(event_1, "=\"{").concat(cusArgs.join(','), " => {").concat(valueWithoutBlock, "}}\" ");
             }
         }
+        else if (key.startsWith('on')) {
+            // handle on[custom event] props
+            var valueWithoutBlock = (0, remove_surrounding_block_1.removeSurroundingBlock)(code);
+            if (valueWithoutBlock === key) {
+                return " ".concat(key, "={").concat(valueWithoutBlock, "} ");
+            }
+            else {
+                return " ".concat(key, "={(").concat(cusArgs.join(','), ") => ").concat(valueWithoutBlock, "}");
+            }
+        }
         else if (key === 'ref') {
             return " bind:this={".concat(code, "} ");
         }
@@ -192,7 +204,9 @@ var blockToSvelte = function (_a) {
         var value = json.properties[key];
         str += " ".concat(key, "=\"").concat(value, "\" ");
     }
-    var stringifiedBindings = Object.entries(json.bindings).map(stringifyBinding(options)).join('');
+    var stringifiedBindings = Object.entries(json.bindings)
+        .map(stringifyBinding(json, options))
+        .join('');
     str += stringifiedBindings;
     // if we have innerHTML, it doesn't matter whether we have closing tags or not, or children or not.
     // we use the innerHTML content as children and don't render the self-closing tag.

package/dist/src/generators/vue/blocks.js

@@ -211,6 +211,7 @@ var SPECIAL_HTML_TAGS = ['style', 'script'];
 var stringifyBinding = function (node) {
     return function (_a) {
         var key = _a[0], value = _a[1];
+        var isValidHtmlTag = html_tags_1.VALID_HTML_TAGS.includes(node.name);
         if (value.type === 'spread') {
             return ''; // we handle this after
         }
@@ -222,7 +223,8 @@ var stringifyBinding = function (node) {
         else {
             // TODO: proper babel transform to replace. Util for this
             var useValue = (value === null || value === void 0 ? void 0 : value.code) || '';
-            if (key.startsWith('on')) {
+            if (key.startsWith('on') && isValidHtmlTag) {
+                // handle html native on[event] props
                 var _b = value.arguments, cusArgs = _b === void 0 ? ['event'] : _b;
                 var event_1 = key.replace('on', '').toLowerCase();
                 if (event_1 === 'change' && node.name === 'input') {
@@ -237,6 +239,11 @@ var stringifyBinding = function (node) {
                 var eventHandlerKey = "".concat(SPECIAL_PROPERTIES.V_ON_AT).concat(event_1);
                 return "".concat(eventHandlerKey, "=\"").concat(eventHandlerValue, "\"");
             }
+            else if (key.startsWith('on')) {
+                // handle on[custom event] props
+                var _c = node.bindings[key].arguments, cusArgs = _c === void 0 ? ['event'] : _c;
+                return ":".concat(key, "=\"(").concat(cusArgs.join(','), ") => ").concat((0, helpers_1.encodeQuotes)(useValue), "\"");
+            }
             else if (key === 'ref') {
                 return "ref=\"".concat((0, helpers_1.encodeQuotes)(useValue), "\"");
             }

package/dist/src/helpers/mitosis-imports.d.ts

@@ -0,0 +1,5 @@
+import * as babel from '@babel/core';
+import { MitosisImport } from '../types/mitosis-component';
+declare const types: typeof babel.types;
+export declare const mapImportDeclarationToMitosisImport: (node: babel.types.ImportDeclaration) => MitosisImport;
+export {};

package/dist/src/helpers/mitosis-imports.js

@@ -0,0 +1,49 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapImportDeclarationToMitosisImport = void 0;
+var babel = __importStar(require("@babel/core"));
+var types = babel.types;
+var mapImportDeclarationToMitosisImport = function (node) {
+    var importObject = {
+        imports: {},
+        path: node.source.value,
+        importKind: node.importKind,
+    };
+    for (var _i = 0, _a = node.specifiers; _i < _a.length; _i++) {
+        var specifier = _a[_i];
+        if (types.isImportSpecifier(specifier)) {
+            importObject.imports[specifier.local.name] = specifier.imported.name;
+        }
+        else if (types.isImportDefaultSpecifier(specifier)) {
+            importObject.imports[specifier.local.name] = 'default';
+        }
+        else if (types.isImportNamespaceSpecifier(specifier)) {
+            importObject.imports[specifier.local.name] = '*';
+        }
+    }
+    return importObject;
+};
+exports.mapImportDeclarationToMitosisImport = mapImportDeclarationToMitosisImport;

package/dist/src/helpers/plugins/process-signals.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSignalAccessPlugin = exports.getSignalTypePlugin = exports.replaceSignalSetters = void 0;
 var core_1 = require("@babel/core");
 var generator_1 = __importDefault(require("@babel/generator"));
-var types_identification_1 = require("../../parsers/jsx/types-identification");
 var babel_transform_1 = require("../babel-transform");
 var capitalize_1 = require("../capitalize");
 var nullable_1 = require("../nullable");
 var replace_identifiers_1 = require("../replace-identifiers");
+var signals_1 = require("../signals");
 var process_code_1 = require("./process-code");
 var replaceSignalSetters = function (_a) {
     var code = _a.code, nodeMaps = _a.nodeMaps;
@@ -75,7 +75,7 @@ var getSignalTypePlugin = function (_a) {
                             return function (code) {
                                 var _a;
                                 if ((_a = json.signals) === null || _a === void 0 ? void 0 : _a.signalTypeImportName) {
-                                    return (0, types_identification_1.mapSignalType)({
+                                    return (0, signals_1.mapSignalType)({
                                         code: code,
                                         signalImportName: json.signals.signalTypeImportName,
                                         target: target,
@@ -87,7 +87,7 @@ var getSignalTypePlugin = function (_a) {
                 })(json);
                 if ((_a = json.signals) === null || _a === void 0 ? void 0 : _a.signalTypeImportName) {
                     json.imports = json.imports || [];
-                    var signalMappedImport = (0, types_identification_1.getSignalMitosisImportForTarget)(target);
+                    var signalMappedImport = (0, signals_1.getSignalMitosisImportForTarget)(target);
                     if (signalMappedImport) {
                         json.imports.push(signalMappedImport);
                     }

package/dist/src/helpers/replace-identifiers.js

@@ -175,7 +175,6 @@ var replaceNodes = function (_a) {
                         orig: (0, generator_1.default)(path.node).code,
                         to: (0, generator_1.default)(x).code,
                     });
-                    console.log({ parent: path.parent });
                     // throw err;
                 }
             }

package/dist/src/helpers/signals/index.d.ts

@@ -0,0 +1 @@
+export * from './signals';

package/dist/src/helpers/signals/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./signals"), exports);

package/dist/src/{parsers/jsx/types-identification.d.ts → helpers/signals/signals.d.ts}

@@ -1,5 +1,9 @@
-import { Project, Symbol } from 'ts-morph';
+import { types } from '@babel/core';
 import { Target } from '../../types/config';
+export declare const getSignalMappingForTarget: (target: Target) => {
+    getTypeReference: (generics?: types.TSType[]) => types.TSTypeReference;
+    importDeclaration: types.ImportDeclaration;
+} | undefined;
 export declare const getSignalMitosisImportForTarget: (target: Target) => import("../..").MitosisImport | undefined;
 export declare const getSignalImportName: (code: string) => string | undefined;
 /**
@@ -13,25 +17,11 @@ export declare const mapSignalType: ({ code, target, signalImportName, }: {
 }) => string;
 /**
  * Processes the `Signal` type usage in a plain TS file:
- * - Finds the Signal import name
- * - Maps the Signal type to the target's equivalent
- * - Adds the equivalent of the Signal import to the file
+ * - Finds the `Signal` import name
+ * - Maps the `Signal` type to the target's equivalent
+ * - Adds the equivalent of the `Signal` import to the file
  */
 export declare const mapSignalTypeInTSFile: ({ code, target }: {
     code: string;
     target: Target;
 }) => string;
-export declare const createTypescriptProject: (tsConfigFilePath: string) => {
-    project: Project;
-    signalSymbol: Symbol;
-};
-export declare const findSignals: (args: {
-    project: Project;
-    signalSymbol: Symbol;
-    code?: string | undefined;
-    filePath?: string | undefined;
-}) => {
-    props: Set<string>;
-    state: Set<string>;
-    context: Set<string>;
-};

package/dist/src/helpers/signals/signals.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSignalTypeInTSFile = exports.mapSignalType = exports.getSignalImportName = exports.getSignalMitosisImportForTarget = exports.getSignalMappingForTarget = void 0;
+var core_1 = require("@babel/core");
+var function_1 = require("fp-ts/lib/function");
+var babel_transform_1 = require("../../helpers/babel-transform");
+var mitosis_imports_1 = require("../mitosis-imports");
+var getSignalMappingForTarget = function (target) {
+    switch (target) {
+        case 'svelte':
+            var importDeclaration = core_1.types.importDeclaration([core_1.types.importSpecifier(core_1.types.identifier('Writable'), core_1.types.identifier('Writable'))], core_1.types.stringLiteral('svelte/store'));
+            importDeclaration.importKind = 'type';
+            return {
+                getTypeReference: function (generics) {
+                    if (generics === void 0) { generics = []; }
+                    return core_1.types.tsTypeReference(core_1.types.identifier('Writable'), core_1.types.tsTypeParameterInstantiation(generics));
+                },
+                importDeclaration: importDeclaration,
+            };
+        default:
+            return undefined;
+    }
+};
+exports.getSignalMappingForTarget = getSignalMappingForTarget;
+var getSignalMitosisImportForTarget = function (target) {
+    var signalType = (0, exports.getSignalMappingForTarget)(target);
+    if (!signalType) {
+        return undefined;
+    }
+    return (0, mitosis_imports_1.mapImportDeclarationToMitosisImport)(signalType.importDeclaration);
+};
+exports.getSignalMitosisImportForTarget = getSignalMitosisImportForTarget;
+var getSignalImportName = function (code) {
+    var foundSignalUsage = false;
+    var signalImportName = undefined;
+    (0, babel_transform_1.babelTransformExpression)(code, {
+        ImportSpecifier: function (path) {
+            if (core_1.types.isIdentifier(path.node.imported) && path.node.imported.name === 'Signal') {
+                if (path.parentPath.isImportDeclaration() &&
+                    path.parentPath.node.source.value === '@builder.io/mitosis') {
+                    /**
+                     * in case the import is aliased, we need to use the local name,
+                     * e.g. `import { Signal as MySignal } from '@builder.io/mitosis'`
+                     */
+                    signalImportName = path.node.local.name;
+                    path.stop();
+                }
+            }
+        },
+    });
+    if (!signalImportName) {
+        return undefined;
+    }
+    (0, babel_transform_1.babelTransformExpression)(code, {
+        TSTypeReference: function (path) {
+            if (core_1.types.isIdentifier(path.node.typeName) && path.node.typeName.name === signalImportName) {
+                foundSignalUsage = true;
+                path.stop();
+            }
+        },
+    });
+    return foundSignalUsage ? signalImportName : undefined;
+};
+exports.getSignalImportName = getSignalImportName;
+var addSignalImport = function (_a) {
+    var code = _a.code, target = _a.target;
+    var signalType = (0, exports.getSignalMappingForTarget)(target);
+    if (!signalType) {
+        return code;
+    }
+    return (0, babel_transform_1.babelTransformExpression)(code, {
+        Program: function (path) {
+            path.node.body.unshift(signalType.importDeclaration);
+        },
+    });
+};
+/**
+ * Finds all `Signal` types and replaces them with the correct type for the given target.
+ * e.g. `Signal<string>` becomes `Writable<string>` for Svelte.
+ */
+var mapSignalType = function (_a) {
+    var code = _a.code, target = _a.target, _b = _a.signalImportName, signalImportName = _b === void 0 ? (0, exports.getSignalImportName)(code) : _b;
+    var signalType = (0, exports.getSignalMappingForTarget)(target);
+    return (0, babel_transform_1.babelTransformExpression)(code, {
+        TSTypeReference: function (path) {
+            var _a;
+            if (core_1.types.isIdentifier(path.node.typeName) && path.node.typeName.name === signalImportName) {
+                var params = ((_a = path.node.typeParameters) === null || _a === void 0 ? void 0 : _a.params) || [];
+                var newType = (signalType === null || signalType === void 0 ? void 0 : signalType.getTypeReference)
+                    ? signalType.getTypeReference(params)
+                    : // if no mapping exists, drop `Signal` and just use the generic type passed to `Signal` as-is.
+                        params[0];
+                path.replaceWith(newType);
+            }
+        },
+    });
+};
+exports.mapSignalType = mapSignalType;
+/**
+ * Processes the `Signal` type usage in a plain TS file:
+ * - Finds the `Signal` import name
+ * - Maps the `Signal` type to the target's equivalent
+ * - Adds the equivalent of the `Signal` import to the file
+ */
+var mapSignalTypeInTSFile = function (_a) {
+    var code = _a.code, target = _a.target;
+    var signalImportName = (0, exports.getSignalImportName)(code);
+    if (!signalImportName) {
+        return code;
+    }
+    return (0, function_1.pipe)((0, exports.mapSignalType)({ target: target, code: code, signalImportName: signalImportName }), function (code) {
+        return addSignalImport({ code: code, target: target });
+    });
+};
+exports.mapSignalTypeInTSFile = mapSignalTypeInTSFile;

package/dist/src/helpers/typescript-project.d.ts

@@ -0,0 +1,8 @@
+import { Project, SourceFile, Symbol } from 'ts-morph';
+export declare const removeMitosisImport: (code: string) => string;
+export declare const getPropsSymbol: (ast: SourceFile) => Symbol | undefined;
+export declare const getContextSymbols: (ast: SourceFile) => Set<Symbol>;
+export declare const createTypescriptProject: (tsConfigFilePath: string) => {
+    project: Project;
+    signalSymbol: Symbol;
+};

package/dist/src/helpers/typescript-project.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypescriptProject = exports.getContextSymbols = exports.getPropsSymbol = exports.removeMitosisImport = void 0;
+var ts_morph_1 = require("ts-morph");
+var babel_transform_1 = require("./babel-transform");
+var removeMitosisImport = function (code) {
+    return (0, babel_transform_1.babelTransformExpression)(code, {
+        ImportDeclaration: function (path) {
+            if (path.node.source.value === '@builder.io/mitosis') {
+                path.remove();
+            }
+        },
+    });
+};
+exports.removeMitosisImport = removeMitosisImport;
+var getPropsSymbol = function (ast) {
+    var propsSymbol = undefined;
+    ast.forEachChild(function (node) {
+        var _a;
+        if (propsSymbol !== undefined)
+            return;
+        if (ts_morph_1.Node.isArrowFunction(node) || ts_morph_1.Node.isFunctionDeclaration(node)) {
+            if (node.hasModifier(ts_morph_1.SyntaxKind.ExportKeyword) &&
+                node.hasModifier(ts_morph_1.SyntaxKind.DefaultKeyword)) {
+                propsSymbol = (_a = node.getParameters()[0]) === null || _a === void 0 ? void 0 : _a.getSymbol();
+            }
+        }
+    });
+    return propsSymbol;
+};
+exports.getPropsSymbol = getPropsSymbol;
+var getContextSymbols = function (ast) {
+    var contextSymbols = new Set();
+    ast.forEachDescendant(function (node) {
+        if (!ts_morph_1.Node.isVariableDeclaration(node))
+            return;
+        var initializer = node.getInitializer();
+        if (!ts_morph_1.Node.isCallExpression(initializer))
+            return;
+        if (initializer.getExpression().getText() !== 'useContext')
+            return;
+        var contextSymbol = node.getNameNode().getSymbol();
+        if (contextSymbol === undefined)
+            return;
+        contextSymbols.add(contextSymbol);
+    });
+    return contextSymbols;
+};
+exports.getContextSymbols = getContextSymbols;
+var getSignalSymbol = function (project) {
+    var symbolExport = project.createSourceFile('homepage3.lite.tsx', "import { Signal } from '@builder.io/mitosis';");
+    // Find the original Signal symbol
+    var signalSymbol = undefined;
+    symbolExport.forEachDescendant(function (node) {
+        var _a;
+        if (ts_morph_1.Node.isImportSpecifier(node)) {
+            signalSymbol = (_a = node.getSymbol()) === null || _a === void 0 ? void 0 : _a.getAliasedSymbol();
+        }
+    });
+    if (signalSymbol === undefined) {
+        throw new Error('Could not find the Mitosis Signal symbol in your TS project. Is `@builder.io/mitosis` installed correctly?');
+    }
+    return signalSymbol;
+};
+var getProject = function (tsConfigFilePath) {
+    try {
+        return new ts_morph_1.Project({ tsConfigFilePath: tsConfigFilePath });
+    }
+    catch (err) {
+        throw new Error('Error creating Typescript Project. Make sure `tsConfigFilePath` points to a valid tsconfig.json file');
+    }
+};
+var createTypescriptProject = function (tsConfigFilePath) {
+    var project = getProject(tsConfigFilePath);
+    var signalSymbol = getSignalSymbol(project);
+    return { project: project, signalSymbol: signalSymbol };
+};
+exports.createTypescriptProject = createTypescriptProject;

package/dist/src/index.d.ts

@@ -29,6 +29,8 @@ export * from './generators/taro';
 export * from './generators/template';
 export * from './generators/vue';
 export * from './helpers/is-mitosis-node';
+export * from './helpers/signals';
+export * from './helpers/typescript-project';
 export * from './parsers/angular';
 export * from './parsers/builder';
 export * from './parsers/context';

package/dist/src/index.js

@@ -41,6 +41,8 @@ __exportStar(require("./generators/taro"), exports);
 __exportStar(require("./generators/template"), exports);
 __exportStar(require("./generators/vue"), exports);
 __exportStar(require("./helpers/is-mitosis-node"), exports);
+__exportStar(require("./helpers/signals"), exports);
+__exportStar(require("./helpers/typescript-project"), exports);
 __exportStar(require("./parsers/angular"), exports);
 __exportStar(require("./parsers/builder"), exports);
 __exportStar(require("./parsers/context"), exports);

package/dist/src/parsers/jsx/hooks/use-target.js

@@ -79,6 +79,7 @@ var getUseTargetStatements = function (path) {
         if (!Object.keys(targets_1.targets).concat('default').includes(prop.key.name)) {
             throw new Error('ERROR Parsing `useTarget()`: Invalid target: ' + prop.key.name);
         }
+        var keyName = prop.key.name;
         var targetCode = prop.value;
         if (isInlinedCodeInsideFunctionBody) {
             if (!(types.isArrowFunctionExpression(targetCode) || types.isFunctionExpression(targetCode)))
@@ -86,12 +87,15 @@ var getUseTargetStatements = function (path) {
             var body = targetCode.body;
             if (types.isBlockStatement(body)) {
                 var code_1 = '';
-                body.body.map(function (statement) {
+                body.body.forEach(function (statement) {
                     code_1 += (0, generator_1.default)(statement).code + '\n';
                 });
+                targetBlock[keyName] = {
+                    code: code_1,
+                };
             }
             else {
-                targetBlock[prop.key.name] = {
+                targetBlock[keyName] = {
                     code: (0, generator_1.default)(body).code,
                 };
             }
@@ -99,7 +103,7 @@ var getUseTargetStatements = function (path) {
         else {
             if (!types.isExpression(targetCode))
                 return undefined;
-            targetBlock[prop.key.name] = {
+            targetBlock[keyName] = {
                 code: (0, generator_1.default)(targetCode).code,
             };
         }

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

@@ -1,8 +1,6 @@
 import * as babel from '@babel/core';
-import { MitosisImport } from '../../types/mitosis-component';
 import { Context, ParseMitosisOptions } from './types';
 declare const types: typeof babel.types;
-export declare const mapImportDeclarationToMitosisImport: (node: babel.types.ImportDeclaration) => MitosisImport;
 export declare const handleImportDeclaration: ({ options, path, context, }: {
     options: Partial<ParseMitosisOptions>;
     path: babel.NodePath<babel.types.ImportDeclaration>;

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

@@ -32,30 +32,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleImportDeclaration = exports.mapImportDeclarationToMitosisImport = void 0;
+exports.handleImportDeclaration = void 0;
 var babel = __importStar(require("@babel/core"));
+var mitosis_imports_1 = require("../../helpers/mitosis-imports");
 var types = babel.types;
-var mapImportDeclarationToMitosisImport = function (node) {
-    var importObject = {
-        imports: {},
-        path: node.source.value,
-        importKind: node.importKind,
-    };
-    for (var _i = 0, _a = node.specifiers; _i < _a.length; _i++) {
-        var specifier = _a[_i];
-        if (types.isImportSpecifier(specifier)) {
-            importObject.imports[specifier.local.name] = specifier.imported.name;
-        }
-        else if (types.isImportDefaultSpecifier(specifier)) {
-            importObject.imports[specifier.local.name] = 'default';
-        }
-        else if (types.isImportNamespaceSpecifier(specifier)) {
-            importObject.imports[specifier.local.name] = '*';
-        }
-    }
-    return importObject;
-};
-exports.mapImportDeclarationToMitosisImport = mapImportDeclarationToMitosisImport;
 var handleImportDeclaration = function (_a) {
     var options = _a.options, path = _a.path, context = _a.context;
     // @builder.io/mitosis or React imports compile away
@@ -64,7 +44,7 @@ var handleImportDeclaration = function (_a) {
         path.remove();
         return;
     }
-    var importObject = (0, exports.mapImportDeclarationToMitosisImport)(path.node);
+    var importObject = (0, mitosis_imports_1.mapImportDeclarationToMitosisImport)(path.node);
     context.builder.component.imports.push(importObject);
     path.remove();
 };

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

@@ -1,2 +1 @@
 export { parseJsx } from './jsx';
-export { createTypescriptProject, mapSignalTypeInTSFile } from './types-identification';

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

@@ -1,8 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapSignalTypeInTSFile = exports.createTypescriptProject = exports.parseJsx = void 0;
+exports.parseJsx = void 0;
 var jsx_1 = require("./jsx");
 Object.defineProperty(exports, "parseJsx", { enumerable: true, get: function () { return jsx_1.parseJsx; } });
-var types_identification_1 = require("./types-identification");
-Object.defineProperty(exports, "createTypescriptProject", { enumerable: true, get: function () { return types_identification_1.createTypescriptProject; } });
-Object.defineProperty(exports, "mapSignalTypeInTSFile", { enumerable: true, get: function () { return types_identification_1.mapSignalTypeInTSFile; } });

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

@@ -47,6 +47,7 @@ var hooks_1 = require("../../constants/hooks");
 var create_mitosis_component_1 = require("../../helpers/create-mitosis-component");
 var json_1 = require("../../helpers/json");
 var replace_new_lines_in_strings_1 = require("../../helpers/replace-new-lines-in-strings");
+var signals_1 = require("../../helpers/signals");
 var ast_1 = require("./ast");
 var component_types_1 = require("./component-types");
 var context_1 = require("./context");
@@ -58,8 +59,8 @@ var hooks_2 = require("./hooks");
 var use_target_1 = require("./hooks/use-target");
 var imports_1 = require("./imports");
 var props_1 = require("./props");
+var signals_2 = require("./signals");
 var state_1 = require("./state");
-var types_identification_1 = require("./types-identification");
 var types = babel.types;
 var typescriptBabelPreset = [preset_typescript_1.default, { isTSX: true, allExtensions: true }];
 var beforeParse = function (path) {
@@ -197,12 +198,12 @@ function parseJsx(jsx, _options) {
     (0, state_1.mapStateIdentifiers)(mitosisComponent);
     (0, context_1.extractContextComponents)(mitosisComponent);
     mitosisComponent.subComponents = subComponentFunctions.map(function (item) { return parseJsx(item, options); });
-    var signalTypeImportName = (0, types_identification_1.getSignalImportName)(jsxToUse);
+    var signalTypeImportName = (0, signals_1.getSignalImportName)(jsxToUse);
     if (signalTypeImportName) {
         mitosisComponent.signals = { signalTypeImportName: signalTypeImportName };
     }
     if (options.tsProject && options.filePath) {
-        var reactiveValues = (0, types_identification_1.findSignals)({
+        var reactiveValues = (0, signals_2.findSignals)({
             filePath: options.filePath,
             project: options.tsProject.project,
             signalSymbol: options.tsProject.signalSymbol,

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

@@ -0,0 +1,11 @@
+import { Project, Symbol } from 'ts-morph';
+export declare const findSignals: (args: {
+    project: Project;
+    signalSymbol: Symbol;
+    code?: string | undefined;
+    filePath?: string | undefined;
+}) => {
+    props: Set<string>;
+    state: Set<string>;
+    context: Set<string>;
+};