babel-plugin-vasille 3.1.5 → 4.0.0

package/lib/expression.js

@@ -35,9 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeName = encodeName;
 exports.idIsIValue = idIsIValue;
-exports.idIsLocal = idIsLocal;
 exports.memberIsIValue = memberIsIValue;
-exports.nodeIsReactiveObject = nodeIsReactiveObject;
+exports.exprIsSure = exprIsSure;
 exports.checkNode = checkNode;
 exports.checkOrIgnoreAllExpressions = checkOrIgnoreAllExpressions;
 exports.checkAllExpressions = checkAllExpressions;
@@ -49,120 +48,107 @@ exports.checkStatement = checkStatement;
 exports.checkFunction = checkFunction;
 const t = __importStar(require("@babel/types"));
 const call_js_1 = require("./call.js");
-const internal_js_1 = require("./internal.js");
+const lib_1 = require("./lib");
+const mesh_1 = require("./mesh");
+const router_1 = require("./router");
+const utils_1 = require("./utils");
 function encodeName(name) {
-    return t.identifier(`Vasille_${name}`);
+    return insertName(name);
+}
+function insertName(name, search) {
+    const id = t.identifier(`Vasille_${name}`);
+    search?.inserted.add(id);
+    return id;
 }
 function addIdentifier(path, search) {
-    if (!search.found.has(path.node.name)) {
-        search.found.set(path.node.name, path.node);
+    const name = unprefixedName(path.node.name);
+    if (!search.found.has(name)) {
+        search.found.set(name, path.node);
     }
-    path.replaceWith(encodeName(path.node.name));
+    path.replaceWith(insertName(name, search));
 }
-function stringify(node) {
-    let name = "";
-    if (t.isStringLiteral(node)) {
-        name = node.value;
-    }
-    if (t.isPrivateName(node)) {
-        name = node.id.name;
-    }
-    if (t.isIdentifier(node)) {
-        name = node.name;
-    }
-    return name;
+function unprefixedName(name) {
+    return name[0] === "$" ? name.slice(1) : name;
 }
 function extractMemberName(path, search) {
     const names = [];
     let it = path.node;
     while (t.isMemberExpression(it)) {
-        const name = stringify(it.property);
-        if (name === "$" && it !== path.node) {
-            throw path.buildCodeFrameError("Vasille: The reactive/observable value is nested");
-        }
+        names.push((0, utils_1.stringify)(it.property));
         it = it.object;
-        names.push(name);
     }
-    names.push(stringify(it));
-    if (t.isIdentifier(it) &&
-        search.stack.get(it.name, internal_js_1.VariableScope.Local) === 1 /* VariableState.Ignored */) {
-        throw path.buildCodeFrameError("Vasille: This node cannot be processed, the root of expression is a local variable");
+    names.push((0, utils_1.stringify)(it));
+    if (names.filter(name => name.startsWith("$")).length > 1) {
+        (0, lib_1.err)(lib_1.Errors.RulesOfVasille, path, "The reactive/observable value is nested", search.external, null);
     }
-    return names.reverse().join("_");
+    return names.reverse().map(unprefixedName).join("_");
 }
 function addMemberExpr(path, search) {
     const name = extractMemberName(path, search);
+    /* istanbul ignore else */
     if (!search.found.has(name)) {
         search.found.set(name, path.node);
     }
-    path.replaceWith(encodeName(name));
+    path.replaceWith(insertName(name, search));
 }
-function addExternalIValue(path, search) {
-    const name = extractMemberName(path, search);
-    if (!search.found.has(name)) {
-        search.found.set(name, path.node.object);
-    }
-    path.replaceWith(encodeName(name));
-}
-function meshIdentifier(path, internal) {
-    if (idIsIValue(path, internal)) {
-        path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
+function meshIdentifier(path) {
+    if (idIsIValue(path)) {
+        path.replaceWith(t.memberExpression(path.node, t.identifier("V")));
     }
 }
-function idIsIValue(path, internal, scope) {
+function idIsIValue(path) {
     const node = path.node;
-    return (REACTIVE_STATES.includes(internal.stack.get(node.name, scope)) &&
-        (!t.isMemberExpression(path.parent) || path.parent.object === node));
-}
-function idIsLocal(path, internal) {
-    return internal.stack.get(path.node.name, internal_js_1.VariableScope.Local) !== undefined;
+    return node.name.startsWith("$") && (!t.isMemberExpression(path.parent) || path.parent.object === node);
 }
-function memberIsIValue(node, internal, scope) {
-    return ((t.isIdentifier(node.object) &&
-        (internal.stack.get(node.object.name, scope) === 3 /* VariableState.ReactiveObject */ ||
-            (t.isIdentifier(node.property) &&
-                node.property.name.startsWith("$") &&
-                !node.property.name.startsWith("$$") &&
-                node.property.name !== "$") ||
-            (t.isStringLiteral(node.property) &&
-                node.property.value.startsWith("$") &&
-                !node.property.value.startsWith("$$") &&
-                node.property.value !== "$"))) ||
-        (t.isMemberExpression(node.object) &&
-            ((t.isIdentifier(node.object.property) && node.object.property.name.startsWith("$$")) ||
-                (t.isStringLiteral(node.object.property) && node.object.property.value.startsWith("$$")))));
+function memberIsIValue(node) {
+    return ((t.isIdentifier(node.property) && node.property.name.startsWith("$")) ||
+        (t.isStringLiteral(node.property) && node.property.value.startsWith("$")));
 }
-function nodeIsReactiveObject(path, internal) {
-    const node = path.node;
-    if (t.isIdentifier(node)) {
-        return internal.stack.get(node.name) === 3 /* VariableState.ReactiveObject */;
+function exprIsSure(path, internal) {
+    if (path.isMemberExpression() &&
+        path.node.computed &&
+        (!t.isStringLiteral(path.node.property) || /^\d+$/.test(path.node.property.value))) {
+        return false;
     }
-    if (t.isOptionalMemberExpression(node) || t.isMemberExpression(node)) {
-        return ((t.isIdentifier(node.property) && node.property.name.startsWith("$$")) ||
-            (t.isStringLiteral(node.property) && node.property.value.startsWith("$$")));
+    if (!path.isMemberExpression() || !(0, utils_1.stringify)(path.node.property).startsWith("$")) {
+        return true;
     }
+    let it = path.node;
+    let names = [];
+    while (t.isMemberExpression(it) || t.isOptionalMemberExpression(it)) {
+        names.push((0, utils_1.stringify)(it.property));
+        it = it.object;
+    }
+    const reactivityData = t.isIdentifier(it) && internal.stack.get(it.name);
+    const propPath = names.reverse().join(".");
+    return (reactivityData && reactivityData[propPath]) || t.isMemberExpression(path.parent);
 }
-function meshMember(path, internal) {
-    if (memberIsIValue(path.node, internal)) {
-        path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
+function meshMember(path) {
+    if (memberIsIValue(path.node)) {
+        path.replaceWith(t.memberExpression(path.node, t.identifier("V"), false, true));
     }
 }
 function meshLValue(path, internal) {
-    const node = path.node;
-    if (t.isIdentifier(node)) {
-        meshIdentifier(path, internal);
+    /* istanbul ignore else */
+    if (path.isIdentifier()) {
+        meshIdentifier(path);
     }
-    else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        meshMember(path, internal);
+    else if (path.isMemberExpression() || path.isOptionalMemberExpression()) {
+        const object = path.get("object");
+        meshMember(path);
+        if (object.isLVal()) {
+            meshLValue(object, internal);
+        }
     }
-    else if (t.isArrayPattern(node)) {
+    else if (path.isArrayPattern()) {
         for (const item of path.get("elements")) {
-            if (t.isOptionalMemberExpression(item.node) || t.isLVal(item.node)) {
+            /* istanbul ignore else */
+            if (item.isOptionalMemberExpression() || item.isLVal()) {
                 meshLValue(item, internal);
             }
         }
     }
-    else if (t.isRestElement(node)) {
+    else if (path.isRestElement()) {
         meshLValue(path.get("argument"), internal);
     }
 }
@@ -171,36 +157,38 @@ function checkNode(path, internal) {
         external: internal,
         found: new Map(),
         self: null,
+        inserted: new Set(),
         stack: internal.stack,
     };
-    if (t.isIdentifier(path.node)) {
-        if (idIsIValue(path, internal)) {
+    if (path.isIdentifier()) {
+        if (idIsIValue(path)) {
             search.self = path.node;
         }
     }
-    if (t.isMemberExpression(path.node)) {
-        if (memberIsIValue(path.node, internal)) {
+    if (path.isMemberExpression()) {
+        if (memberIsIValue(path.node)) {
             search.self = path.node;
         }
-        else if (t.isIdentifier(path.node.property) && path.node.property.name === "$") {
-            search.self = path.node.object;
-        }
+    }
+    if (path.isExpression() && (0, call_js_1.calls)(path, ["ref"], internal)) {
+        (0, mesh_1.meshAllUnknown)(path.get("arguments"), internal);
+        search.self = path.node;
     }
     if (search.self) {
         return search;
     }
-    internal.stack.fixLocalIndex();
     internal.stack.push();
-    if (t.isExpression(path.node)) {
+    /* istanbul ignore else */
+    if (path.isExpression()) {
         checkExpression(path, search);
     }
     internal.stack.pop();
-    internal.stack.resetLocalIndex();
     return search;
 }
 function checkOrIgnoreAllExpressions(nodePaths, search) {
     for (const path of nodePaths) {
-        if (t.isExpression(path.node)) {
+        /* istanbul ignore else */
+        if (path.isExpression()) {
             checkExpression(path, search);
         }
     }
@@ -212,20 +200,21 @@ function checkAllExpressions(nodePaths, search) {
 }
 function checkAllUnknown(paths, internal) {
     for (const path of paths) {
-        if (t.isSpreadElement(path.node)) {
+        /* istanbul ignore else */
+        if (path.isSpreadElement()) {
             checkExpression(path.get("argument"), internal);
         }
-        else if (t.isExpression(path.node)) {
+        else if (path.isExpression()) {
             checkExpression(path, internal);
         }
     }
 }
 function checkOrIgnoreExpression(path, search) {
-    if (t.isExpression(path.node)) {
+    /* istanbul ignore else */
+    if (path.isExpression()) {
         checkExpression(path, search);
     }
 }
-const REACTIVE_STATES = [2 /* VariableState.Reactive */, 4 /* VariableState.ReactivePointer */];
 function checkExpression(nodePath, search) {
     const expr = nodePath.node;
     switch (expr && expr.type) {
@@ -241,9 +230,9 @@ function checkExpression(nodePath, search) {
             break;
         }
         case "Identifier": {
-            if (expr && t.isIdentifier(expr)) {
-                if (idIsIValue(nodePath, search.external, internal_js_1.VariableScope.Global) &&
-                    !idIsLocal(nodePath, search.external)) {
+            /* istanbul ignore else */
+            if (expr && nodePath.isIdentifier()) {
+                if (idIsIValue(nodePath)) {
                     addIdentifier(nodePath, search);
                 }
             }
@@ -256,11 +245,21 @@ function checkExpression(nodePath, search) {
         }
         case "CallExpression": {
             const path = nodePath;
-            if ((0, call_js_1.calls)(path.node, call_js_1.composeOnly, search.external)) {
-                throw path.buildCodeFrameError("Vasille: Usage of hints is restricted here");
+            if ((0, call_js_1.calls)(path, ["router"], search.external)) {
+                if (!search.external.stateOnly) {
+                    (0, router_1.routerReplace)(path);
+                }
+                else {
+                    (0, lib_1.err)(lib_1.Errors.IncompatibleContext, path, "The router is not available in stores", search.external, null);
+                }
+            }
+            else {
+                if ((0, call_js_1.calls)(path, call_js_1.hintFunctions, search.external)) {
+                    (0, lib_1.err)(lib_1.Errors.IncompatibleContext, path, "Usage of hints is restricted here", search.external, null);
+                }
+                checkOrIgnoreExpression(path.get("callee"), search);
+                checkAllUnknown(path.get("arguments"), search);
             }
-            checkOrIgnoreExpression(path.get("callee"), search);
-            checkAllUnknown(path.get("arguments"), search);
             break;
         }
         case "OptionalCallExpression": {
@@ -271,20 +270,30 @@ function checkExpression(nodePath, search) {
         }
         case "AssignmentExpression": {
             const path = nodePath;
-            meshLValue(path.get("left"), search.external);
-            checkExpression(path.get("right"), 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, property, right.node));
+                }
+            }
+            else {
+                meshLValue(left, search.external);
+                checkExpression(right, search);
+            }
             break;
         }
         case "MemberExpression":
         case "OptionalMemberExpression": {
             const path = nodePath;
             const node = path.node;
-            if (memberIsIValue(node, search.external, internal_js_1.VariableScope.Global)) {
+            if (memberIsIValue(node)) {
                 addMemberExpr(path, search);
             }
-            else if (t.isIdentifier(node.property) && node.property.name === "$") {
-                addExternalIValue(path, search);
-            }
             else {
                 checkExpression(path.get("object"), search);
                 checkOrIgnoreExpression(path.get("property"), search);
@@ -329,6 +338,7 @@ function checkExpression(nodePath, search) {
         case "UpdateExpression": {
             const path = nodePath;
             const arg = path.node.argument;
+            /* istanbul ignore else */
             if (t.isLVal(arg)) {
                 meshLValue(path.get("argument"), search.external);
             }
@@ -394,10 +404,12 @@ function checkExpression(nodePath, search) {
             break;
         }
         case "JSXFragment": {
-            throw nodePath.buildCodeFrameError("Vasille: JSX fragment is not allowed here");
+            (0, lib_1.err)(lib_1.Errors.IncompatibleContext, nodePath, "JSX fragment is not allowed here", search.external, null);
+            break;
         }
         case "JSXElement": {
-            throw nodePath.buildCodeFrameError("Vasille: JSX element is not allowed here");
+            (0, lib_1.err)(lib_1.Errors.IncompatibleContext, nodePath, "JSX element is not allowed here", search.external, null);
+            break;
         }
     }
 }
@@ -406,36 +418,15 @@ function checkStatements(paths, search) {
         checkStatement(path, search);
     }
 }
-function ignoreLocals(val, search) {
-    if (t.isIdentifier(val)) {
-        search.stack.set(val.name, 1 /* VariableState.Ignored */);
-    }
-    else if (t.isObjectPattern(val)) {
-        for (const prop of val.properties) {
-            if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
-                search.stack.set(prop.value.name, 1 /* VariableState.Ignored */);
-            }
-            else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
-                search.stack.set(prop.argument.name, 1 /* VariableState.Ignored */);
-            }
-            else if (t.isObjectProperty(prop) && t.isAssignmentPattern(prop.value)) {
-                ignoreLocals(prop.value.left, search);
-            }
-        }
-    }
-    else if (t.isArrayPattern(val)) {
-        for (const element of val.elements) {
-            if (element && !t.isVoidPattern(element)) {
-                ignoreLocals(element, search);
-            }
+function ignoreLocals(path, search) {
+    const val = path.node;
+    if (t.isVariableDeclaration(val)) {
+        for (const declarator of path.get("declarations")) {
+            (0, mesh_1.ignoreParams)(declarator.get("id"), search.external, ["id", "array"]);
         }
     }
-    else if (t.isVariableDeclaration(val)) {
-        for (const declarator of val.declarations) {
-            if (!t.isVoidPattern(declarator.id)) {
-                ignoreLocals(declarator.id, search);
-            }
-        }
+    else {
+        (0, mesh_1.ignoreParams)(path, search.external, ["id", "array"]);
     }
 }
 function checkStatement(path, search) {
@@ -462,7 +453,7 @@ function checkStatement(path, search) {
             break;
         case "ForInStatement": {
             const _path = path;
-            ignoreLocals(_path.node.left, search);
+            ignoreLocals(_path.get("left"), search);
             checkExpression(_path.get("right"), search);
             checkStatement(_path.get("body"), search);
             break;
@@ -478,6 +469,7 @@ function checkStatement(path, search) {
         case "ForStatement": {
             const _path = path;
             const node = _path.node;
+            /* istanbul ignore else */
             if (node.init) {
                 if (t.isExpression(node.init)) {
                     checkExpression(_path.get("init"), search);
@@ -535,6 +527,7 @@ function checkStatement(path, search) {
         case "TryStatement":
             const handlerPath = path.get("handler");
             checkStatement(path.get("block"), search);
+            /* istanbul ignore else */
             if (handlerPath.node) {
                 checkStatement(handlerPath.get("body"), search);
             }
@@ -543,7 +536,7 @@ function checkStatement(path, search) {
         case "VariableDeclaration": {
             const _path = path;
             for (const declaration of _path.get("declarations")) {
-                ignoreLocals(declaration.node.id, search);
+                ignoreLocals(declaration.get("id"), search);
                 checkExpression(declaration.get("init"), search);
             }
             break;
@@ -560,9 +553,21 @@ function checkStatement(path, search) {
 }
 function checkFunction(path, search) {
     const node = path.node;
-    for (const param of node.params) {
+    for (const param of path.get("params")) {
         ignoreLocals(param, search);
     }
+    if (path.isFunctionDeclaration() && path.node.id) {
+        const idPath = path.get("id");
+        /* istanbul ignore else */
+        if (idPath.isIdentifier()) {
+            search.stack.set(idPath.node.name, {});
+            (0, lib_1.checkNonReactiveName)(idPath, search.external);
+        }
+    }
+    if (t.isFunctionExpression(node) && node.id) {
+        search.stack.push();
+        search.stack.set(node.id.name, {});
+    }
     if (t.isExpression(node.body)) {
         checkExpression(path.get("body"), search);
     }
@@ -570,4 +575,7 @@ function checkFunction(path, search) {
         const bodyPath = path.get("body");
         checkStatement(bodyPath, search);
     }
+    if (t.isFunctionExpression(node) && node.id) {
+        search.stack.pop();
+    }
 }

package/lib/index.js

@@ -7,7 +7,10 @@ function default_1() {
         name: "Vasille",
         visitor: {
             Program(path, params) {
-                (0, transformer_js_1.trProgram)(path, params.opts.devMode !== false);
+                (0, transformer_js_1.transformProgram)(path, params.file.opts.filename, {
+                    devMode: params.opts.devMode !== false,
+                    strictFolders: params.opts.strictFolders !== false,
+                });
             },
         },
     };

package/lib/internal.js

@@ -33,36 +33,21 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ctx = exports.StackedStates = exports.VariableScope = void 0;
+exports.ctx = exports.StackedStates = void 0;
 const t = __importStar(require("@babel/types"));
-var VariableScope;
-(function (VariableScope) {
-    VariableScope[VariableScope["Any"] = 0] = "Any";
-    VariableScope[VariableScope["Local"] = 1] = "Local";
-    VariableScope[VariableScope["Global"] = 2] = "Global";
-})(VariableScope || (exports.VariableScope = VariableScope = {}));
 class StackedStates {
+    maps = [];
     constructor() {
-        this.maps = [];
-        this.localIndex = -1;
         this.push();
     }
-    fixLocalIndex() {
-        this.localIndex = this.maps.length;
-    }
-    resetLocalIndex() {
-        this.localIndex = -1;
-    }
     push() {
         this.maps.push(new Map());
     }
     pop() {
         this.maps.pop();
     }
-    get(name, scope) {
-        for (let i = (this.localIndex === -1 || scope !== VariableScope.Global
-            ? this.maps.length
-            : Math.min(this.maps.length, this.localIndex)) - 1; i >= (this.localIndex === -1 || scope !== VariableScope.Local ? 0 : this.localIndex); i--) {
+    get(name) {
+        for (let i = this.maps.length - 1; i >= 0; i--) {
             if (this.maps[i].has(name)) {
                 return this.maps[i].get(name);
             }

package/lib/jsx-detect.js

@@ -34,67 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exprHasJsx = exprHasJsx;
-exports.statementHasJsx = statementHasJsx;
 exports.bodyHasJsx = bodyHasJsx;
 const t = __importStar(require("@babel/types"));
 function exprHasJsx(node) {
-    if (t.isBinaryExpression(node)) {
-        return (t.isExpression(node.left) && exprHasJsx(node.left)) || exprHasJsx(node.right);
-    }
-    if (t.isConditionalExpression(node)) {
-        return exprHasJsx(node.consequent) || exprHasJsx(node.alternate);
-    }
-    if (t.isLogicalExpression(node)) {
-        return exprHasJsx(node.left) || exprHasJsx(node.right);
-    }
     return t.isJSXElement(node) || t.isJSXFragment(node);
 }
-function statementHasJsx(statement) {
-    if (t.isExpressionStatement(statement)) {
-        return exprHasJsx(statement.expression);
-    }
-    if (t.isBlockStatement(statement)) {
-        return bodyHasJsx(statement);
-    }
-    if (t.isDoWhileStatement(statement)) {
-        return statementHasJsx(statement.body);
-    }
-    if (t.isForInStatement(statement)) {
-        return statementHasJsx(statement.body);
-    }
-    if (t.isSwitchStatement(statement)) {
-        return statement.cases.some(_case => {
-            return _case.consequent.some(statementHasJsx);
-        });
-    }
-    if (t.isWhileStatement(statement)) {
-        return statementHasJsx(statement.body);
-    }
-    if (t.isForOfStatement(statement)) {
-        return statementHasJsx(statement.body);
-    }
-    if (t.isLabeledStatement(statement)) {
-        return statementHasJsx(statement.body);
-    }
-    if (t.isReturnStatement(statement)) {
-        return !!statement.argument && exprHasJsx(statement.argument);
-    }
-    if (t.isTryStatement(statement)) {
-        return (statementHasJsx(statement.block) ||
-            (!!statement.handler && statementHasJsx(statement.handler.body)) ||
-            (!!statement.finalizer && statementHasJsx(statement.finalizer)));
-    }
-    if (t.isIfStatement(statement)) {
-        return statementHasJsx(statement.consequent) || (!!statement.alternate && statementHasJsx(statement.alternate));
-    }
-    if (t.isForStatement(statement)) {
-        return statementHasJsx(statement.body);
-    }
-    return false;
-}
 function bodyHasJsx(node) {
     if (t.isExpression(node)) {
         return exprHasJsx(node);
     }
-    return node.body.some(statementHasJsx);
+    return node.body.some(statement => {
+        return t.isExpressionStatement(statement) && exprHasJsx(statement.expression);
+    });
 }