babel-plugin-vasille 5.1.2 → 5.1.3

package/lib/expression.js

@@ -54,6 +54,7 @@ const lib_1 = require("./lib");
 const mesh_1 = require("./mesh");
 const router_1 = require("./router");
 const utils_1 = require("./utils");
+const operators_1 = require("./operators");
 function insertName(name, search) {
     const id = t.identifier(name);
     search?.inserted.add(id);
@@ -69,7 +70,8 @@ function addExpression(path, search) {
         let it = path.node;
         while (t.isMemberExpression(it) || t.isIdentifier(it)) {
             const name = (0, utils_1.stringify)(t.isMemberExpression(it) ? it.property : it);
-            if (it !== path.node && name.startsWith("$")) {
+            const computed = t.isMemberExpression(it) ? it.computed : false;
+            if (it !== path.node && name.startsWith("$") && !computed) {
                 (0, lib_1.err)(lib_1.Errors.RulesOfVasille, path, "The reactive/observable value is nested", search.external, null);
             }
             it = t.isMemberExpression(it) ? it.object : null;
@@ -95,10 +97,11 @@ function meshIdentifier(path) {
 }
 function idIsIValue(path) {
     const node = path.node;
-    return node.name.startsWith("$") && (!t.isMemberExpression(path.parent) || path.parent.object === node);
+    return (node.name.startsWith("$") &&
+        (!(t.isMemberExpression(path.parent) && !path.parent.computed) || path.parent.object === node));
 }
 function memberIsIValue(node) {
-    return ((t.isIdentifier(node.property) && node.property.name.startsWith("$")) ||
+    return ((t.isIdentifier(node.property) && node.property.name.startsWith("$") && !node.computed) ||
         (t.isStringLiteral(node.property) && node.property.value.startsWith("$")));
 }
 function memberIsIValueInExpr(path, search) {
@@ -191,6 +194,9 @@ function checkNode(path, internal, area, name) {
         path.replaceWith((0, lib_1.ref)(refValue, internal, area, name));
         search.self = path.node;
     }
+    if (path.isTSAsExpression() || path.isTSSatisfiesExpression()) {
+        return checkNode(path.get("expression"), internal, area, name);
+    }
     if (search.self) {
         return search;
     }
@@ -302,13 +308,7 @@ function checkExpression(nodePath, search) {
             const left = path.get("left");
             const right = path.get("right");
             if (left.isMemberExpression() && !exprIsSure(left, search.external)) {
-                const property = left.node.property;
-                (0, mesh_1.meshExpression)(left.get("object"), search.external);
-                checkExpression(right, search);
-                /* istanbul ignore else */
-                if (!t.isPrivateName(property)) {
-                    path.replaceWith(search.external.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, right.node, path.node));
-                }
+                (0, operators_1.meshAssigment)(path, left, right, left.node.property, search.external);
             }
             else {
                 meshLValue(left, search.external);

package/lib/jsx.js

@@ -48,18 +48,21 @@ function transformJsx(path, conditions, internal) {
     }
     return transformJsxArray(path.get("children"), internal);
 }
+function textIsSpacesOnly(node) {
+    return t.isJSXText(node) && /^\s+$/.test(node.value) && node.value !== " ";
+}
 function transformJsxArray(paths, internal) {
     const result = [];
     const conditions = { cases: null };
     paths.forEach(path => {
-        if (!path.isJSXElement() && !(path.isJSXText() && /^\s+$/.test(path.node.value))) {
+        if (!path.isJSXElement() && !textIsSpacesOnly(path.node)) {
             result.push(...processConditions(conditions, internal));
         }
         if (path.isJSXElement() || path.isJSXFragment()) {
             result.push(...transformJsx(path, conditions, internal));
         }
         else if (path.isJSXText()) {
-            if (!/^\s+$/.test(path.node.value)) {
+            if (!textIsSpacesOnly(path.node)) {
                 const fixed = path.node.value
                     .replace(/\n\s+$/m, "")
                     .replace(/^\s*\n\s+/m, "")
@@ -561,26 +564,16 @@ function transformJsxElement(path, conditions, internal) {
             if (!t.isJSXText(item)) {
                 return true;
             }
-            return !!item.value.trim();
+            return !textIsSpacesOnly(item);
         });
         const isInternal = internal.mapping.has(name.name);
-        // The child is a slot value
-        if (filteredChildren.length === 1 &&
-            t.isJSXExpressionContainer(filteredChildren[0]) &&
-            (t.isFunctionExpression(filteredChildren[0].expression) ||
-                t.isArrowFunctionExpression(filteredChildren[0].expression))) {
-            transformJsxExpressionContainer(path.get("children")[element.children.indexOf(filteredChildren[0])], internal, true, isInternal, false, true);
-            run = filteredChildren[0].expression;
-        }
-        else {
-            const statements = transformJsxArray(path.get("children"), internal);
-            if (statements.length > 0) {
-                const params = [internal_js_1.ctx];
-                if (!isInternal) {
-                    params.unshift(t.identifier(`_${internal.prefix}`));
-                }
-                run = t.arrowFunctionExpression(params, t.blockStatement(statements));
+        const statements = transformJsxArray(path.get("children"), internal);
+        if (statements.length > 0) {
+            const params = [internal_js_1.ctx];
+            if (!isInternal) {
+                params.unshift(t.identifier(`_${internal.prefix}`));
             }
+            run = t.arrowFunctionExpression(params, t.blockStatement(statements));
         }
         const ret = [];
         const filter = (v) => {

package/lib/lib.js

@@ -112,6 +112,9 @@ function bindCall(path, expr, data, internal, name) {
     return false;
 }
 function exprCall(path, expr, internal, opts, area) {
+    if (path.isTSAsExpression() || path.isTSSatisfiesExpression()) {
+        return exprCall(path.get("expression"), path.node.expression, internal, opts, area);
+    }
     if (parseCalculateCall(path, internal, area, opts.name)) {
         return true;
     }

package/lib/mesh.js

@@ -61,6 +61,7 @@ const router_1 = require("./router");
 const utils_1 = require("./utils");
 const transformer_1 = require("./transformer");
 const process_types_1 = require("./process-types");
+const operators_1 = require("./operators");
 function meshOrIgnoreAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
         /* istanbul ignore else */
@@ -285,12 +286,7 @@ function meshExpression(nodePath, internal) {
                     property.name[0] === "$" &&
                     t.isThisExpression(left.node.object) &&
                     ((right.isIdentifier() && (0, expression_js_1.idIsIValue)(right)) || (right.isMemberExpression() && (0, expression_js_1.memberIsIValue)(right.node))))) {
-                    meshExpression(left.get("object"), internal);
-                    meshExpression(right, internal);
-                    /* istanbul ignore else */
-                    if (!t.isPrivateName(property)) {
-                        path.replaceWith(internal.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, right.node, path.node));
-                    }
+                    (0, operators_1.meshAssigment)(path, left, right, property, internal);
                 }
             }
             else if (internal.devLayer &&
@@ -309,9 +305,10 @@ function meshExpression(nodePath, internal) {
             const path = nodePath;
             const node = path.node;
             const property = path.node.property;
+            const propertyPath = path.get("property");
             meshExpression(path.get("object"), internal);
-            if (t.isExpression(property) && !t.isIdentifier(property)) {
-                meshOrIgnoreExpression(path.get("property"), internal);
+            if (t.isExpression(property) && (!propertyPath.isIdentifier() || (node.computed && (0, expression_js_1.idIsIValue)(propertyPath)))) {
+                meshOrIgnoreExpression(propertyPath, internal);
             }
             if ((0, expression_js_1.memberIsIValue)(node)) {
                 if (!(0, expression_js_1.nodeIsMeshed)(path)) {
@@ -1113,6 +1110,15 @@ function composeStatement(path, internal) {
                     }
                     meshInit = false;
                 }
+                else if ((0, call_js_1.calls)(declaration.get("init"), call_js_1.dependencyInjections, internal)) {
+                    const callPath = declaration.get("init");
+                    callPath.node.arguments.unshift(internal_js_1.ctx);
+                    meshAllUnknown(callPath.get("arguments"), internal);
+                    meshInit = false;
+                    if (t.isIdentifier(id)) {
+                        (0, lib_js_1.checkNonReactiveName)(declaration.get("id"), internal);
+                    }
+                }
                 else if (t.isIdentifier(id)) {
                     const idPath = declaration.get("id");
                     internal.stack.set(id.name, {});
@@ -1187,7 +1193,8 @@ function composeStatement(path, internal) {
                     else if (kind === "const" &&
                         (initPath.isOptionalMemberExpression() || initPath.isMemberExpression()) &&
                         initPath.node.computed &&
-                        t.isIdentifier(initPath.node.property)) {
+                        t.isIdentifier(initPath.node.property) &&
+                        !(0, expression_js_1.idIsIValue)(initPath.get("property"))) {
                         const path = initPath;
                         const property = path.get("property");
                         meshExpression(path.get("object"), internal);

package/lib/operators.js

@@ -0,0 +1,90 @@
+"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.assignmentToBinaryOperator = assignmentToBinaryOperator;
+exports.assignmentToLogicalOperator = assignmentToLogicalOperator;
+exports.meshAssigment = meshAssigment;
+const internal_1 = require("./internal");
+const mesh_1 = require("./mesh");
+const t = __importStar(require("@babel/types"));
+const assigmentToBinaryMap = {
+    "+=": "+",
+    "-=": "-",
+    "/=": "/",
+    "%=": "%",
+    "*=": "*",
+    "**=": "**",
+    "&=": "&",
+    "|=": "|",
+    ">>=": ">>",
+    ">>>=": ">>>",
+    "<<=": "<<",
+    "^=": "^",
+};
+const assigmentToLogicalMap = {
+    "&&=": "&&",
+    "||=": "||",
+    "??=": "??",
+};
+function assignmentToBinaryOperator(operator) {
+    if (operator in assigmentToBinaryMap) {
+        return assigmentToBinaryMap[operator];
+    }
+}
+function assignmentToLogicalOperator(operator) {
+    if (operator in assigmentToLogicalMap) {
+        return assigmentToLogicalMap[operator];
+    }
+}
+function meshAssigment(path, left, right, property, internal) {
+    const binary = assignmentToBinaryOperator(path.node.operator);
+    const logical = assignmentToLogicalOperator(path.node.operator);
+    (0, mesh_1.meshExpression)(left.get("object"), internal);
+    (0, mesh_1.meshExpression)(right, internal);
+    /* istanbul ignore else */
+    if (!t.isPrivateName(property)) {
+        let replaceWith = right.node;
+        if (logical || binary) {
+            const meshedLeft = t.optionalMemberExpression(left.node, internal_1.V, false, true);
+            if (binary) {
+                replaceWith = t.binaryExpression(binary, meshedLeft, right.node);
+            }
+            if (logical) {
+                replaceWith = t.logicalExpression(logical, meshedLeft, right.node);
+            }
+        }
+        path.replaceWith(internal.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, replaceWith, path.node));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-vasille",
-  "version": "5.1.2",
+  "version": "5.1.3",
   "description": "Convert Vasille Meta Language code to pure JavaScript",
   "main": "lib/index.js",
   "type": "commonjs",
@@ -41,7 +41,7 @@
     "@types/babel__core": "^7.20.5",
     "@types/jest": "^30.0.0",
     "@types/jsdom": "^21.1.7",
-    "@types/node": "^24.2.1",
+    "@types/node": "^25.6.0",
     "cross-env": "^10.0.0",
     "jest": "^30.0.5",
     "jsdom": "^26.1.0",

package/types/operators.d.ts

@@ -0,0 +1,25 @@
+import { NodePath, types } from "@babel/core";
+import { Internal } from "./internal";
+declare const assigmentToBinaryMap: {
+    readonly "+=": "+";
+    readonly "-=": "-";
+    readonly "/=": "/";
+    readonly "%=": "%";
+    readonly "*=": "*";
+    readonly "**=": "**";
+    readonly "&=": "&";
+    readonly "|=": "|";
+    readonly ">>=": ">>";
+    readonly ">>>=": ">>>";
+    readonly "<<=": "<<";
+    readonly "^=": "^";
+};
+declare const assigmentToLogicalMap: {
+    readonly "&&=": "&&";
+    readonly "||=": "||";
+    readonly "??=": "??";
+};
+export declare function assignmentToBinaryOperator(operator: string): (typeof assigmentToBinaryMap)[keyof typeof assigmentToBinaryMap] | undefined;
+export declare function assignmentToLogicalOperator(operator: string): (typeof assigmentToLogicalMap)[keyof typeof assigmentToLogicalMap] | undefined;
+export declare function meshAssigment(path: NodePath<types.AssignmentExpression>, left: NodePath<types.MemberExpression>, right: NodePath<types.Expression>, property: types.PrivateName | types.Expression, internal: Internal): void;
+export {};