@builder.io/mitosis 0.0.0-dev-20260605060721

package/dist/src/plugins/map-styles.d.ts

@@ -0,0 +1,12 @@
+import { TraverseContext } from 'neotraverse/legacy';
+import { MitosisComponent } from '../types/mitosis-component';
+import { MitosisStyles } from '../types/mitosis-styles';
+type MapStylesOptions = {
+    map: (styles: MitosisStyles, context: TraverseContext) => MitosisStyles;
+};
+export declare const mapStyles: (pluginOptions: MapStylesOptions) => (options: any) => {
+    json: {
+        pre: (json: MitosisComponent) => void;
+    };
+};
+export {};

package/dist/src/plugins/map-styles.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapStyles = void 0;
+const get_styles_1 = require("../helpers/get-styles");
+const traverse_nodes_1 = require("../helpers/traverse-nodes");
+const mapStyles = (pluginOptions) => (options) => ({
+    json: {
+        pre: (json) => {
+            (0, traverse_nodes_1.traverseNodes)(json, (node, context) => {
+                const styles = (0, get_styles_1.getStyles)(node);
+                (0, get_styles_1.setStyles)(node, pluginOptions.map(styles || {}, context));
+            });
+        },
+    },
+});
+exports.mapStyles = mapStyles;

package/dist/src/symbols/symbol-processor.d.ts

@@ -0,0 +1,20 @@
+import { MitosisComponent } from '../types/mitosis-component';
+import { BuilderContent, BuilderElement } from '@builder.io/sdk';
+export type SymbolHierarchy = {
+    depthFirstSymbols: BuilderElement[];
+} & {
+    [id: string]: string[];
+};
+/**
+ * Ensure every symbol in a BuilderContent tree has a unique ID.
+ * Mutates the data tree directly.
+ */
+export declare function ensureAllSymbolsHaveIds(content: BuilderContent): void;
+export declare function convertBuilderContentToSymbolHierarchy(content: BuilderContent, { collectComponentStyles, collectComponentState, }?: {
+    collectComponentStyles?: string[];
+    collectComponentState?: Record<string, any>;
+}): SymbolHierarchy;
+export declare function convertBuilderElementToMitosisComponent(element: BuilderElement): MitosisComponent | null;
+export declare function getJsxSymbolComponentName(id: string): string;
+export declare function hashCodeAsString(obj: any): string;
+export declare function hashCode(obj: any, hash?: number): number;

package/dist/src/symbols/symbol-processor.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashCode = exports.hashCodeAsString = exports.getJsxSymbolComponentName = exports.convertBuilderElementToMitosisComponent = exports.convertBuilderContentToSymbolHierarchy = exports.ensureAllSymbolsHaveIds = void 0;
+const minify_1 = require("../generators/helpers/minify");
+const builder_1 = require("../parsers/builder");
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+/**
+ * Ensure every symbol in a BuilderContent tree has a unique ID.
+ * Mutates the data tree directly.
+ */
+function ensureAllSymbolsHaveIds(content) {
+    let counter = 0;
+    const ids = new Set();
+    (0, legacy_1.default)(content).forEach(function (el) {
+        var _a, _b, _c;
+        if (this.key === 'jsCode' && isString(el) && el.endsWith('return _virtual_index')) {
+            // Sometimes rollup adds a final `return _virtual_index` but that causes VM evaluation to fail.
+            // Instead of a return on the last line, it needs a plain expression on the last line. Luckily
+            // because the rollup compile behavior is consistent this works pretty reliably
+            el = el.replace(/return _virtual_index$/, '_virtual_index');
+            this.parent && (this.parent.node.jsCode = el);
+        }
+        if ((0, builder_1.isBuilderElement)(el)) {
+            if (((_a = el === null || el === void 0 ? void 0 : el.component) === null || _a === void 0 ? void 0 : _a.name) === 'Symbol') {
+                const id = getIdFromSymbol(el);
+                if (id) {
+                    if (ids.has(id)) {
+                        if ((_c = (_b = el.component) === null || _b === void 0 ? void 0 : _b.options) === null || _c === void 0 ? void 0 : _c.symbol) {
+                            const id = pad(counter++);
+                            el.component.options.symbol.entry = id;
+                            if (el.component.options.symbol.content) {
+                                el.component.options.symbol.content.id = id;
+                            }
+                            ids.add(id);
+                        }
+                    }
+                    else {
+                        ids.add(id);
+                    }
+                }
+            }
+        }
+    });
+}
+exports.ensureAllSymbolsHaveIds = ensureAllSymbolsHaveIds;
+//TODO(misko): needs test
+function convertBuilderContentToSymbolHierarchy(content, { collectComponentStyles, collectComponentState, } = {}) {
+    var _a, _b;
+    if (collectComponentState && ((_a = content.data) === null || _a === void 0 ? void 0 : _a.state)) {
+        const state = (_b = content.data) === null || _b === void 0 ? void 0 : _b.state;
+        collectComponentState['ROOT_COMPONENT_STATE'] = state;
+    }
+    const path = [-1, content.id];
+    const hierarchy = {
+        depthFirstSymbols: [],
+        [content.id]: [],
+    };
+    (0, legacy_1.default)(content).forEach(function (el) {
+        var _a, _b, _c;
+        let cssCode = el === null || el === void 0 ? void 0 : el.cssCode;
+        if (cssCode) {
+            collectComponentStyles && collectComponentStyles.push((0, minify_1.minify) `${cssCode}`);
+        }
+        while (path[0 /* Path.DEPTH */] >= this.path.length) {
+            path.shift();
+            path.shift();
+        }
+        if ((0, builder_1.isBuilderElement)(el)) {
+            if (((_a = el === null || el === void 0 ? void 0 : el.component) === null || _a === void 0 ? void 0 : _a.name) === 'Symbol') {
+                if (collectComponentState) {
+                    const symbol = el.component.options.symbol;
+                    const props = symbol.data || (symbol.data = {});
+                    const state = (_c = (_b = symbol.content) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.state;
+                    if (state) {
+                        const id = hashCodeAsString(state);
+                        props['serverStateId'] = id;
+                        collectComponentState[id] = state;
+                    }
+                }
+                if (path[0 /* Path.DEPTH */] < this.path.length) {
+                    const id = getIdFromSymbol(el);
+                    hierarchy[id] = [];
+                    addIfMissing(hierarchy[path[1 /* Path.ID */]], id);
+                    path.unshift(this.path.length, id);
+                }
+                // TODO(misko): This should be `el.content` not `el`
+                // Because we don't wante to take the `<Symbol>` with us.
+                // TODO(misko): Do we really want to add ALL symbols? Even duplicates?
+                hierarchy.depthFirstSymbols.unshift(el);
+            }
+        }
+    });
+    return hierarchy;
+}
+exports.convertBuilderContentToSymbolHierarchy = convertBuilderContentToSymbolHierarchy;
+function convertBuilderElementToMitosisComponent(element) {
+    var _a, _b;
+    const symbolValue = (_b = (_a = element.component) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.symbol;
+    const elContent = symbolValue === null || symbolValue === void 0 ? void 0 : symbolValue.content;
+    if (!elContent) {
+        console.warn('Symbol missing content', element.id);
+        delete element.component; // TODO(misko): Should this be assign `undefined` for perf?
+        element.children = [];
+        return null;
+    }
+    const id = getIdFromSymbol(element);
+    const componentName = getJsxSymbolComponentName(id);
+    delete element.component; // TODO(misko): Should this be assign `undefined` for perf?
+    element.children = [
+        (0, builder_1.createBuilderElement)({
+            component: {
+                name: componentName,
+                options: symbolValue.data,
+            },
+            properties: {
+                'builder-content-id': id,
+            },
+        }),
+    ];
+    const mitosisComponent = {
+        ...(0, builder_1.builderContentToMitosisComponent)(elContent, {
+            includeBuilderExtras: true,
+            preserveTextBlocks: true,
+        }),
+        name: componentName,
+    };
+    mitosisComponent.meta.builderElId = element.id;
+    return mitosisComponent;
+}
+exports.convertBuilderElementToMitosisComponent = convertBuilderElementToMitosisComponent;
+function getJsxSymbolComponentName(id) {
+    return 'Component' + id.toUpperCase().replace(/-/g, '');
+}
+exports.getJsxSymbolComponentName = getJsxSymbolComponentName;
+function getIdFromSymbol(el) {
+    var _a, _b, _c;
+    // TODO(misko): Don't use entry us el.id???
+    return (_c = (_b = (_a = el.component) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.symbol) === null || _c === void 0 ? void 0 : _c.entry;
+}
+function addIfMissing(array, value) {
+    if (array.indexOf(value) == -1) {
+        array.push(value);
+    }
+}
+function isString(value) {
+    return typeof value == 'string';
+}
+function hashCodeAsString(obj) {
+    return Number(Math.abs(hashCode(obj))).toString(36);
+}
+exports.hashCodeAsString = hashCodeAsString;
+function hashCode(obj, hash = 0) {
+    let value = 0;
+    switch (typeof obj) {
+        case 'number':
+            value = obj;
+            break;
+        case 'undefined':
+            value = Number.MIN_SAFE_INTEGER;
+            break;
+        case 'string':
+            for (let i = 0; i < obj.length; i++) {
+                hash = hashCodeApply(hash, obj.charCodeAt(i));
+            }
+            value = obj.length;
+        case 'boolean':
+            value = obj ? 1 : 0;
+            break;
+        case 'object':
+            if (obj === null) {
+                value = Number.MAX_SAFE_INTEGER;
+            }
+            else if (Array.isArray(obj)) {
+                for (let i = 0; i < obj.length; i++) {
+                    hash = hashCode(obj[i], hash);
+                }
+            }
+            else {
+                for (const key of Object.keys(obj).sort()) {
+                    if (obj.hasOwnProperty(key)) {
+                        hash = hashCode(obj[key], hash);
+                    }
+                }
+            }
+            break;
+    }
+    return hashCodeApply(hash, value);
+}
+exports.hashCode = hashCode;
+function hashCodeApply(hash, value) {
+    hash = (hash << 5) - hash + value;
+    hash |= 0; // Convert to 32bit integer
+    return hash;
+}
+function pad(value) {
+    const padding = '000000';
+    let result = padding + String(value);
+    return result.substring(result.length - padding.length);
+}

package/dist/src/targets.d.ts

@@ -0,0 +1,25 @@
+export declare const builder: (options?: import("./generators/builder").ToBuilderOptions) => ({ component }: import(".").TranspilerArgs) => import("@builder.io/sdk").BuilderContent;
+export declare const targets: {
+    readonly alpine: import(".").TranspilerGenerator<import("./generators/alpine").ToAlpineOptions>;
+    readonly angular: import(".").TranspilerGenerator<import("./generators/angular").ToAngularOptions>;
+    readonly customElement: import(".").TranspilerGenerator<import("./generators/html").ToHtmlOptions>;
+    readonly html: import(".").TranspilerGenerator<import("./generators/html").ToHtmlOptions>;
+    readonly mitosis: import(".").TranspilerGenerator<Partial<import("./generators/mitosis").ToMitosisOptions>>;
+    readonly liquid: import(".").TranspilerGenerator<import("./generators/liquid").ToLiquidOptions>;
+    readonly react: import(".").TranspilerGenerator<Partial<import("./generators/react").ToReactOptions>>;
+    readonly reactNative: import(".").TranspilerGenerator<Partial<import("./generators/react-native").ToReactNativeOptions>>;
+    readonly solid: import(".").TranspilerGenerator<Partial<import("./generators/solid").ToSolidOptions>>;
+    readonly svelte: import(".").TranspilerGenerator<import("./generators/svelte").ToSvelteOptions>;
+    readonly swift: import(".").TranspilerGenerator<import("./generators/swift").ToSwiftOptions>;
+    readonly template: import(".").TranspilerGenerator<import("./generators/template").ToTemplateOptions>;
+    readonly webcomponent: import(".").TranspilerGenerator<import("./generators/html").ToHtmlOptions>;
+    readonly vue: import(".").TranspilerGenerator<Partial<import("./generators/vue").ToVueOptions>>;
+    readonly stencil: import(".").TranspilerGenerator<import("./generators/stencil").ToStencilOptions>;
+    readonly qwik: import(".").TranspilerGenerator<import("./generators/qwik").ToQwikOptions>;
+    readonly marko: import(".").TranspilerGenerator<import("./generators/marko").ToMarkoOptions>;
+    readonly preact: import(".").TranspilerGenerator<Partial<import("./generators/react").ToReactOptions>>;
+    readonly lit: import(".").TranspilerGenerator<import("./generators/lit").ToLitOptions>;
+    readonly rsc: import(".").TranspilerGenerator<Partial<import("./generators/react").ToReactOptions>>;
+    readonly taro: import(".").TranspilerGenerator<Partial<import("./generators/react").ToReactOptions>>;
+};
+export type Targets = keyof typeof targets;

package/dist/src/targets.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targets = exports.builder = void 0;
+const alpine_1 = require("./generators/alpine");
+const angular_1 = require("./generators/angular");
+const builder_1 = require("./generators/builder");
+const html_1 = require("./generators/html");
+const liquid_1 = require("./generators/liquid");
+const lit_1 = require("./generators/lit");
+const marko_1 = require("./generators/marko");
+const mitosis_1 = require("./generators/mitosis");
+const qwik_1 = require("./generators/qwik");
+const react_1 = require("./generators/react");
+const react_native_1 = require("./generators/react-native");
+const rsc_1 = require("./generators/rsc");
+const solid_1 = require("./generators/solid");
+const stencil_1 = require("./generators/stencil");
+const svelte_1 = require("./generators/svelte");
+const swift_1 = require("./generators/swift");
+const taro_1 = require("./generators/taro");
+const template_1 = require("./generators/template");
+const vue_1 = require("./generators/vue");
+exports.builder = builder_1.componentToBuilder;
+exports.targets = {
+    alpine: alpine_1.componentToAlpine,
+    angular: angular_1.componentToAngular,
+    customElement: html_1.componentToCustomElement,
+    html: html_1.componentToHtml,
+    mitosis: mitosis_1.componentToMitosis,
+    liquid: liquid_1.componentToLiquid,
+    react: react_1.componentToReact,
+    reactNative: react_native_1.componentToReactNative,
+    solid: solid_1.componentToSolid,
+    svelte: svelte_1.componentToSvelte,
+    swift: swift_1.componentToSwift,
+    template: template_1.componentToTemplate,
+    webcomponent: html_1.componentToCustomElement,
+    vue: vue_1.componentToVue,
+    stencil: stencil_1.componentToStencil,
+    qwik: qwik_1.componentToQwik,
+    marko: marko_1.componentToMarko,
+    preact: react_1.componentToPreact,
+    lit: lit_1.componentToLit,
+    rsc: rsc_1.componentToRsc,
+    taro: taro_1.componentToTaro,
+};

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

@@ -0,0 +1,103 @@
+import type { ParseMitosisOptions } from '../parsers/jsx';
+import { targets } from '../targets';
+import type { MitosisComponent } from './mitosis-component';
+import { BaseTranspilerOptions, TranspilerGenerator } from './transpiler';
+export type Format = 'esm' | 'cjs';
+export type Language = 'js' | 'ts';
+interface TranspilerOptions {
+    format?: Format;
+}
+type Targets = typeof targets;
+export type Target = keyof Targets;
+export type GeneratorOptions = {
+    [K in Target]: NonNullable<Parameters<Targets[K]>[0]> & {
+        transpiler?: TranspilerOptions;
+    };
+};
+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;
+    /**
+     * Apply common options to all targets
+     */
+    commonOptions?: Omit<BaseTranspilerOptions, 'experimental'>;
+    /**
+     * List of targets to compile to.
+     */
+    targets: Target[];
+    /**
+     * The output directory. Defaults to `output`.
+     */
+    dest?: string;
+    /**
+     * globs of files to transpile. Defaults to `src/*`.
+     */
+    files?: string | string[];
+    /**
+     * Optional list of globs to exclude from transpilation.
+     */
+    exclude?: string[];
+    /**
+     * The directory where overrides are stored. The structure of the override directory must match that of the source code,
+     * with each target having its own sub-directory: `${overridesDir}/${target}/*`
+     * Defaults to `overrides`.
+     */
+    overridesDir?: string;
+    /**
+     * Dictionary of per-target configuration. For each target, the available options can be inspected by going to
+     * `packages/core/src/generators/xxx/types.ts`.
+     *
+     * Example:
+     *
+     * ```js
+     * options: {
+     *   vue: {
+     *     prettier: false,
+     *     namePrefix: (path) => path + '-my-vue-code',
+     *   },
+     *   react: {
+     *     stateType: 'builder';
+     *     stylesType: 'styled-jsx'
+     *     plugins: [myPlugin]
+     *   }
+     * }
+     * ```
+     */
+    options: Partial<GeneratorOptions>;
+    /**
+     * Configure a custom parser function which takes a string and returns MitosisJSON
+     * Defaults to the JSXParser of this project (src/parsers/jsx)
+     */
+    parser?: (code: string, path?: string) => MitosisComponent | Promise<MitosisComponent>;
+    /**
+     * Configure a custom function that provides the output path for each target.
+     * If you don't provide a path for a target by returning `undefined`,
+     * the default path will be used, which is the target name in kebabCase.
+     */
+    getTargetPath?: ({ target }: {
+        target: Target;
+    }) => string | undefined;
+    /**
+     * Provide options to the parser.
+     */
+    parserOptions?: {
+        jsx: Partial<ParseMitosisOptions> & {
+            /**
+             * Path to your project's `tsconfig.json` file. Needed for advanced types parsing (e.g. signals).
+             */
+            tsConfigFilePath?: string;
+        };
+    };
+};
+export {};

package/dist/src/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+export type JSONPrimitive = string | null | number | boolean | undefined;
+export type JSONObject = {
+    [key: string]: _JSON | undefined;
+};
+/**
+ * We use an underscore to avoid collisions with the global `JSON` primitive type.
+ */
+export type _JSON = JSONPrimitive | JSONObject | _JSON[];
+export type JSONPrimitiveOrNode = JSONPrimitive | babel.Node;
+export type JSONOrNodeObject = {
+    [key: string]: JSONOrNode;
+};
+export type JSONOrNode = JSONPrimitiveOrNode | JSONOrNodeObject | JSONOrNode[];

package/dist/src/types/json.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,55 @@
+import { AlpineMetadata } from '../generators/alpine/types';
+import { AngularMetadata } from '../generators/angular/types';
+import { BuilderMetadata } from '../generators/builder/types';
+import { HtmlMetadata } from '../generators/html/types';
+import { LiquidMetadata } from '../generators/liquid/types';
+import { LitMetadata } from '../generators/lit/types';
+import { MarkoMetadata } from '../generators/marko/types';
+import { MitosisMetadata } from '../generators/mitosis/types';
+import { QwikMetadata } from '../generators/qwik/types';
+import { ReactNativeMetadata } from '../generators/react-native/types';
+import { ReactServerComponentsMetadata } from '../generators/rsc/types';
+import { SolidMetadata } from '../generators/solid/types';
+import { StencilMetadata } from '../generators/stencil/types';
+import { SvelteMetadata } from '../generators/svelte/types';
+import { SwiftMetadata } from '../generators/swift/types';
+import { TaroMetadata } from '../generators/taro/types';
+import { TemplateMetadata } from '../generators/template/types';
+import { AttributePassingType, ReactMetadata, Target, VueMetadata } from '..';
+type Targets = typeof import('../targets').targets;
+type TargetOptions = {
+    [K in Target]?: Partial<NonNullable<Parameters<Targets[K]>[0]>>;
+};
+export type ComponentMetadata = {
+    [index: string]: any;
+    httpRequests?: Record<string, string>;
+    options?: TargetOptions;
+    /** @deprecated Use this for web-components to change the tagName  */
+    tagName?: string;
+    /** @deprecated Use this for react forwardRef */
+    forwardRef?: string;
+    /** Enables shadowDom for web-components */
+    isAttachedToShadowDom?: boolean;
+    /** Enables/disables attribute passing for frameworks with custom elements like angular and stencil */
+    attributePassing?: AttributePassingType;
+    alpine?: AlpineMetadata;
+    angular?: AngularMetadata;
+    builder?: BuilderMetadata;
+    html?: HtmlMetadata;
+    lit?: LitMetadata;
+    liquid?: LiquidMetadata;
+    marko?: MarkoMetadata;
+    mitosis?: MitosisMetadata;
+    qwik?: QwikMetadata;
+    react?: ReactMetadata;
+    reactNative?: ReactNativeMetadata;
+    rsc?: ReactServerComponentsMetadata;
+    solid?: SolidMetadata;
+    stencil?: StencilMetadata;
+    svelte?: SvelteMetadata;
+    swift?: SwiftMetadata;
+    taro?: TaroMetadata;
+    template?: TemplateMetadata;
+    vue?: VueMetadata;
+};
+export {};

package/dist/src/types/metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,162 @@
+import { Dictionary } from '../helpers/typescript';
+import { Target } from './config';
+import { JSONObject } from './json';
+import { ComponentMetadata } from './metadata';
+import { MitosisNode } from './mitosis-node';
+/**
+ * @example
+ *  // import core, { useState, someThing as someAlias } from '..'
+ *  {
+ *    path: '@builder.io/mitosis',
+ *    imports: {
+ *      useState: 'useState',
+ *      someAlias: 'someThing',
+ *      core: 'default',
+ *    }
+ *  }
+ *
+ * @example
+ *  // import * as core from '..'
+ *  {
+ *    path: '@builder.io/mitosis',
+ *    imports: {
+ *      core: '*',
+ *    }
+ *  }
+ */
+export interface MitosisImport {
+    path: string;
+    imports: {
+        [key: string]: string | undefined;
+    };
+    importKind?: 'type' | 'typeof' | 'value' | null;
+}
+export type ReactivityType = 'normal' | 'reactive';
+export type ContextOptions = {
+    type?: ReactivityType;
+};
+export interface ContextGetInfo extends ContextOptions {
+    name: string;
+    path: string;
+}
+export interface ContextSetInfo extends ContextOptions {
+    name: string;
+    value?: MitosisState;
+    ref?: string;
+}
+export type BaseHook = {
+    code: string;
+    deps?: string;
+    depsArray?: string[];
+};
+export type MitosisComponentInput = {
+    name: string;
+    defaultValue: any;
+};
+export type MitosisExports = {
+    [name: string]: MitosisExport;
+};
+export interface MitosisExport {
+    code: string;
+    usedInLocal?: boolean;
+    isFunction?: boolean;
+}
+export type StateValueType = 'function' | 'getter' | 'method' | 'property';
+export type StateValue = {
+    code: string;
+    typeParameter?: string;
+    type: StateValueType;
+    propertyType?: ReactivityType;
+};
+export type MitosisState = Dictionary<StateValue | undefined>;
+export type TargetBlock<Return, Targets extends Target = Target> = Partial<{
+    [T in Targets | 'default']?: Return;
+}>;
+export type TargetBlockCode = TargetBlock<{
+    code: string;
+}>;
+export type TargetBlockDefinition = TargetBlockCode & {
+    settings: {
+        requiresDefault: boolean;
+    };
+};
+export type OnEventHook = BaseHook & {
+    refName: string;
+    eventName: string;
+    isRoot: boolean;
+    deps?: never;
+    eventArgName: string;
+    elementArgName?: string;
+};
+export type OnMountHook = BaseHook & {
+    onSSR?: boolean;
+};
+export type MitosisComponent = {
+    '@type': '@builder.io/mitosis/component';
+    name: string;
+    imports: MitosisImport[];
+    exports?: MitosisExports;
+    meta: JSONObject & {
+        useMetadata?: ComponentMetadata;
+    };
+    inputs: MitosisComponentInput[];
+    state: MitosisState;
+    context: {
+        get: Dictionary<ContextGetInfo>;
+        set: Dictionary<ContextSetInfo>;
+    };
+    signals?: {
+        signalTypeImportName?: string;
+    };
+    props?: {
+        [name: string]: {
+            propertyType: ReactivityType;
+            optional: boolean;
+        };
+    };
+    refs: {
+        [useRef: string]: {
+            typeParameter?: string;
+            argument: string;
+        };
+    };
+    hooks: {
+        init?: BaseHook;
+        onInit?: BaseHook;
+        onMount: OnMountHook[];
+        onUnMount?: BaseHook;
+        preComponent?: BaseHook;
+        postComponent?: BaseHook;
+        onUpdate?: BaseHook[];
+        onEvent: OnEventHook[];
+    };
+    targetBlocks?: Dictionary<TargetBlockDefinition>;
+    children: MitosisNode[];
+    subComponents: MitosisComponent[];
+    types?: string[];
+    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.
+     */
+    compileContext?: {
+        [K in Target]?: {
+            state?: MitosisState;
+            hooks?: {
+                [hookName: string]: BaseHook;
+            };
+            extra?: Record<string, any>;
+        };
+    };
+};

package/dist/src/types/mitosis-component.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });