@builder.io/mitosis 0.0.0-dev-20260605060721

package/dist/src/parsers/svelte/helpers/mitosis-node.d.ts

@@ -0,0 +1,2 @@
+import { MitosisNode } from '../../../types/mitosis-node';
+export declare function createMitosisNode(): MitosisNode;

package/dist/src/parsers/svelte/helpers/mitosis-node.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMitosisNode = void 0;
+function createMitosisNode() {
+    return {
+        '@type': '@builder.io/mitosis/node',
+        name: '',
+        meta: {},
+        scope: {},
+        children: [],
+        bindings: {},
+        properties: {},
+        slots: {},
+    };
+}
+exports.createMitosisNode = createMitosisNode;

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

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

package/dist/src/parsers/svelte/helpers/post-process.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcess = exports.preventNameCollissions = void 0;
+const generator_1 = __importDefault(require("@babel/generator"));
+const parser = __importStar(require("@babel/parser"));
+const types = __importStar(require("@babel/types"));
+const replace_identifiers_1 = require("../../../helpers/replace-identifiers");
+const bindings_1 = require("./bindings");
+const getArgs = (code) => {
+    try {
+        let parsed = parser.parse(code);
+        let body = parsed.program.body[0];
+        if (types.isFunctionDeclaration(body)) {
+            return body.params.map((p) => (0, generator_1.default)(p).code);
+        }
+    }
+    catch (e) { }
+    return [];
+};
+function preventNameCollissions(json, item) {
+    let output = item.code;
+    const argumentsOutput = getArgs(output);
+    output = (0, replace_identifiers_1.replaceNodes)({
+        code: output,
+        nodeMaps: argumentsOutput.map((arg) => ({
+            from: types.identifier(arg),
+            to: types.identifier(`${arg}_`),
+        })),
+    });
+    return (argumentsOutput === null || argumentsOutput === void 0 ? void 0 : argumentsOutput.length)
+        ? {
+            ...item,
+            code: output,
+            arguments: getArgs(output),
+        }
+        : { ...item, code: output };
+}
+exports.preventNameCollissions = preventNameCollissions;
+function prependProperties(json, code) {
+    return (0, replace_identifiers_1.replaceNodes)({
+        code,
+        nodeMaps: Object.keys(json.props).map((property) => ({
+            from: types.identifier(property),
+            to: types.memberExpression(types.identifier('props'), types.identifier(property)),
+        })),
+    });
+}
+function prependState(json, input) {
+    let output = input;
+    for (const stateKey of Object.keys(json.state)) {
+        output = (0, replace_identifiers_1.replaceIdentifiers)({
+            code: output,
+            from: stateKey,
+            to: `state.${stateKey}`,
+        });
+    }
+    return output;
+}
+function addPropertiesAndState(json, input) {
+    let output = input;
+    output = prependProperties(json, output);
+    output = prependState(json, output);
+    return output;
+}
+function addPropertiesAndStateToNode(json, node) {
+    var _a;
+    for (const key of Object.keys(node.bindings)) {
+        if (Object.prototype.hasOwnProperty.call(node.bindings, key)) {
+            const value = node.bindings[key];
+            node.bindings[key].code = addPropertiesAndState(json, (_a = value === null || value === void 0 ? void 0 : value.code) !== null && _a !== void 0 ? _a : '').trim();
+        }
+    }
+}
+function postProcessState(json) {
+    for (const key of Object.keys(json.state)) {
+        const item = json.state[key];
+        if ((item === null || item === void 0 ? void 0 : item.type) !== 'property') {
+            const output = preventNameCollissions(json, item);
+            output.code = addPropertiesAndState(json, output.code);
+            json.state[key] = {
+                ...item,
+                ...output,
+            };
+        }
+    }
+}
+function postProcessChildren(json, children) {
+    var _a;
+    for (const node of children) {
+        addPropertiesAndStateToNode(json, node);
+        (0, bindings_1.processBindings)(json, node);
+        let children = [];
+        if (((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            children = node.children;
+        }
+        const metaValues = (Object.values(node.meta) || []);
+        if (metaValues.length > 0) {
+            const metaChildren = metaValues.filter((item) => {
+                return (item === null || item === void 0 ? void 0 : item['@type']) === '@builder.io/mitosis/node';
+            });
+            children = [...children, ...metaChildren];
+        }
+        postProcessChildren(json, children);
+    }
+}
+function addPropertiesAndStateToHook(json, hook) {
+    return {
+        code: addPropertiesAndState(json, hook.code),
+        deps: addPropertiesAndState(json, hook.deps || ''),
+    };
+}
+function postProcessHooks(json) {
+    const hookKeys = Object.keys(json.hooks);
+    for (const key of hookKeys) {
+        let hook = json.hooks[key];
+        if (!hook) {
+            continue;
+        }
+        if (Array.isArray(hook)) {
+            hook.forEach((item, index) => {
+                hook.splice(index, 1, addPropertiesAndStateToHook(json, item));
+            });
+        }
+        else {
+            hook = addPropertiesAndStateToHook(json, hook);
+        }
+    }
+}
+function postProcessContext(json) {
+    var _a;
+    for (const key of Object.keys(json.context.set)) {
+        if ((_a = json.context.set[key]) === null || _a === void 0 ? void 0 : _a.ref) {
+            json.context.set[key].ref = addPropertiesAndState(json, json.context.set[key].ref);
+        }
+    }
+}
+function postProcess(json) {
+    // Call preventNameCollissions here, before the rest (where it applies -- function arguments for now)
+    // State (everything except type === 'property')
+    postProcessState(json);
+    // Children
+    postProcessChildren(json, json.children);
+    // Hooks
+    postProcessHooks(json);
+    // Context
+    postProcessContext(json);
+}
+exports.postProcess = postProcess;

package/dist/src/parsers/svelte/helpers/string.d.ts

@@ -0,0 +1,3 @@
+export declare function uniqueName(existingItems: string[], reference: string): string;
+export declare function insertAt(string_: string, sub: string, pos: number): string;
+export declare function stripQuotes(string_: string): string;

package/dist/src/parsers/svelte/helpers/string.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripQuotes = exports.insertAt = exports.uniqueName = void 0;
+// helper functions for strings
+const lodash_1 = require("lodash");
+function uniqueName(existingItems, reference) {
+    let index = 0;
+    let match = false;
+    while (false === match) {
+        if (!existingItems.includes(reference)) {
+            match = true;
+            break;
+        }
+        index++;
+    }
+    return (0, lodash_1.camelCase)(`${reference}${index}`);
+}
+exports.uniqueName = uniqueName;
+function insertAt(string_, sub, pos) {
+    return `${string_.slice(0, pos)}${sub}${string_.slice(pos)}`;
+}
+exports.insertAt = insertAt;
+function stripQuotes(string_) {
+    return string_.replace(/["']+/g, '');
+}
+exports.stripQuotes = stripQuotes;

package/dist/src/parsers/svelte/html/actions.d.ts

@@ -0,0 +1,3 @@
+import type { Element } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseAction(json: SveltosisComponent, nodeReference: string, attribute: Element['attributes'][number]): void;

package/dist/src/parsers/svelte/html/actions.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAction = void 0;
+const astring_1 = require("astring");
+const string_1 = require("../helpers/string");
+function parseAction(json, nodeReference, attribute) {
+    var _a;
+    const methodName = attribute.name;
+    let parameters = '';
+    if (['Identifier', 'ObjectExpression'].includes((_a = attribute.expression) === null || _a === void 0 ? void 0 : _a.type)) {
+        parameters = (0, astring_1.generate)(attribute.expression);
+    }
+    const actionHandler = (0, string_1.uniqueName)(Object.keys(json.state), 'actionHandler');
+    json.state[actionHandler] = {
+        code: 'null',
+        type: 'property',
+        propertyType: 'normal',
+    };
+    const initHandler = `if (${nodeReference}) { ${actionHandler} = ${methodName}(${nodeReference}, ${parameters}); };\n`;
+    json.hooks.onMount.push({
+        code: initHandler,
+    });
+    // Handle Destroy / Re-Mount
+    const onReferenceUpdate = `
+    if (!${nodeReference} && ${actionHandler}) { 
+      ${actionHandler}?.destroy(); 
+      ${actionHandler} = null; 
+    } else if (${nodeReference} && !${actionHandler}) { 
+      ${initHandler} 
+    };\n
+  `;
+    json.hooks.onUpdate = json.hooks.onUpdate || [];
+    json.hooks.onUpdate.push({
+        code: onReferenceUpdate,
+        deps: `[${nodeReference}]`,
+    });
+    // Handle Update
+    if (parameters) {
+        const onUpdate = `${actionHandler}?.update(${parameters})\n`;
+        json.hooks.onUpdate.push({
+            code: onUpdate,
+            deps: `[${parameters}]`,
+        });
+    }
+}
+exports.parseAction = parseAction;

package/dist/src/parsers/svelte/html/each.d.ts

@@ -0,0 +1,4 @@
+import type { TemplateNode } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import { MitosisNode } from '../../../types/mitosis-node';
+import type { SveltosisComponent } from '../types';
+export declare function parseEach(json: SveltosisComponent, node: TemplateNode): MitosisNode;

package/dist/src/parsers/svelte/html/each.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEach = void 0;
+const children_1 = require("../helpers/children");
+const mitosis_node_1 = require("../helpers/mitosis-node");
+const bindings_1 = require("../../../helpers/bindings");
+function parseEach(json, node) {
+    return {
+        ...(0, mitosis_node_1.createMitosisNode)(),
+        name: 'For',
+        scope: { forName: node.context.name },
+        bindings: {
+            each: (0, bindings_1.createSingleBinding)({
+                code: node.expression.name,
+            }),
+        },
+        children: (0, children_1.parseChildren)(json, node),
+    };
+}
+exports.parseEach = parseEach;

package/dist/src/parsers/svelte/html/element.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateNode } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseElement(json: SveltosisComponent, node: TemplateNode): import("../../..").MitosisNode;

package/dist/src/parsers/svelte/html/element.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseElement = void 0;
+const astring_1 = require("astring");
+const lodash_1 = require("lodash");
+const children_1 = require("../helpers/children");
+const mitosis_node_1 = require("../helpers/mitosis-node");
+const string_1 = require("../helpers/string");
+const actions_1 = require("./actions");
+const bindings_1 = require("../../../helpers/bindings");
+const SPECIAL_ELEMENTS = new Set(['svelte:component', 'svelte:element']);
+function parseElement(json, node) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    const mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = node.name;
+    const useReference = () => {
+        const nodeReference = (0, string_1.uniqueName)(Object.keys(json.refs), node.name);
+        if (!Object.keys(json.refs).includes(nodeReference)) {
+            json.refs[nodeReference] = { argument: '', typeParameter: '' };
+            mitosisNode.bindings.ref = (0, bindings_1.createSingleBinding)({ code: nodeReference });
+        }
+        return nodeReference;
+    };
+    /*
+      Parse special elements such as svelte:component and svelte:element
+    */
+    if (SPECIAL_ELEMENTS.has(node.name)) {
+        const expression = (0, astring_1.generate)(node.expression || node.tag);
+        let prefix = 'state';
+        if (json.props[expression]) {
+            prefix = 'props';
+        }
+        mitosisNode.name = `${prefix}.${expression}`;
+    }
+    if ((_a = node.attributes) === null || _a === void 0 ? void 0 : _a.length) {
+        for (const attribute of node.attributes) {
+            switch (attribute.type) {
+                case 'Attribute': {
+                    switch ((_b = attribute.value[0]) === null || _b === void 0 ? void 0 : _b.type) {
+                        case 'Text': {
+                            const value = attribute.value[0];
+                            // if there are already conditional class declarations
+                            // add class names defined here to the bindings code as well
+                            if (attribute.name === 'class' && ((_d = (_c = mitosisNode.bindings.class) === null || _c === void 0 ? void 0 : _c.code) === null || _d === void 0 ? void 0 : _d.length)) {
+                                mitosisNode.bindings.class.code = (0, string_1.insertAt)(mitosisNode.bindings.class.code, ` ${value.data} `, 1);
+                            }
+                            else {
+                                mitosisNode.properties[attribute.name] = value.data;
+                            }
+                            break;
+                        }
+                        case 'MustacheTag': {
+                            const value = attribute.value[0];
+                            const expression = value.expression;
+                            let code = (0, astring_1.generate)(expression);
+                            if (attribute.name === 'class') {
+                                code = ((_f = (_e = mitosisNode.bindings.class) === null || _e === void 0 ? void 0 : _e.code) === null || _f === void 0 ? void 0 : _f.length)
+                                    ? (0, string_1.insertAt)(mitosisNode.bindings.class.code, ' ${' + code + '}', mitosisNode.bindings.class.code.length - 1)
+                                    : '`${' + code + '}`';
+                            }
+                            mitosisNode.bindings[attribute.name] = (0, bindings_1.createSingleBinding)({ code });
+                            break;
+                        }
+                        case 'AttributeShorthand': {
+                            // e.g. <input {value}/>
+                            const value = attribute.value[0];
+                            const code = value.expression.name;
+                            mitosisNode.bindings[code] = (0, bindings_1.createSingleBinding)({ code });
+                            break;
+                        }
+                        default: {
+                            const name = attribute.name;
+                            mitosisNode.bindings[name] = (0, bindings_1.createSingleBinding)({
+                                code: attribute.value.toString(),
+                            });
+                        }
+                    }
+                    break;
+                }
+                case 'Spread': {
+                    const expression = attribute.expression;
+                    mitosisNode.bindings[expression.name] = {
+                        code: expression.name,
+                        type: 'spread',
+                        spreadType: 'normal',
+                    };
+                    break;
+                }
+                case 'EventHandler': {
+                    let object = {
+                        code: '',
+                        arguments: [],
+                    };
+                    if (((_g = attribute.expression) === null || _g === void 0 ? void 0 : _g.type) === 'ArrowTypeFunction') {
+                        const expression = attribute.expression;
+                        let code = (0, astring_1.generate)(expression.body);
+                        object = {
+                            code,
+                            arguments: (_j = (_h = expression.body) === null || _h === void 0 ? void 0 : _h.arguments) === null || _j === void 0 ? void 0 : _j.map((a) => { var _a; return (_a = a.name) !== null && _a !== void 0 ? _a : []; }),
+                        };
+                    }
+                    else if (attribute.expression) {
+                        let code = (0, astring_1.generate)(attribute.expression);
+                        if (((_k = attribute.expression.body) === null || _k === void 0 ? void 0 : _k.type) === 'CallExpression') {
+                            code = (0, astring_1.generate)(attribute.expression.body);
+                        }
+                        if (!code.startsWith(')') && !code.endsWith(')')) {
+                            code += '()';
+                        }
+                        if (!((_l = attribute.expression.arguments) === null || _l === void 0 ? void 0 : _l.length) &&
+                            !((_o = (_m = attribute.expression.body) === null || _m === void 0 ? void 0 : _m.arguments) === null || _o === void 0 ? void 0 : _o.length)) {
+                            code = code.replace(/\(\)/g, '(event)');
+                        }
+                        let args = undefined;
+                        if (attribute.expression.type === 'ArrowFunctionExpression') {
+                            args = (_q = (_p = attribute.expression.params) === null || _p === void 0 ? void 0 : _p.map((arg) => (0, astring_1.generate)(arg))) !== null && _q !== void 0 ? _q : [];
+                        }
+                        else if (attribute.expression.type === 'CallExpression' &&
+                            attribute.expression.arguments.length) {
+                            args = [];
+                        }
+                        object = {
+                            code,
+                            arguments: args,
+                        };
+                    }
+                    else {
+                        object = {
+                            code: `props.on${(0, lodash_1.upperFirst)(attribute.name)}(event)`,
+                            arguments: ['event'],
+                        };
+                    }
+                    mitosisNode.bindings[`on${(0, lodash_1.upperFirst)(attribute.name)}`] = (0, bindings_1.createSingleBinding)(object);
+                    // add event handlers as props (e.g. props.onClick)
+                    json.props = {
+                        ...json.props,
+                        [`on${(0, lodash_1.upperFirst)(attribute.name)}`]: { default: () => ({}) },
+                    };
+                    break;
+                }
+                case 'Binding': {
+                    /*
+                      adding onChange handlers for bind:group and bind:property is done during post processing
+                      same goes for replacing the group binding with checked
+                      see helpers/post-process.ts
+                    */
+                    const expression = attribute.expression;
+                    const binding = expression.name;
+                    let name = attribute.name;
+                    // template ref
+                    if (attribute.name === 'this') {
+                        name = 'ref';
+                        json.refs[binding] = {
+                            argument: 'null',
+                            typeParameter: 'any',
+                        };
+                        if (Object.prototype.hasOwnProperty.call(json.state, binding)) {
+                            delete json.state[binding];
+                        }
+                    }
+                    if (name !== 'ref' && name !== 'group' && name !== 'this') {
+                        const onChangeCode = `${binding} = event.target.value`;
+                        mitosisNode.bindings['onChange'] = (0, bindings_1.createSingleBinding)({
+                            code: onChangeCode,
+                            arguments: ['event'],
+                        });
+                    }
+                    mitosisNode.bindings[name] = (0, bindings_1.createSingleBinding)({
+                        code: binding,
+                    });
+                    break;
+                }
+                case 'Class': {
+                    const expression = attribute.expression;
+                    // conditional classes (e.g. class:disabled or class:disabled={disabled})
+                    const binding = `${(0, astring_1.generate)(expression)} ? '${attribute.name}'  : ''`;
+                    let code = '';
+                    // if there are existing class declarations
+                    // add them here instead and remove them from properties
+                    // to avoid duplicate class declarations in certain frameworks
+                    if ((_s = (_r = mitosisNode.properties) === null || _r === void 0 ? void 0 : _r.class) === null || _s === void 0 ? void 0 : _s.length) {
+                        code = `${mitosisNode.properties.class} `;
+                        delete mitosisNode.properties.class;
+                    }
+                    // if class code is already defined (meaning there is more than 1 conditional class declaration)
+                    // append it to the string instead of assigning it
+                    if (mitosisNode.bindings.class &&
+                        Object.prototype.hasOwnProperty.call(mitosisNode.bindings.class, 'code') &&
+                        ((_t = mitosisNode.bindings.class) === null || _t === void 0 ? void 0 : _t.code.length)) {
+                        code = (0, string_1.insertAt)(mitosisNode.bindings.class.code, ' ${' + binding + '}', mitosisNode.bindings.class.code.length - 1);
+                        mitosisNode.bindings.class = (0, bindings_1.createSingleBinding)({ code });
+                    }
+                    else {
+                        // otherwise just assign
+                        code = '`' + code + '${' + binding + '}`';
+                        mitosisNode.bindings.class = (0, bindings_1.createSingleBinding)({ code });
+                    }
+                    break;
+                }
+                case 'Action': {
+                    (0, actions_1.parseAction)(json, useReference(), attribute);
+                    break;
+                }
+                // No default
+            }
+        }
+    }
+    let filteredChildren = [];
+    if (node.children) {
+        filteredChildren = (0, children_1.filterChildren)(node.children);
+    }
+    if (filteredChildren.length === 1 && filteredChildren[0].type === 'RawMustacheTag') {
+        const child = filteredChildren[0];
+        mitosisNode.children = [];
+        mitosisNode.bindings.innerHTML = (0, bindings_1.createSingleBinding)({
+            code: (0, astring_1.generate)(child.expression),
+        });
+    }
+    else {
+        mitosisNode.children = (0, children_1.parseChildren)(json, node);
+    }
+    return mitosisNode;
+}
+exports.parseElement = parseElement;

package/dist/src/parsers/svelte/html/fragment.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateNode } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseFragment(json: SveltosisComponent, node: TemplateNode): import("../../..").MitosisNode;

package/dist/src/parsers/svelte/html/fragment.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFragment = void 0;
+const children_1 = require("../helpers/children");
+const mitosis_node_1 = require("../helpers/mitosis-node");
+function parseFragment(json, node) {
+    let mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'Fragment';
+    mitosisNode.children = (0, children_1.parseChildren)(json, node);
+    // if there is only one child, don't even bother to render the fragment as it is not necessary
+    if (mitosisNode.children.length === 1) {
+        mitosisNode = mitosisNode.children[0];
+    }
+    return mitosisNode;
+}
+exports.parseFragment = parseFragment;

package/dist/src/parsers/svelte/html/if-else.d.ts

@@ -0,0 +1,3 @@
+import type { TemplateNode } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseIfElse(json: SveltosisComponent, node: TemplateNode): import("../../..").MitosisNode;

package/dist/src/parsers/svelte/html/if-else.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfElse = void 0;
+const astring_1 = require("astring");
+const _1 = require(".");
+const children_1 = require("../helpers/children");
+const mitosis_node_1 = require("../helpers/mitosis-node");
+const bindings_1 = require("../../../helpers/bindings");
+function parseIfElse(json, node) {
+    var _a, _b, _c;
+    const mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'Show';
+    mitosisNode.bindings = {
+        when: (0, bindings_1.createSingleBinding)({
+            code: (0, astring_1.generate)(node.expression),
+        }),
+    };
+    mitosisNode.children = (0, children_1.parseChildren)(json, node);
+    if (node.else) {
+        mitosisNode.meta.else =
+            ((_a = node.else.children) === null || _a === void 0 ? void 0 : _a.length) === 1
+                ? (0, _1.parseHtmlNode)(json, node.else.children[0])
+                : {
+                    ...(0, mitosis_node_1.createMitosisNode)(),
+                    name: 'div',
+                    children: (_c = (_b = node.else.children) === null || _b === void 0 ? void 0 : _b.map((n) => (0, _1.parseHtmlNode)(json, n))) !== null && _c !== void 0 ? _c : [],
+                };
+    }
+    return mitosisNode;
+}
+exports.parseIfElse = parseIfElse;

package/dist/src/parsers/svelte/html/index.d.ts

@@ -0,0 +1,5 @@
+import type { MitosisNode } from '../../../types/mitosis-node';
+import type { Ast, TemplateNode } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseHtml(ast: Ast, json: SveltosisComponent): void;
+export declare function parseHtmlNode(json: SveltosisComponent, node: TemplateNode): MitosisNode | undefined;