@builder.io/mitosis 0.0.0-dev-20260605060721

package/dist/src/parsers/jsx/props.js

@@ -0,0 +1,64 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undoPropsDestructure = void 0;
+const babel = __importStar(require("@babel/core"));
+const { types } = babel;
+function undoPropsDestructure(path) {
+    const { node } = path;
+    if (node.params.length && types.isObjectPattern(node.params[0])) {
+        const param = node.params[0];
+        const propsMap = param.properties.reduce((pre, cur) => {
+            if (types.isObjectProperty(cur) &&
+                types.isIdentifier(cur.key) &&
+                types.isIdentifier(cur.value)) {
+                pre[cur.value.name] = `props.${cur.key.name}`;
+                return pre;
+            }
+            return pre;
+        }, {});
+        if (param.typeAnnotation) {
+            node.params = [
+                {
+                    ...babel.types.identifier('props'),
+                    typeAnnotation: param.typeAnnotation,
+                },
+            ];
+            path.replaceWith(node);
+        }
+        path.traverse({
+            JSXExpressionContainer(path) {
+                const { node } = path;
+                if (types.isIdentifier(node.expression)) {
+                    const { name } = node.expression;
+                    if (propsMap[name]) {
+                        path.replaceWith(babel.types.jsxExpressionContainer(babel.types.identifier(propsMap[name])));
+                    }
+                }
+            },
+        });
+    }
+}
+exports.undoPropsDestructure = undoPropsDestructure;

package/dist/src/parsers/jsx/signals.d.ts

@@ -0,0 +1,9 @@
+import { Project } from 'ts-morph';
+export declare const findSignals: ({ filePath, project }: {
+    project: Project;
+    filePath: string;
+}) => {
+    props: Set<string>;
+    state: Set<string>;
+    context: Set<string>;
+};

package/dist/src/parsers/jsx/signals.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSignals = void 0;
+const ts_morph_1 = require("ts-morph");
+const typescript_project_1 = require("../../helpers/typescript-project");
+const MITOSIS_IMPORT_PATHS = [
+    // actual production path
+    '/node_modules/@builder.io/mitosis/',
+    // possible path if symlinking mitosis locally
+    '/mitosis/packages/core/',
+];
+const findSignals = ({ filePath, project }) => {
+    const ast = project.getSourceFileOrThrow(filePath);
+    if (ast === undefined) {
+        throw new Error('Could not find AST. Please provide a correct `filePath`.');
+    }
+    const reactiveValues = {
+        props: new Set(),
+        state: new Set(),
+        context: new Set(),
+    };
+    const propsSymbol = (0, typescript_project_1.getPropsSymbol)(ast);
+    const contextSymbols = (0, typescript_project_1.getContextSymbols)(ast);
+    const checkIsSignalSymbol = (type) => {
+        var _a;
+        const symbol = (_a = type.getTargetType()) === null || _a === void 0 ? void 0 : _a.getAliasSymbol();
+        if (!symbol || symbol.getName() !== 'Signal')
+            return false;
+        const compilerSymbol = symbol === null || symbol === void 0 ? void 0 : symbol.compilerSymbol;
+        const parent = compilerSymbol.parent;
+        if (!parent)
+            return false;
+        if (MITOSIS_IMPORT_PATHS.some((path) => parent.getName().includes(path))) {
+            return true;
+        }
+        return false;
+    };
+    const checkIsOptionalSignal = (node) => {
+        let hasUndefined = false;
+        let hasSignal = false;
+        const perfectMatch = node
+            .getType()
+            .getUnionTypes()
+            .every((type) => {
+            if (type.isUndefined()) {
+                hasUndefined = true;
+                return true;
+            }
+            else if (checkIsSignalSymbol(type)) {
+                hasSignal = true;
+                return true;
+            }
+            return false;
+        });
+        return perfectMatch && hasUndefined && hasSignal;
+    };
+    ast.forEachDescendant((parentNode) => {
+        if (ts_morph_1.Node.isPropertyAccessExpression(parentNode)) {
+            const node = parentNode.getExpression();
+            const isOptionalAccess = parentNode.hasQuestionDotToken();
+            const isSignal = isOptionalAccess
+                ? checkIsOptionalSignal(node)
+                : checkIsSignalSymbol(node.getType());
+            if (!isSignal)
+                return;
+            let isInsideType = false;
+            let isInsideDeclaration = false;
+            node.getParentWhile((parent, child) => {
+                // stop once we hit the function block
+                if (ts_morph_1.Node.isBlock(child) || ts_morph_1.Node.isBlock(parent)) {
+                    return false;
+                }
+                // crawl up parents to make sure we're not inside a type
+                if (ts_morph_1.Node.isTypeNode(parent) || ts_morph_1.Node.isTypeAliasDeclaration(parent)) {
+                    isInsideType = true;
+                    return false;
+                }
+                return true;
+            });
+            if (isInsideType)
+                return;
+            if (isInsideDeclaration)
+                return;
+            const nodeSymbol = node.getSymbol();
+            if (ts_morph_1.Node.isPropertyAccessExpression(node) &&
+                node.getExpression().getSymbol() === propsSymbol) {
+                reactiveValues.props.add(node.getNameNode().getText());
+            }
+            else if (nodeSymbol && contextSymbols.has(nodeSymbol)) {
+                reactiveValues.context.add(node.getText());
+            }
+            else {
+                reactiveValues.state.add(node.getText());
+            }
+        }
+    });
+    return reactiveValues;
+};
+exports.findSignals = findSignals;

package/dist/src/parsers/jsx/state.d.ts

@@ -0,0 +1,17 @@
+import { MitosisComponent, MitosisState } from '../../types/mitosis-component';
+import { ObjectExpression } from '@babel/types';
+/**
+ * Convert state identifiers from React hooks format to the state.* format Mitosis needs
+ * e.g.
+ *   text -> state.text
+ *   setText(...) -> state.text = ...
+ *
+ * This also applies to components that use both useState and useStore.
+ * e.g.
+ * const [foo, setFoo] = useState(1)
+ * const store = useStore({
+ *   bar() { return foo } // becomes bar() { return state.foo }
+ * })`
+ */
+export declare function mapStateIdentifiers(json: MitosisComponent, stateProperties: string[]): void;
+export declare const parseStateObjectToMitosisState: (object: ObjectExpression, isState?: boolean) => MitosisState;

package/dist/src/parsers/jsx/state.js

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStateObjectToMitosisState = exports.mapStateIdentifiers = void 0;
+const babel_transform_1 = require("../../helpers/babel-transform");
+const capitalize_1 = require("../../helpers/capitalize");
+const is_mitosis_node_1 = require("../../helpers/is-mitosis-node");
+const process_code_1 = require("../../helpers/plugins/process-code");
+const replace_identifiers_1 = require("../../helpers/replace-identifiers");
+const core_1 = require("@babel/core");
+const types_1 = require("@babel/types");
+const function_1 = require("fp-ts/lib/function");
+const legacy_1 = __importDefault(require("neotraverse/legacy"));
+const helpers_1 = require("./helpers");
+function mapStateIdentifiersInExpression(expression, stateProperties) {
+    const setExpressions = stateProperties.map((propertyName) => `set${(0, capitalize_1.capitalize)(propertyName)}`);
+    return (0, function_1.pipe)((0, babel_transform_1.babelTransformExpression)(expression, {
+        Identifier(path) {
+            if (stateProperties.includes(path.node.name)) {
+                if (
+                // ignore member expressions, as the `stateProperty` is going to be at the module scope.
+                !((0, types_1.isMemberExpression)(path.parent) && path.parent.property === path.node) &&
+                    !((0, types_1.isOptionalMemberExpression)(path.parent) && path.parent.property === path.node) &&
+                    // ignore declarations of that state property, e.g. `function foo() {}`
+                    !(0, types_1.isDeclaration)(path.parent) &&
+                    !(0, types_1.isFunctionDeclaration)(path.parent) &&
+                    !((0, types_1.isFunctionExpression)(path.parent) && path.parent.id === path.node) &&
+                    // ignore object keys
+                    !((0, types_1.isObjectProperty)(path.parent) && path.parent.key === path.node)) {
+                    let hasTypeParent = false;
+                    path.findParent((parent) => {
+                        if ((0, types_1.isTSType)(parent) || (0, types_1.isTSInterfaceBody)(parent)) {
+                            hasTypeParent = true;
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (hasTypeParent) {
+                        return;
+                    }
+                    const newExpression = (0, types_1.memberExpression)((0, types_1.identifier)('state'), (0, types_1.identifier)(path.node.name));
+                    try {
+                        path.replaceWith(newExpression);
+                    }
+                    catch (err) {
+                        console.error(err);
+                        // console.log('err: ', {
+                        //   from: generate(path.parent).code,
+                        //   fromChild: generate(path.node).code,
+                        //   to: newExpression,
+                        //   // err,
+                        // });
+                    }
+                }
+            }
+        },
+        CallExpression(path) {
+            if ((0, types_1.isIdentifier)(path.node.callee)) {
+                if (setExpressions.includes(path.node.callee.name)) {
+                    // setFoo -> foo
+                    const statePropertyName = (0, helpers_1.uncapitalize)(path.node.callee.name.slice(3));
+                    // setFoo(...) -> state.foo = ...
+                    path.replaceWith((0, types_1.assignmentExpression)('=', (0, types_1.identifier)(`state.${statePropertyName}`), path.node.arguments[0]));
+                }
+            }
+        },
+    }), (code) => code.trim());
+}
+const consolidateClassBindings = (item) => {
+    if (item.bindings.className) {
+        if (item.bindings.class) {
+            // TO-DO: it's too much work to merge 2 bindings, so just remove the old one for now.
+            item.bindings.class = item.bindings.className;
+        }
+        else {
+            item.bindings.class = item.bindings.className;
+        }
+        delete item.bindings.className;
+    }
+    if (item.properties.className) {
+        if (item.properties.class) {
+            item.properties.class = `${item.properties.class} ${item.properties.className}`;
+        }
+        else {
+            item.properties.class = item.properties.className;
+        }
+        delete item.properties.className;
+    }
+    if (item.properties.class && item.bindings.class) {
+        console.warn(`[${item.name}]: Ended up with both a property and binding for 'class'.`);
+    }
+};
+/**
+ * Convert state identifiers from React hooks format to the state.* format Mitosis needs
+ * e.g.
+ *   text -> state.text
+ *   setText(...) -> state.text = ...
+ *
+ * This also applies to components that use both useState and useStore.
+ * e.g.
+ * const [foo, setFoo] = useState(1)
+ * const store = useStore({
+ *   bar() { return foo } // becomes bar() { return state.foo }
+ * })`
+ */
+function mapStateIdentifiers(json, stateProperties) {
+    const plugin = (0, process_code_1.createCodeProcessorPlugin)(() => (code) => mapStateIdentifiersInExpression(code, stateProperties));
+    plugin(json);
+    for (const key in json.targetBlocks) {
+        const targetBlock = json.targetBlocks[key];
+        for (const targetBlockKey of Object.keys(targetBlock)) {
+            const block = targetBlock[targetBlockKey];
+            if (block && 'code' in block) {
+                block.code = mapStateIdentifiersInExpression(block.code, stateProperties);
+            }
+        }
+    }
+    (0, legacy_1.default)(json).forEach(function (item) {
+        // only consolidate bindings for HTML tags, not custom components
+        // custom components are always PascalCase, e.g. MyComponent
+        // but HTML tags are lowercase, e.g. div
+        if ((0, is_mitosis_node_1.isMitosisNode)(item) && item.name.toLowerCase() === item.name) {
+            consolidateClassBindings(item);
+        }
+    });
+}
+exports.mapStateIdentifiers = mapStateIdentifiers;
+/**
+ * Replaces `this.` with `state.` and trims code
+ * @param code origin code
+ */
+const getCleanedStateCode = (code) => {
+    return (0, replace_identifiers_1.replaceNodes)({
+        code,
+        nodeMaps: [
+            {
+                from: core_1.types.thisExpression(),
+                to: core_1.types.identifier('state'),
+            },
+        ],
+    }).trim();
+};
+const processStateObjectSlice = (item) => {
+    if ((0, types_1.isObjectProperty)(item)) {
+        if ((0, types_1.isFunctionExpression)(item.value)) {
+            return {
+                code: getCleanedStateCode((0, helpers_1.parseCode)(item.value)),
+                type: 'function',
+            };
+        }
+        else if ((0, types_1.isArrowFunctionExpression)(item.value)) {
+            /**
+             * Arrow functions are normally converted to object methods to work around
+             * limitations with arrow functions in state in frameworks such as Svelte.
+             * However, this conversion does not work for async arrow functions due to
+             * how we handle parsing in `handleErrorOrExpression` for parsing
+             * expressions. That code does not detect async functions in order to apply
+             * its parsing workarounds. Even if it did, it does not consider async code
+             * when prefixing with "function". This would result in "function async foo()"
+             * which is not a valid function expression definition.
+             */
+            // TODO ENG-7256 Find a way to do this without diverging code path
+            if (item.value.async) {
+                const func = (0, types_1.functionExpression)(item.key, item.value.params, item.value.body, false, true);
+                return {
+                    code: (0, helpers_1.parseCode)(func).trim(),
+                    type: 'function',
+                };
+            }
+            const n = (0, types_1.objectMethod)('method', item.key, item.value.params, item.value.body);
+            // Replace this. with state. to handle following
+            // const state = useStore({ _do: () => {this._active = !!id;}})
+            const code = getCleanedStateCode((0, helpers_1.parseCode)(n));
+            return {
+                code: code,
+                type: 'method',
+            };
+        }
+        else {
+            // Remove typescript types, e.g. from
+            // { foo: ('string' as SomeType) }
+            if ((0, types_1.isTSAsExpression)(item.value)) {
+                return {
+                    code: getCleanedStateCode((0, helpers_1.parseCode)(item.value.expression)),
+                    type: 'property',
+                    propertyType: 'normal',
+                };
+            }
+            return {
+                code: getCleanedStateCode((0, helpers_1.parseCode)(item.value)),
+                type: 'property',
+                propertyType: 'normal',
+            };
+        }
+    }
+    else if ((0, types_1.isObjectMethod)(item)) {
+        // TODO ENG-7256 Find a way to do this without diverging code path
+        if (item.async) {
+            const func = (0, types_1.functionExpression)(item.key, item.params, item.body, false, true);
+            return {
+                code: (0, helpers_1.parseCode)(func).trim(),
+                type: 'function',
+            };
+        }
+        const method = (0, types_1.objectMethod)(item.kind, item.key, item.params, item.body, false, false, item.async);
+        const n = getCleanedStateCode((0, helpers_1.parseCode)({ ...method, returnType: null }));
+        const isGetter = item.kind === 'get';
+        return {
+            code: n,
+            type: isGetter ? 'getter' : 'method',
+        };
+    }
+    else {
+        throw new Error('Unexpected state value type', item);
+    }
+};
+const processDefaultPropsSlice = (item) => {
+    if ((0, types_1.isObjectProperty)(item)) {
+        if ((0, types_1.isFunctionExpression)(item.value) || (0, types_1.isArrowFunctionExpression)(item.value)) {
+            return {
+                code: (0, helpers_1.parseCode)(item.value),
+                type: 'method',
+            };
+        }
+        else {
+            // Remove typescript types, e.g. from
+            // { foo: ('string' as SomeType) }
+            if ((0, types_1.isTSAsExpression)(item.value)) {
+                return {
+                    code: (0, helpers_1.parseCode)(item.value.expression),
+                    type: 'property',
+                    propertyType: 'normal',
+                };
+            }
+            return {
+                code: (0, helpers_1.parseCode)(item.value),
+                type: 'property',
+                propertyType: 'normal',
+            };
+        }
+    }
+    else if ((0, types_1.isObjectMethod)(item)) {
+        const n = (0, helpers_1.parseCode)({ ...item, returnType: null });
+        const isGetter = item.kind === 'get';
+        return {
+            code: n,
+            type: isGetter ? 'getter' : 'method',
+        };
+    }
+    else {
+        throw new Error('Unexpected state value type', item);
+    }
+};
+const parseStateObjectToMitosisState = (object, isState = true) => {
+    const state = {};
+    object.properties.forEach((x) => {
+        if ((0, types_1.isSpreadElement)(x)) {
+            throw new Error('Parse Error: Mitosis cannot consume spread element in state object: ' + x);
+        }
+        if ((0, types_1.isPrivateName)(x.key)) {
+            throw new Error('Parse Error: Mitosis cannot consume private name in state object: ' + x.key);
+        }
+        if (!(0, types_1.isIdentifier)(x.key) && !(0, types_1.isStringLiteral)(x.key)) {
+            throw new Error('Parse Error: Mitosis cannot consume non-identifier and non-string key in state object: ' +
+                x.key);
+        }
+        const keyName = (0, types_1.isStringLiteral)(x.key) ? x.key.value : x.key.name;
+        state[keyName] = isState ? processStateObjectSlice(x) : processDefaultPropsSlice(x);
+    });
+    return state;
+};
+exports.parseStateObjectToMitosisState = parseStateObjectToMitosisState;

package/dist/src/parsers/jsx/types.d.ts

@@ -0,0 +1,29 @@
+import { MitosisComponent } from '../../types/mitosis-component';
+import { Project } from 'ts-morph';
+export type ParseMitosisOptions = {
+    jsonHookNames?: string[];
+    compileAwayPackages?: string[];
+    typescript: boolean;
+    tsProject?: {
+        project: Project;
+    };
+    filePath?: string;
+    /**
+     * When `true`, the `blocksSlots` field on Mitosis Nodes will be used to transform
+     * deeply nested JSX elements found on properties. Note that not every generator
+     * supports parsing `blocksSlots`.
+     * Defaults to `false`.
+     */
+    enableBlocksSlots?: boolean;
+};
+export type ResolvedImport = {
+    path: string;
+    value: string;
+};
+export type Context = {
+    cwd?: string;
+    builder: {
+        component: MitosisComponent;
+        resolvedImports?: ResolvedImport[];
+    };
+};

package/dist/src/parsers/jsx/types.js

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

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCss = void 0;
+const parseCss = (ast, json) => {
+    var _a;
+    json.style = (_a = ast.css) === null || _a === void 0 ? void 0 : _a.content.styles;
+};
+exports.parseCss = parseCss;

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

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

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processBindings = void 0;
+const bindings_1 = require("../../../helpers/bindings");
+function replaceGroupWithChecked(node, isArray = false) {
+    var _a, _b, _c;
+    if ((_b = (_a = node.bindings.group) === null || _a === void 0 ? void 0 : _a.code) === null || _b === void 0 ? void 0 : _b.length) {
+        const bindingValue = (_c = node.bindings.value) === null || _c === void 0 ? void 0 : _c.code;
+        const propertyValue = node.properties.value;
+        const groupBinding = node.bindings.group.code;
+        let code = '';
+        if (isArray) {
+            code = bindingValue
+                ? `${groupBinding}.includes(${bindingValue})`
+                : `${groupBinding}.includes('${propertyValue}')`;
+        }
+        else {
+            code = bindingValue
+                ? `${groupBinding} === ${bindingValue}`
+                : `${groupBinding} === '${propertyValue}'`;
+        }
+        node.bindings['checked'] = (0, bindings_1.createSingleBinding)({
+            code,
+        });
+        delete node.bindings.group;
+    }
+}
+/* post-processes bindings
+  bind:group https://svelte.dev/docs#template-syntax-element-directives-bind-group
+  bind:property https://svelte.dev/docs#template-syntax-component-directives-bind-this
+  bind:this https://svelte.dev/docs#template-syntax-component-directives-bind-this
+
+  - replaces group binding with checked for checkboxes and radios (supported inputs for bind:group)
+  - adds onChange for bind:group and bind:property (event.target.value OR event.target.checked)
+*/
+function processBindings(json, node) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let name;
+    let target = 'event.target.value';
+    let binding = '';
+    let isArray = false;
+    if (Object.prototype.hasOwnProperty.call(node.bindings, 'group')) {
+        name = 'group';
+        binding = (_b = (_a = node.bindings.group) === null || _a === void 0 ? void 0 : _a.code) !== null && _b !== void 0 ? _b : '';
+        if (binding.startsWith('state.')) {
+            const stateObject = json.state[binding.replace(/^state\./, '')];
+            isArray = Array.isArray(stateObject === null || stateObject === void 0 ? void 0 : stateObject.code);
+        }
+        replaceGroupWithChecked(node, isArray);
+        if (node.properties.type === 'checkbox' && !node.properties.value) {
+            target = 'event.target.checked';
+        }
+    }
+    else if (Object.prototype.hasOwnProperty.call(node.bindings, 'this')) {
+        name = 'ref';
+        binding = (_d = (_c = node.bindings.this) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : '';
+    }
+    else if (Object.prototype.hasOwnProperty.call(node.bindings, 'onChange') &&
+        node.properties.type === 'checkbox') {
+        target = 'event.target.checked';
+        binding = (_f = (_e = node.bindings.onChange) === null || _e === void 0 ? void 0 : _e.code.split('=')[0]) !== null && _f !== void 0 ? _f : '';
+    }
+    let onChangeCode = `${binding} = ${target}`;
+    // If the binding is an array, we should push / splice rather than assigning
+    if (isArray) {
+        onChangeCode = `event.target.checked ? ${binding}.push(${target}) : ${binding}.splice(${binding}.indexOf(${node.properties.value ? `'${node.properties.value}'` : (_g = node.bindings.value) === null || _g === void 0 ? void 0 : _g.code}), 1)`;
+    }
+    if (name !== 'ref' && binding) {
+        node.bindings['onChange'] = (0, bindings_1.createSingleBinding)({
+            code: onChangeCode,
+            arguments: ['event'],
+        });
+    }
+}
+exports.processBindings = processBindings;

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChildren = exports.filterChildren = void 0;
+const html_1 = require("../html");
+function filterChildren(children) {
+    var _a;
+    return ((_a = children === null || children === void 0 ? void 0 : children.filter((n) => { var _a; return n.type !== 'Comment' && (n.type !== 'Text' || ((_a = n.data) === null || _a === void 0 ? void 0 : _a.trim().length)); })) !== null && _a !== void 0 ? _a : []);
+}
+exports.filterChildren = filterChildren;
+function parseChildren(json, node) {
+    const children = [];
+    if (node.children) {
+        for (const child of filterChildren(node.children)) {
+            const mitosisNode = (0, html_1.parseHtmlNode)(json, child);
+            if (mitosisNode) {
+                children.push(mitosisNode);
+            }
+        }
+    }
+    return children;
+}
+exports.parseChildren = parseChildren;

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseObjectExpression = void 0;
+const astring_1 = require("astring");
+const references_1 = require("../instance/references");
+function parseObjectExpression(json, node) {
+    const properties = node.properties.map((n) => {
+        const node_ = n;
+        return {
+            key: (0, astring_1.generate)(node_.key),
+            value: (0, references_1.getParsedValue)(json, node_.value),
+        };
+    });
+    const c = {};
+    for (const item of properties) {
+        Object.assign(c, { [item.key]: item.value });
+    }
+    return c;
+}
+exports.parseObjectExpression = parseObjectExpression;

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

@@ -0,0 +1,2 @@
+import type { SveltosisComponent } from '../types';
+export declare function addToOnInitHook(json: SveltosisComponent, code: string): void;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToOnInitHook = void 0;
+function addToOnInitHook(json, code) {
+    var _a;
+    if ((_a = json.hooks.onInit) === null || _a === void 0 ? void 0 : _a.code.length) {
+        json.hooks.onInit.code += `\n ${code}`;
+    }
+    else {
+        json.hooks.onInit = {
+            code,
+        };
+    }
+}
+exports.addToOnInitHook = addToOnInitHook;