@builder.io/mitosis 0.0.78 → 0.0.79

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;

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHtmlNode = exports.parseHtml = void 0;
+var compiler_1 = require("svelte/compiler");
+var each_1 = require("./each");
+var element_1 = require("./element");
+var fragment_1 = require("./fragment");
+var if_else_1 = require("./if-else");
+var mustache_tag_1 = require("./mustache-tag");
+var slot_1 = require("./slot");
+var text_1 = require("./text");
+function parseHtml(ast, json) {
+    var _a, _b;
+    // todo: should filter children and check if just 1 has length
+    var html = ((_a = ast.html.children) === null || _a === void 0 ? void 0 : _a.length) === 2 && ((_b = ast.html.children[0].raw) === null || _b === void 0 ? void 0 : _b.trim().length) === 0
+        ? ast.html.children[1]
+        : ast.html;
+    (0, compiler_1.walk)(html, {
+        enter: function (node, parent) {
+            var templateNode = node;
+            var parentTemplateNode = parent;
+            if ((parentTemplateNode === null || parentTemplateNode === void 0 ? void 0 : parentTemplateNode.children) || templateNode.data === '\n\n') {
+                this.skip();
+                return;
+            }
+            var mitosisNode = parseHtmlNode(json, templateNode);
+            if (mitosisNode) {
+                json.children.push(mitosisNode);
+            }
+        },
+    });
+}
+exports.parseHtml = parseHtml;
+function parseHtmlNode(json, node) {
+    var mitosisNode = {
+        '@type': '@builder.io/mitosis/node',
+        name: '',
+        meta: {},
+        scope: {},
+        children: [],
+        bindings: {},
+        properties: {},
+    };
+    switch (node.type) {
+        case 'Element':
+        case 'InlineComponent': {
+            return (0, element_1.parseElement)(json, node);
+        }
+        case 'MustacheTag': {
+            return (0, mustache_tag_1.parseMustacheTag)(node);
+        }
+        case 'RawMustacheTag': {
+            return (0, mustache_tag_1.parseRawMustacheTag)(node);
+        }
+        case 'IfBlock': {
+            return (0, if_else_1.parseIfElse)(json, node);
+        }
+        case 'EachBlock': {
+            return (0, each_1.parseEach)(json, node);
+        }
+        case 'Text': {
+            return (0, text_1.parseText)(node);
+        }
+        case 'Fragment': {
+            return (0, fragment_1.parseFragment)(json, node);
+        }
+        case 'Slot': {
+            return (0, slot_1.parseSlot)(json, node);
+        }
+        case 'Comment': {
+            // do nothing :) probably skip?
+            break;
+        }
+        default: {
+            mitosisNode.name = 'div';
+        }
+    }
+}
+exports.parseHtmlNode = parseHtmlNode;

package/dist/src/parsers/svelte/html/mustache-tag.d.ts

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

package/dist/src/parsers/svelte/html/mustache-tag.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRawMustacheTag = exports.parseMustacheTag = void 0;
+var astring_1 = require("astring");
+var mitosis_node_1 = require("../helpers/mitosis-node");
+function parseMustacheTag(node) {
+    var mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'div';
+    mitosisNode.bindings['_text'] = {
+        code: (0, astring_1.generate)(node.expression),
+    };
+    return mitosisNode;
+}
+exports.parseMustacheTag = parseMustacheTag;
+function parseRawMustacheTag(node) {
+    var mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'div';
+    mitosisNode.bindings.innerHTML = {
+        code: (0, astring_1.generate)(node.expression),
+    };
+    return mitosisNode;
+}
+exports.parseRawMustacheTag = parseRawMustacheTag;

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSlot = void 0;
+var lodash_1 = require("lodash");
+var children_1 = require("../helpers/children");
+var mitosis_node_1 = require("../helpers/mitosis-node");
+function parseSlot(json, node) {
+    var _a, _b;
+    var mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    if (node.attributes.length > 0 &&
+        node.attributes[0].value.length > 0 &&
+        ((_a = node.attributes[0].value[0].data) === null || _a === void 0 ? void 0 : _a.trim().length)) {
+        mitosisNode.name = 'div';
+        var slotName = (0, lodash_1.upperFirst)((_b = node.attributes[0].value[0]) === null || _b === void 0 ? void 0 : _b.data);
+        mitosisNode.bindings._text = {
+            code: "props.slot".concat(slotName),
+        };
+    }
+    else {
+        mitosisNode.name = 'Slot';
+    }
+    mitosisNode.children = (0, children_1.parseChildren)(json, node);
+    return mitosisNode;
+}
+exports.parseSlot = parseSlot;

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

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

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

@@ -0,0 +1,21 @@
+"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.parseText = void 0;
+var mitosis_node_1 = require("../helpers/mitosis-node");
+function parseText(node) {
+    return __assign(__assign({}, (0, mitosis_node_1.createMitosisNode)()), { name: 'div', properties: {
+            _text: node.data,
+        } });
+}
+exports.parseText = parseText;

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

@@ -0,0 +1,2 @@
+import type { MitosisComponent } from '../../types/mitosis-component';
+export declare const parseSvelte: (string_: string, path?: string) => Promise<MitosisComponent>;

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

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSvelte = void 0;
+var compiler_1 = require("svelte/compiler");
+var svelte_preprocess_1 = __importDefault(require("svelte-preprocess"));
+var lodash_1 = require("lodash");
+var module_1 = require("./module");
+var instance_1 = require("./instance");
+var css_1 = require("./css");
+var html_1 = require("./html");
+var post_process_1 = require("./helpers/post-process");
+var typescript_1 = require("./typescript");
+function mapAstToMitosisJson(ast, name, string_, usesTypescript) {
+    if (string_ === void 0) { string_ = ''; }
+    if (usesTypescript === void 0) { usesTypescript = false; }
+    var json = {
+        '@type': '@builder.io/mitosis/component',
+        inputs: [],
+        state: {},
+        props: {},
+        refs: {},
+        hooks: {},
+        imports: [],
+        children: [],
+        context: { get: {}, set: {} },
+        subComponents: [],
+        meta: {},
+        name: name,
+        style: undefined,
+    };
+    (0, module_1.parseModule)(ast, json);
+    (0, instance_1.parseInstance)(ast, json);
+    (0, html_1.parseHtml)(ast, json);
+    (0, css_1.parseCss)(ast, json);
+    (0, post_process_1.postProcess)(json);
+    if (usesTypescript) {
+        (0, typescript_1.collectTypes)(string_, json);
+    }
+    return (0, lodash_1.omit)(json, ['props']);
+}
+var parseSvelte = function (string_, path) {
+    var _a, _b;
+    if (path === void 0) { path = 'MyComponent.svelte'; }
+    return __awaiter(this, void 0, void 0, function () {
+        var usesTypescript, processedString, ast, componentName;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    usesTypescript = (0, typescript_1.isTypeScriptComponent)(string_);
+                    return [4 /*yield*/, (0, compiler_1.preprocess)(string_, [
+                            (0, svelte_preprocess_1.default)({
+                                typescript: usesTypescript ? { tsconfigFile: false } : false,
+                            }),
+                        ], {
+                            filename: path.split('/').pop(),
+                        })];
+                case 1:
+                    processedString = _c.sent();
+                    ast = (0, compiler_1.parse)(processedString.code);
+                    componentName = (_b = (_a = path.split('/').pop()) === null || _a === void 0 ? void 0 : _a.split('.')[0]) !== null && _b !== void 0 ? _b : 'MyComponent';
+                    return [2 /*return*/, mapAstToMitosisJson(ast, componentName, string_, usesTypescript)];
+            }
+        });
+    });
+};
+exports.parseSvelte = parseSvelte;

package/dist/src/parsers/svelte/instance/context.d.ts

@@ -0,0 +1,5 @@
+import type { VariableDeclaration, ExpressionStatement } from 'estree';
+import type { SveltosisComponent } from '../types';
+export declare function parseGetContext(json: SveltosisComponent, node: VariableDeclaration): void;
+export declare function parseHasContext(json: SveltosisComponent, node: VariableDeclaration): void;
+export declare function parseSetContext(json: SveltosisComponent, node: ExpressionStatement): void;

package/dist/src/parsers/svelte/instance/context.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSetContext = exports.parseHasContext = exports.parseGetContext = void 0;
+var astring_1 = require("astring");
+var string_1 = require("../helpers/string");
+function parseGetContext(json, node) {
+    var _a;
+    if (node.declarations.length > 0) {
+        var declaration = node.declarations[0];
+        var name_1 = declaration.id.name;
+        var arguments_ = (_a = declaration.init) === null || _a === void 0 ? void 0 : _a.arguments;
+        if (arguments === null || arguments === void 0 ? void 0 : arguments.length) {
+            var argument = arguments_[0];
+            json.context.get[name_1] = {
+                name: (0, astring_1.generate)(argument),
+                path: '',
+            };
+        }
+    }
+}
+exports.parseGetContext = parseGetContext;
+function parseHasContext(json, node) {
+    var _a;
+    if (node.declarations.length > 0) {
+        var declaration = node.declarations[0];
+        var name_2 = declaration.id.name;
+        var arguments_ = (_a = declaration.init) === null || _a === void 0 ? void 0 : _a.arguments;
+        if (arguments === null || arguments === void 0 ? void 0 : arguments.length) {
+            var argument = arguments_[0];
+            var generatedArgument = (0, astring_1.generate)(argument);
+            json.context.get[(0, string_1.stripQuotes)(generatedArgument)] = {
+                name: generatedArgument,
+                path: '',
+            };
+            json.state[name_2] = {
+                code: "get ".concat(name_2, "() { return ").concat((0, string_1.stripQuotes)(generatedArgument), " !== undefined}"),
+                type: 'getter',
+            };
+        }
+    }
+}
+exports.parseHasContext = parseHasContext;
+function parseSetContext(json, node) {
+    var _a;
+    if (node.type === 'ExpressionStatement' &&
+        node.expression.type === 'CallExpression' &&
+        ((_a = node.expression.arguments) === null || _a === void 0 ? void 0 : _a.length)) {
+        var hook = node.expression.callee.name;
+        if (hook === 'setContext') {
+            var key = node.expression.arguments[0];
+            var value = node.expression.arguments[1];
+            json.context.set[key.value] = {
+                name: (0, astring_1.generate)(key),
+                ref: (0, astring_1.generate)(value),
+            };
+        }
+    }
+}
+exports.parseSetContext = parseSetContext;