babel-plugin-vasille 3.1.1 → 3.1.5

package/lib/mesh.js

@@ -1,22 +1,73 @@
-import * as t from "@babel/types";
-import { calls, composeOnly, styleOnly } from "./call.js";
-import { idIsIValue, memberIsIValue, nodeIsReactiveObject } from "./expression.js";
-import { ctx } from "./internal.js";
-import { transformJsx } from "./jsx.js";
-import { arrayModel, exprCall, forwardOnlyExpr, mapModel, named, own, parseCalculateCall, reactiveObject, ref, setModel, } from "./lib.js";
-export function meshOrIgnoreAllExpressions(nodePaths, internal) {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    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;
+exports.meshComposeCall = meshComposeCall;
+exports.meshAllUnknown = meshAllUnknown;
+exports.meshLValue = meshLValue;
+exports.meshOrIgnoreExpression = meshOrIgnoreExpression;
+exports.meshExpression = meshExpression;
+exports.meshStatements = meshStatements;
+exports.ignoreParams = ignoreParams;
+exports.reactiveArrayPattern = reactiveArrayPattern;
+exports.meshStatement = meshStatement;
+exports.meshFunction = meshFunction;
+exports.composeExpression = composeExpression;
+exports.composeStatements = composeStatements;
+exports.composeStatement = composeStatement;
+exports.compose = compose;
+const t = __importStar(require("@babel/types"));
+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)) {
             meshExpression(path, internal);
         }
     }
 }
-export function meshAllExpressions(nodePaths, internal) {
+function meshAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
         meshExpression(path, internal);
     }
 }
-export function meshComposeCall(call, name, nodePath, 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");
@@ -24,16 +75,13 @@ export function meshComposeCall(call, name, nodePath, internal) {
     const fnPath = nodePath.get("arguments")[0];
     compose(fnPath, internal, false);
     if (!internal.stateOnly) {
-        arg.params.unshift(ctx);
+        arg.params.unshift(internal_js_1.ctx);
     }
     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]);
-    }
 }
-export function meshAllUnknown(paths, internal) {
+function meshAllUnknown(paths, internal) {
     for (const path of paths) {
         if (t.isSpreadElement(path.node)) {
             meshExpression(path.get("argument"), internal);
@@ -43,23 +91,23 @@ export function meshAllUnknown(paths, internal) {
         }
     }
 }
-export function meshLValue(path, internal) {
+function meshLValue(path, internal) {
     const node = path.node;
     if (t.isExpression(node)) {
         meshExpression(path, internal);
     }
 }
-export function meshOrIgnoreExpression(path, internal) {
+function meshOrIgnoreExpression(path, internal) {
     if (t.isExpression(path.node)) {
         meshExpression(path, internal);
     }
 }
-export function meshExpression(nodePath, internal, isRoot) {
+function meshExpression(nodePath, internal, isRoot) {
     const expr = nodePath.node;
     if (!expr) {
         return;
     }
-    if (calls(expr, ["compose", "extend", "state"], internal)) {
+    if ((0, call_js_1.calls)(expr, ["compose", "store"], internal)) {
         meshComposeCall(expr, null, nodePath, internal);
         return;
     }
@@ -76,7 +124,7 @@ export function meshExpression(nodePath, internal, isRoot) {
         }
         case "Identifier": {
             const state = internal.stack.get(expr.name);
-            if (idIsIValue(nodePath, internal)) {
+            if ((0, expression_js_1.idIsIValue)(nodePath, internal)) {
                 nodePath.replaceWith(t.memberExpression(expr, t.identifier(state === 4 /* VariableState.ReactivePointer */ ? "$$" : "$")));
             }
             break;
@@ -89,8 +137,8 @@ export function meshExpression(nodePath, internal, isRoot) {
         case "CallExpression":
         case "OptionalCallExpression": {
             const path = nodePath;
-            const callsFn = calls(path.node, composeOnly, internal);
-            const callsStyleHint = calls(path.node, styleOnly, 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`);
             }
@@ -99,7 +147,7 @@ export function meshExpression(nodePath, internal, isRoot) {
             }
             meshOrIgnoreExpression(path.get("callee"), internal);
             meshAllUnknown(path.get("arguments"), internal);
-            if (calls(path.node, ["calculate"], 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], []));
@@ -116,7 +164,7 @@ export function meshExpression(nodePath, internal, isRoot) {
             let replaced = false;
             meshLValue(path.get("left"), internal);
             if (t.isIdentifier(left) && internal.stack.get(left.name) === 4 /* VariableState.ReactivePointer */) {
-                const replaceWith = 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);
                     replaced = true;
@@ -136,7 +184,7 @@ export function meshExpression(nodePath, internal, isRoot) {
             if (t.isExpression(property) && !t.isIdentifier(property)) {
                 meshOrIgnoreExpression(path.get("property"), internal);
             }
-            if (memberIsIValue(node, internal)) {
+            if ((0, expression_js_1.memberIsIValue)(node, internal)) {
                 path.replaceWith(t.memberExpression(node, t.identifier("$")));
             }
             break;
@@ -224,7 +272,7 @@ export function meshExpression(nodePath, internal, isRoot) {
                         !path.node.computed &&
                         t.isIdentifier(path.node.key) &&
                         t.isExpression(valuePath.node)) {
-                        const call = exprCall(valuePath, valuePath.node, internal);
+                        const call = (0, lib_js_1.exprCall)(valuePath, valuePath.node, internal);
                         if (call) {
                             if (path.node.key.name.startsWith("$")) {
                                 valuePath.replaceWith(call);
@@ -276,12 +324,12 @@ export function meshExpression(nodePath, internal, isRoot) {
         }
     }
 }
-export function meshStatements(paths, internal) {
+function meshStatements(paths, internal) {
     for (const path of paths) {
         meshStatement(path, internal);
     }
 }
-export function ignoreParams(val, internal) {
+function ignoreParams(val, internal) {
     if (t.isAssignmentPattern(val)) {
         val = val.left;
     }
@@ -317,7 +365,7 @@ function ignoreObjectPattern(pattern, internal) {
         }
     }
 }
-export function reactiveArrayPattern(path, internal) {
+function reactiveArrayPattern(path, internal) {
     if (t.isArrayPattern(path.node)) {
         path.node.elements.forEach((element, index) => {
             if (t.isIdentifier(element)) {
@@ -360,7 +408,7 @@ function meshClassBody(path, internal) {
         }
     }
 }
-export function meshStatement(path, internal) {
+function meshStatement(path, internal) {
     const statement = path.node;
     switch (statement && statement.type) {
         case "BlockStatement":
@@ -448,7 +496,7 @@ export function meshStatement(path, internal) {
             const _path = path;
             for (const declaration of _path.get("declarations")) {
                 const expr = declaration.node.init;
-                if (expr && t.isIdentifier(declaration.node.id) && calls(expr, ["compose", "extend", "state"], internal)) {
+                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);
                 }
                 else {
@@ -487,7 +535,7 @@ export function meshStatement(path, internal) {
         }
     }
 }
-export function meshFunction(path, internal) {
+function meshFunction(path, internal) {
     if (t.isFunctionDeclaration(path.node) && path.node.id) {
         internal.stack.set(path.node.id.name, 1 /* VariableState.Ignored */);
     }
@@ -508,7 +556,7 @@ export function meshFunction(path, internal) {
     }
     internal.stack.pop();
 }
-export function composeExpression(path, internal, isRoot) {
+function composeExpression(path, internal, isRoot) {
     const expr = path.node;
     switch (expr && expr.type) {
         case "AssignmentExpression": {
@@ -518,11 +566,11 @@ export function composeExpression(path, internal, isRoot) {
         case "CallExpression":
         case "OptionalCallExpression": {
             const call = expr;
-            if (calls(call, ["watch"], internal)) {
-                const args = parseCalculateCall(path, internal);
+            if ((0, call_js_1.calls)(call, ["watch"], internal)) {
+                const args = (0, lib_js_1.parseCalculateCall)(path, internal);
                 if (args) {
                     if (args[1].elements.length > 0) {
-                        path.replaceWith(t.callExpression(t.memberExpression(ctx, t.identifier("watch")), args));
+                        path.replaceWith(t.callExpression(t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
                     }
                     else {
                         path.replaceWith(t.callExpression(args[0], []));
@@ -548,18 +596,18 @@ export function composeExpression(path, internal, isRoot) {
             if (internal.stateOnly) {
                 throw path.buildCodeFrameError("Vasille: JSX is not allowed in states");
             }
-            path.replaceWithMultiple(transformJsx(path, internal));
+            path.replaceWithMultiple((0, jsx_js_1.transformJsx)(path, internal));
             break;
         default:
             meshExpression(path, internal, isRoot);
     }
 }
-export function composeStatements(paths, internal, isRoot) {
+function composeStatements(paths, internal, isRoot) {
     for (const path of paths) {
         composeStatement(path, internal, isRoot);
     }
 }
-export function composeStatement(path, internal, isRoot) {
+function composeStatement(path, internal, isRoot) {
     const statement = path.node;
     if (!statement) {
         return;
@@ -659,35 +707,35 @@ export function composeStatement(path, internal, isRoot) {
                     return [idName(pattern.elements[0]), idName(pattern.elements[1])];
                 }
                 ignoreParams(declaration.node.id, internal);
-                if (calls(declaration.node.init, ["awaited"], internal)) {
+                if ((0, call_js_1.calls)(declaration.node.init, ["awaited"], internal)) {
                     reactiveArrayPattern(declaration.get("id"), internal);
                     meshAllUnknown(declaration.get("init").get("arguments"), internal);
-                    named(declaration.node.init, idDoubleName(), 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 (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 (calls(init, ["bind"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["bind"], internal)) {
                         const argument = init.arguments[0];
                         const argumentPath = declaration.get("init").get("arguments")[0];
                         let replaceWith = declares === 2 /* VariableState.Reactive */
-                            ? forwardOnlyExpr(argumentPath, argument, internal)
-                            : exprCall(argumentPath, argument, internal, idName());
+                            ? (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])
-                                    : ref(argument, internal, idName());
+                                    : (0, lib_js_1.ref)(argument, internal, idName());
                         }
                         if (declares === 2 /* VariableState.Reactive */) {
                             internal.stack.set(id.name, 4 /* VariableState.ReactivePointer */);
-                            replaceWith = own(replaceWith, internal, idName());
+                            replaceWith = (0, lib_js_1.own)(replaceWith, internal, idName());
                         }
                         else {
                             internal.stack.set(id.name, 2 /* VariableState.Reactive */);
@@ -695,58 +743,58 @@ export function composeStatement(path, internal, isRoot) {
                         declaration.get("init").replaceWith(replaceWith);
                         meshInit = !replaceWith;
                     }
-                    else if (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(ref(t.isExpression(argument) ? argument : null, internal, idName()));
+                        declaration.get("init").replaceWith((0, lib_js_1.ref)(t.isExpression(argument) ? argument : null, internal, idName()));
                     }
-                    else if (calls(init, ["reactiveObject"], internal)) {
+                    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(reactiveObject(value, internal, idName()));
+                            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`);
                         }
                     }
-                    else if (calls(init, ["arrayModel"], 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(arrayModel(value, internal, idName()));
+                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(value, internal, idName()));
                         }
                         else {
-                            declaration.get("init").replaceWith(arrayModel(null, internal, idName()));
+                            declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(null, internal, idName()));
                         }
                     }
-                    else if (calls(init, ["mapModel", "setModel"], internal)) {
+                    else if ((0, call_js_1.calls)(init, ["mapModel", "setModel"], internal)) {
                         const args = init.arguments;
-                        const name = calls(init, ["mapModel", "setModel"], internal);
+                        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" ? mapModel(args, internal, idName()) : setModel(args, internal, idName()));
+                            .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") {
                             throw declaration.buildCodeFrameError(`Vasille: Objects must be must be declared as constants`);
                         }
-                        declaration.get("init").replaceWith(reactiveObject(init, internal, idName()));
+                        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") {
                             throw declaration.buildCodeFrameError(`Vasille: Arrays must be must be declared as constants`);
                         }
-                        declaration.get("init").replaceWith(arrayModel(init, internal, idName()));
+                        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") {
@@ -756,26 +804,26 @@ export function composeStatement(path, internal, isRoot) {
                             declaration
                                 .get("init")
                                 .replaceWith(init.callee.name === "Map"
-                                ? mapModel(init.arguments, internal, idName())
-                                : setModel(init.arguments, internal, idName()));
+                                ? (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 = 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 ? own(replaceWith, internal, idName()) : ref(declaration.node.init, internal, idName()));
+                            .replaceWith(replaceWith ? (0, lib_js_1.own)(replaceWith, internal, idName()) : (0, lib_js_1.ref)(declaration.node.init, internal, idName()));
                     }
                     else {
-                        const replaceWith = exprCall(declaration.get("init"), declaration.node.init, internal, idName());
+                        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 */
-                            : nodeIsReactiveObject(declaration.get("init"), internal)
+                            : (0, expression_js_1.nodeIsReactiveObject)(declaration.get("init"), internal)
                                 ? 3 /* VariableState.ReactiveObject */
                                 : 1 /* VariableState.Ignored */);
                         meshInit = !replaceWith;
@@ -807,7 +855,7 @@ export function composeStatement(path, internal, isRoot) {
             meshStatement(path, internal);
     }
 }
-export function compose(path, internal, isInternalSlot) {
+function compose(path, internal, isInternalSlot) {
     internal.stack.push();
     const node = path.node;
     const params = node.params;

package/lib/transformer.js

@@ -1,7 +1,43 @@
-import * as t from "@babel/types";
-import { StackedStates } from "./internal.js";
-import { meshStatement } from "./mesh.js";
-import { findStyleInNode } from "./css-transformer.js";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    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.trProgram = trProgram;
+const t = __importStar(require("@babel/types"));
+const internal_js_1 = require("./internal.js");
+const mesh_js_1 = require("./mesh.js");
+const css_transformer_js_1 = require("./css-transformer.js");
 const imports = new Map([["vasille-web", "VasilleWeb"]]);
 const ignoreMembers = new Set([
     "value",
@@ -21,13 +57,12 @@ const ignoreMembers = new Set([
     "laptop",
     "prefersDark",
     "prefersLight",
-    "state",
 ]);
 function extractText(node) {
     // no case found for string literal
     return node.name;
 }
-export function trProgram(path, devMode) {
+function trProgram(path, devMode) {
     let id;
     let stylesConnected = false;
     const internal = {
@@ -38,7 +73,7 @@ export function trProgram(path, devMode) {
         set id(expr) {
             id = expr;
         },
-        stack: new StackedStates(),
+        stack: new internal_js_1.StackedStates(),
         mapping: new Map(),
         global: "",
         prefix: "Vasille_",
@@ -89,8 +124,8 @@ export function trProgram(path, devMode) {
             if (!id) {
                 return;
             }
-            else if (!stylesConnected || !findStyleInNode(statementPath, internal)) {
-                meshStatement(statementPath, internal);
+            else if (!stylesConnected || !(0, css_transformer_js_1.findStyleInNode)(statementPath, internal)) {
+                (0, mesh_js_1.meshStatement)(statementPath, internal);
             }
         }
     }

package/lib-node/call.js

@@ -71,10 +71,10 @@ function calls(node, names, internal) {
                 if (requiresContextSet.has(callee.name) && t.isCallExpression(node)) {
                     node.arguments.unshift(internal_js_1.ctx);
                 }
-                if (mapped === "state") {
+                if (mapped === "store") {
                     internal.stateOnly = true;
                 }
-                if (mapped === "compose" || mapped === "extend") {
+                if (mapped === "compose") {
                     internal.stateOnly = false;
                 }
                 return mapped;

package/lib-node/mesh.js

@@ -80,9 +80,6 @@ function meshComposeCall(call, name, nodePath, internal) {
     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) {
     for (const path of paths) {
@@ -110,7 +107,7 @@ function meshExpression(nodePath, internal, isRoot) {
     if (!expr) {
         return;
     }
-    if ((0, call_js_1.calls)(expr, ["compose", "extend", "state"], internal)) {
+    if ((0, call_js_1.calls)(expr, ["compose", "store"], internal)) {
         meshComposeCall(expr, null, nodePath, internal);
         return;
     }
@@ -499,7 +496,7 @@ function meshStatement(path, internal) {
             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", "extend", "state"], internal)) {
+                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);
                 }
                 else {

package/lib-node/transformer.js

@@ -57,7 +57,6 @@ const ignoreMembers = new Set([
     "laptop",
     "prefersDark",
     "prefersLight",
-    "state",
 ]);
 function extractText(node) {
     // no case found for string literal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-vasille",
-  "version": "3.1.1",
+  "version": "3.1.5",
   "description": "Convert Vasille Meta Language code to pure JavaScript",
   "main": "lib-node/index.js",
   "type": "commonjs",
@@ -50,7 +50,7 @@
     "typescript": "^5.8.3",
     "vasille": "^3.1.0",
     "vasille-css": "^3.1.0",
-    "vasille-dx": "^3.1.0",
-    "vasille-web": "^3.1.0"
+    "vasille-dx": "^3.1.3",
+    "vasille-web": "^3.1.5"
   }
 }