babel-plugin-vasille 0.99.5 → 3.1.0

package/lib-node/mesh.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.meshOrIgnoreAllExpressions = meshOrIgnoreAllExpressions;
 exports.meshAllExpressions = meshAllExpressions;
@@ -30,7 +40,6 @@ exports.meshAllUnknown = meshAllUnknown;
 exports.meshLValue = meshLValue;
 exports.meshOrIgnoreExpression = meshOrIgnoreExpression;
 exports.meshExpression = meshExpression;
-exports.meshBody = meshBody;
 exports.meshStatements = meshStatements;
 exports.ignoreParams = ignoreParams;
 exports.reactiveArrayPattern = reactiveArrayPattern;
@@ -41,11 +50,11 @@ exports.composeStatements = composeStatements;
 exports.composeStatement = composeStatement;
 exports.compose = compose;
 const t = __importStar(require("@babel/types"));
-const call_1 = require("./call");
-const internal_1 = require("./internal");
-const jsx_detect_1 = require("./jsx-detect");
-const lib_1 = require("./lib");
-const jsx_1 = require("./jsx");
+const call_js_1 = require("./call.js");
+const expression_js_1 = require("./expression.js");
+const internal_js_1 = require("./internal.js");
+const jsx_js_1 = require("./jsx.js");
+const lib_js_1 = require("./lib.js");
 function meshOrIgnoreAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
         if (t.isExpression(path.node)) {
@@ -65,12 +74,14 @@ function meshComposeCall(call, name, nodePath, internal) {
     }
     const fnPath = nodePath.get("arguments")[0];
     compose(fnPath, internal, false);
-    arg.params.unshift(internal_1.ctx);
-    if (t.isArrowFunctionExpression(arg) && internal.devMode) {
-        fnPath.replaceWith(t.functionExpression(t.identifier(internal.prefix + (name ? name.name : "Default")), arg.params, t.isBlockStatement(arg.body) ? arg.body : t.blockStatement([t.returnStatement(arg.body)]), false, arg.async));
+    if (!internal.stateOnly) {
+        arg.params.unshift(internal_js_1.ctx);
     }
-    else if (t.isFunctionExpression(arg) && name && internal.devMode) {
-        arg.id = t.identifier(internal.prefix + name.name);
+    if (internal.devMode) {
+        call.arguments.push(t.stringLiteral(`${internal.prefix}:${name ? name.name : "#anonymouse"}`));
+    }
+    if (t.isIdentifier(call.callee) && call.callee.name === "state") {
+        nodePath.replaceWith(call.arguments[0]);
     }
 }
 function meshAllUnknown(paths, internal) {
@@ -85,26 +96,21 @@ function meshAllUnknown(paths, internal) {
 }
 function meshLValue(path, internal) {
     const node = path.node;
-    if (t.isArrayPattern(node) ||
-        t.isObjectPattern(node) ||
-        t.isTSParameterProperty(node) ||
-        t.isAssignmentPattern(node) ||
-        t.isRestElement(node)) {
-        return;
+    if (t.isExpression(node)) {
+        meshExpression(path, internal);
     }
-    meshExpression(path, internal);
 }
 function meshOrIgnoreExpression(path, internal) {
     if (t.isExpression(path.node)) {
         meshExpression(path, internal);
     }
 }
-function meshExpression(nodePath, internal) {
+function meshExpression(nodePath, internal, isRoot) {
     const expr = nodePath.node;
     if (!expr) {
         return;
     }
-    if ((0, call_1.calls)(expr, ["compose", "extend"], internal)) {
+    if ((0, call_js_1.calls)(expr, ["compose", "extend", "state"], internal)) {
         meshComposeCall(expr, null, nodePath, internal);
         return;
     }
@@ -121,11 +127,8 @@ function meshExpression(nodePath, internal) {
         }
         case "Identifier": {
             const state = internal.stack.get(expr.name);
-            if (state === 2 /* VariableState.Reactive */) {
-                nodePath.replaceWith(t.memberExpression(expr, t.identifier("$")));
-            }
-            else if (state === 4 /* VariableState.ReactivePointer */) {
-                nodePath.replaceWith(t.memberExpression(expr, t.identifier("$$")));
+            if ((0, expression_js_1.idIsIValue)(nodePath, internal)) {
+                nodePath.replaceWith(t.memberExpression(expr, t.identifier(state === 4 /* VariableState.ReactivePointer */ ? "$$" : "$")));
             }
             break;
         }
@@ -134,50 +137,43 @@ function meshExpression(nodePath, internal) {
             meshAllUnknown(path.get("elements"), internal);
             break;
         }
-        case "TupleExpression": {
-            const path = nodePath;
-            meshAllUnknown(path.get("elements"), internal);
-            break;
-        }
         case "CallExpression":
         case "OptionalCallExpression": {
             const path = nodePath;
-            const callsFn = (0, call_1.calls)(path.node, call_1.composeOnly, internal);
-            const callsStyleHint = (0, call_1.calls)(path.node, call_1.styleOnly, internal);
-            const callsStyleCreate = (0, call_1.calls)(path.node, ["webStyleSheet"], internal);
+            const callsFn = (0, call_js_1.calls)(path.node, call_js_1.composeOnly, internal);
+            const callsStyleHint = (0, call_js_1.calls)(path.node, call_js_1.styleOnly, internal);
             if (callsFn) {
                 throw path.buildCodeFrameError(`Vasille: Usage of hint "${callsFn}" is restricted here`);
             }
             if (callsStyleHint) {
                 throw path.buildCodeFrameError(`Vasille: Usage of style hint "${callsStyleHint}" is restricted here`);
             }
-            if (callsStyleCreate) {
-                throw path.buildCodeFrameError("Vasille: Styles can be created in moldule level code only");
-            }
             meshOrIgnoreExpression(path.get("callee"), internal);
             meshAllUnknown(path.get("arguments"), internal);
-            if ((0, call_1.calls)(path.node, ["calculate"], internal)) {
-                if (path.node.arguments.length !== 1 && !t.isExpression(path.node.arguments[0])) {
+            if ((0, call_js_1.calls)(path.node, ["calculate"], internal)) {
+                if (path.node.arguments.length === 1 &&
+                    (t.isFunctionExpression(path.node.arguments[0]) || t.isArrowFunctionExpression(path.node.arguments[0]))) {
+                    path.replaceWith(t.callExpression(path.node.arguments[0], []));
+                }
+                else {
                     throw path.buildCodeFrameError("Vasille: Incorrect calculate argument");
                 }
-                path.replaceWith(t.callExpression(path.node.arguments[0], []));
             }
             break;
         }
         case "AssignmentExpression": {
             const path = nodePath;
             const left = path.node.left;
+            let replaced = false;
             meshLValue(path.get("left"), internal);
             if (t.isIdentifier(left) && internal.stack.get(left.name) === 4 /* VariableState.ReactivePointer */) {
-                const replaceWith = (0, lib_1.forwardOnlyExpr)(path.get("right"), path.node.right, internal);
+                const replaceWith = (0, lib_js_1.forwardOnlyExpr)(path.get("right"), path.node.right, internal);
                 if (replaceWith) {
                     path.get("right").replaceWith(replaceWith);
-                }
-                else {
-                    meshExpression(path.get("right"), internal);
+                    replaced = true;
                 }
             }
-            else {
+            if (!replaced) {
                 meshExpression(path.get("right"), internal);
             }
             break;
@@ -191,7 +187,7 @@ function meshExpression(nodePath, internal) {
             if (t.isExpression(property) && !t.isIdentifier(property)) {
                 meshOrIgnoreExpression(path.get("property"), internal);
             }
-            if (t.isIdentifier(node.object) && internal.stack.get(node.object.name) === 3 /* VariableState.ReactiveObject */) {
+            if ((0, expression_js_1.memberIsIValue)(node, internal)) {
                 path.replaceWith(t.memberExpression(node, t.identifier("$")));
             }
             break;
@@ -226,11 +222,6 @@ function meshExpression(nodePath, internal) {
             meshAllExpressions(path.get("expressions"), internal);
             break;
         }
-        case "ParenthesizedExpression": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
         case "UnaryExpression": {
             const path = nodePath;
             meshExpression(path.get("argument"), internal);
@@ -251,27 +242,6 @@ function meshExpression(nodePath, internal) {
             meshExpression(path.get("argument"), internal);
             break;
         }
-        case "TypeCastExpression": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
-        case "BindExpression": {
-            const path = nodePath;
-            meshExpression(path.get("callee"), internal);
-            meshExpression(path.get("object"), internal);
-            break;
-        }
-        case "PipelineTopicExpression": {
-            const path = nodePath;
-            meshExpression(path.get("expression"), internal);
-            break;
-        }
-        case "PipelineBareFunction": {
-            const path = nodePath;
-            meshExpression(path.get("callee"), internal);
-            break;
-        }
         case "TSInstantiationExpression": {
             const path = nodePath;
             meshExpression(path.get("expression"), internal);
@@ -299,16 +269,38 @@ function meshExpression(nodePath, internal) {
                 if (t.isObjectProperty(prop)) {
                     const path = propPath;
                     const valuePath = path.get("value");
-                    if (valuePath instanceof Array) {
-                        meshAllExpressions(valuePath, internal);
+                    let replaced = false;
+                    if (isRoot &&
+                        internal.stateOnly &&
+                        !path.node.computed &&
+                        t.isIdentifier(path.node.key) &&
+                        t.isExpression(valuePath.node)) {
+                        const call = (0, lib_js_1.exprCall)(valuePath, valuePath.node, internal);
+                        if (call) {
+                            if (path.node.key.name.startsWith("$")) {
+                                valuePath.replaceWith(call);
+                            }
+                            else {
+                                throw path.buildCodeFrameError("Vasille: Reactive value property name must start with $");
+                            }
+                            replaced = true;
+                        }
+                        else if (t.isIdentifier(valuePath.node) &&
+                            internal.stack.get(valuePath.node.name) === 3 /* VariableState.ReactiveObject */ &&
+                            !path.node.key.name.startsWith("$$")) {
+                            throw path.buildCodeFrameError("Vasille: Reactive object property name must start with $$");
+                        }
                     }
-                    else {
+                    if (!replaced) {
                         meshOrIgnoreExpression(valuePath, internal);
                     }
                 }
                 else if (t.isObjectMethod(prop)) {
                     meshFunction(propPath, internal);
                 }
+                else if (isRoot && internal.stateOnly && t.isSpreadElement(prop)) {
+                    throw propPath.buildCodeFrameError("Vasille: Spread element is not allowed here");
+                }
                 else {
                     meshAllUnknown([propPath], internal);
                 }
@@ -323,41 +315,16 @@ function meshExpression(nodePath, internal) {
             meshFunction(nodePath, internal);
             break;
         }
+        case "ClassExpression": {
+            meshClassBody(nodePath.get("body"), internal);
+            break;
+        }
         case "JSXFragment": {
             throw nodePath.buildCodeFrameError("Vasille: JSX fragment is not allowed here");
         }
         case "JSXElement": {
             throw nodePath.buildCodeFrameError("Vasille: JSX element is not allowed here");
         }
-        case "BigIntLiteral":
-        case "BooleanLiteral":
-        case "ClassExpression":
-        case "DecimalLiteral":
-        case "DoExpression":
-        case "Import":
-        case "ImportExpression":
-        case "MetaProperty":
-        case "ModuleExpression":
-        case "NullLiteral":
-        case "NumericLiteral":
-        case "PipelinePrimaryTopicReference":
-        case "RecordExpression":
-        case "RegExpLiteral":
-        case "StringLiteral":
-        case "Super":
-        case "TSNonNullExpression":
-        case "ThisExpression":
-        case "TopicReference":
-    }
-}
-function meshBody(path, internal) {
-    if (t.isExpression(path.node)) {
-        meshExpression(path, internal);
-    }
-    else {
-        for (const statementPath of path.get("body")) {
-            meshStatement(statementPath, internal);
-        }
     }
 }
 function meshStatements(paths, internal) {
@@ -373,14 +340,7 @@ function ignoreParams(val, internal) {
         internal.stack.set(val.name, 1 /* VariableState.Ignored */);
     }
     else if (t.isObjectPattern(val)) {
-        for (const prop of val.properties) {
-            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-                internal.stack.set(prop.value.name, 1 /* VariableState.Ignored */);
-            }
-            else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
-                internal.stack.set(prop.argument.name, 1 /* VariableState.Ignored */);
-            }
-        }
+        ignoreObjectPattern(val, internal);
     }
     else if (t.isArrayPattern(val)) {
         for (const element of val.elements) {
@@ -390,28 +350,70 @@ function ignoreParams(val, internal) {
         }
     }
 }
-function reactiveArrayPattern(expr, internal) {
-    if (t.isArrayPattern(expr)) {
-        for (const element of expr.elements) {
-            if (t.isIdentifier(element)) {
-                internal.stack.set(element.name, 2 /* VariableState.Reactive */);
+function ignoreObjectPattern(pattern, internal) {
+    for (const property of pattern.properties) {
+        if (t.isObjectProperty(property)) {
+            if (t.isObjectPattern(property.value)) {
+                ignoreObjectPattern(property.value, internal);
+            }
+            else if (t.isAssignmentPattern(property.value)) {
+                ignoreParams(property.value, internal);
             }
+            else if (t.isIdentifier(property.value)) {
+                internal.stack.set(property.value.name, 1 /* VariableState.Ignored */);
+            }
+        }
+        if (t.isRestElement(property)) {
+            internal.stack.set(property.argument.name, 1 /* VariableState.Ignored */);
         }
     }
-    else if (t.isIdentifier(expr)) {
-        internal.stack.set(expr.name, 3 /* VariableState.ReactiveObject */);
+}
+function reactiveArrayPattern(path, internal) {
+    if (t.isArrayPattern(path.node)) {
+        path.node.elements.forEach((element, index) => {
+            if (t.isIdentifier(element)) {
+                internal.stack.set(element.name, index < 2 ? 2 /* VariableState.Reactive */ : 1 /* VariableState.Ignored */);
+            }
+        });
     }
     else {
-        return false;
+        throw path.buildCodeFrameError("Vasille: Expected array pattern");
+    }
+}
+function meshForEachHeader(path, internal) {
+    const left = path.node.left;
+    meshExpression(path.get("right"), internal);
+    if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
+        ignoreParams(left.declarations[0].id, internal);
+    }
+}
+function meshForHeader(path, internal) {
+    const node = path.node;
+    if (node.init) {
+        if (t.isExpression(node.init)) {
+            meshExpression(path.get("init"), internal);
+        }
+        else {
+            const variablePath = path.get("init");
+            for (const declarationPath of variablePath.get("declarations")) {
+                meshExpression(declarationPath.get("init"), internal);
+                ignoreParams(declarationPath.node.id, internal);
+            }
+        }
+    }
+    meshExpression(path.get("test"), internal);
+    meshExpression(path.get("update"), internal);
+}
+function meshClassBody(path, internal) {
+    for (const item of path.get("body")) {
+        if (t.isClassMethod(item.node) || t.isClassPrivateMethod(item.node)) {
+            meshFunction(item, internal);
+        }
     }
-    return true;
 }
 function meshStatement(path, internal) {
     const statement = path.node;
-    if (!statement) {
-        return;
-    }
-    switch (statement.type) {
+    switch (statement && statement.type) {
         case "BlockStatement":
             internal.stack.push();
             meshStatements(path.get("body"), internal);
@@ -430,46 +432,24 @@ function meshStatement(path, internal) {
             break;
         case "ForInStatement": {
             const _path = path;
-            const left = _path.node.left;
             internal.stack.push();
-            meshExpression(_path.get("right"), internal);
-            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
-                ignoreParams(left.declarations[0].id, internal);
-            }
+            meshForEachHeader(_path, internal);
             meshStatement(_path.get("body"), internal);
             internal.stack.pop();
             break;
         }
         case "ForOfStatement": {
             const _path = path;
-            const left = _path.node.left;
             internal.stack.push();
-            meshExpression(_path.get("right"), internal);
-            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
-                ignoreParams(left.declarations[0].id, internal);
-            }
+            meshForEachHeader(_path, internal);
             meshStatement(_path.get("body"), internal);
             internal.stack.pop();
             break;
         }
         case "ForStatement": {
             const _path = path;
-            const node = _path.node;
             internal.stack.push();
-            if (node.init) {
-                if (t.isExpression(node.init)) {
-                    meshExpression(_path.get("init"), internal);
-                }
-                else {
-                    const variablePath = _path.get("init");
-                    for (const declarationPath of variablePath.get("declarations")) {
-                        meshExpression(declarationPath.get("init"), internal);
-                        ignoreParams(declarationPath.node.id, internal);
-                    }
-                }
-            }
-            meshExpression(_path.get("test"), internal);
-            meshExpression(_path.get("update"), internal);
+            meshForHeader(_path, internal);
             meshStatement(_path.get("body"), internal);
             internal.stack.pop();
             break;
@@ -510,20 +490,21 @@ function meshStatement(path, internal) {
             break;
         case "TryStatement":
             meshStatement(path.get("block"), internal);
+            if (path.node.handler) {
+                meshStatement(path.get("handler").get("body"), internal);
+            }
+            meshStatement(path.get("finalizer"), internal);
             break;
         case "VariableDeclaration": {
             const _path = path;
             for (const declaration of _path.get("declarations")) {
                 const expr = declaration.node.init;
-                let ignore = true;
-                if (expr && t.isIdentifier(declaration.node.id) && (0, call_1.calls)(expr, ["compose", "extend"], internal)) {
+                if (expr && t.isIdentifier(declaration.node.id) && (0, call_js_1.calls)(expr, ["compose", "extend", "state"], internal)) {
                     meshComposeCall(expr, declaration.node.id, declaration.get("init"), internal);
                 }
                 else {
                     meshExpression(declaration.get("init"), internal);
-                    if (ignore) {
-                        ignoreParams(declaration.node.id, internal);
-                    }
+                    ignoreParams(declaration.node.id, internal);
                 }
             }
             break;
@@ -536,49 +517,25 @@ function meshStatement(path, internal) {
             internal.stack.pop();
             break;
         }
-        case "WithStatement": {
-            const _path = path;
-            meshExpression(_path.get("object"), internal);
-            internal.stack.push();
-            meshStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
         case "ExportNamedDeclaration": {
             meshStatement(path.get("declaration"), internal);
             break;
         }
-        // Ignored
-        case "ExportDefaultDeclaration":
-        case "ExportAllDeclaration":
-        case "BreakStatement":
-        case "ContinueStatement":
-        case "DebuggerStatement":
-        case "EmptyStatement":
         case "ClassDeclaration":
-        case "ImportDeclaration":
-        case "DeclareClass":
-        case "DeclareFunction":
-        case "DeclareInterface":
-        case "DeclareModule":
-        case "DeclareModuleExports":
-        case "DeclareTypeAlias":
-        case "DeclareOpaqueType":
-        case "DeclareVariable":
-        case "DeclareExportDeclaration":
-        case "DeclareExportAllDeclaration":
-        case "InterfaceDeclaration":
-        case "OpaqueType":
-        case "TypeAlias":
-        case "EnumDeclaration":
-        case "TSDeclareFunction":
-        case "TSInterfaceDeclaration":
-        case "TSTypeAliasDeclaration":
-        case "TSEnumDeclaration":
-        case "TSModuleDeclaration":
-        case "TSImportEqualsDeclaration":
-        case "TSExportAssignment":
-        case "TSNamespaceExportDeclaration":
+            meshClassBody(path.get("body"), internal);
+            break;
+        case "ExportDefaultDeclaration": {
+            const declarationPath = path.get("declaration");
+            if (t.isExpression(declarationPath.node)) {
+                meshExpression(declarationPath, internal);
+            }
+            else if (t.isFunctionDeclaration(declarationPath.node)) {
+                meshFunction(declarationPath, internal);
+            }
+            else if (t.isClassDeclaration(declarationPath.node)) {
+                meshClassBody(declarationPath.get("body"), internal);
+            }
+        }
     }
 }
 function meshFunction(path, internal) {
@@ -602,87 +559,70 @@ function meshFunction(path, internal) {
     }
     internal.stack.pop();
 }
-function composeExpression(path, internal) {
+function composeExpression(path, internal, isRoot) {
     const expr = path.node;
-    if (!expr) {
-        return;
-    }
-    switch (expr.type) {
+    switch (expr && expr.type) {
         case "AssignmentExpression": {
-            const assign = expr;
-            if ((0, call_1.calls)(assign.right, ["awaited"], internal)) {
-                reactiveArrayPattern(assign.left, internal);
-            }
-            else {
-                meshExpression(path, internal);
-            }
+            meshExpression(path, internal);
             break;
         }
         case "CallExpression":
         case "OptionalCallExpression": {
             const call = expr;
-            let replaced = false;
-            if ((0, call_1.calls)(call, ["watch"], internal)) {
-                const args = (0, lib_1.parseCalculateCall)(path, internal);
+            if ((0, call_js_1.calls)(call, ["watch"], internal)) {
+                const args = (0, lib_js_1.parseCalculateCall)(path, internal);
                 if (args) {
-                    path.replaceWith(t.callExpression(t.memberExpression(internal_1.ctx, t.identifier("watch")), args));
-                    replaced = true;
-                }
-            }
-            else if ((0, call_1.calls)(call, ["arrayModel"], internal)) {
-                const value = call.arguments[0];
-                if (t.isArrayExpression(value)) {
-                    path.replaceWith((0, lib_1.arrayModel)(value, internal));
-                    replaced = true;
-                }
-                else {
-                    path.buildCodeFrameError(`Vasille: arrayModel requires array expression as argument`);
+                    if (args[1].elements.length > 0) {
+                        path.replaceWith(t.callExpression(t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
+                    }
+                    else {
+                        path.replaceWith(t.callExpression(args[0], []));
+                    }
                 }
             }
-            else if ((0, call_1.calls)(call, ["mapModel", "setModel"], internal)) {
-                const args = call.arguments;
-                const name = (0, call_1.calls)(call, ["mapModel", "setModel"], internal);
-                path.replaceWith(name === "mapModel" ? (0, lib_1.mapModel)(args, internal) : (0, lib_1.setModel)(args, internal));
-                replaced = true;
-            }
-            if (!replaced) {
+            else {
                 meshExpression(path, internal);
             }
             break;
         }
+        case "LogicalExpression":
+            composeExpression(path.get("left"), internal);
+            composeExpression(path.get("right"), internal);
+            break;
+        case "ConditionalExpression":
+            meshExpression(path.get("test"), internal);
+            composeExpression(path.get("consequent"), internal);
+            composeExpression(path.get("alternate"), internal);
+            break;
         case "JSXElement":
         case "JSXFragment":
-            path.replaceWithMultiple((0, jsx_1.transformJsx)(path, internal));
+            if (internal.stateOnly) {
+                throw path.buildCodeFrameError("Vasille: JSX is not allowed in states");
+            }
+            path.replaceWithMultiple((0, jsx_js_1.transformJsx)(path, internal));
             break;
         default:
-            meshExpression(path, internal);
+            meshExpression(path, internal, isRoot);
     }
 }
-function composeStatements(paths, internal) {
+function composeStatements(paths, internal, isRoot) {
     for (const path of paths) {
-        composeStatement(path, internal);
+        composeStatement(path, internal, isRoot);
     }
 }
-function composeStatement(path, internal) {
+function composeStatement(path, internal, isRoot) {
     const statement = path.node;
     if (!statement) {
         return;
     }
     switch (statement.type) {
         case "FunctionDeclaration": {
-            const _path = path;
-            const fn = _path.node;
-            if ((0, jsx_detect_1.bodyHasJsx)(fn.body)) {
-                compose(_path, internal, false);
-            }
-            else {
-                meshFunction(_path, internal);
-            }
+            meshFunction(path, internal);
             break;
         }
         case "BlockStatement": {
             internal.stack.push();
-            composeStatements(path.get("body"), internal);
+            composeStatements(path.get("body"), internal, isRoot);
             internal.stack.pop();
             break;
         }
@@ -700,34 +640,16 @@ function composeStatement(path, internal) {
         }
         case "ForInStatement": {
             const _path = path;
-            const left = _path.node.left;
             internal.stack.push();
-            meshExpression(_path.get("right"), internal);
-            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
-                ignoreParams(left.declarations[0].id, internal);
-            }
+            meshForEachHeader(_path, internal);
             composeStatement(_path.get("body"), internal);
             internal.stack.pop();
             break;
         }
         case "ForStatement": {
             const _path = path;
-            const node = _path.node;
             internal.stack.push();
-            if (node.init) {
-                if (t.isExpression(node.init)) {
-                    meshExpression(_path.get("init"), internal);
-                }
-                else {
-                    const variablePath = _path.get("init");
-                    for (const declarationPath of variablePath.get("declarations")) {
-                        meshExpression(declarationPath.get("init"), internal);
-                        ignoreParams(declarationPath.node.id, internal);
-                    }
-                }
-            }
-            meshExpression(_path.get("test"), internal);
-            meshExpression(_path.get("update"), internal);
+            meshForHeader(_path, internal);
             composeStatement(_path.get("body"), internal);
             internal.stack.pop();
             break;
@@ -747,7 +669,7 @@ function composeStatement(path, internal) {
             composeStatement(path.get("body"), internal);
             break;
         case "ReturnStatement":
-            composeExpression(path.get("argument"), internal);
+            composeExpression(path.get("argument"), internal, isRoot);
             break;
         case "SwitchStatement": {
             const _path = path;
@@ -761,7 +683,10 @@ function composeStatement(path, internal) {
             break;
         }
         case "TryStatement":
+            const tryHandler = path.get("handler");
             composeStatement(path.get("block"), internal);
+            tryHandler.node && composeStatement(tryHandler.get("body"), internal);
+            composeStatement(path.get("finalizer"), internal);
             break;
         case "VariableDeclaration": {
             const _path = path;
@@ -773,111 +698,137 @@ function composeStatement(path, internal) {
             for (const declaration of _path.get("declarations")) {
                 const id = declaration.node.id;
                 let meshInit = true;
+                function idName(target = id) {
+                    let name = "#";
+                    if (t.isIdentifier(target)) {
+                        name = target.name;
+                    }
+                    return name;
+                }
+                function idDoubleName() {
+                    const pattern = id;
+                    return [idName(pattern.elements[0]), idName(pattern.elements[1])];
+                }
                 ignoreParams(declaration.node.id, internal);
-                if ((0, call_1.calls)(declaration.node.init, ["awaited"], internal)) {
-                    reactiveArrayPattern(declaration.node.id, internal);
+                if ((0, call_js_1.calls)(declaration.node.init, ["awaited"], internal)) {
+                    reactiveArrayPattern(declaration.get("id"), internal);
                     meshAllUnknown(declaration.get("init").get("arguments"), internal);
+                    (0, lib_js_1.named)(declaration.node.init, idDoubleName(), internal);
                     meshInit = false;
                 }
                 else if (t.isIdentifier(id)) {
                     internal.stack.set(id.name, declares);
                     const init = declaration.node.init;
-                    if ((0, call_1.calls)(init, ["value"], internal)) {
+                    if ((0, call_js_1.calls)(init, ["value"], internal)) {
                         internal.stack.set(id.name, 1 /* VariableState.Ignored */);
                         declaration.get("init").replaceWith(init.arguments[0]);
                         _path.node.kind = kind;
                     }
-                    else if ((0, call_1.calls)(init, ["bind"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["bind"], internal)) {
                         const argument = init.arguments[0];
-                        const replaceWith = declares === 2 /* VariableState.Reactive */
-                            ? (0, lib_1.forwardOnlyExpr)(declaration.get("init"), argument, internal)
-                            : (0, lib_1.exprCall)(declaration.get("init"), argument, internal);
-                        let insertNode = replaceWith !== null && replaceWith !== void 0 ? replaceWith : (0, lib_1.ref)(t.isExpression(argument) ? argument : null);
+                        const argumentPath = declaration.get("init").get("arguments")[0];
+                        let replaceWith = declares === 2 /* VariableState.Reactive */
+                            ? (0, lib_js_1.forwardOnlyExpr)(argumentPath, argument, internal)
+                            : (0, lib_js_1.exprCall)(argumentPath, argument, internal, idName());
+                        if (!replaceWith) {
+                            replaceWith =
+                                declares === 2 /* VariableState.Reactive */
+                                    ? t.callExpression(t.memberExpression(internal.id, t.identifier("r")), [argument])
+                                    : (0, lib_js_1.ref)(argument, internal, idName());
+                        }
                         if (declares === 2 /* VariableState.Reactive */) {
                             internal.stack.set(id.name, 4 /* VariableState.ReactivePointer */);
-                            insertNode = (0, lib_1.own)(insertNode);
+                            replaceWith = (0, lib_js_1.own)(replaceWith, internal, idName());
                         }
                         else {
                             internal.stack.set(id.name, 2 /* VariableState.Reactive */);
                         }
-                        declaration.get("init").replaceWith(insertNode);
+                        declaration.get("init").replaceWith(replaceWith);
                         meshInit = !replaceWith;
                     }
-                    else if ((0, call_1.calls)(init, ["ref"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["ref"], internal)) {
                         const argument = init.arguments[0];
                         internal.stack.set(id.name, 2 /* VariableState.Reactive */);
-                        declaration.get("init").replaceWith((0, lib_1.ref)(t.isExpression(argument) ? argument : null));
+                        declaration.get("init").replaceWith((0, lib_js_1.ref)(t.isExpression(argument) ? argument : null, internal, idName()));
                     }
-                    else if ((0, call_1.calls)(init, ["reactiveObject"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["reactiveObject"], internal)) {
                         const value = init.arguments[0];
                         if (kind !== "const") {
-                            declaration.buildCodeFrameError(`Vasille: Reactive objects must be must be declared as constants`);
+                            throw declaration.buildCodeFrameError(`Vasille: Reactive objects must be must be declared as constants`);
                         }
                         if (t.isObjectExpression(value)) {
-                            declaration.get("init").replaceWith((0, lib_1.reactiveObject)(value, internal));
+                            declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(value, internal, idName()));
                             internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
                         }
                         else {
-                            declaration.buildCodeFrameError(`Vasille: reactiveObject requires object expression as argument`);
+                            throw declaration.buildCodeFrameError(`Vasille: reactiveObject requires object expression as argument`);
                         }
                     }
-                    else if ((0, call_1.calls)(init, ["arrayModel"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["arrayModel"], internal)) {
                         const value = init.arguments[0];
                         if (kind !== "const") {
-                            declaration.buildCodeFrameError(`Vasille: Array models must be must be declared as constants`);
+                            throw declaration.buildCodeFrameError(`Vasille: Array models must be must be declared as constants`);
                         }
                         if (t.isArrayExpression(value)) {
-                            declaration.get("init").replaceWith((0, lib_1.arrayModel)(value, internal));
+                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(value, internal, idName()));
                         }
                         else {
-                            declaration.buildCodeFrameError(`Vasille: arrayModel requires array expression as argument`);
+                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(null, internal, idName()));
                         }
                     }
-                    else if ((0, call_1.calls)(init, ["mapModel", "setModel"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["mapModel", "setModel"], internal)) {
                         const args = init.arguments;
-                        const name = (0, call_1.calls)(init, ["mapModel", "setModel"], internal);
+                        const name = (0, call_js_1.calls)(init, ["mapModel", "setModel"], internal);
                         if (kind !== "const") {
-                            declaration.buildCodeFrameError(`Vasille: ${name === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
+                            throw declaration.buildCodeFrameError(`Vasille: ${name === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
                         }
                         declaration
                             .get("init")
-                            .replaceWith(name === "mapModel" ? (0, lib_1.mapModel)(args, internal) : (0, lib_1.setModel)(args, internal));
+                            .replaceWith(name === "mapModel" ? (0, lib_js_1.mapModel)(args, internal, idName()) : (0, lib_js_1.setModel)(args, internal, idName()));
                     }
                     else if (t.isObjectExpression(init)) {
                         if (kind !== "const") {
-                            declaration.buildCodeFrameError(`Vasille: Objects must be must be declared as constants`);
+                            throw declaration.buildCodeFrameError(`Vasille: Objects must be must be declared as constants`);
                         }
-                        declaration.get("init").replaceWith((0, lib_1.reactiveObject)(init, internal));
+                        declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(init, internal, idName()));
                         internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
                     }
                     else if (t.isArrayExpression(init)) {
                         if (kind !== "const") {
-                            declaration.buildCodeFrameError(`Vasille: Arrays must be must be declared as constants`);
+                            throw declaration.buildCodeFrameError(`Vasille: Arrays must be must be declared as constants`);
                         }
-                        declaration.get("init").replaceWith((0, lib_1.arrayModel)(init, internal));
+                        declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(init, internal, idName()));
                     }
                     else if (t.isNewExpression(init) && t.isIdentifier(init.callee)) {
                         if (init.callee.name === "Map" || init.callee.name === "Set") {
                             if (kind !== "const") {
-                                declaration.buildCodeFrameError(`Vasille: ${init.callee.name === "Map" ? "Maps" : "Sets"} must be declared as constants`);
+                                throw declaration.buildCodeFrameError(`Vasille: ${init.callee.name === "Map" ? "Maps" : "Sets"} must be declared as constants`);
                             }
                             declaration
                                 .get("init")
-                                .replaceWith(init.callee.name === "Map" ? (0, lib_1.mapModel)(init.arguments, internal) : (0, lib_1.setModel)(init.arguments, internal));
+                                .replaceWith(init.callee.name === "Map"
+                                ? (0, lib_js_1.mapModel)(init.arguments, internal, idName())
+                                : (0, lib_js_1.setModel)(init.arguments, internal, idName()));
                         }
                     }
                     else if (declares === 2 /* VariableState.Reactive */) {
-                        const replaceWith = (0, lib_1.forwardOnlyExpr)(declaration.get("init"), declaration.node.init, internal);
+                        const replaceWith = (0, lib_js_1.forwardOnlyExpr)(declaration.get("init"), declaration.node.init, internal);
                         meshInit = !replaceWith;
                         internal.stack.set(id.name, replaceWith ? 4 /* VariableState.ReactivePointer */ : 2 /* VariableState.Reactive */);
-                        declaration.get("init").replaceWith(replaceWith ? (0, lib_1.own)(replaceWith) : (0, lib_1.ref)(declaration.node.init));
+                        declaration
+                            .get("init")
+                            .replaceWith(replaceWith ? (0, lib_js_1.own)(replaceWith, internal, idName()) : (0, lib_js_1.ref)(declaration.node.init, internal, idName()));
                     }
                     else {
-                        const replaceWith = (0, lib_1.exprCall)(declaration.get("init"), declaration.node.init, internal);
+                        const replaceWith = (0, lib_js_1.exprCall)(declaration.get("init"), declaration.node.init, internal, idName());
                         if (replaceWith) {
                             declaration.get("init").replaceWith(replaceWith);
                         }
-                        internal.stack.set(id.name, replaceWith ? 2 /* VariableState.Reactive */ : 1 /* VariableState.Ignored */);
+                        internal.stack.set(id.name, replaceWith
+                            ? 2 /* VariableState.Reactive */
+                            : (0, expression_js_1.nodeIsReactiveObject)(declaration.get("init"), internal)
+                                ? 3 /* VariableState.ReactiveObject */
+                                : 1 /* VariableState.Ignored */);
                         meshInit = !replaceWith;
                     }
                 }
@@ -895,17 +846,10 @@ function composeStatement(path, internal) {
             internal.stack.pop();
             break;
         }
-        case "WithStatement": {
-            throw path.buildCodeFrameError("Vasille: Usage of 'with' in components is restricted");
-        }
         case "ForOfStatement": {
             const _path = path;
-            const left = _path.node.left;
             internal.stack.push();
-            meshExpression(_path.get("right"), internal);
-            if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
-                ignoreParams(left.declarations[0].id, internal);
-            }
+            meshForEachHeader(_path, internal);
             composeStatement(_path.get("body"), internal);
             internal.stack.pop();
             break;
@@ -915,9 +859,6 @@ function composeStatement(path, internal) {
     }
 }
 function compose(path, internal, isInternalSlot) {
-    if (t.isFunctionDeclaration(path.node) && path.node.id) {
-        internal.stack.set(path.node.id.name, 1 /* VariableState.Ignored */);
-    }
     internal.stack.push();
     const node = path.node;
     const params = node.params;
@@ -925,50 +866,57 @@ function compose(path, internal, isInternalSlot) {
     if (t.isFunctionExpression(node) && node.id) {
         internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
     }
-    if (params.length > 1) {
-        throw path.get("params")[1].buildCodeFrameError("Vasille: JSX compoent must have no more then 1 parameter");
+    if (params.length > 1 && !isInternalSlot) {
+        throw path.get("params")[1].buildCodeFrameError("Vasille: JSX component must have no more then 1 parameter");
     }
-    for (const param of params) {
-        const target = t.isAssignmentPattern(param) ? param.left : param;
-        if (t.isIdentifier(target)) {
-            internal.stack.set(target.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+    for (const param of path.get("params")) {
+        const node = param.node;
+        if (t.isAssignmentPattern(node)) {
+            throw param.buildCodeFrameError("Vasille: No default value allowed here");
         }
-        else if (t.isObjectPattern(target)) {
-            for (const prop of target.properties) {
-                if (t.isObjectProperty(prop)) {
-                    if (t.isIdentifier(prop.value)) {
-                        internal.stack.set(prop.value.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */);
+        if (t.isIdentifier(node)) {
+            internal.stack.set(node.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+        }
+        else if (isInternalSlot && t.isObjectPattern(node)) {
+            ignoreObjectPattern(node, internal);
+        }
+        else if (t.isObjectPattern(node)) {
+            for (const prop of param.get("properties")) {
+                const node = prop.node;
+                if (t.isObjectProperty(node)) {
+                    const key = node.key;
+                    let keyName = "";
+                    if (t.isIdentifier(node.value)) {
+                        keyName = node.value.name;
+                    }
+                    else if (t.isIdentifier(key) && !node.computed) {
+                        keyName = key.name;
                     }
-                    else if (t.isIdentifier(prop.key)) {
-                        internal.stack.set(prop.key.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */);
+                    internal.stack.set(keyName, 2 /* VariableState.Reactive */);
+                    if (t.isAssignmentPattern(node.value)) {
+                        const assignPath = prop.get("value");
+                        assignPath
+                            .get("right")
+                            .replaceWith(t.callExpression(t.memberExpression(internal.id, t.identifier("r")), [assignPath.node.right]));
+                    }
+                    else if (!t.isIdentifier(node.value)) {
+                        throw prop.buildCodeFrameError("Vasille: Value decomposition is not allowed here");
                     }
                 }
-                else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
-                    internal.stack.set(prop.argument.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+                if (t.isRestElement(node)) {
+                    internal.stack.set(node.argument.name, 3 /* VariableState.ReactiveObject */);
                 }
             }
         }
         else {
-            throw path.get("params")[0].buildCodeFrameError("Vasille: Parameter must be an identifier of object pattern");
-        }
-    }
-    for (const param of path.get("params")) {
-        if (t.isObjectPattern(param.node)) {
-            for (const prop of param.get("properties")) {
-                if (t.isObjectProperty(prop.node) && t.isAssignmentPattern(prop.node.value)) {
-                    const assignPath = prop.get("value");
-                    assignPath
-                        .get("right")
-                        .replaceWith(t.callExpression(t.memberExpression(internal.id, t.identifier("r")), [assignPath.node.right]));
-                }
-            }
+            throw param.buildCodeFrameError("Vasille: Expected identifier or object pattern");
         }
     }
     if (t.isExpression(body)) {
-        composeExpression(path.get("body"), internal);
+        composeExpression(path.get("body"), internal, true);
     }
     else if (t.isBlockStatement(body)) {
-        composeStatement(path.get("body"), internal);
+        composeStatement(path.get("body"), internal, true);
     }
     internal.stack.pop();
 }