babel-plugin-vasille 0.99.0

package/lib-node/expression.js

@@ -0,0 +1,552 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeName = encodeName;
+exports.checkNode = checkNode;
+exports.checkOrIgnoreAllExpressions = checkOrIgnoreAllExpressions;
+exports.checkAllExpressions = checkAllExpressions;
+exports.checkAllUnknown = checkAllUnknown;
+exports.chekOrIgnoreExpression = chekOrIgnoreExpression;
+exports.checkExpression = checkExpression;
+exports.checkStatements = checkStatements;
+exports.checkStatement = checkStatement;
+exports.checkFunction = checkFunction;
+const t = __importStar(require("@babel/types"));
+const internal_js_1 = require("./internal.js");
+function encodeName(name) {
+    return t.identifier(`Vasille_${name}`);
+}
+function addIdentifier(path, search) {
+    if (!search.found.has(path.node.name)) {
+        search.found.set(path.node.name, path.node);
+    }
+    path.replaceWith(encodeName(path.node.name));
+}
+function stringify(node) {
+    if (t.isIdentifier(node)) {
+        return node.name;
+    }
+    if (t.isStringLiteral(node)) {
+        return node.value;
+    }
+    if (t.isPrivateName(node)) {
+        return node.id.name;
+    }
+    return "$";
+}
+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");
+        }
+        it = it.object;
+        names.push();
+    }
+    names.push(stringify(it));
+    if (t.isIdentifier(it) && search.stack.get(it.name) === 1 /* VariableState.Ignored */) {
+        throw path.buildCodeFrameError("Vasille: This node cannot be processed, the root of expression is a local variable");
+    }
+    return names.reverse().join("_");
+}
+function addMemberExpr(path, search) {
+    const name = extractMemberName(path, search);
+    if (!search.found.has(name)) {
+        search.found.set(name, path.node);
+    }
+    path.replaceWith(encodeName(name));
+}
+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) {
+    const state = internal.stack.get(path.node.name);
+    if (state === 2 /* VariableState.Reactive */ || state === 4 /* VariableState.ReactivePointer */) {
+        path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
+    }
+}
+function meshMember(path, internal) {
+    if (t.isIdentifier(path.node.object) && internal.stack.get(path.node.object.name) === 3 /* VariableState.ReactiveObject */) {
+        path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
+    }
+}
+function meshLValue(path, internal) {
+    if (t.isIdentifier(path.node)) {
+        meshIdentifier(path, internal);
+    }
+    else if (t.isMemberExpression(path.node) || t.isOptionalMemberExpression(path.node)) {
+        meshMember(path, internal);
+    }
+    else {
+        path.traverse({
+            Identifier(path) {
+                meshIdentifier(path, internal);
+            },
+            MemberExpression(path) {
+                meshMember(path, internal);
+            },
+            OptionalMemberExpression(path) {
+                meshMember(path, internal);
+            },
+        });
+    }
+}
+function checkNode(path, internal) {
+    const search = {
+        external: internal,
+        found: new Map(),
+        self: null,
+        stack: new internal_js_1.StackedStates(),
+    };
+    if (t.isIdentifier(path.node)) {
+        const state = internal.stack.get(path.node.name);
+        if (state === 2 /* VariableState.Reactive */ || state == 4 /* VariableState.ReactivePointer */) {
+            search.self = path.node;
+        }
+    }
+    if (t.isMemberExpression(path.node)) {
+        if (t.isIdentifier(path.node.object) &&
+            internal.stack.get(path.node.object.name) === 3 /* VariableState.ReactiveObject */) {
+            search.self = path.node;
+        }
+        if (t.isIdentifier(path.node.property) && path.node.property.name === "$") {
+            search.self = path.node.object;
+        }
+    }
+    if (search.self) {
+        return search;
+    }
+    if (t.isExpression(path.node)) {
+        checkExpression(path, search);
+    }
+    return search;
+}
+function checkOrIgnoreAllExpressions(nodePaths, search) {
+    for (const path of nodePaths) {
+        if (t.isExpression(path.node)) {
+            checkExpression(path, search);
+        }
+    }
+}
+function checkAllExpressions(nodePaths, search) {
+    for (const path of nodePaths) {
+        checkExpression(path, search);
+    }
+}
+function checkAllUnknown(paths, internal) {
+    for (const path of paths) {
+        if (t.isSpreadElement(path.node)) {
+            checkExpression(path.get("argument"), internal);
+        }
+        else if (t.isExpression(path.node)) {
+            checkExpression(path, internal);
+        }
+    }
+}
+function chekOrIgnoreExpression(path, search) {
+    if (t.isExpression(path.node)) {
+        checkExpression(path, search);
+    }
+}
+function checkExpression(nodePath, search) {
+    const expr = nodePath.node;
+    if (!expr) {
+        return;
+    }
+    switch (expr.type) {
+        case "TemplateLiteral": {
+            const path = nodePath;
+            checkOrIgnoreAllExpressions(path.get("expressions"), search);
+            break;
+        }
+        case "TaggedTemplateExpression": {
+            const path = nodePath;
+            checkExpression(path.get("quasi"), search);
+            break;
+        }
+        case "Identifier": {
+            if (search.stack.get(expr.name) !== 1 /* VariableState.Ignored */) {
+                if (search.external.stack.get(expr.name) === 2 /* VariableState.Reactive */) {
+                    addIdentifier(nodePath, search);
+                }
+            }
+            break;
+        }
+        case "ArrayExpression": {
+            const path = nodePath;
+            checkAllUnknown(path.get("elements"), search);
+            break;
+        }
+        case "TupleExpression": {
+            const path = nodePath;
+            checkAllUnknown(path.get("elements"), search);
+            break;
+        }
+        case "CallExpression": {
+            const path = nodePath;
+            chekOrIgnoreExpression(path.get("callee"), search);
+            checkAllUnknown(path.get("arguments"), search);
+            break;
+        }
+        case "OptionalCallExpression": {
+            const path = nodePath;
+            checkExpression(path.get("callee"), search);
+            checkAllUnknown(path.get("arguments"), search);
+            break;
+        }
+        case "AssignmentExpression": {
+            const path = nodePath;
+            meshLValue(path.get("left"), search.external);
+            checkExpression(path.get("right"), search);
+            break;
+        }
+        case "MemberExpression":
+        case "OptionalMemberExpression": {
+            const path = nodePath;
+            const node = path.node;
+            checkExpression(path.get("object"), search);
+            chekOrIgnoreExpression(path.get("property"), search);
+            if (t.isIdentifier(node.object) && search.external.stack.get(node.object.name) === 3 /* VariableState.ReactiveObject */) {
+                addMemberExpr(path, search);
+            }
+            else if (t.isIdentifier(node.property) && node.property.name === "$") {
+                addExternalIValue(path, search);
+            }
+            break;
+        }
+        case "BinaryExpression": {
+            const path = nodePath;
+            chekOrIgnoreExpression(path.get("left"), search);
+            checkExpression(path.get("right"), search);
+            break;
+        }
+        case "ConditionalExpression": {
+            const path = nodePath;
+            checkExpression(path.get("test"), search);
+            checkExpression(path.get("consequent"), search);
+            checkExpression(path.get("alternate"), search);
+            break;
+        }
+        case "LogicalExpression": {
+            const path = nodePath;
+            checkExpression(path.get("left"), search);
+            checkExpression(path.get("right"), search);
+            break;
+        }
+        case "NewExpression": {
+            const path = nodePath;
+            chekOrIgnoreExpression(path.get("callee"), search);
+            checkAllUnknown(path.get("arguments"), search);
+            break;
+        }
+        case "SequenceExpression": {
+            const path = nodePath;
+            checkAllExpressions(path.get("expressions"), search);
+            break;
+        }
+        case "ParenthesizedExpression": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "UnaryExpression": {
+            const path = nodePath;
+            checkExpression(path.get("argument"), search);
+            break;
+        }
+        case "UpdateExpression": {
+            const path = nodePath;
+            checkExpression(path.get("argument"), search);
+            break;
+        }
+        case "YieldExpression": {
+            const path = nodePath;
+            checkExpression(path.get("argument"), search);
+            break;
+        }
+        case "AwaitExpression": {
+            const path = nodePath;
+            checkExpression(path.get("argument"), search);
+            break;
+        }
+        case "TypeCastExpression": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "BindExpression": {
+            const path = nodePath;
+            checkExpression(path.get("callee"), search);
+            checkExpression(path.get("object"), search);
+            break;
+        }
+        case "PipelineTopicExpression": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "PipelineBareFunction": {
+            const path = nodePath;
+            checkExpression(path.get("callee"), search);
+            break;
+        }
+        case "TSInstantiationExpression": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "TSAsExpression": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "TSSatisfiesExpression": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "TSTypeAssertion": {
+            const path = nodePath;
+            checkExpression(path.get("expression"), search);
+            break;
+        }
+        case "ObjectExpression": {
+            const path = nodePath;
+            for (const propPath of path.get("properties")) {
+                const prop = propPath.node;
+                if (t.isObjectProperty(prop)) {
+                    const path = propPath;
+                    const valuePath = path.get("value");
+                    if (valuePath instanceof Array) {
+                        checkAllExpressions(valuePath, search);
+                    }
+                    else {
+                        chekOrIgnoreExpression(valuePath, search);
+                    }
+                }
+                else if (t.isObjectMethod(prop)) {
+                    checkFunction(propPath, search);
+                }
+                else {
+                    checkAllUnknown([propPath], search);
+                }
+            }
+            break;
+        }
+        case "FunctionExpression": {
+            checkFunction(nodePath, search);
+            break;
+        }
+        case "ArrowFunctionExpression": {
+            checkFunction(nodePath, search);
+            break;
+        }
+        case "JSXFragment": {
+            throw nodePath.buildCodeFrameError("Vasille: JSX fragment is not allowed here");
+        }
+        case "JSXElement": {
+            throw nodePath.buildCodeFrameError("Vasille: JSX element is not allowed here");
+        }
+    }
+}
+function checkStatements(paths, search) {
+    for (const path of paths) {
+        checkStatement(path, search);
+    }
+}
+function ignoreLocals(val, search) {
+    if (t.isAssignmentPattern(val)) {
+        val = val.left;
+    }
+    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.isArrayPattern(val)) {
+        for (const element of val.elements) {
+            if (element) {
+                ignoreLocals(element, search);
+            }
+        }
+    }
+    else if (t.isVariableDeclaration(val)) {
+        for (const declarator of val.declarations) {
+            ignoreLocals(declarator.id, search);
+        }
+    }
+}
+function checkStatement(path, search) {
+    const statement = path.node;
+    if (!statement) {
+        return;
+    }
+    switch (statement.type) {
+        case "BlockStatement":
+            search.stack.push();
+            checkStatements(path.get("body"), search);
+            search.stack.pop();
+            break;
+        case "DoWhileStatement": {
+            const _path = path;
+            checkExpression(_path.get("test"), search);
+            search.stack.push();
+            checkStatement(_path.get("body"), search);
+            search.stack.pop();
+            break;
+        }
+        case "ExpressionStatement":
+            checkExpression(path.get("expression"), search);
+            break;
+        case "ForInStatement": {
+            const _path = path;
+            ignoreLocals(_path.node.left, search);
+            checkExpression(_path.get("right"), search);
+            checkStatement(_path.get("body"), search);
+            break;
+        }
+        case "ForOfStatement": {
+            const _path = path;
+            checkExpression(_path.get("right"), search);
+            search.stack.push();
+            checkStatement(_path.get("body"), search);
+            search.stack.pop();
+            break;
+        }
+        case "ForStatement": {
+            const _path = path;
+            const node = _path.node;
+            if (node.init) {
+                if (t.isExpression(node.init)) {
+                    checkExpression(_path.get("init"), search);
+                }
+                else {
+                    const variablePath = _path.get("init");
+                    for (const declarationPath of variablePath.get("declarations")) {
+                        checkExpression(declarationPath.get("init"), search);
+                    }
+                }
+            }
+            checkExpression(_path.get("test"), search);
+            checkExpression(_path.get("update"), search);
+            search.stack.push();
+            checkStatement(_path.get("body"), search);
+            search.stack.pop();
+            break;
+        }
+        case "FunctionDeclaration":
+            checkFunction(path, search);
+            break;
+        case "IfStatement": {
+            const _path = path;
+            checkExpression(_path.get("test"), search);
+            search.stack.push();
+            checkStatement(_path.get("consequent"), search);
+            search.stack.pop();
+            search.stack.push();
+            checkStatement(_path.get("alternate"), search);
+            search.stack.pop();
+            break;
+        }
+        case "LabeledStatement":
+            search.stack.push();
+            checkStatement(path.get("body"), search);
+            search.stack.pop();
+            break;
+        case "ReturnStatement":
+            checkExpression(path.get("argument"), search);
+            break;
+        case "SwitchStatement": {
+            const _path = path;
+            checkExpression(_path.get("discriminant"), search);
+            search.stack.push();
+            for (const _case of _path.get("cases")) {
+                checkExpression(_case.get("test"), search);
+                checkStatements(_case.get("consequent"), search);
+            }
+            search.stack.pop();
+            break;
+        }
+        case "ThrowStatement":
+            checkExpression(path.get("argument"), search);
+            break;
+        case "TryStatement":
+            checkStatement(path.get("block"), search);
+            break;
+        case "VariableDeclaration": {
+            const _path = path;
+            for (const declaration of _path.get("declarations")) {
+                const expr = declaration.node.init;
+                ignoreLocals(declaration.node.id, search);
+                checkExpression(declaration.get("init"), search);
+            }
+            break;
+        }
+        case "WhileStatement": {
+            const _path = path;
+            checkExpression(_path.get("test"), search);
+            search.stack.push();
+            checkStatement(_path.get("body"), search);
+            search.stack.pop();
+            break;
+        }
+        case "WithStatement": {
+            const _path = path;
+            checkExpression(_path.get("object"), search);
+            search.stack.push();
+            checkStatement(_path.get("body"), search);
+            search.stack.pop();
+            break;
+        }
+        case "ExportNamedDeclaration": {
+            checkStatement(path.get("declaration"), search);
+            break;
+        }
+    }
+}
+function checkFunction(path, search) {
+    const node = path.node;
+    if (t.isExpression(node.body)) {
+        checkExpression(path.get("body"), search);
+    }
+    else {
+        const bodyPath = path.get("body");
+        checkStatement(bodyPath, search);
+    }
+}

package/lib-node/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const transformer_js_1 = require("./transformer.js");
+function default_1() {
+    return {
+        name: "Vasille",
+        visitor: {
+            Program(path, params) {
+                (0, transformer_js_1.trProgram)(path, params.devMode !== false);
+            },
+        },
+    };
+}

package/lib-node/internal.js

@@ -0,0 +1,52 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ctx = exports.StackedStates = void 0;
+const t = __importStar(require("@babel/types"));
+class StackedStates {
+    constructor() {
+        this.maps = [];
+        this.push();
+    }
+    push() {
+        this.maps.push(new Map());
+    }
+    pop() {
+        this.maps.pop();
+    }
+    get(name) {
+        for (let i = this.maps.length - 1; i >= 0; i--) {
+            if (this.maps[i].has(name)) {
+                return this.maps[i].get(name);
+            }
+        }
+        return undefined;
+    }
+    set(name, state) {
+        this.maps[this.maps.length - 1].set(name, state);
+    }
+}
+exports.StackedStates = StackedStates;
+exports.ctx = t.identifier("Vasille");

package/lib-node/jsx-detect.js

@@ -0,0 +1,88 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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);
+    }
+    if (t.isSequenceExpression(node)) {
+        return node.expressions.some(item => exprHasJsx(item));
+    }
+    if (t.isParenthesizedExpression(node)) {
+        return exprHasJsx(node.expression);
+    }
+    if (t.isDoExpression(node)) {
+        return bodyHasJsx(node.body);
+    }
+    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);
+    }
+    return false;
+}
+function bodyHasJsx(node) {
+    if (t.isExpression(node)) {
+        return exprHasJsx(node);
+    }
+    return node.body.some(statementHasJsx);
+}