@builder.io/mitosis 0.0.78 → 0.0.79

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;
+var astring_1 = require("astring");
+var 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,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunctions = void 0;
+var types_1 = require("@babel/types");
+var astring_1 = require("astring");
+var lodash_1 = require("lodash");
+var compiler_1 = require("svelte/compiler");
+var string_1 = require("../helpers/string");
+function parseFunctions(json, node) {
+    var id = node.id;
+    var dispatchEventName;
+    var code = (0, astring_1.generate)(node);
+    (0, compiler_1.walk)(node, {
+        enter: function (node) {
+            switch (node.type) {
+                case 'CallExpression': {
+                    var node_ = node;
+                    var callee = node_.callee;
+                    if ((callee === null || callee === void 0 ? void 0 : callee.name) === 'dispatch') {
+                        var event_1 = (0, astring_1.generate)(node_.arguments[0]);
+                        dispatchEventName = event_1;
+                    }
+                    break;
+                }
+                case 'UpdateExpression': {
+                    if ((0, types_1.isUpdateExpression)(node) && (0, types_1.isIdentifier)(node.argument)) {
+                        var argument = node.argument.name;
+                        if (node.operator === '++') {
+                            code = code.replace('++', " = ".concat(argument, " + 1"));
+                        }
+                        else if (node.operator === '--') {
+                            code = code.replace('--', " = ".concat(argument, " - 1"));
+                        }
+                    }
+                    break;
+                }
+                case 'AssignmentExpression': {
+                    if ((0, types_1.isAssignmentExpression)(node) && (0, types_1.isIdentifier)(node.left)) {
+                        var argument = node.left.name;
+                        if (node.operator === '+=') {
+                            code = code.replace('+=', "= ".concat(argument, " +"));
+                        }
+                        else if (node.operator === '-=') {
+                            code = code.replace('-=', "= ".concat(argument, " -"));
+                        }
+                    }
+                    break;
+                }
+            }
+        },
+    });
+    if (dispatchEventName) {
+        var regex = new RegExp("dispatch\\(".concat(dispatchEventName, ",?"));
+        code = code.replace(regex, "props.on".concat((0, lodash_1.capitalize)((0, string_1.stripQuotes)(dispatchEventName)), "("));
+    }
+    json.state[id.name] = {
+        code: 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,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAfterUpdate = exports.parseOnDestroy = exports.parseOnMount = void 0;
+var astring_1 = require("astring");
+function parseHookBody(node, stripCurlyBraces) {
+    var _a;
+    if (stripCurlyBraces === void 0) { stripCurlyBraces = true; }
+    var arguments_ = (_a = node.expression) === null || _a === void 0 ? void 0 : _a.arguments;
+    var 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 = {
+        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,42 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseImports = void 0;
+function parseImports(json, node) {
+    var _a;
+    var 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?
+    var importSpecifiers = Object.values(node.specifiers).map(function (index) {
+        var _a;
+        return _a = {},
+            _a[index.local.name] = index.type === 'ImportDefaultSpecifier' ? 'default' : index.local.name,
+            _a;
+    });
+    var imports = {};
+    for (var _i = 0, importSpecifiers_1 = importSpecifiers; _i < importSpecifiers_1.length; _i++) {
+        var specifier = importSpecifiers_1[_i];
+        Object.assign(imports, specifier);
+    }
+    // only add imports which are actually used
+    if (Object.keys(imports).length > 0) {
+        json.imports = __spreadArray(__spreadArray([], json.imports, true), [
+            { imports: imports, path: source.replace('.svelte', '.lite') },
+        ], false);
+        // 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 '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,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInstance = void 0;
+var compiler_1 = require("svelte/compiler");
+var astring_1 = require("astring");
+var hooks_1 = require("./hooks");
+var functions_1 = require("./functions");
+var context_1 = require("./context");
+var imports_1 = require("./imports");
+var properties_1 = require("./properties");
+var reactive_1 = require("./reactive");
+var references_1 = require("./references");
+var statements_1 = require("./statements");
+var expressions_1 = require("./expressions");
+var handleImportDeclaration = function (json, node) {
+    (0, imports_1.parseImports)(json, node);
+};
+var handleExportNamedDeclaration = function (json, node) {
+    (0, properties_1.parseProperties)(json, node);
+};
+var handleMemberExpression = function (json, node, parent) {
+    (0, expressions_1.parseMemberExpression)(json, node, parent);
+};
+var handleExpressionStatement = function (json, node, parent) {
+    var _a;
+    if (node.expression.type === 'CallExpression') {
+        if (node.expression.callee.type === 'MemberExpression') {
+            handleMemberExpression(json, node, parent);
+            return;
+        }
+        var 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') {
+        var onMountCode = ((_a = json.hooks.onMount) === null || _a === void 0 ? void 0 : _a.code) || '';
+        json.hooks.onMount = {
+            code: "".concat(onMountCode, "\n").concat((0, astring_1.generate)(node), ";\n"),
+        };
+    }
+};
+var handleFunctionDeclaration = function (json, node) {
+    (0, functions_1.parseFunctions)(json, node);
+};
+var handleVariableDeclaration = function (json, node) {
+    var _a, _b, _c, _d;
+    var 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);
+    }
+};
+var handleLabeledStatement = function (json, node) {
+    if (node.label.name === '$') {
+        (0, reactive_1.parseReactive)(json, node);
+    }
+};
+var handleStatement = function (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: function (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;

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

@@ -0,0 +1,34 @@
+"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.parseProperties = void 0;
+function parseProperties(json, node) {
+    var _a;
+    var _b, _c;
+    var declarations = (_b = node.declaration) === null || _b === void 0 ? void 0 : _b.declarations;
+    if (declarations === null || declarations === void 0 ? void 0 : declarations.length) {
+        var declaration = declarations[0];
+        var property = declaration.id.name;
+        var value = (_c = declaration.init) === null || _c === void 0 ? void 0 : _c.value;
+        var propertyObject = (_a = {},
+            _a[property] = {
+                default: value,
+            },
+            _a);
+        json.props = __assign(__assign({}, json.props), propertyObject);
+        json.defaultProps = Object.fromEntries(Object.keys(json.props)
+            .filter(function (key) { return json.props[key].default; })
+            .map(function (key) { return [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,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReactive = void 0;
+var astring_1 = require("astring");
+function parseReactive(json, node) {
+    var body = node.body;
+    var expression = body === null || body === void 0 ? void 0 : body.expression;
+    if (!expression) {
+        var wrap = node.body.type !== 'BlockStatement';
+        var name_1 = "reactive".concat(Object.values(json.state).filter(function (index) { return (index === null || index === void 0 ? void 0 : index.type) === 'getter'; }).length);
+        json.state[name_1] = {
+            code: "get ".concat(name_1, "() ").concat(wrap ? '{' : '').concat((0, astring_1.generate)(node.body)).concat(wrap ? '}' : ''),
+            type: 'getter',
+        };
+    }
+    else if (expression.left) {
+        var name_2 = expression.left.name;
+        json.state[name_2] = {
+            code: "get ".concat(name_2, "() {\n return ").concat((0, astring_1.generate)(expression.right), "}"),
+            type: 'getter',
+        };
+    }
+}
+exports.parseReactive = parseReactive;

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

@@ -0,0 +1,4 @@
+import type { VariableDeclaration, Expression, Pattern } 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;
+var astring_1 = require("astring");
+var lodash_1 = require("lodash");
+var 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;
+    var declaration = node.declarations[0];
+    var code;
+    var 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(function (element) {
+                return getParsedValue(json, element);
+            });
+            if ((0, lodash_1.some)(code, function (c) { return isPropertyOrStateReference(c); })) {
+                var name_1 = declaration.id.name;
+                json.state[name_1] = {
+                    code: "get ".concat(name_1, "() { return [").concat(code.map(function (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 = (_b = declaration === null || declaration === void 0 ? void 0 : declaration.init) === null || _b === void 0 ? void 0 : _b.value;
+        }
+    }
+    json.state[declaration.id.name] = {
+        code: JSON.stringify(code),
+        type: 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;
+var astring_1 = require("astring");
+var hooks_1 = require("../helpers/hooks");
+function parseStatementAtProgramLevel(json, node) {
+    var 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 '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,46 @@
+"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.parseModule = void 0;
+var compiler_1 = require("svelte/compiler");
+var astring_1 = require("astring");
+function handleExportNamedDeclaration(json, node) {
+    var _a;
+    var _b, _c, _d;
+    var declarations = (_b = node.declaration) === null || _b === void 0 ? void 0 : _b.declarations;
+    if (declarations === null || declarations === void 0 ? void 0 : declarations.length) {
+        var declaration = declarations[0];
+        var property = declaration.id.name;
+        var isFunction = ((_c = declaration.init) === null || _c === void 0 ? void 0 : _c.type) === 'FunctionExpression' ||
+            ((_d = declaration.init) === null || _d === void 0 ? void 0 : _d.type) === 'ArrowFunctionExpression';
+        var exportObject = (_a = {},
+            _a[property] = {
+                code: (0, astring_1.generate)(node),
+                isFunction: isFunction,
+            },
+            _a);
+        json.exports = __assign(__assign({}, json.exports), exportObject);
+    }
+}
+function parseModule(ast, json) {
+    (0, compiler_1.walk)(ast.module, {
+        enter: function (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 declare 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;