@builder.io/mitosis 0.0.0-dev-20260605060721

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProperties = void 0;
+function parseProperties(json, node) {
+    var _a, _b;
+    const declarations = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.declarations;
+    if (declarations === null || declarations === void 0 ? void 0 : declarations.length) {
+        const declaration = declarations[0];
+        const property = declaration.id.name;
+        const value = (_b = declaration.init) === null || _b === void 0 ? void 0 : _b.value;
+        const propertyObject = {
+            [property]: {
+                default: value,
+            },
+        };
+        json.props = { ...json.props, ...propertyObject };
+        json.defaultProps = Object.fromEntries(Object.keys(json.props)
+            .filter((key) => json.props[key].default)
+            .map((key) => [key, json.props[key].default]));
+    }
+}
+exports.parseProperties = parseProperties;

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReactive = void 0;
+const astring_1 = require("astring");
+function parseReactive(json, node) {
+    const body = node.body;
+    const expression = body === null || body === void 0 ? void 0 : body.expression;
+    if (!expression) {
+        const wrap = node.body.type !== 'BlockStatement';
+        const name = `reactive${Object.values(json.state).filter((index) => (index === null || index === void 0 ? void 0 : index.type) === 'getter').length}`;
+        json.state[name] = {
+            code: `get ${name}() ${wrap ? '{' : ''}${(0, astring_1.generate)(node.body)}${wrap ? '}' : ''}`,
+            type: 'getter',
+        };
+    }
+    else if (expression.type === 'AssignmentExpression') {
+        const { name } = expression.left;
+        json.state[name] = {
+            code: `get ${name}() {\n return ${(0, astring_1.generate)(expression.right)}}`,
+            type: 'getter',
+        };
+    }
+    else if (expression.type === 'CallExpression') {
+        if (node.body.type === 'ExpressionStatement') {
+            json.hooks.onUpdate = json.hooks.onUpdate || [];
+            json.hooks.onUpdate.push({
+                code: (0, astring_1.generate)(node.body),
+                deps: `[${expression.arguments.map((arg) => (0, astring_1.generate)(arg))}]`,
+            });
+        }
+    }
+}
+exports.parseReactive = parseReactive;

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

@@ -0,0 +1,4 @@
+import type { Expression, Pattern, VariableDeclaration } from 'estree';
+import type { SveltosisComponent } from '../types';
+export declare function getParsedValue(json: SveltosisComponent, element: Expression | Pattern): {};
+export declare function parseReferences(json: SveltosisComponent, node: VariableDeclaration): void;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReferences = exports.getParsedValue = void 0;
+const astring_1 = require("astring");
+const lodash_1 = require("lodash");
+const expressions_1 = require("../helpers/expressions");
+function getParsedValue(json, element) {
+    switch (element.type) {
+        case 'Identifier': {
+            return element.name;
+        }
+        case 'ObjectExpression': {
+            return (0, expressions_1.parseObjectExpression)(json, element);
+        }
+        default: {
+            return element.value;
+        }
+    }
+}
+exports.getParsedValue = getParsedValue;
+function isPropertyOrStateReference(index) {
+    return (0, lodash_1.isString)(index) && (index.includes('props.') || index.includes('state.'));
+}
+function parseReferences(json, node) {
+    var _a, _b, _c;
+    const declaration = node.declarations[0];
+    let code;
+    let type = 'property';
+    switch ((_a = declaration === null || declaration === void 0 ? void 0 : declaration.init) === null || _a === void 0 ? void 0 : _a.type) {
+        case 'ArrayExpression': {
+            code = declaration.init.elements.map((element) => {
+                return getParsedValue(json, element);
+            });
+            if ((0, lodash_1.some)(code, (c) => isPropertyOrStateReference(c))) {
+                const name = declaration.id.name;
+                json.state[name] = {
+                    code: `get ${name}() { return [${code.map((c) => {
+                        if (isPropertyOrStateReference(c)) {
+                            return c;
+                        }
+                        return JSON.stringify(c);
+                    })}]}`,
+                    type: 'getter',
+                };
+                return;
+            }
+            break;
+        }
+        case 'ObjectExpression': {
+            code = (0, expressions_1.parseObjectExpression)(json, declaration.init);
+            break;
+        }
+        case 'FunctionExpression': {
+            declaration.init.id = declaration.id;
+            code = (0, astring_1.generate)(declaration.init);
+            type = 'function';
+            break;
+        }
+        default: {
+            code = (_c = (_b = declaration === null || declaration === void 0 ? void 0 : declaration.init) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : null;
+        }
+    }
+    json.state[declaration.id.name] = {
+        code: JSON.stringify(code),
+        type,
+    };
+}
+exports.parseReferences = parseReferences;

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStatementAtProgramLevel = void 0;
+const astring_1 = require("astring");
+const hooks_1 = require("../helpers/hooks");
+function parseStatementAtProgramLevel(json, node) {
+    const statement = (0, astring_1.generate)(node);
+    (0, hooks_1.addToOnInitHook)(json, statement);
+}
+exports.parseStatementAtProgramLevel = parseStatementAtProgramLevel;

package/dist/src/parsers/svelte/module/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 parseModule(ast: Ast, json: SveltosisComponent): void;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModule = void 0;
+const astring_1 = require("astring");
+const compiler_1 = require("svelte/compiler");
+function handleExportNamedDeclaration(json, node) {
+    var _a, _b, _c;
+    const declarations = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.declarations;
+    if (declarations === null || declarations === void 0 ? void 0 : declarations.length) {
+        const declaration = declarations[0];
+        const property = declaration.id.name;
+        const isFunction = ((_b = declaration.init) === null || _b === void 0 ? void 0 : _b.type) === 'FunctionExpression' ||
+            ((_c = declaration.init) === null || _c === void 0 ? void 0 : _c.type) === 'ArrowFunctionExpression';
+        const exportObject = {
+            [property]: {
+                code: (0, astring_1.generate)(node),
+                isFunction,
+            },
+        };
+        json.exports = { ...json.exports, ...exportObject };
+    }
+}
+function parseModule(ast, json) {
+    (0, compiler_1.walk)(ast.module, {
+        enter(node) {
+            switch (node.type) {
+                case 'ExportNamedDeclaration':
+                    handleExportNamedDeclaration(json, node);
+                    break;
+            }
+        },
+    });
+}
+exports.parseModule = parseModule;

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

@@ -0,0 +1,4 @@
+import { MitosisComponent } from '../../../types/mitosis-component';
+export type SveltosisComponent = MitosisComponent & {
+    props: any;
+};

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

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

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

@@ -0,0 +1,7 @@
+import type { SveltosisComponent } from '../types';
+export declare function isTypeScriptComponent(string_: string): boolean;
+/** Create a tag matching regexp. */
+export declare function createTagRegex(tagName: string, flags?: string): RegExp;
+/** Transform an attribute string into a key-value object */
+export declare function parseAttributes(attributesString: string): Record<string, any>;
+export declare function collectTypes(string_: string, json: SveltosisComponent): void;

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

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectTypes = exports.parseAttributes = exports.createTagRegex = exports.isTypeScriptComponent = void 0;
+const babel = __importStar(require("@babel/core"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const parser = __importStar(require("@babel/parser"));
+const types = __importStar(require("@babel/types"));
+const lodash_1 = require("lodash");
+function isTypeScriptComponent(string_) {
+    const regex = createTagRegex('script', 'gi');
+    const match = regex.exec(string_);
+    const { lang } = parseAttributes(((match === null || match === void 0 ? void 0 : match.length) && match[1]) || '');
+    return lang === 'ts';
+}
+exports.isTypeScriptComponent = isTypeScriptComponent;
+/** Create a tag matching regexp. */
+function createTagRegex(tagName, flags) {
+    return new RegExp(`/<!--[^]*?-->|<${tagName}(\\s[^]*?)?(?:>([^]*?)<\\/${tagName}>|\\/>)`, flags);
+}
+exports.createTagRegex = createTagRegex;
+/** Transform an attribute string into a key-value object */
+function parseAttributes(attributesString) {
+    return attributesString
+        .split(/\s+/)
+        .filter(Boolean)
+        .reduce((accumulator, attribute) => {
+        const [name, value] = attribute.split('=');
+        // istanbul ignore next
+        accumulator[name] = value ? value.replace(/["']/g, '') : true;
+        return accumulator;
+    }, {});
+}
+exports.parseAttributes = parseAttributes;
+function getScriptContent(markup, module) {
+    const regex = createTagRegex('script', 'gi');
+    let match;
+    while ((match = regex.exec(markup)) !== null) {
+        const { context } = parseAttributes(match[1] || '');
+        if ((context !== 'module' && !module) || (context === 'module' && module)) {
+            return match[2];
+        }
+    }
+    return '';
+}
+function collectTypes(string_, json) {
+    var _a;
+    const module = getScriptContent(string_, true); // module
+    const instance = getScriptContent(string_, false); // instance
+    function traverse(script_) {
+        const ast = parser.parse(script_, {
+            sourceType: 'module',
+            plugins: ['typescript'],
+        });
+        babel.traverse(ast, {
+            enter(path) {
+                var _a;
+                // alias or interface (e.g. type Props = { } or interface Props {} )
+                if (types.isTSTypeAliasDeclaration(path.node) ||
+                    types.isTSInterfaceDeclaration(path.node)) {
+                    json.types = [...((_a = json.types) !== null && _a !== void 0 ? _a : []), (0, generator_1.default)(path.node).code];
+                    path.skip();
+                }
+                else if (types.isTSTypeAnnotation(path.node)) {
+                    // add to actual ref
+                    const reference = (0, generator_1.default)(path.parent).code;
+                    const type = (0, generator_1.default)(path.node.typeAnnotation).code;
+                    // add to ref
+                    if (Object.prototype.hasOwnProperty.call(json.refs, reference)) {
+                        json.refs[reference].typeParameter = type;
+                    }
+                    // temp add to prop object.
+                    // after having finished traversing, we'll create the prop type declaration
+                    if (Object.prototype.hasOwnProperty.call(json.props, reference)) {
+                        json.props[reference].type = type;
+                    }
+                }
+            },
+        });
+    }
+    traverse(module);
+    traverse(instance);
+    // add prop type declaration to json.types and set the propsTypeRef
+    if ((0, lodash_1.some)(json.props, (property) => !!property.type)) {
+        let propertyTypeDeclaration = `type Props = {`;
+        propertyTypeDeclaration += Object.keys((0, lodash_1.pickBy)(json.props, (property) => !!property.type))
+            .map((key) => {
+            return `${key}: ${json.props[key].type};`;
+        })
+            .join('\n');
+        propertyTypeDeclaration += '}';
+        json.types = [...((_a = json.types) !== null && _a !== void 0 ? _a : []), propertyTypeDeclaration];
+        json.propsTypeRef = 'Props';
+    }
+}
+exports.collectTypes = collectTypes;

package/dist/src/plugins/compile-away-builder-components.d.ts

@@ -0,0 +1,15 @@
+import { type MitosisPlugin } from '..';
+import { TraverseContext } from 'neotraverse/legacy';
+import { MitosisComponent } from '../types/mitosis-component';
+import { MitosisNode } from '../types/mitosis-node';
+type CompileAwayComponentsMap = {
+    [key: string]: (node: MitosisNode, context: TraverseContext, components: CompileAwayComponentsMap) => MitosisNode | void;
+};
+export declare const components: CompileAwayComponentsMap;
+type CompileAwayBuilderComponentsOptions = {
+    only?: string[];
+    omit?: string[];
+};
+export declare const compileAwayBuilderComponentsFromTree: (tree: MitosisNode | MitosisComponent, components: CompileAwayComponentsMap) => void;
+export declare const compileAwayBuilderComponents: (pluginOptions?: CompileAwayBuilderComponentsOptions) => MitosisPlugin;
+export {};