@builder.io/mitosis 0.0.0-dev-20260605060721

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHtmlNode = exports.parseHtml = void 0;
+const compiler_1 = require("svelte/compiler");
+const each_1 = require("./each");
+const element_1 = require("./element");
+const fragment_1 = require("./fragment");
+const if_else_1 = require("./if-else");
+const mustache_tag_1 = require("./mustache-tag");
+const slot_1 = require("./slot");
+const text_1 = require("./text");
+function parseHtml(ast, json) {
+    var _a, _b;
+    // todo: should filter children and check if just 1 has length
+    const 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(node, parent) {
+            const templateNode = node;
+            const parentTemplateNode = parent;
+            if ((parentTemplateNode === null || parentTemplateNode === void 0 ? void 0 : parentTemplateNode.children) || templateNode.data === '\n\n') {
+                this.skip();
+                return;
+            }
+            const mitosisNode = parseHtmlNode(json, templateNode);
+            if (mitosisNode) {
+                json.children.push(mitosisNode);
+            }
+        },
+    });
+}
+exports.parseHtml = parseHtml;
+function parseHtmlNode(json, node) {
+    const mitosisNode = {
+        '@type': '@builder.io/mitosis/node',
+        name: '',
+        meta: {},
+        scope: {},
+        children: [],
+        bindings: {},
+        properties: {},
+        slots: {},
+    };
+    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 '../../../../../node_modules/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,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRawMustacheTag = exports.parseMustacheTag = void 0;
+const astring_1 = require("astring");
+const bindings_1 = require("../../../helpers/bindings");
+const mitosis_node_1 = require("../helpers/mitosis-node");
+function parseMustacheTag(node) {
+    const mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'div';
+    mitosisNode.bindings['_text'] = (0, bindings_1.createSingleBinding)({
+        code: (0, astring_1.generate)(node.expression),
+    });
+    return mitosisNode;
+}
+exports.parseMustacheTag = parseMustacheTag;
+function parseRawMustacheTag(node) {
+    const mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'div';
+    mitosisNode.bindings.innerHTML = (0, bindings_1.createSingleBinding)({
+        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 '../../../../../node_modules/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,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSlot = void 0;
+const lodash_1 = require("lodash");
+const children_1 = require("../helpers/children");
+const mitosis_node_1 = require("../helpers/mitosis-node");
+function parseSlot(json, node) {
+    var _a, _b;
+    const mitosisNode = (0, mitosis_node_1.createMitosisNode)();
+    mitosisNode.name = 'Slot';
+    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)) {
+        const slotName = (0, lodash_1.upperFirst)((0, lodash_1.camelCase)((_b = node.attributes[0].value[0]) === null || _b === void 0 ? void 0 : _b.data));
+        mitosisNode.properties.name = slotName;
+    }
+    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,66 @@
+import type { TemplateNode } from '../../../../../node_modules/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: {};
+    type?: "user-symbol" | undefined;
+    bindings: {
+        [key: string]: import("../../..").Binding | undefined;
+    };
+    children: import("../../..").MitosisNode[];
+    slots?: {
+        [key: string]: import("../../..").MitosisNode[];
+    } | undefined;
+    localizedValues?: {
+        [index: string]: import("../../..").BuilderLocalizedValue;
+    } | undefined;
+    blocksSlots?: import("../../..").BlockSlot | undefined;
+} | {
+    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;
+    };
+    type?: "user-symbol" | undefined;
+    bindings: {
+        [key: string]: import("../../..").Binding | undefined;
+    };
+    children: import("../../..").MitosisNode[];
+    slots?: {
+        [key: string]: import("../../..").MitosisNode[];
+    } | undefined;
+    localizedValues?: {
+        [index: string]: import("../../..").BuilderLocalizedValue;
+    } | undefined;
+    blocksSlots?: import("../../..").BlockSlot | undefined;
+} | {
+    name: string;
+    properties: {
+        _text: any;
+    };
+    '@type': "@builder.io/mitosis/node";
+    meta: import("../../../types/json").JSONObject;
+    scope: {};
+    type?: "user-symbol" | undefined;
+    bindings: {
+        [key: string]: import("../../..").Binding | undefined;
+    };
+    children: import("../../..").MitosisNode[];
+    slots?: {
+        [key: string]: import("../../..").MitosisNode[];
+    } | undefined;
+    localizedValues?: {
+        [index: string]: import("../../..").BuilderLocalizedValue;
+    } | undefined;
+    blocksSlots?: import("../../..").BlockSlot | undefined;
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseText = void 0;
+const mitosis_node_1 = require("../helpers/mitosis-node");
+function parseText(node) {
+    return {
+        ...(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,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSvelte = void 0;
+const lodash_1 = require("lodash");
+const svelte_preprocess_1 = __importDefault(require("svelte-preprocess"));
+const compiler_1 = require("svelte/compiler");
+const css_1 = require("./css");
+const post_process_1 = require("./helpers/post-process");
+const html_1 = require("./html");
+const instance_1 = require("./instance");
+const module_1 = require("./module");
+const typescript_1 = require("./typescript");
+function mapAstToMitosisJson(ast, name, string_ = '', usesTypescript = false) {
+    const json = {
+        '@type': '@builder.io/mitosis/component',
+        inputs: [],
+        state: {},
+        props: {},
+        refs: {},
+        hooks: {
+            onMount: [],
+            onEvent: [],
+        },
+        imports: [],
+        children: [],
+        context: { get: {}, set: {} },
+        subComponents: [],
+        meta: {},
+        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']);
+}
+const parseSvelte = async function (string_, path = 'MyComponent.svelte') {
+    var _a, _b;
+    const usesTypescript = (0, typescript_1.isTypeScriptComponent)(string_);
+    const processedString = await (0, compiler_1.preprocess)(string_, [
+        (0, svelte_preprocess_1.default)({
+            typescript: usesTypescript ? { tsconfigFile: false } : false,
+        }),
+    ], {
+        filename: path.split('/').pop(),
+    });
+    const ast = (0, compiler_1.parse)(processedString.code);
+    const componentName = (_b = (_a = path.split('/').pop()) === null || _a === void 0 ? void 0 : _a.split('.')[0]) !== null && _b !== void 0 ? _b : 'MyComponent';
+    return mapAstToMitosisJson(ast, componentName, string_, usesTypescript);
+};
+exports.parseSvelte = parseSvelte;

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

@@ -0,0 +1,5 @@
+import type { ExpressionStatement, VariableDeclaration } 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;
+const astring_1 = require("astring");
+const string_1 = require("../helpers/string");
+function parseGetContext(json, node) {
+    var _a;
+    if (node.declarations.length > 0) {
+        const declaration = node.declarations[0];
+        const { name } = declaration.id;
+        const arguments_ = (_a = declaration.init) === null || _a === void 0 ? void 0 : _a.arguments;
+        if (arguments === null || arguments === void 0 ? void 0 : arguments.length) {
+            const argument = arguments_[0];
+            json.context.get[name] = {
+                name: (0, astring_1.generate)(argument),
+                path: '',
+            };
+        }
+    }
+}
+exports.parseGetContext = parseGetContext;
+function parseHasContext(json, node) {
+    var _a;
+    if (node.declarations.length > 0) {
+        const declaration = node.declarations[0];
+        const { name } = declaration.id;
+        const arguments_ = (_a = declaration.init) === null || _a === void 0 ? void 0 : _a.arguments;
+        if (arguments === null || arguments === void 0 ? void 0 : arguments.length) {
+            const argument = arguments_[0];
+            const generatedArgument = (0, astring_1.generate)(argument);
+            json.context.get[(0, string_1.stripQuotes)(generatedArgument)] = {
+                name: generatedArgument,
+                path: '',
+            };
+            json.state[name] = {
+                code: `get ${name}() { return ${(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)) {
+        const hook = node.expression.callee.name;
+        if (hook === 'setContext') {
+            const key = node.expression.arguments[0];
+            const 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;

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

@@ -0,0 +1,3 @@
+import { BaseNode, ExpressionStatement } from 'estree';
+import type { SveltosisComponent } from '../types';
+export declare function parseMemberExpression(json: SveltosisComponent, node: ExpressionStatement, parent?: BaseNode): void;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMemberExpression = void 0;
+const astring_1 = require("astring");
+const hooks_1 = require("../helpers/hooks");
+function parseMemberExpression(json, node, parent) {
+    if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Program') {
+        (0, hooks_1.addToOnInitHook)(json, (0, astring_1.generate)(node));
+    }
+}
+exports.parseMemberExpression = parseMemberExpression;

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

@@ -0,0 +1,3 @@
+import type { FunctionDeclaration } from 'estree';
+import type { SveltosisComponent } from '../types';
+export declare function parseFunctions(json: SveltosisComponent, node: FunctionDeclaration): void;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunctions = void 0;
+const types_1 = require("@babel/types");
+const astring_1 = require("astring");
+const lodash_1 = require("lodash");
+const compiler_1 = require("svelte/compiler");
+const string_1 = require("../helpers/string");
+function parseFunctions(json, node) {
+    const id = node.id;
+    let dispatchEventName;
+    let code = (0, astring_1.generate)(node);
+    (0, compiler_1.walk)(node, {
+        enter(node) {
+            switch (node.type) {
+                case 'CallExpression': {
+                    const node_ = node;
+                    const callee = node_.callee;
+                    if ((callee === null || callee === void 0 ? void 0 : callee.name) === 'dispatch') {
+                        dispatchEventName = (0, astring_1.generate)(node_.arguments[0]);
+                    }
+                    break;
+                }
+                case 'UpdateExpression': {
+                    if ((0, types_1.isUpdateExpression)(node)) {
+                        const expression = node;
+                        if ((0, types_1.isIdentifier)(expression.argument)) {
+                            const argument = expression.argument.name;
+                            if (expression.operator === '++') {
+                                code = code.replace('++', ` = ${argument} + 1`);
+                            }
+                            else if (expression.operator === '--') {
+                                code = code.replace('--', ` = ${argument} - 1`);
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'AssignmentExpression': {
+                    if ((0, types_1.isAssignmentExpression)(node)) {
+                        const expression = node;
+                        if ((0, types_1.isIdentifier)(expression.left)) {
+                            const argument = expression.left.name;
+                            if (expression.operator === '+=') {
+                                code = code.replace('+=', `= ${argument} +`);
+                            }
+                            else if (expression.operator === '-=') {
+                                code = code.replace('-=', `= ${argument} -`);
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        },
+    });
+    if (dispatchEventName) {
+        const regex = new RegExp(`dispatch\\(${dispatchEventName},?`);
+        code = code.replace(regex, `props.on${(0, lodash_1.capitalize)((0, string_1.stripQuotes)(dispatchEventName))}(`);
+    }
+    json.state[id.name] = {
+        code,
+        type: 'function',
+    };
+}
+exports.parseFunctions = parseFunctions;

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAfterUpdate = exports.parseOnDestroy = exports.parseOnMount = void 0;
+const astring_1 = require("astring");
+function parseHookBody(node, stripCurlyBraces = true) {
+    var _a;
+    const arguments_ = (_a = node.expression) === null || _a === void 0 ? void 0 : _a.arguments;
+    let code = (0, astring_1.generate)(arguments_[0].body);
+    if (stripCurlyBraces && (code === null || code === void 0 ? void 0 : code.trim().length) && code[0] === '{' && code[code.length - 1] === '}')
+        code = code.slice(1, -1);
+    return code;
+}
+function parseOnMount(json, node) {
+    json.hooks.onMount.push({
+        code: parseHookBody(node),
+    });
+}
+exports.parseOnMount = parseOnMount;
+function parseOnDestroy(json, node) {
+    json.hooks.onUnMount = {
+        code: parseHookBody(node),
+    };
+}
+exports.parseOnDestroy = parseOnDestroy;
+function parseAfterUpdate(json, node) {
+    json.hooks.onUpdate = [
+        {
+            code: parseHookBody(node),
+        },
+    ];
+}
+exports.parseAfterUpdate = parseAfterUpdate;

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

@@ -0,0 +1,3 @@
+import type { ImportDeclaration } from 'estree';
+import type { SveltosisComponent } from '../types';
+export declare function parseImports(json: SveltosisComponent, node: ImportDeclaration): void;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseImports = void 0;
+function parseImports(json, node) {
+    var _a;
+    const source = (_a = node.source) === null || _a === void 0 ? void 0 : _a.value;
+    if (source === 'svelte')
+        return; // Do not import anything from svelte
+    // ^ Maybe this should even be stricter and only allow relative imports and alias ones
+    // as you can't import any other svelte specific libraries either...Or can we?
+    const importSpecifiers = Object.values(node.specifiers).map((index) => {
+        return {
+            [index.local.name]: index.type === 'ImportDefaultSpecifier' ? 'default' : index.local.name,
+        };
+    });
+    const imports = {};
+    for (const specifier of importSpecifiers) {
+        Object.assign(imports, specifier);
+    }
+    // only add imports which are actually used
+    if (Object.keys(imports).length > 0) {
+        json.imports = [
+            ...json.imports,
+            { imports, path: source.replace('.svelte', '.lite') },
+        ];
+        // TODO: if import source already exist, combine them
+        // e.g. import { lowercase } from 'lodash';
+        // e.g. import { uppercase } from 'lodash';
+        // should become import { lowercase, uppercase } from 'lodash';
+    }
+}
+exports.parseImports = parseImports;

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

@@ -0,0 +1,3 @@
+import type { Ast } from '../../../../../node_modules/svelte/types/compiler/interfaces';
+import type { SveltosisComponent } from '../types';
+export declare function parseInstance(ast: Ast, json: SveltosisComponent): void;

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInstance = void 0;
+const astring_1 = require("astring");
+const compiler_1 = require("svelte/compiler");
+const context_1 = require("./context");
+const expressions_1 = require("./expressions");
+const functions_1 = require("./functions");
+const hooks_1 = require("./hooks");
+const imports_1 = require("./imports");
+const properties_1 = require("./properties");
+const reactive_1 = require("./reactive");
+const references_1 = require("./references");
+const statements_1 = require("./statements");
+const handleImportDeclaration = (json, node) => {
+    (0, imports_1.parseImports)(json, node);
+};
+const handleExportNamedDeclaration = (json, node) => {
+    (0, properties_1.parseProperties)(json, node);
+};
+const handleMemberExpression = (json, node, parent) => {
+    (0, expressions_1.parseMemberExpression)(json, node, parent);
+};
+const handleExpressionStatement = (json, node, parent) => {
+    if (node.expression.type === 'CallExpression') {
+        if (node.expression.callee.type === 'MemberExpression') {
+            handleMemberExpression(json, node, parent);
+            return;
+        }
+        const callee = node.expression.callee;
+        switch (callee.name) {
+            case 'setContext': {
+                (0, context_1.parseSetContext)(json, node);
+                break;
+            }
+            case 'onMount': {
+                (0, hooks_1.parseOnMount)(json, node);
+                break;
+            }
+            case 'onDestroy': {
+                (0, hooks_1.parseOnDestroy)(json, node);
+                break;
+            }
+            case 'onAfterUpdate': {
+                (0, hooks_1.parseAfterUpdate)(json, node);
+                break;
+            }
+        }
+        // No default
+    }
+    else if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Program') {
+        json.hooks.onMount.push({
+            code: (0, astring_1.generate)(node),
+        });
+    }
+};
+const handleFunctionDeclaration = (json, node) => {
+    (0, functions_1.parseFunctions)(json, node);
+};
+const handleVariableDeclaration = (json, node) => {
+    var _a, _b, _c, _d;
+    const init = (_a = node.declarations[0]) === null || _a === void 0 ? void 0 : _a.init;
+    if ((init === null || init === void 0 ? void 0 : init.type) === 'CallExpression' && ((_b = init === null || init === void 0 ? void 0 : init.callee) === null || _b === void 0 ? void 0 : _b.name) === 'getContext') {
+        (0, context_1.parseGetContext)(json, node);
+    }
+    else if ((init === null || init === void 0 ? void 0 : init.type) === 'CallExpression' &&
+        ((_c = init === null || init === void 0 ? void 0 : init.callee) === null || _c === void 0 ? void 0 : _c.name) === 'hasContext') {
+        (0, context_1.parseHasContext)(json, node);
+    }
+    else if ((init === null || init === void 0 ? void 0 : init.type) === 'CallExpression' &&
+        ((_d = init === null || init === void 0 ? void 0 : init.callee) === null || _d === void 0 ? void 0 : _d.name) === 'createEventDispatcher') {
+        // ignore
+    }
+    else {
+        (0, references_1.parseReferences)(json, node);
+    }
+};
+const handleLabeledStatement = (json, node) => {
+    if (node.label.name === '$') {
+        (0, reactive_1.parseReactive)(json, node);
+    }
+};
+const handleStatement = (json, node, parent) => {
+    if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Program') {
+        (0, statements_1.parseStatementAtProgramLevel)(json, node);
+    }
+};
+function parseInstance(ast, json) {
+    (0, compiler_1.walk)(ast.instance, {
+        enter(node, parent) {
+            switch (node.type) {
+                case 'ImportDeclaration':
+                    handleImportDeclaration(json, node);
+                    break;
+                case 'ExportNamedDeclaration':
+                    handleExportNamedDeclaration(json, node);
+                    break;
+                case 'ExpressionStatement':
+                    handleExpressionStatement(json, node, parent);
+                    break;
+                case 'FunctionDeclaration':
+                    handleFunctionDeclaration(json, node);
+                    break;
+                case 'VariableDeclaration':
+                    parent.type === 'Program' && handleVariableDeclaration(json, node);
+                    break;
+                case 'LabeledStatement':
+                    handleLabeledStatement(json, node);
+                    break;
+                case 'IfStatement':
+                case 'SwitchStatement':
+                case 'TryStatement':
+                case 'DoWhileStatement':
+                case 'ForStatement':
+                case 'ForInStatement':
+                case 'ForOfStatement':
+                    handleStatement(json, node, parent);
+                    break;
+            }
+        },
+    });
+}
+exports.parseInstance = parseInstance;

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

@@ -0,0 +1,3 @@
+import type { ExportNamedDeclaration } from 'estree';
+import type { SveltosisComponent } from '../types';
+export declare function parseProperties(json: SveltosisComponent, node: ExportNamedDeclaration): void;