babel-plugin-vasille 3.1.5 → 4.0.0

package/lib/mesh.js

@@ -43,6 +43,7 @@ exports.meshExpression = meshExpression;
 exports.meshStatements = meshStatements;
 exports.ignoreParams = ignoreParams;
 exports.reactiveArrayPattern = reactiveArrayPattern;
+exports.processObjectExpression = processObjectExpression;
 exports.meshStatement = meshStatement;
 exports.meshFunction = meshFunction;
 exports.composeExpression = composeExpression;
@@ -55,9 +56,13 @@ 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");
+const order_check_1 = require("./order-check");
+const router_1 = require("./router");
+const utils_1 = require("./utils");
 function meshOrIgnoreAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
-        if (t.isExpression(path.node)) {
+        /* istanbul ignore else */
+        if (path.isExpression()) {
             meshExpression(path, internal);
         }
     }
@@ -67,50 +72,46 @@ function meshAllExpressions(nodePaths, internal) {
         meshExpression(path, internal);
     }
 }
-function meshComposeCall(call, name, nodePath, internal) {
-    const arg = call.arguments[0];
-    if (call.arguments.length !== 1 || !(t.isFunctionExpression(arg) || t.isArrowFunctionExpression(arg))) {
-        throw nodePath.buildCodeFrameError("Vasille: Invalid arguments");
+function meshComposeCall(name, path, internal) {
+    const args = path.isCallExpression() && path.get("arguments");
+    const arg = args && (args[0].isFunctionExpression() || args[0].isArrowFunctionExpression()) && args[0];
+    if (!args || !arg || args.length !== 1) {
+        return (0, lib_js_1.err)(lib_js_1.Errors.IncorrectArguments, path, "Invalid arguments number", internal);
     }
-    const fnPath = nodePath.get("arguments")[0];
-    compose(fnPath, internal, false);
-    if (!internal.stateOnly) {
-        arg.params.unshift(internal_js_1.ctx);
-    }
-    if (internal.devMode) {
-        call.arguments.push(t.stringLiteral(`${internal.prefix}:${name ? name.name : "#anonymouse"}`));
+    compose(arg, internal, false, false);
+    arg.node.params.unshift(internal_js_1.ctx);
+    if (internal.devMode && path.isCallExpression()) {
+        path.node.arguments.push(t.stringLiteral(name ? name : "#"));
     }
 }
 function meshAllUnknown(paths, internal) {
     for (const path of paths) {
-        if (t.isSpreadElement(path.node)) {
+        /* istanbul ignore else */
+        if (path.isSpreadElement()) {
             meshExpression(path.get("argument"), internal);
         }
-        else if (t.isExpression(path.node)) {
+        else if (path.isExpression()) {
             meshExpression(path, internal);
         }
     }
 }
 function meshLValue(path, internal) {
-    const node = path.node;
-    if (t.isExpression(node)) {
+    /* istanbul ignore else */
+    if (path.isExpression() || path.isIdentifier()) {
         meshExpression(path, internal);
     }
 }
 function meshOrIgnoreExpression(path, internal) {
-    if (t.isExpression(path.node)) {
+    /* istanbul ignore else */
+    if (path.isExpression()) {
         meshExpression(path, internal);
     }
 }
-function meshExpression(nodePath, internal, isRoot) {
+function meshExpression(nodePath, internal) {
     const expr = nodePath.node;
     if (!expr) {
         return;
     }
-    if ((0, call_js_1.calls)(expr, ["compose", "store"], internal)) {
-        meshComposeCall(expr, null, nodePath, internal);
-        return;
-    }
     switch (expr.type) {
         case "TemplateLiteral": {
             const path = nodePath;
@@ -123,9 +124,8 @@ function meshExpression(nodePath, internal, isRoot) {
             break;
         }
         case "Identifier": {
-            const state = internal.stack.get(expr.name);
-            if ((0, expression_js_1.idIsIValue)(nodePath, internal)) {
-                nodePath.replaceWith(t.memberExpression(expr, t.identifier(state === 4 /* VariableState.ReactivePointer */ ? "$$" : "$")));
+            if ((0, expression_js_1.idIsIValue)(nodePath)) {
+                nodePath.replaceWith(t.memberExpression(expr, t.identifier("V")));
             }
             break;
         }
@@ -137,41 +137,84 @@ function meshExpression(nodePath, internal, isRoot) {
         case "CallExpression":
         case "OptionalCallExpression": {
             const path = nodePath;
-            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`);
+            const argPath = path.get("arguments")[0];
+            // compose call
+            if (!internal.isComposing && (0, call_js_1.calls)(nodePath, ["page"], internal)) {
+                const firstArg = nodePath.node.typeParameters?.params[0];
+                const string = t.isTSLiteralType(firstArg) && t.isStringLiteral(firstArg.literal) && firstArg.literal.value;
+                if (string && !internal.filename.replace(/\.[tj]sx?$/, "").endsWith(string)) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, nodePath.get("typeParameters"), "Page path does not match the file path", internal);
+                }
+                meshComposeCall(null, nodePath, internal);
             }
-            if (callsStyleHint) {
-                throw path.buildCodeFrameError(`Vasille: Usage of style hint "${callsStyleHint}" is restricted here`);
+            else if (!internal.isComposing && (0, call_js_1.calls)(nodePath, call_js_1.composeFunctions, internal)) {
+                meshComposeCall(null, nodePath, internal);
             }
-            meshOrIgnoreExpression(path.get("callee"), internal);
-            meshAllUnknown(path.get("arguments"), internal);
-            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], []));
+            // raw call
+            else if ((0, call_js_1.calls)(path, ["raw"], internal)) {
+                if (argPath && argPath.isExpression()) {
+                    meshExpression(argPath, internal);
+                    path.replaceWith(argPath);
                 }
                 else {
-                    throw path.buildCodeFrameError("Vasille: Incorrect calculate argument");
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncorrectArguments, argPath ?? path, "Failed to parse raw value", internal);
+                }
+            }
+            // arrayModel/setModel/mapModel call
+            else if (!internal.isComposing && (0, call_js_1.calls)(path, call_js_1.modelFunctions, internal)) {
+                /* istanbul ignore else */
+                if (argPath) {
+                    meshAllUnknown([argPath], internal);
+                }
+                path.node.arguments.unshift(t.nullLiteral());
+            }
+            // router call
+            else if (internal.isComposing && (0, call_js_1.calls)(path, ["router"], internal)) {
+                if (!internal.stateOnly) {
+                    (0, router_1.routerReplace)(path);
+                }
+                else {
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "The router is not available in stores", internal);
+                }
+            }
+            // watch call
+            else if ((0, call_js_1.calls)(path, ["watch"], internal)) {
+                (0, lib_js_1.processCalculateCall)(path, internal);
+            }
+            else if (path.isCallExpression() &&
+                t.isIdentifier(path.node.callee) &&
+                path.node.callee.name.startsWith("prompt")) {
+                if (!internal.isComposing) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "Prompts can be constructed only from components", internal);
+                }
+                path.node.arguments.unshift(internal_js_1.ctx);
+            }
+            // call any other function, invalid if code calls a hint
+            else {
+                if ((0, call_js_1.calls)(path, call_js_1.hintFunctions, internal)) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, `Usage of hints is restricted here`, internal);
                 }
+                meshOrIgnoreExpression(path.get("callee"), internal);
+                meshAllUnknown(path.get("arguments"), internal);
             }
             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_js_1.forwardOnlyExpr)(path.get("right"), path.node.right, internal);
-                if (replaceWith) {
-                    path.get("right").replaceWith(replaceWith);
-                    replaced = true;
+            const left = path.get("left");
+            const right = path.get("right");
+            if (left.isMemberExpression() && !(0, expression_js_1.exprIsSure)(left, internal)) {
+                const property = left.node.property;
+                meshExpression(left.get("object"), internal);
+                meshExpression(right, internal);
+                /* istanbul ignore else */
+                if (!t.isPrivateName(property)) {
+                    path.replaceWith(internal.set(left.node.object, property, right.node));
                 }
             }
-            if (!replaced) {
-                meshExpression(path.get("right"), internal);
+            else {
+                meshLValue(left, internal);
+                meshExpression(right, internal);
             }
             break;
         }
@@ -184,8 +227,13 @@ function meshExpression(nodePath, internal, isRoot) {
             if (t.isExpression(property) && !t.isIdentifier(property)) {
                 meshOrIgnoreExpression(path.get("property"), internal);
             }
-            if ((0, expression_js_1.memberIsIValue)(node, internal)) {
-                path.replaceWith(t.memberExpression(node, t.identifier("$")));
+            if ((0, expression_js_1.memberIsIValue)(node)) {
+                if ((0, expression_js_1.exprIsSure)(path, internal)) {
+                    path.replaceWith(t.memberExpression(path.node, t.identifier("V")));
+                }
+                else {
+                    path.replaceWith(t.optionalMemberExpression(path.node, t.identifier("V"), false, true));
+                }
             }
             break;
         }
@@ -260,48 +308,7 @@ function meshExpression(nodePath, internal, isRoot) {
             break;
         }
         case "ObjectExpression": {
-            const path = nodePath;
-            for (const propPath of path.get("properties")) {
-                const prop = propPath.node;
-                if (t.isObjectProperty(prop)) {
-                    const path = propPath;
-                    const valuePath = path.get("value");
-                    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 $$");
-                        }
-                    }
-                    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);
-                }
-            }
+            processObjectExpression(nodePath, internal);
             break;
         }
         case "FunctionExpression": {
@@ -313,14 +320,21 @@ function meshExpression(nodePath, internal, isRoot) {
             break;
         }
         case "ClassExpression": {
-            meshClassBody(nodePath.get("body"), internal);
+            const classPath = nodePath;
+            const idPath = classPath.get("id");
+            if (idPath.isIdentifier()) {
+                (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+            }
+            meshClassBody(classPath.get("body"), internal);
             break;
         }
         case "JSXFragment": {
-            throw nodePath.buildCodeFrameError("Vasille: JSX fragment is not allowed here");
+            (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, nodePath, "JSX fragment is not allowed here", internal);
+            break;
         }
         case "JSXElement": {
-            throw nodePath.buildCodeFrameError("Vasille: JSX element is not allowed here");
+            (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, nodePath, "JSX element is not allowed here", internal);
+            break;
         }
     }
 }
@@ -329,72 +343,136 @@ function meshStatements(paths, internal) {
         meshStatement(path, internal);
     }
 }
-function ignoreParams(val, internal) {
-    if (t.isAssignmentPattern(val)) {
-        val = val.left;
+function ignoreParams(path, internal, allowReactiveId) {
+    /* istanbul ignore else */
+    // param with default value
+    if (path.isAssignmentPattern()) {
+        const left = path.get("left");
+        meshExpression(path.get("right"), internal);
+        ignoreParams(left, internal, false);
+        /* istanbul ignore else */
+        if (!allowReactiveId && left.isIdentifier()) {
+            (0, lib_js_1.checkNonReactiveName)(left, internal);
+        }
     }
-    if (t.isIdentifier(val)) {
-        internal.stack.set(val.name, 1 /* VariableState.Ignored */);
+    // param is identifier
+    else if (path.isIdentifier()) {
+        internal.stack.set(path.node.name, {});
+        if (!allowReactiveId || !allowReactiveId.includes("id")) {
+            (0, lib_js_1.checkNonReactiveName)(path, internal);
+        }
     }
-    else if (t.isObjectPattern(val)) {
-        ignoreObjectPattern(val, internal);
+    // param is object destruction
+    else if (path.isObjectPattern()) {
+        ignoreObjectPattern(path, internal);
     }
-    else if (t.isArrayPattern(val)) {
-        for (const element of val.elements) {
+    // param is array destruction
+    else if (path.isArrayPattern()) {
+        for (const element of path.get("elements")) {
             if (element) {
-                ignoreParams(element, internal);
+                ignoreParams(element, internal, allowReactiveId && allowReactiveId.includes("array") && ["id", "array"]);
+                if ((!allowReactiveId || !allowReactiveId.includes("array")) && element.isIdentifier()) {
+                    (0, lib_js_1.checkNonReactiveName)(element, internal);
+                }
             }
         }
     }
+    // rest element
+    else if (path.isRestElement()) {
+        ignoreParams(path.get("argument"), internal, false);
+    }
+    // something else
+    else {
+        meshLValue(path, internal);
+    }
 }
 function ignoreObjectPattern(pattern, internal) {
-    for (const property of pattern.properties) {
-        if (t.isObjectProperty(property)) {
-            if (t.isObjectPattern(property.value)) {
-                ignoreObjectPattern(property.value, internal);
+    for (const path of pattern.get("properties")) {
+        if (path.isObjectProperty()) {
+            const property = path.node;
+            const originName = (t.isStringLiteral(property.key) && property.key.value) ||
+                (!property.computed && t.isIdentifier(property.key) && property.key.name);
+            const newName = (t.isIdentifier(property.value) && property.value.name) ||
+                (t.isAssignmentPattern(property.value) && t.isIdentifier(property.value.left) && property.value.left.name);
+            if (originName && newName && originName.startsWith("$") !== newName.startsWith("$")) {
+                (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, path.get("value"), `Property "${originName}" can not be renamed to "${newName}": ` +
+                    (originName.startsWith("$") ? `rename it to "$${newName}"` : `rename it to "${newName.substring(1)}"`), internal);
+            }
+            const valuePath = path.get("value");
+            /* istanbul ignore else */
+            if (valuePath.isObjectPattern()) {
+                /* istanbul ignore else */
+                if (originName && originName.startsWith("$")) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, path, "You can not destruct a reactive value", internal);
+                }
+                ignoreObjectPattern(path.get("value"), internal);
             }
-            else if (t.isAssignmentPattern(property.value)) {
-                ignoreParams(property.value, internal);
+            else if (valuePath.isAssignmentPattern()) {
+                const right = valuePath.get("right");
+                ignoreParams(valuePath.get("left"), internal, ["id"]);
+                meshExpression(right, internal);
+                if (property.computed && t.isIdentifier(property.key)) {
+                    right.replaceWith(internal.match(t.stringLiteral(property.key.name), right.node));
+                }
+                else if ((t.isIdentifier(property.key) && property.key.name.startsWith("$")) ||
+                    (t.isStringLiteral(property.key) && property.key.value.startsWith("$"))) {
+                    right.replaceWith(internal.ref(right.node));
+                }
             }
             else if (t.isIdentifier(property.value)) {
-                internal.stack.set(property.value.name, 1 /* VariableState.Ignored */);
+                internal.stack.set(property.value.name, {});
+                if (property.computed) {
+                    path
+                        .get("value")
+                        .replaceWith(t.assignmentPattern(property.value, internal.match(t.stringLiteral(property.value.name))));
+                }
+                else if (property.value.name.startsWith("$")) {
+                    path.get("value").replaceWith(t.assignmentPattern(property.value, internal.ref()));
+                }
             }
         }
-        if (t.isRestElement(property)) {
-            internal.stack.set(property.argument.name, 1 /* VariableState.Ignored */);
+        if (path.isRestElement() && t.isIdentifier(path.node.argument)) {
+            internal.stack.set(path.node.argument.name, {});
         }
     }
 }
 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 */);
+    if (path.isArrayPattern()) {
+        path.get("elements").forEach((element, index) => {
+            /* istanbul ignore else */
+            if (index < 2) {
+                (0, lib_js_1.checkReactiveName)(element, internal);
+            }
+            else if (element.isIdentifier()) {
+                (0, lib_js_1.checkNonReactiveName)(element, internal);
+                internal.stack.set(element.node.name, {});
             }
         });
     }
     else {
-        throw path.buildCodeFrameError("Vasille: Expected array pattern");
+        (0, lib_js_1.err)(lib_js_1.Errors.TokenNotSupported, path, "Expected array pattern", internal);
     }
 }
 function meshForEachHeader(path, internal) {
     const left = path.node.left;
     meshExpression(path.get("right"), internal);
+    /* istanbul ignore else */
     if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
-        ignoreParams(left.declarations[0].id, internal);
+        ignoreParams(path.get("left").get("declarations")[0].get("id"), internal, false);
     }
 }
 function meshForHeader(path, internal) {
     const node = path.node;
+    /* istanbul ignore else */
     if (node.init) {
-        if (t.isExpression(node.init)) {
-            meshExpression(path.get("init"), internal);
+        const initPath = path.get("init");
+        if (initPath.isExpression()) {
+            meshExpression(initPath, internal);
         }
         else {
-            const variablePath = path.get("init");
-            for (const declarationPath of variablePath.get("declarations")) {
+            for (const declarationPath of initPath.get("declarations")) {
                 meshExpression(declarationPath.get("init"), internal);
-                ignoreParams(declarationPath.node.id, internal);
+                ignoreParams(declarationPath.get("id"), internal, false);
             }
         }
     }
@@ -403,10 +481,92 @@ function meshForHeader(path, internal) {
 }
 function meshClassBody(path, internal) {
     for (const item of path.get("body")) {
-        if (t.isClassMethod(item.node) || t.isClassPrivateMethod(item.node)) {
+        /* istanbul ignore else */
+        if (item.isClassMethod() || item.isClassPrivateMethod()) {
             meshFunction(item, internal);
         }
+        else if (item.isClassProperty()) {
+            meshExpression(item.get("value"), internal);
+        }
+        else if (item.isClassAccessorProperty()) {
+            meshExpression(item.get("value"), internal);
+        }
+        else if (item.isClassPrivateProperty()) {
+            meshExpression(item.get("value"), internal);
+        }
+    }
+}
+function procedureProcessObjectExpression(path, internal, state, prefix) {
+    for (const prop of path.get("properties")) {
+        const keyPath = prop.get("key");
+        const valuePath = prop.get("value");
+        /* istanbul ignore else */
+        if (prop.isObjectProperty()) {
+            // the property name is known in compile time
+            if ((!prop.node.computed || keyPath.isStringLiteral()) && valuePath.isExpression()) {
+                const call = (internal.isComposing && !internal.isFunctionParsing) ||
+                    (0, call_js_1.calls)(valuePath, ["ref", "bind", "calculate"], internal)
+                    ? (0, expression_js_1.checkNode)(valuePath, internal)
+                    : null;
+                const name = (0, utils_1.stringify)(keyPath.node);
+                if ((call?.found.size ?? 0) > 0) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, valuePath, "Objects can not contains bind expressions", internal);
+                }
+                else if (call?.self) {
+                    if (!name.startsWith("$")) {
+                        (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, keyPath, "Reactive field name must start with $", internal);
+                    }
+                    state[name] = 1;
+                }
+                else {
+                    if (valuePath.isObjectExpression()) {
+                        procedureProcessObjectExpression(valuePath, internal, state, `${prefix}${name}.`);
+                    }
+                    else {
+                        meshExpression(valuePath, internal);
+                    }
+                    if (name.startsWith("$")) {
+                        if (internal.isComposing && !internal.isFunctionParsing) {
+                            valuePath.replaceWith(internal.ref(valuePath.node));
+                            state[name] = 1;
+                        }
+                        else {
+                            (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, prop.get("key"), "This property is not a reactive", internal);
+                        }
+                    }
+                }
+            }
+            // the property name is unknown in compile time
+            else {
+                meshOrIgnoreExpression(keyPath, internal);
+                meshLValue(valuePath, internal);
+                /* istanbul ignore else */
+                if (keyPath.isExpression() && valuePath.isExpression()) {
+                    valuePath.replaceWith(internal.match(keyPath.node, valuePath.node));
+                }
+            }
+        }
+        else if (prop.isObjectMethod()) {
+            if ((keyPath.isIdentifier() && keyPath.node.name.startsWith("$") && !prop.node.computed) ||
+                (keyPath.isStringLiteral() && keyPath.node.value.startsWith("$"))) {
+                (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, prop.get("key"), "Method name can not start with $", internal);
+            }
+            meshStatement(prop.get("body"), internal);
+        }
+        else if (prop.isSpreadElement()) {
+            const argumentPath = prop.get("argument");
+            if (argumentPath.isObjectExpression()) {
+                procedureProcessObjectExpression(argumentPath, internal, state, prefix);
+            }
+            else {
+                meshExpression(argumentPath, internal);
+            }
+        }
     }
+    return state;
+}
+function processObjectExpression(path, internal) {
+    return procedureProcessObjectExpression(path, internal, {}, "");
 }
 function meshStatement(path, internal) {
     const statement = path.node;
@@ -487,6 +647,7 @@ function meshStatement(path, internal) {
             break;
         case "TryStatement":
             meshStatement(path.get("block"), internal);
+            /* istanbul ignore else */
             if (path.node.handler) {
                 meshStatement(path.get("handler").get("body"), internal);
             }
@@ -495,13 +656,122 @@ function meshStatement(path, internal) {
         case "VariableDeclaration": {
             const _path = path;
             for (const declaration of _path.get("declarations")) {
-                const expr = declaration.node.init;
-                if (expr && t.isIdentifier(declaration.node.id) && (0, call_js_1.calls)(expr, ["compose", "store"], internal)) {
-                    meshComposeCall(expr, declaration.node.id, declaration.get("init"), internal);
+                const initPath = declaration.get("init");
+                const composeMethod = (0, call_js_1.calls)(initPath, call_js_1.composeFunctions, internal);
+                const id = declaration.node.id;
+                const idPath = declaration.get("id");
+                if (t.isIdentifier(id) && composeMethod) {
+                    const name = id.name;
+                    const idPath = declaration.get("id");
+                    const isNotUpperCase = name[0].toUpperCase() !== name[0];
+                    const isNotLowerCase = name[0].toLowerCase() !== name[0];
+                    function report(error) {
+                        (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, idPath, error, internal);
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["compose", "component"], internal)) {
+                        if (isNotUpperCase) {
+                            report("The component name must start with a uppercase letter");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/components/")) {
+                            report("Components must be placed in a folder named `components`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["view"], internal)) {
+                        if (isNotUpperCase) {
+                            report("The view name must start with a uppercase letter");
+                        }
+                        if (!name.endsWith("View")) {
+                            report("The view name must end with `View`");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/views/")) {
+                            report("Views must be placed in a folder named `views`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["store"], internal)) {
+                        if (isNotLowerCase) {
+                            report("The store name must start with a lowercase letter");
+                        }
+                        if (!name.endsWith("Store")) {
+                            report("The store name must end with `Store`");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/stores/")) {
+                            report("Stores must be placed in a folder named `stores`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["model"], internal)) {
+                        if (isNotLowerCase) {
+                            report("The model constructor function name must start with a lowercase letter");
+                        }
+                        if (!name.endsWith("Model")) {
+                            report("The model constructor function name must end with `Model`");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/models/")) {
+                            report("Models must be placed in a folder named `models`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["modal"], internal)) {
+                        if (isNotUpperCase) {
+                            report("The modal component name must start with a uppercase letter");
+                        }
+                        if (!name.endsWith("Modal")) {
+                            report("The modal component name must end with `Modal`");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/modals/")) {
+                            report("Modals must be placed in a folder named `modals`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["prompt"], internal)) {
+                        if (!name.startsWith("prompt")) {
+                            report("The prompt function name must start with `prompt`");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/prompts/")) {
+                            report("Prompts must be placed in a folder named `prompts`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["screen"], internal)) {
+                        if (!name.endsWith("Screen")) {
+                            report("The screen name must start with `Screen`");
+                        }
+                        if (internal.strictFolders && !internal.filename.includes("/screens/")) {
+                            report("Screens must be placed in a folder named `screens`");
+                        }
+                    }
+                    if ((0, call_js_1.calls)(initPath, ["page"], internal)) {
+                        report("Use export default instead");
+                    }
+                    if (t.isExportNamedDeclaration(path.parent)) {
+                        /* istanbul ignore else */
+                        if (![".ts", ".tsx", ".js", ".jsx"].some(ext => {
+                            return internal.filename.endsWith(`${name}${ext}`);
+                        })) {
+                            report(`File name is not correct, expected ${name}.ts, ${name}.tsx, ${name}.js or ${name}.jsx`);
+                        }
+                    }
+                    meshComposeCall(id.name, initPath, internal);
                 }
+                // calculate call
+                else if ((0, call_js_1.calls)(initPath, ["calculate"], internal) && (0, lib_js_1.processCalculateCall)(initPath, internal)) {
+                    (0, lib_js_1.checkReactiveName)(idPath, internal);
+                }
+                // ref call
+                else if ((0, call_js_1.calls)(initPath, call_js_1.reactivityFunctions, internal)) {
+                    meshAllUnknown(initPath.get("arguments"), internal);
+                    (0, lib_js_1.checkReactiveName)(idPath, internal);
+                }
+                // bind call
+                else if ((0, call_js_1.calls)(initPath, ["bind"], internal) && (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { strong: true })) {
+                    (0, lib_js_1.checkReactiveName)(idPath, internal);
+                }
+                // variable declaration
                 else {
-                    meshExpression(declaration.get("init"), internal);
-                    ignoreParams(declaration.node.id, internal);
+                    ignoreParams(declaration.get("id"), internal, ["id", "array"]);
+                    idPath.isIdentifier() && (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+                    if (initPath.isObjectExpression() && t.isIdentifier(declaration.node.id) && _path.node.kind === "const") {
+                        internal.stack.set(declaration.node.id.name, processObjectExpression(initPath, internal));
+                    }
+                    else {
+                        meshExpression(initPath, internal);
+                    }
                 }
             }
             break;
@@ -518,116 +788,134 @@ function meshStatement(path, internal) {
             meshStatement(path.get("declaration"), internal);
             break;
         }
-        case "ClassDeclaration":
-            meshClassBody(path.get("body"), internal);
+        case "ClassDeclaration": {
+            const classPath = path;
+            const idPath = classPath.get("id");
+            /* istanbul ignore else */
+            if (idPath.isIdentifier()) {
+                (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+            }
+            meshClassBody(classPath.get("body"), internal);
             break;
+        }
         case "ExportDefaultDeclaration": {
             const declarationPath = path.get("declaration");
-            if (t.isExpression(declarationPath.node)) {
+            /* istanbul ignore else */
+            // export default 23;
+            if (declarationPath.isExpression()) {
                 meshExpression(declarationPath, internal);
             }
-            else if (t.isFunctionDeclaration(declarationPath.node)) {
+            // export default function ..
+            else if (declarationPath.isFunctionDeclaration()) {
                 meshFunction(declarationPath, internal);
             }
-            else if (t.isClassDeclaration(declarationPath.node)) {
+            // export default class ..
+            else if (declarationPath.isClassDeclaration()) {
                 meshClassBody(declarationPath.get("body"), internal);
             }
         }
     }
 }
 function meshFunction(path, internal) {
-    if (t.isFunctionDeclaration(path.node) && path.node.id) {
-        internal.stack.set(path.node.id.name, 1 /* VariableState.Ignored */);
+    if (path.isFunctionDeclaration() && path.node.id) {
+        const idPath = path.get("id");
+        /* istanbul ignore else */
+        if (idPath.isIdentifier()) {
+            internal.stack.set(path.node.id.name, {});
+            (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+        }
     }
     internal.stack.push();
-    const node = path.node;
-    if (t.isFunctionExpression(node) && node.id) {
-        internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
+    if (path.isFunctionExpression() && path.node.id) {
+        internal.stack.set(path.node.id.name, {});
     }
-    for (const param of node.params) {
-        ignoreParams(param, internal);
+    for (const param of path.get("params")) {
+        ignoreParams(param, internal, false);
     }
-    if (t.isExpression(node.body)) {
-        meshExpression(path.get("body"), internal);
+    const bodyPath = path.get("body");
+    /* istanbul ignore else */
+    if (bodyPath.isExpression()) {
+        meshExpression(bodyPath, internal);
     }
-    else {
-        const bodyPath = path.get("body");
+    else if (bodyPath.isBlockStatement()) {
         meshStatement(bodyPath, internal);
     }
     internal.stack.pop();
 }
-function composeExpression(path, internal, isRoot) {
+function composeExpression(path, internal) {
     const expr = path.node;
     switch (expr && expr.type) {
-        case "AssignmentExpression": {
-            meshExpression(path, internal);
-            break;
-        }
         case "CallExpression":
         case "OptionalCallExpression": {
-            const call = expr;
-            if ((0, call_js_1.calls)(call, ["watch"], internal)) {
-                const args = (0, lib_js_1.parseCalculateCall)(path, internal);
+            if ((0, call_js_1.calls)(path, ["watch"], internal)) {
+                (0, lib_js_1.parseCalculateCall)(path, internal);
+                const args = path.node.arguments;
+                /* istanbul ignore else */
                 if (args) {
-                    if (args[1].elements.length > 0) {
-                        path.replaceWith(t.callExpression(t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
+                    if (args[2].elements.length <= 0) {
+                        path.replaceWith(t.callExpression(args[1], []));
                     }
-                    else {
-                        path.replaceWith(t.callExpression(args[0], []));
+                }
+            }
+            else if ((0, call_js_1.calls)(path, ["beforeMount", "afterMount"], internal)) {
+                const arg = path.get("arguments")[0];
+                if (arg && (arg.isFunctionExpression() || arg.isArrowFunctionExpression())) {
+                    const body = arg.isFunctionExpression() ? arg.get("body") : arg.get("body");
+                    /* istanbul ignore else */
+                    if (body.isBlockStatement()) {
+                        composeStatements(body.get("body"), internal);
+                        path.replaceWith(t.callExpression(arg.node, []));
                     }
+                    else if (body.isExpression()) {
+                        composeExpression(body, internal);
+                        path.replaceWith(body);
+                    }
+                }
+                else {
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncorrectArguments, path, "Incorrect hint argument", internal);
+                }
+            }
+            else if ((0, call_js_1.calls)(path, ["beforeDestroy"], internal)) {
+                if (internal.stateOnly) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "Stores in Vasille.JS are not destroyable", internal);
                 }
+                path.get("callee").replaceWith(t.memberExpression(internal_js_1.ctx, t.identifier("runOnDestroy")));
             }
             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":
             if (internal.stateOnly) {
-                throw path.buildCodeFrameError("Vasille: JSX is not allowed in states");
+                return (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "JSX is not allowed in states", internal);
             }
-            path.replaceWithMultiple((0, jsx_js_1.transformJsx)(path, internal));
+            const conditions = { cases: null };
+            path.replaceWithMultiple([
+                ...(0, jsx_js_1.transformJsx)(path, conditions, internal),
+                ...(0, jsx_js_1.processConditions)(conditions, internal),
+            ]);
             break;
         default:
-            meshExpression(path, internal, isRoot);
+            meshExpression(path, internal);
     }
 }
-function composeStatements(paths, internal, isRoot) {
+function composeStatements(paths, internal) {
     for (const path of paths) {
-        composeStatement(path, internal, isRoot);
+        composeStatement(path, internal);
     }
 }
-function composeStatement(path, internal, isRoot) {
+function composeStatement(path, internal) {
     const statement = path.node;
-    if (!statement) {
-        return;
-    }
-    switch (statement.type) {
+    switch (statement?.type) {
         case "FunctionDeclaration": {
             meshFunction(path, internal);
             break;
         }
         case "BlockStatement": {
             internal.stack.push();
-            composeStatements(path.get("body"), internal, isRoot);
-            internal.stack.pop();
-            break;
-        }
-        case "DoWhileStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            composeStatement(_path.get("body"), internal);
+            composeStatements(path.get("body"), internal);
             internal.stack.pop();
             break;
         }
@@ -635,68 +923,19 @@ function composeStatement(path, internal, isRoot) {
             composeExpression(path.get("expression"), internal);
             break;
         }
-        case "ForInStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForEachHeader(_path, internal);
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ForStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForHeader(_path, internal);
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "IfStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            composeStatement(_path.get("consequent"), internal);
-            internal.stack.pop();
-            internal.stack.push();
-            composeStatement(_path.get("alternate"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "LabeledStatement":
-            composeStatement(path.get("body"), internal);
-            break;
         case "ReturnStatement":
-            composeExpression(path.get("argument"), internal, isRoot);
-            break;
-        case "SwitchStatement": {
-            const _path = path;
-            meshExpression(_path.get("discriminant"), internal);
-            internal.stack.push();
-            for (const _case of _path.get("cases")) {
-                meshExpression(_case.get("test"), internal);
-                composeStatements(_case.get("consequent"), internal);
-            }
-            internal.stack.pop();
-            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);
+            composeExpression(path.get("argument"), internal);
             break;
         case "VariableDeclaration": {
             const _path = path;
             const kind = _path.node.kind;
-            const declares = kind === "const" ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */;
-            if (kind === "let" || kind === "var") {
-                _path.node.kind = "const";
-            }
+            let switchToConst = true;
             for (const declaration of _path.get("declarations")) {
                 const id = declaration.node.id;
                 let meshInit = true;
                 function idName(target = id) {
                     let name = "#";
+                    /* istanbul ignore else */
                     if (t.isIdentifier(target)) {
                         name = target.name;
                     }
@@ -704,216 +943,157 @@ function composeStatement(path, internal, isRoot) {
                 }
                 function idDoubleName() {
                     const pattern = id;
-                    return [idName(pattern.elements[0]), idName(pattern.elements[1])];
+                    return [idName(pattern.elements?.[0]), idName(pattern.elements?.[1])];
                 }
-                ignoreParams(declaration.node.id, internal);
-                if ((0, call_js_1.calls)(declaration.node.init, ["awaited"], internal)) {
+                ignoreParams(declaration.get("id"), internal, ["id", "array"]);
+                /* istanbul ignore else */
+                if ((0, call_js_1.calls)(declaration.get("init"), ["awaited"], internal)) {
+                    const callPath = declaration.get("init");
                     reactiveArrayPattern(declaration.get("id"), internal);
-                    meshAllUnknown(declaration.get("init").get("arguments"), internal);
-                    (0, lib_js_1.named)(declaration.node.init, idDoubleName(), internal);
+                    meshAllUnknown(callPath.get("arguments"), internal);
+                    /* istanbul ignore else */
+                    if (internal.devMode) {
+                        callPath.node.arguments.push(internal_js_1.ctx);
+                    }
+                    (0, lib_js_1.named)(callPath.node, idDoubleName(), internal, 2);
                     meshInit = false;
                 }
                 else if (t.isIdentifier(id)) {
-                    internal.stack.set(id.name, declares);
+                    const idPath = declaration.get("id");
+                    internal.stack.set(id.name, {});
                     const init = declaration.node.init;
-                    if ((0, call_js_1.calls)(init, ["value"], internal)) {
-                        internal.stack.set(id.name, 1 /* VariableState.Ignored */);
+                    const initPath = declaration.get("init");
+                    // let a = raw(0)
+                    if ((0, call_js_1.calls)(initPath, ["raw"], internal)) {
                         declaration.get("init").replaceWith(init.arguments[0]);
                         _path.node.kind = kind;
+                        switchToConst = false;
+                        (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
-                    else if ((0, call_js_1.calls)(init, ["bind"], internal)) {
+                    // const x = bind(a + b);
+                    else if ((0, call_js_1.calls)(initPath, ["bind", "calculate"], internal)) {
                         const argument = init.arguments[0];
-                        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());
+                        const isReactive = (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { name: idName(), strong: true });
+                        meshInit = !isReactive;
+                        if (!isReactive) {
+                            declaration.get("init").replaceWith((0, lib_js_1.ref)(argument, internal, idName()));
                         }
-                        if (declares === 2 /* VariableState.Reactive */) {
-                            internal.stack.set(id.name, 4 /* VariableState.ReactivePointer */);
-                            replaceWith = (0, lib_js_1.own)(replaceWith, internal, idName());
-                        }
-                        else {
-                            internal.stack.set(id.name, 2 /* VariableState.Reactive */);
-                        }
-                        declaration.get("init").replaceWith(replaceWith);
-                        meshInit = !replaceWith;
+                        (0, lib_js_1.checkReactiveName)(idPath, internal);
                     }
-                    else if ((0, call_js_1.calls)(init, ["ref"], internal)) {
+                    // let y = ref(2)
+                    else if ((0, call_js_1.calls)(initPath, ["ref"], internal)) {
+                        meshAllUnknown(initPath.get("arguments"), internal);
                         const argument = init.arguments[0];
-                        internal.stack.set(id.name, 2 /* VariableState.Reactive */);
                         declaration.get("init").replaceWith((0, lib_js_1.ref)(t.isExpression(argument) ? argument : null, internal, idName()));
+                        (0, lib_js_1.checkReactiveName)(idPath, internal);
+                        meshInit = false;
                     }
-                    else if ((0, call_js_1.calls)(init, ["reactiveObject"], internal)) {
-                        const value = init.arguments[0];
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Reactive objects must be must be declared as constants`);
-                        }
-                        if (t.isObjectExpression(value)) {
-                            declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(value, internal, idName()));
-                            internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
-                        }
-                        else {
-                            throw declaration.buildCodeFrameError(`Vasille: reactiveObject requires object expression as argument`);
-                        }
+                    // const arr = arrayModel()
+                    else if ((0, call_js_1.calls)(initPath, ["arrayModel"], internal)) {
+                        (0, lib_js_1.processModelCall)(initPath, "Array", kind === "const", internal, idName());
+                        meshInit = false;
+                        (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
-                    else if ((0, call_js_1.calls)(init, ["arrayModel"], internal)) {
-                        const value = init.arguments[0];
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Array models must be must be declared as constants`);
-                        }
-                        if (t.isArrayExpression(value)) {
-                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(value, internal, idName()));
-                        }
-                        else {
-                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(null, internal, idName()));
-                        }
+                    // const map = mapModel();
+                    else if ((0, call_js_1.calls)(initPath, ["mapModel"], internal)) {
+                        (0, lib_js_1.processModelCall)(initPath, "Map", kind === "const", internal, idName());
+                        meshInit = false;
+                        (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
-                    else if ((0, call_js_1.calls)(init, ["mapModel", "setModel"], internal)) {
-                        const args = init.arguments;
-                        const name = (0, call_js_1.calls)(init, ["mapModel", "setModel"], internal);
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: ${name === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
-                        }
-                        declaration
-                            .get("init")
-                            .replaceWith(name === "mapModel" ? (0, lib_js_1.mapModel)(args, internal, idName()) : (0, lib_js_1.setModel)(args, internal, idName()));
+                    // const set = setModel();
+                    else if ((0, call_js_1.calls)(initPath, ["setModel"], internal)) {
+                        (0, lib_js_1.processModelCall)(initPath, "Set", kind === "const", internal, idName());
+                        meshInit = false;
+                        (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
+                    // const x = { .. }
                     else if (t.isObjectExpression(init)) {
-                        if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Objects must be must be declared as constants`);
-                        }
-                        declaration.get("init").replaceWith((0, lib_js_1.reactiveObject)(init, internal, idName()));
-                        internal.stack.set(id.name, 3 /* VariableState.ReactiveObject */);
+                        internal.stack.set(id.name, processObjectExpression(initPath, internal));
+                        meshInit = false;
+                        (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
-                    else if (t.isArrayExpression(init)) {
+                    // const a = []
+                    else if (initPath.isArrayExpression()) {
                         if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: Arrays must be must be declared as constants`);
+                            (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, declaration, "Arrays must be must be declared as constants", 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") {
-                                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_js_1.mapModel)(init.arguments, internal, idName())
-                                : (0, lib_js_1.setModel)(init.arguments, internal, idName()));
+                        meshExpression(initPath, internal);
+                        meshInit = false;
+                        initPath.replaceWith((0, lib_js_1.arrayModel)([initPath.node], internal, idName()));
+                        (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+                    }
+                    // const s = new Set(), const m = new Map()
+                    else if (initPath.isNewExpression() && t.isIdentifier(initPath.node.callee)) {
+                        const name = initPath.node.callee.name;
+                        if (name === "Map" || name === "Set") {
+                            (0, lib_js_1.processModelCall)(initPath, name, kind === "const", internal, idName());
+                            meshInit = false;
+                            (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                         }
                     }
-                    else if (declares === 2 /* VariableState.Reactive */) {
-                        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_js_1.own)(replaceWith, internal, idName()) : (0, lib_js_1.ref)(declaration.node.init, internal, idName()));
+                    else if (kind === "let") {
+                        meshExpression(declaration.get("init"), internal);
+                        declaration.get("init").replaceWith((0, lib_js_1.ref)(declaration.node.init, internal, idName()));
+                        (0, lib_js_1.checkReactiveName)(idPath, internal);
+                        meshInit = false;
                     }
                     else {
-                        const replaceWith = (0, lib_js_1.exprCall)(declaration.get("init"), declaration.node.init, internal, idName());
-                        if (replaceWith) {
-                            declaration.get("init").replaceWith(replaceWith);
+                        const isReactive = (0, lib_js_1.exprCall)(declaration.get("init"), declaration.node.init, internal, {
+                            name: idName(),
+                            strong: true,
+                        });
+                        if (isReactive) {
+                            (0, lib_js_1.checkReactiveName)(idPath, internal);
                         }
-                        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;
+                        else {
+                            (0, lib_js_1.checkNonReactiveName)(idPath, internal);
+                        }
+                        meshInit = !isReactive;
                     }
                 }
+                else if (t.isObjectPattern(id)) {
+                    ignoreObjectPattern(declaration.get("id"), internal);
+                }
                 if (meshInit) {
                     meshExpression(declaration.get("init"), internal);
                 }
             }
-            break;
-        }
-        case "WhileStatement": {
-            const _path = path;
-            meshExpression(_path.get("test"), internal);
-            internal.stack.push();
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
-            break;
-        }
-        case "ForOfStatement": {
-            const _path = path;
-            internal.stack.push();
-            meshForEachHeader(_path, internal);
-            composeStatement(_path.get("body"), internal);
-            internal.stack.pop();
+            if (switchToConst && kind === "let") {
+                _path.node.kind = "const";
+            }
             break;
         }
         default:
             meshStatement(path, internal);
     }
 }
-function compose(path, internal, isInternalSlot) {
+function compose(path, internal, isInternalSlot, isSlot) {
     internal.stack.push();
     const node = path.node;
     const params = node.params;
-    const body = node.body;
+    const body = path.isArrowFunctionExpression() ? path.get("body") : path.get("body");
     if (t.isFunctionExpression(node) && node.id) {
-        internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
+        internal.stack.set(node.id.name, {});
     }
     if (params.length > 1 && !isInternalSlot) {
-        throw path.get("params")[1].buildCodeFrameError("Vasille: JSX component must have no more then 1 parameter");
+        (0, lib_js_1.err)(lib_js_1.Errors.IncorrectArguments, path.get("params")[1], "Extra parameters are not allowed", internal);
     }
     for (const param of path.get("params")) {
-        const node = param.node;
-        if (t.isAssignmentPattern(node)) {
-            throw param.buildCodeFrameError("Vasille: No default value allowed here");
-        }
-        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;
-                    }
-                    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");
-                    }
-                }
-                if (t.isRestElement(node)) {
-                    internal.stack.set(node.argument.name, 3 /* VariableState.ReactiveObject */);
-                }
-            }
-        }
-        else {
-            throw param.buildCodeFrameError("Vasille: Expected identifier or object pattern");
-        }
+        ignoreParams(param, internal, false);
+    }
+    if (!isSlot) {
+        internal.isComposing = true;
+    }
+    /* istanbul ignore else */
+    if (body.isExpression()) {
+        composeExpression(body, internal);
     }
-    if (t.isExpression(body)) {
-        composeExpression(path.get("body"), internal, true);
+    else if (body.isBlockStatement()) {
+        (0, order_check_1.checkOrder)(body.get("body"), internal);
+        composeStatement(body, internal);
     }
-    else if (t.isBlockStatement(body)) {
-        composeStatement(path.get("body"), internal, true);
+    if (!isSlot) {
+        internal.isComposing = false;
     }
     internal.stack.pop();
 }