@builder.io/mitosis 0.0.77 → 0.0.79

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

@@ -0,0 +1,15 @@
+"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: {},
+    };
+}
+exports.createMitosisNode = createMitosisNode;

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

@@ -0,0 +1,9 @@
+import type { SveltosisComponent } from '../types';
+export declare function preventNameCollissions(json: SveltosisComponent, input: string, arguments_: string[], prepend?: string, append?: string): {
+    code: string;
+    arguments: string[];
+} | {
+    code: string;
+    arguments?: undefined;
+};
+export declare function postProcess(json: SveltosisComponent): void;

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

@@ -0,0 +1,177 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcess = exports.preventNameCollissions = void 0;
+var bindings_1 = require("./bindings");
+function preventNameCollissions(json, input, arguments_, prepend, append) {
+    if (prepend === void 0) { prepend = ''; }
+    if (append === void 0) { append = '_'; }
+    var output = input;
+    var argumentsOutput = arguments_;
+    var keys = __spreadArray(__spreadArray(__spreadArray([], Object.keys(json.props), true), Object.keys(json.state), true), Object.keys(json.refs), true);
+    var _loop_1 = function (key) {
+        var regex = function () { return new RegExp("(?<!=(?:\\s))".concat(key, "\\b"), 'g'); };
+        var isInArguments = false;
+        argumentsOutput.forEach(function (argument, index) {
+            if (regex().test(argument)) {
+                isInArguments = true;
+                argumentsOutput.splice(index, 1, argument.replace(regex(), "".concat(prepend).concat(key).concat(append)));
+            }
+        });
+        var isInOutput = regex().test(output);
+        if (isInArguments && isInOutput) {
+            output = output.replace(regex(), "".concat(prepend).concat(key).concat(append));
+        }
+    };
+    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+        var key = keys_1[_i];
+        _loop_1(key);
+    }
+    return (argumentsOutput === null || argumentsOutput === void 0 ? void 0 : argumentsOutput.length)
+        ? {
+            code: output,
+            arguments: argumentsOutput,
+        }
+        : { code: output };
+}
+exports.preventNameCollissions = preventNameCollissions;
+function prependProperties(json, input) {
+    var output = input;
+    var propertyKeys = Object.keys(json.props);
+    for (var _i = 0, propertyKeys_1 = propertyKeys; _i < propertyKeys_1.length; _i++) {
+        var property = propertyKeys_1[_i];
+        var regex = new RegExp("(?<!(\\.|'|\"|`))\\b(props\\.)?".concat(property, "\\b"), 'g');
+        if (regex.test(output)) {
+            output = output.replace(regex, "props.".concat(property));
+        }
+    }
+    return output;
+}
+function prependState(json, input) {
+    var output = input;
+    var stateKeys = Object.keys(json.state);
+    for (var _i = 0, stateKeys_1 = stateKeys; _i < stateKeys_1.length; _i++) {
+        var state = stateKeys_1[_i];
+        var regex = new RegExp("(?<!(\\.|'|\"|`|function ))\\b(state\\.)?".concat(state, "\\b(?!(\\s+)?\\()"), 'g');
+        if (regex.test(output)) {
+            output = output.replace(regex, "state.".concat(state));
+        }
+    }
+    return output;
+}
+function addPropertiesAndState(json, input) {
+    var output = input;
+    output = prependProperties(json, output);
+    output = prependState(json, output);
+    return output;
+}
+function addPropertiesAndStateToNode(json, node) {
+    var _a, _b, _c;
+    for (var _i = 0, _d = Object.keys(node.bindings); _i < _d.length; _i++) {
+        var key = _d[_i];
+        if (Object.prototype.hasOwnProperty.call(node.bindings, key)) {
+            node.bindings[key] = {
+                code: addPropertiesAndState(json, (_b = (_a = node.bindings[key]) === null || _a === void 0 ? void 0 : _a.code) !== null && _b !== void 0 ? _b : '').trim(),
+                type: (_c = node.bindings[key]) === null || _c === void 0 ? void 0 : _c.type,
+            };
+        }
+    }
+}
+function postProcessState(json) {
+    for (var _i = 0, _a = Object.keys(json.state); _i < _a.length; _i++) {
+        var key = _a[_i];
+        var item = json.state[key];
+        if ((item === null || item === void 0 ? void 0 : item.type) !== 'property') {
+            var output = preventNameCollissions(json, item.code, (item === null || item === void 0 ? void 0 : item.arguments) || []);
+            output.code = addPropertiesAndState(json, output.code);
+            json.state[key] = __assign(__assign({}, item), output);
+        }
+    }
+}
+function postProcessChildren(json, children) {
+    var _a;
+    for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+        var node = children_1[_i];
+        addPropertiesAndStateToNode(json, node);
+        (0, bindings_1.processBindings)(json, node);
+        var children_2 = [];
+        if (((_a = node.children) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            children_2 = node.children;
+        }
+        var metaValues = (Object.values(node.meta) || []);
+        if (metaValues.length > 0) {
+            var metaChildren = metaValues.filter(function (item) {
+                return (item === null || item === void 0 ? void 0 : item['@type']) === '@builder.io/mitosis/node';
+            });
+            children_2 = __spreadArray(__spreadArray([], children_2, true), metaChildren, true);
+        }
+        postProcessChildren(json, children_2);
+    }
+}
+function addPropertiesAndStateToHook(json, hook) {
+    return {
+        code: addPropertiesAndState(json, hook.code),
+        deps: addPropertiesAndState(json, hook.deps || ''),
+    };
+}
+function postProcessHooks(json) {
+    var hookKeys = Object.keys(json.hooks);
+    var _loop_2 = function (key) {
+        var hook = json.hooks[key];
+        if (!hook) {
+            return "continue";
+        }
+        if (key === 'onUpdate' && Array.isArray(hook)) {
+            hook.forEach(function (item, index) {
+                var _a;
+                (_a = json.hooks[key]) === null || _a === void 0 ? void 0 : _a.splice(index, 1, addPropertiesAndStateToHook(json, item));
+            });
+            return "continue";
+        }
+        json.hooks[key] = addPropertiesAndStateToHook(json, hook);
+    };
+    for (var _i = 0, hookKeys_1 = hookKeys; _i < hookKeys_1.length; _i++) {
+        var key = hookKeys_1[_i];
+        _loop_2(key);
+    }
+}
+function postProcessContext(json) {
+    var _a;
+    for (var _i = 0, _b = Object.keys(json.context.set); _i < _b.length; _i++) {
+        var key = _b[_i];
+        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
+var lodash_1 = require("lodash");
+function uniqueName(existingItems, reference) {
+    var index = 0;
+    var match = false;
+    while (false === match) {
+        if (!existingItems.includes(reference)) {
+            match = true;
+            break;
+        }
+        index++;
+    }
+    return (0, lodash_1.camelCase)("".concat(reference).concat(index));
+}
+exports.uniqueName = uniqueName;
+function insertAt(string_, sub, pos) {
+    return "".concat(string_.slice(0, pos)).concat(sub).concat(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 '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,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAction = void 0;
+var string_1 = require("../helpers/string");
+var astring_1 = require("astring");
+function parseAction(json, nodeReference, attribute) {
+    var _a, _b;
+    var methodName = attribute.name;
+    var parameters = '';
+    if (['Identifier', 'ObjectExpression'].includes((_a = attribute.expression) === null || _a === void 0 ? void 0 : _a.type)) {
+        parameters = (0, astring_1.generate)(attribute.expression);
+    }
+    var actionHandler = (0, string_1.uniqueName)(Object.keys(json.state), 'actionHandler');
+    json.state[actionHandler] = {
+        code: 'null',
+        type: 'property',
+    };
+    var initHandler = "if (".concat(nodeReference, ") { ").concat(actionHandler, " = ").concat(methodName, "(").concat(nodeReference, ", ").concat(parameters, "); };\n");
+    // Handle Mount
+    var onMountCode = ((_b = json.hooks.onMount) === null || _b === void 0 ? void 0 : _b.code) || '';
+    json.hooks.onMount = {
+        code: "".concat(onMountCode, "\n").concat(initHandler, ";\n"),
+    };
+    // Handle Destroy / Re-Mount
+    var onReferenceUpdate = "\n    if (!".concat(nodeReference, " && ").concat(actionHandler, ") { \n      ").concat(actionHandler, "?.destroy(); \n      ").concat(actionHandler, " = null; \n    } else if (").concat(nodeReference, " && !").concat(actionHandler, ") { \n      ").concat(initHandler, " \n    };\n\n  ");
+    json.hooks.onUpdate = json.hooks.onUpdate || [];
+    json.hooks.onUpdate.push({
+        code: onReferenceUpdate,
+        deps: "[".concat(nodeReference, "]"),
+    });
+    // Handle Update
+    if (parameters) {
+        var onUpdate = "".concat(actionHandler, "?.update(").concat(parameters, ")\n");
+        json.hooks.onUpdate.push({
+            code: onUpdate,
+            deps: "[".concat(parameters, "]"),
+        });
+    }
+}
+exports.parseAction = parseAction;

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

@@ -0,0 +1,35 @@
+import type { TemplateNode } from 'svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseEach(json: SveltosisComponent, node: TemplateNode): {
+    name: string;
+    scope: {
+        forName: any;
+    };
+    bindings: {
+        each: {
+            code: any;
+        };
+    };
+    children: import("../../..").MitosisNode[];
+    '@type': "@builder.io/mitosis/node";
+    meta: import("../../../types/json").JSONObject;
+    properties: {
+        [key: string]: string | undefined;
+    };
+} | {
+    name: string;
+    scope: {
+        forName: any;
+    };
+    bindings: {
+        each: {
+            code: any;
+        };
+    };
+    children: import("../../..").MitosisNode[];
+    '@type': "@builder.io/mitosis/node";
+    meta: import("../../../types/json").JSONObject;
+    properties: {
+        [key: string]: string | undefined;
+    };
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEach = void 0;
+var mitosis_node_1 = require("../helpers/mitosis-node");
+var children_1 = require("../helpers/children");
+function parseEach(json, node) {
+    return __assign(__assign({}, (0, mitosis_node_1.createMitosisNode)()), { name: 'For', scope: { forName: node.context.name }, bindings: {
+            each: {
+                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 '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,222 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseElement = void 0;
+var astring_1 = require("astring");
+var lodash_1 = require("lodash");
+var mitosis_node_1 = require("../helpers/mitosis-node");
+var children_1 = require("../helpers/children");
+var string_1 = require("../helpers/string");
+var actions_1 = require("./actions");
+var SPECIAL_ELEMENTS = new Set(['svelte:component', 'svelte:element']);
+function parseElement(json, node) {
+    var _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    var mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = node.name;
+    var useReference = function () {
+        var 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 = {
+                code: nodeReference,
+            };
+        }
+        return nodeReference;
+    };
+    /*
+      Parse special elements such as svelte:component and svelte:element
+    */
+    if (SPECIAL_ELEMENTS.has(node.name)) {
+        var expression = (0, astring_1.generate)(node.expression || node.tag);
+        var prefix = 'state';
+        if (json.props[expression]) {
+            prefix = 'props';
+        }
+        mitosisNode.name = "".concat(prefix, ".").concat(expression);
+    }
+    if ((_b = node.attributes) === null || _b === void 0 ? void 0 : _b.length) {
+        for (var _i = 0, _s = node.attributes; _i < _s.length; _i++) {
+            var attribute = _s[_i];
+            switch (attribute.type) {
+                case 'Attribute': {
+                    switch ((_c = attribute.value[0]) === null || _c === void 0 ? void 0 : _c.type) {
+                        case 'Text': {
+                            var 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' && ((_e = (_d = mitosisNode.bindings.class) === null || _d === void 0 ? void 0 : _d.code) === null || _e === void 0 ? void 0 : _e.length)) {
+                                mitosisNode.bindings.class.code = (0, string_1.insertAt)(mitosisNode.bindings.class.code, " ".concat(value.data, " "), 1);
+                            }
+                            else {
+                                mitosisNode.properties[attribute.name] = value.data;
+                            }
+                            break;
+                        }
+                        case 'MustacheTag': {
+                            var value = attribute.value[0];
+                            var expression = value.expression;
+                            var code = (0, astring_1.generate)(expression);
+                            if (attribute.name === 'class') {
+                                code = ((_g = (_f = mitosisNode.bindings.class) === null || _f === void 0 ? void 0 : _f.code) === null || _g === void 0 ? void 0 : _g.length)
+                                    ? (0, string_1.insertAt)(mitosisNode.bindings.class.code, ' ${' + code + '}', mitosisNode.bindings.class.code.length - 1)
+                                    : '`${' + code + '}`';
+                            }
+                            mitosisNode.bindings[attribute.name] = {
+                                code: code,
+                            };
+                            break;
+                        }
+                        case 'AttributeShorthand': {
+                            // e.g. <input {value}/>
+                            var value = attribute.value[0];
+                            var code = value.expression.name;
+                            mitosisNode.bindings[code] = {
+                                code: code,
+                            };
+                            break;
+                        }
+                        default: {
+                            var name_1 = attribute.name;
+                            mitosisNode.bindings[name_1] = { code: attribute.value.toString() };
+                        }
+                    }
+                    break;
+                }
+                case 'Spread': {
+                    var expression = attribute.expression;
+                    mitosisNode.bindings[expression.name] = {
+                        code: expression.name,
+                        type: 'spread',
+                    };
+                    break;
+                }
+                case 'EventHandler': {
+                    var object = { code: '', arguments: [] };
+                    if (((_h = attribute.expression) === null || _h === void 0 ? void 0 : _h.type) === 'ArrowTypeFunction') {
+                        var expression = attribute.expression;
+                        object = {
+                            code: (0, astring_1.generate)(expression.body),
+                            arguments: (_k = (_j = expression.body) === null || _j === void 0 ? void 0 : _j.arguments) === null || _k === void 0 ? void 0 : _k.map(function (a) { return a.name; }),
+                        };
+                    }
+                    else if (attribute.expression) {
+                        var code = (0, astring_1.generate)(attribute.expression);
+                        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)');
+                        }
+                        object = {
+                            code: code,
+                            arguments: ['event'],
+                        };
+                    }
+                    else {
+                        object = {
+                            code: "props.on".concat((0, lodash_1.upperFirst)(attribute.name), "(event)"),
+                            arguments: ['event'],
+                        };
+                    }
+                    mitosisNode.bindings["on".concat((0, lodash_1.upperFirst)(attribute.name))] = object;
+                    // add event handlers as props (e.g. props.onClick)
+                    json.props = __assign(__assign({}, json.props), (_a = {}, _a["on".concat((0, lodash_1.upperFirst)(attribute.name))] = { default: function () { return ({}); } }, _a));
+                    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
+                    */
+                    var expression = attribute.expression;
+                    var binding = expression.name;
+                    var name_2 = attribute.name;
+                    // template ref
+                    if (attribute.name === 'this') {
+                        name_2 = 'ref';
+                        json.refs[binding] = {
+                            argument: 'null',
+                            typeParameter: 'any',
+                        };
+                        if (Object.prototype.hasOwnProperty.call(json.state, binding)) {
+                            delete json.state[binding];
+                        }
+                    }
+                    if (name_2 !== 'ref' && name_2 !== 'group' && name_2 !== 'this') {
+                        var onChangeCode = "".concat(binding, " = event.target.value");
+                        mitosisNode.bindings['onChange'] = {
+                            code: onChangeCode,
+                            arguments: ['event'],
+                        };
+                    }
+                    mitosisNode.bindings[name_2] = {
+                        code: binding,
+                    };
+                    break;
+                }
+                case 'Class': {
+                    var expression = attribute.expression;
+                    // conditional classes (e.g. class:disabled or class:disabled={disabled})
+                    var binding = "".concat((0, astring_1.generate)(expression), " ? '").concat(attribute.name, "'  : ''");
+                    var 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 ((_q = (_p = mitosisNode.properties) === null || _p === void 0 ? void 0 : _p.class) === null || _q === void 0 ? void 0 : _q.length) {
+                        code = "".concat(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') &&
+                        ((_r = mitosisNode.bindings.class) === null || _r === void 0 ? void 0 : _r.code.length)) {
+                        code = (0, string_1.insertAt)(mitosisNode.bindings.class.code, ' ${' + binding + '}', mitosisNode.bindings.class.code.length - 1);
+                        mitosisNode.bindings.class = {
+                            code: code,
+                        };
+                    }
+                    else {
+                        // otherwise just assign
+                        code = '`' + code + '${' + binding + '}`';
+                        mitosisNode.bindings.class = {
+                            code: code,
+                        };
+                    }
+                    break;
+                }
+                case 'Action': {
+                    (0, actions_1.parseAction)(json, useReference(), attribute);
+                    break;
+                }
+                // No default
+            }
+        }
+    }
+    var filteredChildren = [];
+    if (node.children) {
+        filteredChildren = (0, children_1.filterChildren)(node.children);
+    }
+    if (filteredChildren.length === 1 && filteredChildren[0].type === 'RawMustacheTag') {
+        var child = filteredChildren[0];
+        mitosisNode.children = [];
+        mitosisNode.bindings.innerHTML = {
+            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 '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;
+var mitosis_node_1 = require("../helpers/mitosis-node");
+var children_1 = require("../helpers/children");
+function parseFragment(json, node) {
+    var 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 '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,37 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfElse = void 0;
+var astring_1 = require("astring");
+var _1 = require(".");
+var mitosis_node_1 = require("../helpers/mitosis-node");
+var children_1 = require("../helpers/children");
+function parseIfElse(json, node) {
+    var _a, _b, _c;
+    var mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'Show';
+    mitosisNode.bindings = {
+        when: {
+            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])
+                : __assign(__assign({}, (0, mitosis_node_1.createMitosisNode)()), { name: 'div', children: (_c = (_b = node.else.children) === null || _b === void 0 ? void 0 : _b.map(function (n) { return (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 '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;