babel-plugin-vasille 3.1.5 → 4.0.0

package/lib/lib.js

@@ -33,121 +33,157 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Errors = void 0;
+exports.err = err;
 exports.named = named;
+exports.processCalculateCall = processCalculateCall;
 exports.parseCalculateCall = parseCalculateCall;
+exports.bindCall = bindCall;
 exports.exprCall = exprCall;
-exports.forwardOnlyExpr = forwardOnlyExpr;
-exports.own = own;
 exports.ref = ref;
-exports.reactiveObject = reactiveObject;
 exports.arrayModel = arrayModel;
 exports.setModel = setModel;
 exports.mapModel = mapModel;
+exports.processModelCall = processModelCall;
+exports.checkReactiveName = checkReactiveName;
+exports.checkNonReactiveName = checkNonReactiveName;
 const t = __importStar(require("@babel/types"));
 const expression_js_1 = require("./expression.js");
 const internal_js_1 = require("./internal.js");
 const call_js_1 = require("./call.js");
+const mesh_1 = require("./mesh");
+var Errors;
+(function (Errors) {
+    Errors[Errors["IncorrectArguments"] = 1] = "IncorrectArguments";
+    Errors[Errors["IncompatibleContext"] = 2] = "IncompatibleContext";
+    Errors[Errors["TokenNotSupported"] = 3] = "TokenNotSupported";
+    Errors[Errors["Dilemma"] = 4] = "Dilemma";
+    Errors[Errors["ParserError"] = 5] = "ParserError";
+    Errors[Errors["RulesOfVasille"] = 6] = "RulesOfVasille";
+})(Errors || (exports.Errors = Errors = {}));
+function err(e, node, content, internal, ret) {
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const error = node.buildCodeFrameError(`Vasille[${e}]{${Errors[e]}}: ${content}`, Error);
+    Error.stackTraceLimit = limit;
+    if (!internal.firstError) {
+        internal.firstError = error;
+    }
+    console.log(error);
+    return ret;
+}
+function unprefixedName(name) {
+    return name[0] === "$" ? name.substring(1) : name;
+}
 function named(call, name, internal, argPos) {
-    if (internal.devMode && !internal.stateOnly && name) {
+    if (internal.devMode && name) {
         while (argPos && call.arguments.length < argPos) {
             call.arguments.push(t.buildUndefinedNode());
         }
-        call.arguments.push(...(typeof name === "string" ? [t.stringLiteral(name)] : name.map(item => t.stringLiteral(item))));
+        call.arguments.push(...(typeof name === "string" ? [name] : name.map(item => item)).map(name => t.stringLiteral(unprefixedName(name))));
     }
     return call;
 }
-function parseCalculateCall(path, internal) {
-    if (t.isCallExpression(path.node) && (0, call_js_1.calls)(path.node, ["calculate", "watch"], internal)) {
-        const call = path.node.arguments[0];
-        if (path.node.arguments.length !== 1) {
-            throw path.buildCodeFrameError("Vasille: Incorrect number of arguments");
-        }
-        if (t.isFunctionExpression(call) || t.isArrowFunctionExpression(call)) {
-            if (call.params.length > 0) {
-                throw path.buildCodeFrameError("Vasille: Argument of calculate cannot have parameters");
-            }
-            const exprData = (0, expression_js_1.checkNode)(path.get("arguments")[0], internal);
-            call.params = [...exprData.found.keys()].map(name => (0, expression_js_1.encodeName)(name));
-            return [call, t.arrayExpression([...exprData.found.values()])];
-        }
-        else {
-            throw path.buildCodeFrameError("Vasille: Argument of calculate must be a function");
+function processCalculateCall(path, internal) {
+    const call = path.node.arguments[0];
+    if (path.node.arguments.length !== 1) {
+        return err(Errors.IncorrectArguments, path, "Incorrect number of arguments", internal, false);
+    }
+    if (t.isFunctionExpression(call) || t.isArrowFunctionExpression(call)) {
+        if (call.params.length > 0) {
+            return err(Errors.IncorrectArguments, path.get("arguments")[0], "Argument of calculate cannot have parameters", internal, false);
         }
+        const exprData = (0, expression_js_1.checkNode)(path.get("arguments")[0], internal);
+        call.params = [...exprData.found.keys()].map(name => (0, expression_js_1.encodeName)(name));
+        path.node.arguments.unshift(internal.isComposing ? internal_js_1.ctx : t.nullLiteral());
+        path.node.arguments.push(t.arrayExpression([...exprData.found.values()]));
+        return true;
     }
-    return null;
+    return err(Errors.IncorrectArguments, path, "Argument of calculate must be a function", internal, false);
 }
-function exprCall(path, expr, internal, name) {
-    const calculateCall = parseCalculateCall(path, internal);
-    if (calculateCall) {
-        return named(t.callExpression(internal.stateOnly
-            ? t.memberExpression(internal.id, t.identifier("ex"))
-            : t.memberExpression(internal_js_1.ctx, t.identifier("expr")), calculateCall), name, internal);
+function parseCalculateCall(path, internal) {
+    if (path.isCallExpression() && (0, call_js_1.calls)(path, ["calculate", "watch"], internal)) {
+        return processCalculateCall(path, internal);
+    }
+    return false;
+}
+function bindCall(path, expr, data, internal, name) {
+    const names = [...data.keys()].map(expression_js_1.encodeName);
+    const dependencies = t.arrayExpression([...data.values()]);
+    if (names.length > 0 && expr) {
+        path.replaceWith(named(internal.expr(t.arrowFunctionExpression(names, expr), dependencies), name, internal, 3));
+        return true;
+    }
+    return false;
+}
+function exprCall(path, expr, internal, opts) {
+    if (parseCalculateCall(path, internal)) {
+        named(path.node, opts.name, internal, 3);
+        return true;
     }
     if (t.isCallExpression(expr) &&
-        (0, call_js_1.calls)(expr, ["forward"], internal) &&
+        (0, call_js_1.calls)(path, ["bind"], internal) &&
         expr.arguments.length === 1 &&
         t.isExpression(expr.arguments[0])) {
-        const data = exprCall(path.get("arguments")[0], expr.arguments[0], internal);
-        if (data && !t.isCallExpression(data)) {
-            return t.callExpression(t.memberExpression(internal.id, t.identifier("fo")), [data]);
+        const argPath = path.get("arguments")[0];
+        const exprData = (0, expression_js_1.checkNode)(argPath, internal);
+        if (exprData.self) {
+            path.replaceWith(internal.forward(exprData.self));
+        }
+        else if (exprData.found.size > 0) {
+            argPath.replaceWith(t.arrowFunctionExpression([...exprData.found.keys()].map(expression_js_1.encodeName), argPath.node));
+            expr.arguments.unshift(internal.isComposing ? internal_js_1.ctx : t.nullLiteral());
+            expr.arguments.push(t.arrayExpression([...exprData.found.values()]));
+            named(expr, opts.name, internal, 3);
+        }
+        else {
+            path.replaceWith(named(internal.ref(argPath.node), opts.name, internal, 1));
         }
+        return true;
     }
     const exprData = (0, expression_js_1.checkNode)(path, internal);
     if (exprData.self) {
-        return exprData.self;
-    }
-    const names = [...exprData.found.keys()].map(name => (0, expression_js_1.encodeName)(name));
-    const dependencies = t.arrayExpression([...exprData.found.values()]);
-    if (names.length > 0 && expr) {
-        return named(t.callExpression(internal.stateOnly
-            ? t.memberExpression(internal.id, t.identifier("ex"))
-            : t.memberExpression(internal_js_1.ctx, t.identifier("expr")), [t.arrowFunctionExpression(names, expr), dependencies]), name, internal);
-    }
-    return null;
-}
-function forwardOnlyExpr(path, expr, internal) {
-    const calculateCall = parseCalculateCall(path, internal);
-    if (calculateCall) {
-        return t.callExpression(t.memberExpression(internal.id, t.identifier("ex")), calculateCall);
-    }
-    const exprData = (0, expression_js_1.checkNode)(path, internal);
-    return exprData.self
-        ? t.callExpression(t.memberExpression(internal.id, t.identifier("fo")), [exprData.self])
-        : exprData.found.size > 0 && expr
-            ? t.callExpression(t.memberExpression(internal.id, t.identifier("ex")), [
-                t.arrowFunctionExpression([...exprData.found.keys()].map(name => (0, expression_js_1.encodeName)(name)), expr),
-                t.arrayExpression([...exprData.found.values()]),
-            ])
-            : null;
-}
-function own(expr, internal, name) {
-    if (internal.stateOnly &&
-        t.isCallExpression(expr) &&
-        t.isMemberExpression(expr.callee) &&
-        t.isIdentifier(expr.callee.property) &&
-        expr.callee.property.name === "fo" &&
-        t.isIdentifier(expr.callee.object) &&
-        expr.callee.object === internal.id) {
-        return expr;
+        if (!opts.strong || (0, expression_js_1.exprIsSure)(path, internal)) {
+            path.replaceWith(exprData.self);
+        }
+        else {
+            path.replaceWith(internal.ensure(exprData.self));
+        }
+        return true;
     }
-    return named(t.callExpression(internal.stateOnly
-        ? t.memberExpression(internal.id, t.identifier("fo"))
-        : t.memberExpression(internal_js_1.ctx, t.identifier("own")), [expr]), name, internal);
+    return bindCall(path, expr, exprData.found, internal, opts.name);
 }
 function ref(expr, internal, name) {
-    return named(t.callExpression(internal.stateOnly
-        ? t.memberExpression(internal.id, t.identifier("r"))
-        : t.memberExpression(internal_js_1.ctx, t.identifier("ref")), expr ? [expr] : []), name, internal, 1);
-}
-function reactiveObject(init, internal, name) {
-    return named(t.callExpression(t.memberExpression(internal.id, t.identifier(internal.stateOnly ? "sro" : "ro")), internal.stateOnly ? [init] : [internal_js_1.ctx, init]), name, internal);
+    return named(internal.ref(expr), name, internal, 1);
 }
-function arrayModel(init, internal, name) {
-    return named(t.callExpression(t.memberExpression(internal.id, t.identifier(internal.stateOnly ? "sam" : "am")), internal.stateOnly ? (init ? [init] : []) : [internal_js_1.ctx, ...(init ? [init] : [])]), name, internal, 2);
+function arrayModel(args, internal, name) {
+    return named(internal.arrayModel(args[0]), name, internal, 2);
 }
 function setModel(args, internal, name) {
-    return named(t.callExpression(t.memberExpression(internal.id, t.identifier(internal.stateOnly ? "ssm" : "sm")), internal.stateOnly ? args : [internal_js_1.ctx, ...args]), name, internal);
+    return named(internal.setModel(args[0]), name, internal, 2);
 }
 function mapModel(args, internal, name) {
-    return named(t.callExpression(t.memberExpression(internal.id, t.identifier(internal.stateOnly ? "smm" : "mm")), internal.stateOnly ? args : [internal_js_1.ctx, ...args]), name, internal);
+    return named(internal.mapModel(args[0]), name, internal, 2);
+}
+function processModelCall(path, type, isConst, internal, name) {
+    const args = path.node.arguments;
+    if (!isConst) {
+        err(Errors.RulesOfVasille, path, `${type} models must be declared as constants`, internal);
+    }
+    (0, mesh_1.meshAllUnknown)(path.get("arguments"), internal);
+    path.replaceWith(type === "Map"
+        ? mapModel(args, internal, name)
+        : type === "Set"
+            ? setModel(args, internal, name)
+            : arrayModel(args, internal, name));
+}
+function checkReactiveName(idPath, internal) {
+    if (!(idPath.isIdentifier() && idPath.node.name.startsWith("$"))) {
+        err(Errors.RulesOfVasille, idPath, "Reactive variable name must start with $", internal);
+    }
+}
+function checkNonReactiveName(idPath, internal) {
+    if (idPath.node.name.startsWith("$")) {
+        err(Errors.RulesOfVasille, idPath, "Non-reactive variable name must not start with $", internal);
+    }
 }