babel-plugin-vasille 4.3.3 → 5.0.0

package/lib/mesh.js

@@ -59,6 +59,7 @@ const lib_js_1 = require("./lib.js");
 const order_check_1 = require("./order-check");
 const router_1 = require("./router");
 const utils_1 = require("./utils");
+const transformer_1 = require("./transformer");
 function meshOrIgnoreAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
         /* istanbul ignore else */
@@ -80,8 +81,8 @@ function meshComposeCall(name, path, internal) {
     }
     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 : "#"));
+    if (internal.devLayer && path.isCallExpression()) {
+        path.node.arguments.push((0, transformer_1.nodeToStaticPosition)(path.node), t.stringLiteral(name ? name : "#"));
     }
 }
 function meshAllUnknown(paths, internal) {
@@ -166,7 +167,18 @@ function meshExpression(nodePath, internal) {
                 if (argPath) {
                     meshAllUnknown([argPath], internal);
                 }
-                path.node.arguments.unshift(t.nullLiteral());
+                const loc = path.node.loc;
+                /* istanbul ignore else */
+                if ((0, call_js_1.calls)(path, ["arrayModel"], internal)) {
+                    path.replaceWith(internal.arrayModel(argPath?.node, path.node, undefined));
+                }
+                else if ((0, call_js_1.calls)(path, ["mapModel"], internal)) {
+                    path.replaceWith(internal.mapModel(argPath?.node, path.node, undefined));
+                }
+                else if ((0, call_js_1.calls)(path, ["setModel"], internal)) {
+                    path.replaceWith(internal.setModel(argPath?.node, path.node, undefined));
+                }
+                path.node.loc = loc;
             }
             // router call
             else if (internal.isComposing && (0, call_js_1.calls)(path, ["router"], internal)) {
@@ -179,7 +191,7 @@ function meshExpression(nodePath, internal) {
             }
             // watch call
             else if ((0, call_js_1.calls)(path, ["watch"], internal)) {
-                (0, lib_js_1.processCalculateCall)(path, internal);
+                (0, lib_js_1.processCalculateCall)(path, internal, path.node, undefined);
             }
             else if (path.isCallExpression() &&
                 t.isIdentifier(path.node.callee) &&
@@ -189,7 +201,14 @@ function meshExpression(nodePath, internal) {
                 }
                 path.node.arguments.unshift(internal_js_1.ctx);
             }
-            // call any other function, invalid if code calls a hint
+            // dependency injection
+            else if (internal.isComposing &&
+                !internal.stateOnly &&
+                (0, call_js_1.calls)(path, call_js_1.dependencyInjections, internal) &&
+                path.node.arguments[0] === internal_js_1.ctx) {
+                meshAllUnknown(path.get("arguments"), internal);
+            }
+            // call any other functions 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);
@@ -222,10 +241,15 @@ function meshExpression(nodePath, internal) {
                     meshExpression(right, internal);
                     /* istanbul ignore else */
                     if (!t.isPrivateName(property)) {
-                        (0, expression_js_1.assignToSetCall)(path, internal, left.node, right.node);
+                        path.replaceWith(internal.set(left.node.object, !left.node.computed && t.isIdentifier(property) ? t.stringLiteral(property.name) : property, right.node, path.node));
                     }
                 }
             }
+            else if (internal.devLayer &&
+                ((left.isIdentifier() && (0, expression_js_1.idIsIValue)(left)) || (left.isMemberExpression() && (0, expression_js_1.memberIsIValue)(left.node)))) {
+                meshExpression(right, internal);
+                path.replaceWith(internal.updateIValue(path.node, left.node, right.node));
+            }
             else {
                 meshLValue(left, internal);
                 meshExpression(right, internal);
@@ -426,11 +450,11 @@ function ignoreObjectPattern(pattern, internal) {
                 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));
+                    right.replaceWith(internal.match(t.stringLiteral(property.key.name), right.node, property));
                 }
                 else if ((t.isIdentifier(property.key) && property.key.name.startsWith("$")) ||
                     (t.isStringLiteral(property.key) && property.key.value.startsWith("$"))) {
-                    right.replaceWith(internal.ref(right.node));
+                    right.replaceWith(internal.ref(right.node, property, undefined));
                 }
             }
             else if (t.isIdentifier(property.value)) {
@@ -438,10 +462,10 @@ function ignoreObjectPattern(pattern, internal) {
                 if (property.computed) {
                     path
                         .get("value")
-                        .replaceWith(t.assignmentPattern(property.value, internal.match(t.stringLiteral(property.value.name))));
+                        .replaceWith(t.assignmentPattern(property.value, internal.match(t.stringLiteral(property.value.name), null, property)));
                 }
                 else if (property.value.name.startsWith("$")) {
-                    path.get("value").replaceWith(t.assignmentPattern(property.value, internal.ref()));
+                    path.get("value").replaceWith(t.assignmentPattern(property.value, internal.ref(null, property, undefined)));
                 }
             }
         }
@@ -503,8 +527,12 @@ function meshClassBody(path, internal) {
             const key = item.get("key");
             const value = item.get("value");
             if (value.isCallExpression() && (0, call_js_1.calls)(value, ["ref"], internal)) {
+                const refValue = value.node.arguments[0];
+                const pos = value.node.loc;
                 (0, lib_js_1.checkReactiveName)(key, internal);
                 meshAllUnknown(value.get("arguments"), internal);
+                value.replaceWith((0, lib_js_1.ref)(t.isExpression(refValue) ? refValue : null, internal, item.node, key.isIdentifier() ? key.node.name : undefined));
+                value.node.loc = pos;
             }
             else {
                 if (key.isIdentifier() && value.node !== null) {
@@ -521,7 +549,7 @@ function meshClassBody(path, internal) {
         }
     }
 }
-function procedureProcessObjectExpression(path, internal, state, prefix) {
+function procedureProcessObjectExpression(path, internal, state) {
     for (const prop of path.get("properties")) {
         const keyPath = prop.get("key");
         const valuePath = prop.get("value");
@@ -531,7 +559,7 @@ function procedureProcessObjectExpression(path, internal, state, prefix) {
             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)
+                    ? (0, expression_js_1.checkNode)(valuePath, internal, prop.node)
                     : null;
                 const name = (0, utils_1.stringify)(keyPath.node);
                 if ((call?.found.size ?? 0) > 0) {
@@ -545,12 +573,12 @@ function procedureProcessObjectExpression(path, internal, state, prefix) {
                 }
                 else {
                     if (valuePath.isObjectExpression()) {
-                        procedureProcessObjectExpression(valuePath, internal, state, `${prefix}${name}.`);
+                        procedureProcessObjectExpression(valuePath, internal, state);
                     }
                     if (name.startsWith("$")) {
                         if (internal.isComposing && !internal.isFunctionParsing) {
                             meshExpression(valuePath, internal);
-                            valuePath.replaceWith(internal.ref(valuePath.node));
+                            valuePath.replaceWith(internal.ref(valuePath.node, prop.node, undefined));
                             state[name] = 1;
                         }
                         else if (!((valuePath.isIdentifier() && (0, expression_js_1.idIsIValue)(valuePath)) ||
@@ -569,7 +597,7 @@ function procedureProcessObjectExpression(path, internal, state, prefix) {
                 meshLValue(valuePath, internal);
                 /* istanbul ignore else */
                 if (keyPath.isExpression() && valuePath.isExpression()) {
-                    valuePath.replaceWith(internal.match(keyPath.node, valuePath.node));
+                    valuePath.replaceWith(internal.match(keyPath.node, valuePath.node, prop.node));
                 }
             }
         }
@@ -579,11 +607,12 @@ function procedureProcessObjectExpression(path, internal, state, prefix) {
                 (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);
+            internal.wrapFunctionBody(prop.node);
         }
         else if (prop.isSpreadElement()) {
             const argumentPath = prop.get("argument");
             if (argumentPath.isObjectExpression()) {
-                procedureProcessObjectExpression(argumentPath, internal, state, prefix);
+                procedureProcessObjectExpression(argumentPath, internal, state);
             }
             else {
                 meshExpression(argumentPath, internal);
@@ -593,7 +622,7 @@ function procedureProcessObjectExpression(path, internal, state, prefix) {
     return state;
 }
 function processObjectExpression(path, internal) {
-    return procedureProcessObjectExpression(path, internal, {}, "");
+    return procedureProcessObjectExpression(path, internal, {});
 }
 function meshStatement(path, internal) {
     const statement = path.node;
@@ -692,6 +721,7 @@ function meshStatement(path, internal) {
                     const idPath = declaration.get("id");
                     const isNotUpperCase = name[0].toUpperCase() !== name[0];
                     const isNotLowerCase = name[0].toLowerCase() !== name[0];
+                    const isExported = t.isExportNamedDeclaration(path.parent);
                     function report(error) {
                         (0, lib_js_1.err)(lib_js_1.Errors.RulesOfVasille, idPath, error, internal);
                     }
@@ -699,7 +729,7 @@ function meshStatement(path, internal) {
                         if (isNotUpperCase) {
                             report("The component name must start with a uppercase letter");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/components/")) {
+                        if (isExported && internal.strictFolders && !internal.filename.includes("/components/")) {
                             report("Components must be placed in a folder named `components`");
                         }
                     }
@@ -710,7 +740,7 @@ function meshStatement(path, internal) {
                         if (!name.endsWith("View")) {
                             report("The view name must end with `View`");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/views/")) {
+                        if (isExported && internal.strictFolders && !internal.filename.includes("/views/")) {
                             report("Views must be placed in a folder named `views`");
                         }
                     }
@@ -721,7 +751,7 @@ function meshStatement(path, internal) {
                         if (!name.endsWith("Store")) {
                             report("The store name must end with `Store`");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/stores/")) {
+                        if (isExported && internal.strictFolders && !internal.filename.includes("/stores/")) {
                             report("Stores must be placed in a folder named `stores`");
                         }
                     }
@@ -732,7 +762,7 @@ function meshStatement(path, internal) {
                         if (!name.endsWith("Model")) {
                             report("The model constructor function name must end with `Model`");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/models/")) {
+                        if (isExported && internal.strictFolders && !internal.filename.includes("/models/")) {
                             report("Models must be placed in a folder named `models`");
                         }
                     }
@@ -743,7 +773,7 @@ function meshStatement(path, internal) {
                         if (!name.endsWith("Modal")) {
                             report("The modal component name must end with `Modal`");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/modals/")) {
+                        if (isExported && internal.strictFolders && !internal.filename.includes("/modals/")) {
                             report("Modals must be placed in a folder named `modals`");
                         }
                     }
@@ -751,7 +781,7 @@ function meshStatement(path, internal) {
                         if (!name.startsWith("prompt")) {
                             report("The prompt function name must start with `prompt`");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/prompts/")) {
+                        if (isExported && internal.strictFolders && !internal.filename.includes("/prompts/")) {
                             report("Prompts must be placed in a folder named `prompts`");
                         }
                     }
@@ -759,14 +789,14 @@ function meshStatement(path, internal) {
                         if (!name.endsWith("Screen")) {
                             report("The screen name must start with `Screen`");
                         }
-                        if (internal.strictFolders && !internal.filename.includes("/screens/")) {
+                        if (isExported && 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)) {
+                    if (isExported) {
                         /* istanbul ignore else */
                         if (![".ts", ".tsx", ".js", ".jsx"].some(ext => {
                             return internal.filename.endsWith(`${name}${ext}`);
@@ -777,16 +807,24 @@ function meshStatement(path, internal) {
                     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);
+                else if ((0, call_js_1.calls)(initPath, ["calculate"], internal) &&
+                    (0, lib_js_1.processCalculateCall)(initPath, internal, declaration.node, t.isIdentifier(id) ? id.name : undefined)) {
+                    if (!idPath.isArrayPattern() && !idPath.isObjectPattern()) {
+                        (0, lib_js_1.checkReactiveName)(idPath, internal);
+                    }
                 }
                 // ref call
-                else if ((0, call_js_1.calls)(initPath, call_js_1.reactivityFunctions, internal)) {
+                else if ((0, call_js_1.calls)(initPath, call_js_1.refFunctions, internal)) {
+                    const refValue = initPath.node.arguments[0];
+                    const pos = initPath.node.loc;
                     meshAllUnknown(initPath.get("arguments"), internal);
                     (0, lib_js_1.checkReactiveName)(idPath, internal);
+                    initPath.replaceWith((0, lib_js_1.ref)(refValue, internal, declaration.node));
+                    initPath.node.loc = pos;
                 }
                 // bind call
-                else if ((0, call_js_1.calls)(initPath, ["bind"], internal) && (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { strong: true })) {
+                else if ((0, call_js_1.calls)(initPath, ["bind"], internal) &&
+                    (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { strong: true }, declaration.node)) {
                     (0, lib_js_1.checkReactiveName)(idPath, internal);
                 }
                 // variable declaration
@@ -867,6 +905,12 @@ function meshFunction(path, internal) {
     else if (bodyPath.isBlockStatement()) {
         meshStatement(bodyPath, internal);
     }
+    if (path.isFunctionExpression() || path.isArrowFunctionExpression()) {
+        path.replaceWith(internal.wrapFunction(path.node));
+    }
+    else {
+        internal.wrapFunctionBody(path.node);
+    }
     internal.stack.pop();
 }
 function composeExpression(path, internal) {
@@ -876,7 +920,7 @@ function composeExpression(path, internal) {
         case "OptionalCallExpression": {
             /* istanbul ignore else */
             if ((0, call_js_1.calls)(path, ["watch"], internal)) {
-                (0, lib_js_1.parseCalculateCall)(path, internal);
+                (0, lib_js_1.parseCalculateCall)(path, internal, path.node, undefined);
                 const args = path.node.arguments;
                 /* istanbul ignore else */
                 if (args) {
@@ -897,10 +941,16 @@ function composeExpression(path, 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);
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "Stores/Models in Vasille.JS are not destroyable", internal);
                 }
                 path.get("callee").replaceWith(t.memberExpression(internal_js_1.ctx, t.identifier("runOnDestroy")));
             }
+            else if ((0, call_js_1.calls)(path, ["share"], internal)) {
+                if (internal.stateOnly) {
+                    (0, lib_js_1.err)(lib_js_1.Errors.IncompatibleContext, path, "Stores/Models in Vasille.JS cannot share dependecies", internal);
+                }
+                path.node.arguments.unshift(internal_js_1.ctx);
+            }
             break;
         }
         case "JSXElement":
@@ -960,7 +1010,10 @@ function composeStatement(path, internal) {
                 }
                 function idDoubleName() {
                     const pattern = id;
-                    return [idName(pattern.elements?.[0]), idName(pattern.elements?.[1])];
+                    return {
+                        names: [idName(pattern.elements?.[0]), idName(pattern.elements?.[1])],
+                        nodes: [pattern.elements?.[0], pattern.elements?.[1]],
+                    };
                 }
                 ignoreParams(declaration.get("id"), internal, ["id", "array"]);
                 /* istanbul ignore else */
@@ -969,10 +1022,15 @@ function composeStatement(path, internal) {
                     reactiveArrayPattern(declaration.get("id"), internal);
                     meshAllUnknown(callPath.get("arguments"), internal);
                     /* istanbul ignore else */
-                    if (internal.devMode) {
-                        callPath.node.arguments.push(internal_js_1.ctx);
+                    if (internal.devLayer) {
+                        const error = t.identifier("error");
+                        const value = t.identifier("value");
+                        const { names, nodes } = idDoubleName();
+                        callPath.node.arguments.push(t.arrowFunctionExpression([error, value], t.blockStatement([
+                            t.expressionStatement(internal.shareStateById(error, names[0])),
+                            t.expressionStatement(internal.shareStateById(value, names[1])),
+                        ])), t.arrayExpression([(0, transformer_1.nodeToStaticPosition)(nodes[0] ?? id), (0, transformer_1.nodeToStaticPosition)(nodes[1] ?? id)]), internal_js_1.inspector);
                     }
-                    (0, lib_js_1.named)(callPath.node, idDoubleName(), internal, 2);
                     meshInit = false;
                 }
                 else if (t.isIdentifier(id)) {
@@ -990,10 +1048,10 @@ function composeStatement(path, internal) {
                     // const x = bind(a + b);
                     else if ((0, call_js_1.calls)(initPath, ["bind", "calculate"], internal)) {
                         const argument = init.arguments[0];
-                        const isReactive = (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { name: idName(), strong: true });
+                        const isReactive = (0, lib_js_1.exprCall)(initPath, initPath.node, internal, { name: idName(), strong: true }, declaration.node);
                         meshInit = !isReactive;
                         if (!isReactive) {
-                            declaration.get("init").replaceWith((0, lib_js_1.ref)(argument, internal, idName()));
+                            declaration.get("init").replaceWith((0, lib_js_1.ref)(argument, internal, declaration.node, idName()));
                         }
                         (0, lib_js_1.checkReactiveName)(idPath, internal);
                     }
@@ -1001,25 +1059,25 @@ function composeStatement(path, internal) {
                     else if ((0, call_js_1.calls)(initPath, ["ref"], internal)) {
                         meshAllUnknown(initPath.get("arguments"), internal);
                         const argument = init.arguments[0];
-                        declaration.get("init").replaceWith((0, lib_js_1.ref)(t.isExpression(argument) ? argument : null, internal, idName()));
+                        declaration.get("init").replaceWith((0, lib_js_1.ref)(argument, internal, declaration.node, idName()));
                         (0, lib_js_1.checkReactiveName)(idPath, internal);
                         meshInit = false;
                     }
                     // const arr = arrayModel()
                     else if ((0, call_js_1.calls)(initPath, ["arrayModel"], internal)) {
-                        (0, lib_js_1.processModelCall)(initPath, "Array", kind === "const", internal, idName());
+                        (0, lib_js_1.processModelCall)(initPath, declaration.node, "Array", kind === "const", internal, idName());
                         meshInit = false;
                         (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
                     // const map = mapModel();
                     else if ((0, call_js_1.calls)(initPath, ["mapModel"], internal)) {
-                        (0, lib_js_1.processModelCall)(initPath, "Map", kind === "const", internal, idName());
+                        (0, lib_js_1.processModelCall)(initPath, declaration.node, "Map", kind === "const", internal, idName());
                         meshInit = false;
                         (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
                     // const set = setModel();
                     else if ((0, call_js_1.calls)(initPath, ["setModel"], internal)) {
-                        (0, lib_js_1.processModelCall)(initPath, "Set", kind === "const", internal, idName());
+                        (0, lib_js_1.processModelCall)(initPath, declaration.node, "Set", kind === "const", internal, idName());
                         meshInit = false;
                         (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
@@ -1036,21 +1094,21 @@ function composeStatement(path, internal) {
                         }
                         meshExpression(initPath, internal);
                         meshInit = false;
-                        initPath.replaceWith((0, lib_js_1.arrayModel)([initPath.node], internal, idName()));
+                        initPath.replaceWith((0, lib_js_1.arrayModel)([initPath.node], declaration.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) &&
                         ["Set", "Map"].includes(initPath.node.callee.name)) {
-                        (0, lib_js_1.processModelCall)(initPath, initPath.node.callee.name, kind === "const", internal, idName());
+                        (0, lib_js_1.processModelCall)(initPath, declaration.node, initPath.node.callee.name, kind === "const", internal, idName());
                         meshInit = false;
                         (0, lib_js_1.checkNonReactiveName)(idPath, internal);
                     }
                     else if (kind === "let") {
                         meshExpression(declaration.get("init"), internal);
                         if (idPath.isIdentifier() && idPath.node.name.startsWith("$")) {
-                            declaration.get("init").replaceWith((0, lib_js_1.ref)(declaration.node.init, internal, idName()));
+                            declaration.get("init").replaceWith((0, lib_js_1.ref)(declaration.node.init, internal, declaration.node, idName()));
                         }
                         else {
                             switchToConst = false;
@@ -1061,7 +1119,7 @@ function composeStatement(path, internal) {
                         const isReactive = (0, lib_js_1.exprCall)(declaration.get("init"), declaration.node.init, internal, {
                             name: idName(),
                             strong: true,
-                        });
+                        }, declaration.node);
                         if (isReactive) {
                             (0, lib_js_1.checkReactiveName)(idPath, internal);
                         }

package/lib/order-check.js

@@ -6,6 +6,7 @@ const lib_1 = require("./lib");
 const componentOrder = [
     { nodeType: ["VariableDeclaration"] },
     { calls: ["watch"] },
+    { calls: ["share"] },
     { nodeType: ["FunctionDeclaration"] },
     { calls: ["beforeMount"] },
     { nodeType: ["JSXElement", "JSXFragment"] },
@@ -34,12 +35,13 @@ function checkOrder(paths, internal) {
                 "Malformed component detected, required component structure is:",
                 "1. Variable declarations.",
                 "2. Watchers/effects (calls of `watch` function).",
-                "3. Function declarations.",
-                "4. Before mount hint (call of `beforeMount` function)",
-                "5. JSX elements and fragments",
-                "6. After mount hint (call of `afterMount` function)",
-                "7. Before destroy hint (call of `beforeDestroy` function)",
-                "8. Return statement",
+                "3. Dependency sharing (calls of `share` function).",
+                "4. Function declarations.",
+                "5. Before mount hint (call of `beforeMount` function)",
+                "6. JSX elements and fragments",
+                "7. After mount hint (call of `afterMount` function)",
+                "8. Before destroy hint (call of `beforeDestroy` function)",
+                "9. Return statement",
                 "All steps are optional, but the order is strict.",
                 "Unlisted statements are not accepted.",
             ].join("\n"), internal);