babel-plugin-vasille 3.1.5 → 4.0.0

package/lib-node/expression.js

@@ -1,573 +0,0 @@
-"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.encodeName = encodeName;
-exports.idIsIValue = idIsIValue;
-exports.idIsLocal = idIsLocal;
-exports.memberIsIValue = memberIsIValue;
-exports.nodeIsReactiveObject = nodeIsReactiveObject;
-exports.checkNode = checkNode;
-exports.checkOrIgnoreAllExpressions = checkOrIgnoreAllExpressions;
-exports.checkAllExpressions = checkAllExpressions;
-exports.checkAllUnknown = checkAllUnknown;
-exports.checkOrIgnoreExpression = checkOrIgnoreExpression;
-exports.checkExpression = checkExpression;
-exports.checkStatements = checkStatements;
-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");
-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) {
-    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 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(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");
-    }
-    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) {
-    if (idIsIValue(path, internal)) {
-        path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
-    }
-}
-function idIsIValue(path, internal, scope) {
-    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;
-}
-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 nodeIsReactiveObject(path, internal) {
-    const node = path.node;
-    if (t.isIdentifier(node)) {
-        return internal.stack.get(node.name) === 3 /* VariableState.ReactiveObject */;
-    }
-    if (t.isOptionalMemberExpression(node) || t.isMemberExpression(node)) {
-        return ((t.isIdentifier(node.property) && node.property.name.startsWith("$$")) ||
-            (t.isStringLiteral(node.property) && node.property.value.startsWith("$$")));
-    }
-}
-function meshMember(path, internal) {
-    if (memberIsIValue(path.node, internal)) {
-        path.replaceWith(t.memberExpression(path.node, t.identifier("$")));
-    }
-}
-function meshLValue(path, internal) {
-    const node = path.node;
-    if (t.isIdentifier(node)) {
-        meshIdentifier(path, internal);
-    }
-    else if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        meshMember(path, internal);
-    }
-    else if (t.isArrayPattern(node)) {
-        for (const item of path.get("elements")) {
-            if (t.isOptionalMemberExpression(item.node) || t.isLVal(item.node)) {
-                meshLValue(item, internal);
-            }
-        }
-    }
-    else if (t.isRestElement(node)) {
-        meshLValue(path.get("argument"), internal);
-    }
-}
-function checkNode(path, internal) {
-    const search = {
-        external: internal,
-        found: new Map(),
-        self: null,
-        stack: internal.stack,
-    };
-    if (t.isIdentifier(path.node)) {
-        if (idIsIValue(path, internal)) {
-            search.self = path.node;
-        }
-    }
-    if (t.isMemberExpression(path.node)) {
-        if (memberIsIValue(path.node, internal)) {
-            search.self = path.node;
-        }
-        else if (t.isIdentifier(path.node.property) && path.node.property.name === "$") {
-            search.self = path.node.object;
-        }
-    }
-    if (search.self) {
-        return search;
-    }
-    internal.stack.fixLocalIndex();
-    internal.stack.push();
-    if (t.isExpression(path.node)) {
-        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)) {
-            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 checkOrIgnoreExpression(path, search) {
-    if (t.isExpression(path.node)) {
-        checkExpression(path, search);
-    }
-}
-const REACTIVE_STATES = [2 /* VariableState.Reactive */, 4 /* VariableState.ReactivePointer */];
-function checkExpression(nodePath, search) {
-    const expr = nodePath.node;
-    switch (expr && expr.type) {
-        case "TemplateLiteral": {
-            const path = nodePath;
-            checkOrIgnoreAllExpressions(path.get("expressions"), search);
-            break;
-        }
-        case "TaggedTemplateExpression": {
-            const path = nodePath;
-            checkExpression(path.get("quasi"), search);
-            path.get("");
-            break;
-        }
-        case "Identifier": {
-            if (expr && t.isIdentifier(expr)) {
-                if (idIsIValue(nodePath, search.external, internal_js_1.VariableScope.Global) &&
-                    !idIsLocal(nodePath, search.external)) {
-                    addIdentifier(nodePath, search);
-                }
-            }
-            break;
-        }
-        case "ArrayExpression": {
-            const path = nodePath;
-            checkAllUnknown(path.get("elements"), search);
-            break;
-        }
-        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");
-            }
-            checkOrIgnoreExpression(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;
-            if (memberIsIValue(node, search.external, internal_js_1.VariableScope.Global)) {
-                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);
-            }
-            break;
-        }
-        case "BinaryExpression": {
-            const path = nodePath;
-            checkOrIgnoreExpression(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;
-            checkOrIgnoreExpression(path.get("callee"), search);
-            checkAllUnknown(path.get("arguments"), search);
-            break;
-        }
-        case "SequenceExpression": {
-            const path = nodePath;
-            checkAllExpressions(path.get("expressions"), search);
-            break;
-        }
-        case "UnaryExpression": {
-            const path = nodePath;
-            checkExpression(path.get("argument"), search);
-            break;
-        }
-        case "UpdateExpression": {
-            const path = nodePath;
-            const arg = path.node.argument;
-            if (t.isLVal(arg)) {
-                meshLValue(path.get("argument"), search.external);
-            }
-            break;
-        }
-        case "YieldExpression": {
-            const path = nodePath;
-            checkExpression(path.get("argument"), search);
-            break;
-        }
-        case "AwaitExpression": {
-            const path = nodePath;
-            checkExpression(path.get("argument"), 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 (path.node.computed) {
-                        checkOrIgnoreExpression(path.get("key"), search);
-                    }
-                    checkOrIgnoreExpression(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.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);
-            }
-        }
-    }
-    else if (t.isVariableDeclaration(val)) {
-        for (const declarator of val.declarations) {
-            if (!t.isVoidPattern(declarator.id)) {
-                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":
-            const handlerPath = path.get("handler");
-            checkStatement(path.get("block"), search);
-            if (handlerPath.node) {
-                checkStatement(handlerPath.get("body"), search);
-            }
-            checkStatement(path.get("finalizer"), search);
-            break;
-        case "VariableDeclaration": {
-            const _path = path;
-            for (const declaration of _path.get("declarations")) {
-                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;
-        }
-    }
-}
-function checkFunction(path, search) {
-    const node = path.node;
-    for (const param of node.params) {
-        ignoreLocals(param, search);
-    }
-    if (t.isExpression(node.body)) {
-        checkExpression(path.get("body"), search);
-    }
-    else {
-        const bodyPath = path.get("body");
-        checkStatement(bodyPath, search);
-    }
-}

package/lib-node/index.js

@@ -1,14 +0,0 @@
-"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.opts.devMode !== false);
-            },
-        },
-    };
-}

package/lib-node/jsx-detect.js

@@ -1,100 +0,0 @@
-"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.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);
-}