@builder.io/mitosis 0.5.23 → 0.5.25

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

@@ -0,0 +1,184 @@
+"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.resolveMetadata = void 0;
+const mitosis_imports_1 = require("../../../helpers/mitosis-imports");
+const helpers_1 = require("../../../parsers/jsx/helpers");
+const babel = __importStar(require("@babel/core"));
+const fs_extra_promise_1 = require("fs-extra-promise");
+const path = __importStar(require("path"));
+const getCodeFromImport = (importObject, currentFile) => {
+    if (currentFile) {
+        // resolve path of import
+        const originFile = path.basename(currentFile);
+        const typescript = (0, helpers_1.isTypescriptFile)(originFile);
+        const importFile = (0, helpers_1.isTypescriptFile)(importObject.path) || importObject.path.endsWith('.js')
+            ? importObject.path
+            : `${importObject.path}.${typescript ? 'ts' : 'js'}`;
+        const importFilePath = path.resolve(path.dirname(currentFile), importFile);
+        if ((0, fs_extra_promise_1.existsSync)(importFilePath)) {
+            return { code: (0, fs_extra_promise_1.readFileSync)(importFilePath).toString(), typescript, importFilePath };
+        }
+        return { typescript };
+    }
+    return {};
+};
+const fillDeclarations = ({ declaration, valueToResolve, currentFilePath, nodePath, }) => {
+    let result = {};
+    for (const variable of declaration.declarations) {
+        if (babel.types.isIdentifier(variable.id)) {
+            if (variable.id.name === valueToResolve && variable.init) {
+                const filled = resolveObjectsRecursive({
+                    node: variable.init,
+                    nodePath,
+                    currentFilePath,
+                });
+                result = {
+                    ...result,
+                    ...filled,
+                };
+            }
+        }
+    }
+    return result;
+};
+const resolve = ({ nodePath, currentFilePath, valueToResolve, resolvedImports, }) => {
+    let result = {};
+    const programNodes = nodePath.node.body;
+    for (const statement of programNodes) {
+        if (babel.types.isImportDeclaration(statement)) {
+            const importObject = (0, mitosis_imports_1.mapImportDeclarationToMitosisImport)(statement);
+            if (Object.keys(importObject.imports).includes(valueToResolve)) {
+                if (resolvedImports) {
+                    // We add this statement, to remove it from imports of generated file
+                    resolvedImports.push({ path: importObject.path, value: valueToResolve });
+                }
+                // In this case the variable was imported
+                const { code, typescript, importFilePath } = getCodeFromImport(importObject, currentFilePath);
+                if (code) {
+                    const jsxToUse = (0, helpers_1.babelStripTypes)(code, typescript);
+                    (0, helpers_1.babelDefaultTransform)(jsxToUse, {
+                        Program(path) {
+                            const statements = path.node.body;
+                            for (const pStatement of statements) {
+                                if (babel.types.isExportNamedDeclaration(pStatement)) {
+                                    const declaration = pStatement.declaration;
+                                    if (babel.types.isVariableDeclaration(declaration)) {
+                                        const filledDeclaration = fillDeclarations({
+                                            declaration,
+                                            valueToResolve,
+                                            currentFilePath: importFilePath,
+                                            nodePath: path,
+                                        });
+                                        result = {
+                                            ...result,
+                                            ...filledDeclaration,
+                                        };
+                                    }
+                                }
+                            }
+                        },
+                    });
+                }
+            }
+        }
+        else if (babel.types.isVariableDeclaration(statement)) {
+            // In this case the variable is inside the same file
+            const filledDeclaration = fillDeclarations({
+                declaration: statement,
+                valueToResolve,
+                currentFilePath,
+                nodePath,
+            });
+            result = {
+                ...result,
+                ...filledDeclaration,
+            };
+        }
+    }
+    return result;
+};
+const resolveObjectsRecursive = ({ node, nodePath, currentFilePath, resolvedImports, }) => {
+    let result = {};
+    if (babel.types.isObjectExpression(node)) {
+        for (const prop of node.properties) {
+            if (babel.types.isObjectProperty(prop)) {
+                if (babel.types.isIdentifier(prop.key)) {
+                    const objectKey = prop.key.name;
+                    if (babel.types.isIdentifier(prop.value)) {
+                        const valueToResolve = prop.value.name;
+                        // In this case we have some variable defined in the same or another file
+                        const resolved = resolve({
+                            nodePath,
+                            currentFilePath,
+                            valueToResolve,
+                            resolvedImports,
+                        });
+                        result = {
+                            ...result,
+                            [objectKey]: { ...resolved },
+                        };
+                    }
+                    else {
+                        // In this case we have a primitive value
+                        const json = (0, helpers_1.parseCodeJson)(prop.value);
+                        result = {
+                            ...result,
+                            [objectKey]: json,
+                        };
+                    }
+                }
+            }
+            else if (babel.types.isSpreadElement(prop)) {
+                if (babel.types.isIdentifier(prop.argument)) {
+                    const valueToResolve = prop.argument.name;
+                    result = {
+                        ...result,
+                        ...resolve({ nodePath, currentFilePath, valueToResolve }),
+                    };
+                }
+            }
+            else {
+                // In this case we have a primitive value
+                result = {
+                    ...result,
+                    ...(0, helpers_1.parseCodeJson)(prop),
+                };
+            }
+        }
+    }
+    return result;
+};
+const resolveMetadata = ({ context, node, nodePath, options, }) => {
+    if (context.cwd && (options === null || options === void 0 ? void 0 : options.filePath)) {
+        const resolvedImports = [];
+        const currentFilePath = `${context.cwd}/${options.filePath}`;
+        const metadata = resolveObjectsRecursive({ node, nodePath, currentFilePath, resolvedImports });
+        context.builder.resolvedImports = resolvedImports;
+        return metadata;
+    }
+    return {};
+};
+exports.resolveMetadata = resolveMetadata;

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

@@ -1,9 +1,7 @@
 import * as babel from '@babel/core';
 import { Context, ParseMitosisOptions } from './types';
-declare const types: typeof babel.types;
 export declare const handleImportDeclaration: ({ options, path, context, }: {
     options: Partial<ParseMitosisOptions>;
     path: babel.NodePath<babel.types.ImportDeclaration>;
     context: Context;
 }) => void;
-export {};

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

@@ -1,33 +1,9 @@
 "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.handleImportDeclaration = void 0;
-const babel = __importStar(require("@babel/core"));
 const mitosis_imports_1 = require("../../helpers/mitosis-imports");
-const { types } = babel;
 const handleImportDeclaration = ({ options, path, context, }) => {
+    var _a;
     // @builder.io/mitosis or React imports compile away
     const customPackages = (options === null || options === void 0 ? void 0 : options.compileAwayPackages) || [];
     if (['react', '@builder.io/mitosis', '@emotion/react', ...customPackages].includes(path.node.source.value)) {
@@ -35,7 +11,13 @@ const handleImportDeclaration = ({ options, path, context, }) => {
         return;
     }
     const importObject = (0, mitosis_imports_1.mapImportDeclarationToMitosisImport)(path.node);
-    context.builder.component.imports.push(importObject);
+    const resolvedImport = (_a = context.builder.resolvedImports) === null || _a === void 0 ? void 0 : _a.find((rImport) => rImport.path === importObject.path);
+    if (resolvedImport) {
+        delete importObject.imports[resolvedImport.value];
+    }
+    if (Object.keys(importObject.imports).length > 0) {
+        context.builder.component.imports.push(importObject);
+    }
     path.remove();
 };
 exports.handleImportDeclaration = handleImportDeclaration;

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

@@ -27,18 +27,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJsx = void 0;
+const hooks_1 = require("../../constants/hooks");
+const create_mitosis_component_1 = require("../../helpers/create-mitosis-component");
 const filter_empty_text_nodes_1 = require("../../helpers/filter-empty-text-nodes");
+const json_1 = require("../../helpers/json");
+const replace_new_lines_in_strings_1 = require("../../helpers/replace-new-lines-in-strings");
+const signals_1 = require("../../helpers/signals");
 const traverse_nodes_1 = require("../../helpers/traverse-nodes");
 const babel = __importStar(require("@babel/core"));
 const generator_1 = __importDefault(require("@babel/generator"));
-const plugin_syntax_typescript_1 = __importDefault(require("@babel/plugin-syntax-typescript"));
 const preset_typescript_1 = __importDefault(require("@babel/preset-typescript"));
 const function_1 = require("fp-ts/lib/function");
-const hooks_1 = require("../../constants/hooks");
-const create_mitosis_component_1 = require("../../helpers/create-mitosis-component");
-const json_1 = require("../../helpers/json");
-const replace_new_lines_in_strings_1 = require("../../helpers/replace-new-lines-in-strings");
-const signals_1 = require("../../helpers/signals");
 const ast_1 = require("./ast");
 const component_types_1 = require("./component-types");
 const context_1 = require("./context");
@@ -70,112 +69,94 @@ const beforeParse = (path) => {
  * @returns A JSON representation of the Mitosis component
  */
 function parseJsx(jsx, _options = {}) {
-    var _a;
     let subComponentFunctions = [];
     const options = {
         typescript: false,
         ..._options,
     };
-    const jsxToUse = options.typescript
-        ? jsx
-        : // strip typescript types by running through babel's TS preset.
-            (_a = babel.transform(jsx, {
-                configFile: false,
-                babelrc: false,
-                presets: [typescriptBabelPreset],
-            })) === null || _a === void 0 ? void 0 : _a.code;
     const stateToScope = [];
-    const output = babel.transform(jsxToUse, {
-        configFile: false,
-        babelrc: false,
-        comments: false,
-        plugins: [
-            [plugin_syntax_typescript_1.default, { isTSX: true }],
-            () => ({
-                visitor: {
-                    JSXExpressionContainer(path, context) {
-                        if (types.isJSXEmptyExpression(path.node.expression)) {
-                            path.remove();
-                        }
-                    },
-                    Program(path, context) {
-                        if (context.builder) {
-                            return;
-                        }
-                        beforeParse(path);
-                        context.builder = {
-                            component: (0, create_mitosis_component_1.createMitosisComponent)(),
-                        };
-                        const keepStatements = path.node.body.filter((statement) => (0, helpers_1.isImportOrDefaultExport)(statement) || (0, component_types_1.isTypeOrInterface)(statement));
-                        context.builder.component.exports = (0, exports_1.generateExports)(path);
-                        subComponentFunctions = path.node.body
-                            .filter((node) => !types.isExportDefaultDeclaration(node) && types.isFunctionDeclaration(node))
-                            .map((node) => `export default ${(0, generator_1.default)(node).code}`);
-                        const preComponentCode = (0, function_1.pipe)(path.node.body.filter((statement) => !(0, helpers_1.isImportOrDefaultExport)(statement)), (0, hooks_2.collectModuleScopeHooks)(context.builder.component, options), types.program, generator_1.default, (generatorResult) => generatorResult.code);
-                        // TODO: support multiple? e.g. for others to add imports?
-                        context.builder.component.hooks.preComponent = { code: preComponentCode };
-                        path.replaceWith(types.program(keepStatements));
-                    },
-                    FunctionDeclaration(path, context) {
-                        const { node } = path;
-                        if (types.isIdentifier(node.id)) {
-                            const name = node.id.name;
-                            if (name[0].toUpperCase() === name[0]) {
-                                path.traverse({
-                                    /**
-                                     * Plugin to find all `useTarget()` assignment calls inside of the component function body
-                                     * and replace them with a magic string.
-                                     */
-                                    CallExpression(path) {
-                                        if (!types.isCallExpression(path.node))
-                                            return;
-                                        if (!types.isIdentifier(path.node.callee))
-                                            return;
-                                        if (path.node.callee.name !== hooks_1.HOOKS.TARGET)
-                                            return;
-                                        const targetBlock = (0, use_target_1.getUseTargetStatements)(path);
-                                        if (!targetBlock)
-                                            return;
-                                        const blockId = (0, use_target_1.getTargetId)(context.builder.component);
-                                        // replace the useTarget() call with a magic string
-                                        path.replaceWith(types.stringLiteral((0, use_target_1.getMagicString)(blockId)));
-                                        // store the target block in the component
-                                        context.builder.component.targetBlocks = {
-                                            ...context.builder.component.targetBlocks,
-                                            [blockId]: targetBlock,
-                                        };
-                                    },
-                                });
-                                path.replaceWith((0, ast_1.jsonToAst)((0, function_parser_1.componentFunctionToJson)(node, context, stateToScope)));
-                            }
-                        }
-                    },
-                    ImportDeclaration(path, context) {
-                        (0, imports_1.handleImportDeclaration)({ options, path, context });
-                    },
-                    ExportDefaultDeclaration(path) {
-                        path.replaceWith(path.node.declaration);
-                    },
-                    JSXElement(path) {
-                        const { node } = path;
-                        path.replaceWith((0, ast_1.jsonToAst)((0, element_parser_1.jsxElementToJson)(node)));
-                    },
-                    ExportNamedDeclaration(path, context) {
-                        const { node } = path;
-                        if (babel.types.isTSInterfaceDeclaration(node.declaration) ||
-                            babel.types.isTSTypeAliasDeclaration(node.declaration)) {
-                            (0, component_types_1.collectTypes)(path, context);
-                        }
-                    },
-                    TSTypeAliasDeclaration(path, context) {
-                        (0, component_types_1.collectTypes)(path, context);
-                    },
-                    TSInterfaceDeclaration(path, context) {
-                        (0, component_types_1.collectTypes)(path, context);
-                    },
-                },
-            }),
-        ],
+    const jsxToUse = (0, helpers_1.babelStripTypes)(jsx, !options.typescript);
+    const output = (0, helpers_1.babelDefaultTransform)(jsxToUse, {
+        JSXExpressionContainer(path, context) {
+            if (types.isJSXEmptyExpression(path.node.expression)) {
+                path.remove();
+            }
+        },
+        Program(path, context) {
+            if (context.builder) {
+                return;
+            }
+            beforeParse(path);
+            context.builder = {
+                component: (0, create_mitosis_component_1.createMitosisComponent)(),
+            };
+            const keepStatements = path.node.body.filter((statement) => (0, helpers_1.isImportOrDefaultExport)(statement) || (0, component_types_1.isTypeOrInterface)(statement));
+            context.builder.component.exports = (0, exports_1.generateExports)(path);
+            subComponentFunctions = path.node.body
+                .filter((node) => !types.isExportDefaultDeclaration(node) && types.isFunctionDeclaration(node))
+                .map((node) => `export default ${(0, generator_1.default)(node).code}`);
+            const preComponentCode = (0, function_1.pipe)(path, (0, hooks_2.collectModuleScopeHooks)(context, options), types.program, generator_1.default, (generatorResult) => generatorResult.code);
+            // TODO: support multiple? e.g. for others to add imports?
+            context.builder.component.hooks.preComponent = { code: preComponentCode };
+            path.replaceWith(types.program(keepStatements));
+        },
+        FunctionDeclaration(path, context) {
+            const { node } = path;
+            if (types.isIdentifier(node.id)) {
+                const name = node.id.name;
+                if (name[0].toUpperCase() === name[0]) {
+                    path.traverse({
+                        /**
+                         * Plugin to find all `useTarget()` assignment calls inside of the component function body
+                         * and replace them with a magic string.
+                         */
+                        CallExpression(path) {
+                            if (!types.isCallExpression(path.node))
+                                return;
+                            if (!types.isIdentifier(path.node.callee))
+                                return;
+                            if (path.node.callee.name !== hooks_1.HOOKS.TARGET)
+                                return;
+                            const targetBlock = (0, use_target_1.getUseTargetStatements)(path);
+                            if (!targetBlock)
+                                return;
+                            const blockId = (0, use_target_1.getTargetId)(context.builder.component);
+                            // replace the useTarget() call with a magic string
+                            path.replaceWith(types.stringLiteral((0, use_target_1.getMagicString)(blockId)));
+                            // store the target block in the component
+                            context.builder.component.targetBlocks = {
+                                ...context.builder.component.targetBlocks,
+                                [blockId]: targetBlock,
+                            };
+                        },
+                    });
+                    path.replaceWith((0, ast_1.jsonToAst)((0, function_parser_1.componentFunctionToJson)(node, context, stateToScope)));
+                }
+            }
+        },
+        ImportDeclaration(path, context) {
+            (0, imports_1.handleImportDeclaration)({ options, path, context });
+        },
+        ExportDefaultDeclaration(path) {
+            path.replaceWith(path.node.declaration);
+        },
+        JSXElement(path) {
+            const { node } = path;
+            path.replaceWith((0, ast_1.jsonToAst)((0, element_parser_1.jsxElementToJson)(node)));
+        },
+        ExportNamedDeclaration(path, context) {
+            const { node } = path;
+            if (babel.types.isTSInterfaceDeclaration(node.declaration) ||
+                babel.types.isTSTypeAliasDeclaration(node.declaration)) {
+                (0, component_types_1.collectTypes)(path, context);
+            }
+        },
+        TSTypeAliasDeclaration(path, context) {
+            (0, component_types_1.collectTypes)(path, context);
+        },
+        TSInterfaceDeclaration(path, context) {
+            (0, component_types_1.collectTypes)(path, context);
+        },
     });
     if (!output || !output.code) {
         throw new Error('Could not parse JSX');

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

@@ -1,5 +1,5 @@
-import { Project } from 'ts-morph';
 import { MitosisComponent } from '../../types/mitosis-component';
+import { Project } from 'ts-morph';
 export type ParseMitosisOptions = {
     jsonHookNames?: string[];
     compileAwayPackages?: string[];
@@ -9,8 +9,14 @@ export type ParseMitosisOptions = {
     };
     filePath?: string;
 };
+export type ResolvedImport = {
+    path: string;
+    value: string;
+};
 export type Context = {
+    cwd?: string;
     builder: {
         component: MitosisComponent;
+        resolvedImports?: ResolvedImport[];
     };
 };

package/dist/src/parsers/svelte/helpers/post-process.d.ts

@@ -7,7 +7,7 @@ type SveltosisStateValue = StateValue & {
 export declare function preventNameCollissions(json: SveltosisComponent, item: SveltosisStateValue): {
     code: string;
     typeParameter?: string | undefined;
-    type: "function" | "getter" | "method" | "property";
+    type: "function" | "method" | "property" | "getter";
     propertyType?: import("../../../types/mitosis-component").ReactivityType | undefined;
     arguments?: string[] | undefined;
 };

package/dist/src/plugins/compile-away-builder-components.d.ts

@@ -1,4 +1,4 @@
-import { type Plugin } from '..';
+import { type MitosisPlugin } from '..';
 import { TraverseContext } from 'neotraverse/legacy';
 import { MitosisComponent } from '../types/mitosis-component';
 import { MitosisNode } from '../types/mitosis-node';
@@ -11,5 +11,5 @@ type CompileAwayBuilderComponentsOptions = {
     omit?: string[];
 };
 export declare const compileAwayBuilderComponentsFromTree: (tree: MitosisNode | MitosisComponent, components: CompileAwayComponentsMap) => void;
-export declare const compileAwayBuilderComponents: (pluginOptions?: CompileAwayBuilderComponentsOptions) => Plugin;
+export declare const compileAwayBuilderComponents: (pluginOptions?: CompileAwayBuilderComponentsOptions) => MitosisPlugin;
 export {};

package/dist/src/types/config.d.ts

@@ -1,7 +1,7 @@
-import type { ParseMitosisOptions } from '../parsers/jsx/types';
+import type { ParseMitosisOptions } from '../parsers/jsx';
 import { targets } from '../targets';
 import type { MitosisComponent } from './mitosis-component';
-import { BaseTranspilerOptions } from './transpiler';
+import { BaseTranspilerOptions, TranspilerGenerator } from './transpiler';
 export type Format = 'esm' | 'cjs';
 export type Language = 'js' | 'ts';
 interface TranspilerOptions {
@@ -17,6 +17,15 @@ export type GeneratorOptions = {
 export type generatorsOption = {
     [K in Target]: NonNullable<Targets[K]>;
 };
+export interface TargetContext {
+    target: Target;
+    generator: TranspilerGenerator<NonNullable<MitosisConfig['options'][Target]>>;
+    outputPath: string;
+}
+export interface OutputFiles {
+    outputDir: string;
+    outputFilePath: string;
+}
 export type MitosisConfig = {
     generators?: generatorsOption;
     /**

package/dist/src/types/mitosis-component.d.ts

@@ -136,6 +136,15 @@ export type MitosisComponent = {
     propsTypeRef?: string;
     defaultProps?: MitosisState;
     style?: string;
+    /**
+     * This data is filled inside cli to provide more data for plugins
+     */
+    pluginData?: {
+        target?: Target;
+        path?: string;
+        outputDir?: string;
+        outputFilePath?: string;
+    };
     /**
      * Used to store context of a component for a specific framework
      * that we need access only during compilation (for internal use only) and gets removed after compilation.

package/dist/src/types/plugins.d.ts

@@ -1,11 +1,19 @@
+import { OutputFiles, TargetContext } from '../types/config';
 import { MitosisComponent } from './mitosis-component';
-export type Plugin = (options?: any) => {
-    json?: {
-        pre?: (json: MitosisComponent) => MitosisComponent | void;
-        post?: (json: MitosisComponent) => MitosisComponent | void;
-    };
-    code?: {
-        pre?: (code: string, json: MitosisComponent) => string;
-        post?: (code: string, json: MitosisComponent) => string;
-    };
+export type MitosisBuildPlugin = (targetContext: TargetContext, files?: {
+    componentFiles: OutputFiles[];
+    nonComponentFiles: OutputFiles[];
+}) => void | Promise<void>;
+export type MitosisJsonPlugin = (json: MitosisComponent) => MitosisComponent | void;
+export type MitosisCodePlugin = (code: string, json: MitosisComponent) => string;
+export type MitosisHook<T> = {
+    pre?: T;
+    post?: T;
+};
+export type MitosisPlugin = (options?: any) => {
+    name?: string;
+    order?: number;
+    build?: MitosisHook<MitosisBuildPlugin>;
+    json?: MitosisHook<MitosisJsonPlugin>;
+    code?: MitosisHook<MitosisCodePlugin>;
 };

package/dist/src/types/transpiler.d.ts

@@ -1,5 +1,5 @@
 import { MitosisComponent } from './mitosis-component';
-import { Plugin } from './plugins';
+import { MitosisPlugin } from './plugins';
 export interface TranspilerArgs {
     path?: string;
     component: MitosisComponent;
@@ -20,7 +20,7 @@ export interface BaseTranspilerOptions {
     /**
      * Mitosis Plugins to run during codegen.
      */
-    plugins?: Plugin[];
+    plugins?: MitosisPlugin[];
     /**
      * Enable `typescript` output
      */
@@ -29,4 +29,14 @@ export interface BaseTranspilerOptions {
      * Preserves explicit filename extensions in import statements.
      */
     explicitImportFileExtension?: boolean;
+    /**
+     * Can be used for cli builds. Preserves explicit filename extensions when regex matches, e.g.:
+     * {
+     *   explicitBuildFileExtension: {
+     *     ".ts":/*.figma.lite.tsx/g,
+     *     ".md":/*.docs.lite.tsx/g
+     *   }
+     * }
+     */
+    explicitBuildFileExtensions?: Record<string, RegExp>;
 }

package/package.json

@@ -22,7 +22,7 @@
     "name": "Builder.io",
     "url": "https://www.builder.io"
   },
-  "version": "0.5.23",
+  "version": "0.5.25",
   "homepage": "https://github.com/BuilderIO/mitosis",
   "main": "./dist/src/index.js",
   "exports": {