babel-plugin-vasille 3.1.5 → 3.2.1

package/lib-node/mesh.js

@@ -50,13 +50,37 @@ exports.composeStatements = composeStatements;
 exports.composeStatement = composeStatement;
 exports.compose = compose;
 const t = __importStar(require("@babel/types"));
+const bridge_1 = require("./bridge");
 const call_js_1 = require("./call.js");
 const expression_js_1 = require("./expression.js");
 const internal_js_1 = require("./internal.js");
 const jsx_js_1 = require("./jsx.js");
 const lib_js_1 = require("./lib.js");
+const router_1 = require("./router");
+const utils_1 = require("./utils");
+const composePropsIndex = {
+    slot: 0,
+    compose: 0,
+    view: 0,
+    mvvmView: 0,
+    mvcView: -1,
+    hybridView: 1,
+    store: 0,
+    screen: -1,
+};
+const composeArgsNumber = {
+    slot: 1,
+    compose: 1,
+    view: 1,
+    mvvmView: 1,
+    mvcView: 1,
+    hybridView: 2,
+    store: 1,
+    screen: 1,
+};
 function meshOrIgnoreAllExpressions(nodePaths, internal) {
     for (const path of nodePaths) {
+        /* istanbul ignore else */
         if (t.isExpression(path.node)) {
             meshExpression(path, internal);
         }
@@ -67,13 +91,16 @@ function meshAllExpressions(nodePaths, internal) {
         meshExpression(path, internal);
     }
 }
-function meshComposeCall(call, name, nodePath, internal) {
+function meshComposeCall(call, name, nodePath, method, internal) {
     const arg = call.arguments[0];
     if (call.arguments.length !== 1 || !(t.isFunctionExpression(arg) || t.isArrowFunctionExpression(arg))) {
         throw nodePath.buildCodeFrameError("Vasille: Invalid arguments");
     }
     const fnPath = nodePath.get("arguments")[0];
-    compose(fnPath, internal, false);
+    const nonePropsFields = compose(fnPath, internal, false, method);
+    if (composeArgsNumber[method] > 1) {
+        call.arguments.push(t.arrayExpression(nonePropsFields.map(item => t.stringLiteral(item))));
+    }
     if (!internal.stateOnly) {
         arg.params.unshift(internal_js_1.ctx);
     }
@@ -83,6 +110,7 @@ function meshComposeCall(call, name, nodePath, internal) {
 }
 function meshAllUnknown(paths, internal) {
     for (const path of paths) {
+        /* istanbul ignore else */
         if (t.isSpreadElement(path.node)) {
             meshExpression(path.get("argument"), internal);
         }
@@ -93,11 +121,13 @@ function meshAllUnknown(paths, internal) {
 }
 function meshLValue(path, internal) {
     const node = path.node;
+    /* istanbul ignore else */
     if (t.isExpression(node)) {
         meshExpression(path, internal);
     }
 }
 function meshOrIgnoreExpression(path, internal) {
+    /* istanbul ignore else */
     if (t.isExpression(path.node)) {
         meshExpression(path, internal);
     }
@@ -107,8 +137,9 @@ function meshExpression(nodePath, internal, isRoot) {
     if (!expr) {
         return;
     }
-    if ((0, call_js_1.calls)(expr, ["compose", "store"], internal)) {
-        meshComposeCall(expr, null, nodePath, internal);
+    let composeMethod = (0, call_js_1.calls)(nodePath, ["compose", "store", "view", "mvvmView", "mvcView", "hybridView"], internal);
+    if (composeMethod) {
+        meshComposeCall(expr, null, nodePath, composeMethod, internal);
         return;
     }
     switch (expr.type) {
@@ -137,23 +168,26 @@ function meshExpression(nodePath, internal, isRoot) {
         case "CallExpression":
         case "OptionalCallExpression": {
             const path = nodePath;
-            const callsFn = (0, call_js_1.calls)(path.node, call_js_1.composeOnly, internal);
-            const callsStyleHint = (0, call_js_1.calls)(path.node, call_js_1.styleOnly, internal);
-            if (callsFn) {
-                throw path.buildCodeFrameError(`Vasille: Usage of hint "${callsFn}" is restricted here`);
-            }
-            if (callsStyleHint) {
-                throw path.buildCodeFrameError(`Vasille: Usage of style hint "${callsStyleHint}" is restricted here`);
-            }
-            meshOrIgnoreExpression(path.get("callee"), internal);
-            meshAllUnknown(path.get("arguments"), internal);
-            if ((0, call_js_1.calls)(path.node, ["calculate"], internal)) {
-                if (path.node.arguments.length === 1 &&
-                    (t.isFunctionExpression(path.node.arguments[0]) || t.isArrowFunctionExpression(path.node.arguments[0]))) {
-                    path.replaceWith(t.callExpression(path.node.arguments[0], []));
+            if (internal.isComposing && (0, call_js_1.calls)(path, ["router"], internal)) {
+                if (!internal.stateOnly) {
+                    (0, router_1.routerReplace)(path);
                 }
                 else {
-                    throw path.buildCodeFrameError("Vasille: Incorrect calculate argument");
+                    throw path.buildCodeFrameError("Vasille: The router is not available in stores");
+                }
+            }
+            else {
+                const callsFn = (0, call_js_1.calls)(path, call_js_1.composeOnly, internal);
+                const callsStyleHint = (0, call_js_1.calls)(path, call_js_1.styleOnly, internal);
+                if (callsFn) {
+                    throw path.buildCodeFrameError(`Vasille: Usage of hint "${callsFn}" is restricted here`);
+                }
+                if (callsStyleHint) {
+                    throw path.buildCodeFrameError(`Vasille: Usage of style hint "${callsStyleHint}" is restricted here`);
+                }
+                if (!(0, bridge_1.processBridgeCall)(path, internal)) {
+                    meshOrIgnoreExpression(path.get("callee"), internal);
+                    meshAllUnknown(path.get("arguments"), internal);
                 }
             }
             break;
@@ -269,12 +303,12 @@ function meshExpression(nodePath, internal, isRoot) {
                     let replaced = false;
                     if (isRoot &&
                         internal.stateOnly &&
-                        !path.node.computed &&
-                        t.isIdentifier(path.node.key) &&
+                        (!path.node.computed || t.isStringLiteral(path.node.key)) &&
+                        (t.isIdentifier(path.node.key) || t.isStringLiteral(path.node.key)) &&
                         t.isExpression(valuePath.node)) {
                         const call = (0, lib_js_1.exprCall)(valuePath, valuePath.node, internal);
                         if (call) {
-                            if (path.node.key.name.startsWith("$")) {
+                            if ((0, utils_1.stringify)(path.node.key).startsWith("$")) {
                                 valuePath.replaceWith(call);
                             }
                             else {
@@ -283,9 +317,13 @@ function meshExpression(nodePath, internal, isRoot) {
                             replaced = true;
                         }
                         else if (t.isIdentifier(valuePath.node) &&
-                            internal.stack.get(valuePath.node.name) === 3 /* VariableState.ReactiveObject */ &&
-                            !path.node.key.name.startsWith("$$")) {
-                            throw path.buildCodeFrameError("Vasille: Reactive object property name must start with $$");
+                            internal.stack.get(valuePath.node.name) === 3 /* VariableState.ReactiveObject */) {
+                            if (!(0, utils_1.stringify)(path.node.key).startsWith("$$")) {
+                                throw path.buildCodeFrameError("Vasille: Reactive object property name must start with $$");
+                            }
+                        }
+                        else if ((0, utils_1.stringify)(path.node.key).startsWith("$")) {
+                            throw path.buildCodeFrameError("Vasille: This property is not a reactive value or object");
                         }
                     }
                     if (!replaced) {
@@ -293,6 +331,9 @@ function meshExpression(nodePath, internal, isRoot) {
                     }
                 }
                 else if (t.isObjectMethod(prop)) {
+                    if ((0, utils_1.stringify)(prop.key).startsWith("$")) {
+                        throw propPath.buildCodeFrameError("Vasille: Method name stating with $ is not allowed");
+                    }
                     meshFunction(propPath, internal);
                 }
                 else if (isRoot && internal.stateOnly && t.isSpreadElement(prop)) {
@@ -330,9 +371,11 @@ function meshStatements(paths, internal) {
     }
 }
 function ignoreParams(val, internal) {
+    /* istanbul ignore else */
     if (t.isAssignmentPattern(val)) {
         val = val.left;
     }
+    /* istanbul ignore else */
     if (t.isIdentifier(val)) {
         internal.stack.set(val.name, 1 /* VariableState.Ignored */);
     }
@@ -349,7 +392,9 @@ function ignoreParams(val, internal) {
 }
 function ignoreObjectPattern(pattern, internal) {
     for (const property of pattern.properties) {
+        /* istanbul ignore else */
         if (t.isObjectProperty(property)) {
+            /* istanbul ignore else */
             if (t.isObjectPattern(property.value)) {
                 ignoreObjectPattern(property.value, internal);
             }
@@ -360,6 +405,7 @@ function ignoreObjectPattern(pattern, internal) {
                 internal.stack.set(property.value.name, 1 /* VariableState.Ignored */);
             }
         }
+        /* istanbul ignore else */
         if (t.isRestElement(property)) {
             internal.stack.set(property.argument.name, 1 /* VariableState.Ignored */);
         }
@@ -368,6 +414,7 @@ function ignoreObjectPattern(pattern, internal) {
 function reactiveArrayPattern(path, internal) {
     if (t.isArrayPattern(path.node)) {
         path.node.elements.forEach((element, index) => {
+            /* istanbul ignore else */
             if (t.isIdentifier(element)) {
                 internal.stack.set(element.name, index < 2 ? 2 /* VariableState.Reactive */ : 1 /* VariableState.Ignored */);
             }
@@ -380,12 +427,14 @@ function reactiveArrayPattern(path, internal) {
 function meshForEachHeader(path, internal) {
     const left = path.node.left;
     meshExpression(path.get("right"), internal);
+    /* istanbul ignore else */
     if (t.isVariableDeclaration(left) && t.isVariableDeclarator(left.declarations[0])) {
         ignoreParams(left.declarations[0].id, internal);
     }
 }
 function meshForHeader(path, internal) {
     const node = path.node;
+    /* istanbul ignore else */
     if (node.init) {
         if (t.isExpression(node.init)) {
             meshExpression(path.get("init"), internal);
@@ -403,9 +452,15 @@ function meshForHeader(path, internal) {
 }
 function meshClassBody(path, internal) {
     for (const item of path.get("body")) {
+        /* istanbul ignore else */
         if (t.isClassMethod(item.node) || t.isClassPrivateMethod(item.node)) {
             meshFunction(item, internal);
         }
+        else if (t.isClassAccessorProperty(item.node) ||
+            t.isClassPrivateProperty(item.node) ||
+            t.isClassProperty(item.node)) {
+            meshExpression(item.get("value"), internal);
+        }
     }
 }
 function meshStatement(path, internal) {
@@ -487,6 +542,7 @@ function meshStatement(path, internal) {
             break;
         case "TryStatement":
             meshStatement(path.get("block"), internal);
+            /* istanbul ignore else */
             if (path.node.handler) {
                 meshStatement(path.get("handler").get("body"), internal);
             }
@@ -496,8 +552,10 @@ function meshStatement(path, internal) {
             const _path = path;
             for (const declaration of _path.get("declarations")) {
                 const expr = declaration.node.init;
-                if (expr && t.isIdentifier(declaration.node.id) && (0, call_js_1.calls)(expr, ["compose", "store"], internal)) {
-                    meshComposeCall(expr, declaration.node.id, declaration.get("init"), internal);
+                const initPath = declaration.get("init");
+                const composeMethod = (0, call_js_1.calls)(initPath, ["compose", "store", "view", "mvvmView", "mvcView", "hybridView", "screen"], internal);
+                if (expr && t.isIdentifier(declaration.node.id) && composeMethod) {
+                    meshComposeCall(expr, declaration.node.id, declaration.get("init"), composeMethod, internal);
                 }
                 else {
                     meshExpression(declaration.get("init"), internal);
@@ -523,6 +581,7 @@ function meshStatement(path, internal) {
             break;
         case "ExportDefaultDeclaration": {
             const declarationPath = path.get("declaration");
+            /* istanbul ignore else */
             if (t.isExpression(declarationPath.node)) {
                 meshExpression(declarationPath, internal);
             }
@@ -565,18 +624,26 @@ function composeExpression(path, internal, isRoot) {
         }
         case "CallExpression":
         case "OptionalCallExpression": {
-            const call = expr;
-            if ((0, call_js_1.calls)(call, ["watch"], internal)) {
+            if ((0, call_js_1.calls)(path, ["watch"], internal)) {
                 const args = (0, lib_js_1.parseCalculateCall)(path, internal);
+                /* istanbul ignore else */
                 if (args) {
                     if (args[1].elements.length > 0) {
-                        path.replaceWith(t.callExpression(t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
+                        path.replaceWith(t.callExpression(internal.stateOnly
+                            ? t.memberExpression(internal.id, t.identifier("ex"))
+                            : t.memberExpression(internal_js_1.ctx, t.identifier("watch")), args));
                     }
                     else {
                         path.replaceWith(t.callExpression(args[0], []));
                     }
                 }
             }
+            else if ((0, call_js_1.calls)(path, ["runOnDestroy"], internal)) {
+                if (internal.stateOnly) {
+                    throw path.buildCodeFrameError("Vasille: Stores in Vasille.JS are not destroyable");
+                }
+                path.get("callee").replaceWith(t.memberExpression(internal_js_1.ctx, t.identifier("runOnDestroy")));
+            }
             else {
                 meshExpression(path, internal);
             }
@@ -689,14 +756,14 @@ function composeStatement(path, internal, isRoot) {
             const _path = path;
             const kind = _path.node.kind;
             const declares = kind === "const" ? 1 /* VariableState.Ignored */ : 2 /* VariableState.Reactive */;
-            if (kind === "let" || kind === "var") {
-                _path.node.kind = "const";
-            }
+            let switchToConst = true;
             for (const declaration of _path.get("declarations")) {
                 const id = declaration.node.id;
+                const bridgeMethod = (0, bridge_1.processBridgeCall)(declaration.get("init"), internal);
                 let meshInit = true;
                 function idName(target = id) {
                     let name = "#";
+                    /* istanbul ignore else */
                     if (t.isIdentifier(target)) {
                         name = target.name;
                     }
@@ -707,7 +774,18 @@ function composeStatement(path, internal, isRoot) {
                     return [idName(pattern.elements[0]), idName(pattern.elements[1])];
                 }
                 ignoreParams(declaration.node.id, internal);
-                if ((0, call_js_1.calls)(declaration.node.init, ["awaited"], internal)) {
+                /* istanbul ignore else */
+                if (bridgeMethod === "value" && declares === 2 /* VariableState.Reactive */ && t.isIdentifier(declaration.node.id)) {
+                    switchToConst = true;
+                    meshInit = false;
+                    internal.stack.set(declaration.node.id.name, 2 /* VariableState.Reactive */);
+                    declaration.get("init").replaceWith((0, lib_js_1.ref)(declaration.node.init, internal, declaration.node.id.name));
+                }
+                else if (bridgeMethod) {
+                    switchToConst = false;
+                    meshInit = false;
+                }
+                else if ((0, call_js_1.calls)(declaration.get("init"), ["awaited"], internal)) {
                     reactiveArrayPattern(declaration.get("id"), internal);
                     meshAllUnknown(declaration.get("init").get("arguments"), internal);
                     (0, lib_js_1.named)(declaration.node.init, idDoubleName(), internal);
@@ -716,12 +794,15 @@ function composeStatement(path, internal, isRoot) {
                 else if (t.isIdentifier(id)) {
                     internal.stack.set(id.name, declares);
                     const init = declaration.node.init;
-                    if ((0, call_js_1.calls)(init, ["value"], internal)) {
+                    const initPath = declaration.get("init");
+                    let callName = false;
+                    if ((0, call_js_1.calls)(initPath, ["value"], internal)) {
                         internal.stack.set(id.name, 1 /* VariableState.Ignored */);
                         declaration.get("init").replaceWith(init.arguments[0]);
                         _path.node.kind = kind;
+                        switchToConst = false;
                     }
-                    else if ((0, call_js_1.calls)(init, ["bind"], internal)) {
+                    else if ((0, call_js_1.calls)(initPath, ["bind"], internal)) {
                         const argument = init.arguments[0];
                         const argumentPath = declaration.get("init").get("arguments")[0];
                         let replaceWith = declares === 2 /* VariableState.Reactive */
@@ -743,12 +824,12 @@ function composeStatement(path, internal, isRoot) {
                         declaration.get("init").replaceWith(replaceWith);
                         meshInit = !replaceWith;
                     }
-                    else if ((0, call_js_1.calls)(init, ["ref"], internal)) {
+                    else if ((0, call_js_1.calls)(initPath, ["ref"], internal)) {
                         const argument = init.arguments[0];
                         internal.stack.set(id.name, 2 /* VariableState.Reactive */);
                         declaration.get("init").replaceWith((0, lib_js_1.ref)(t.isExpression(argument) ? argument : null, internal, idName()));
                     }
-                    else if ((0, call_js_1.calls)(init, ["reactiveObject"], internal)) {
+                    else if ((0, call_js_1.calls)(initPath, ["reactiveObject"], internal)) {
                         const value = init.arguments[0];
                         if (kind !== "const") {
                             throw declaration.buildCodeFrameError(`Vasille: Reactive objects must be must be declared as constants`);
@@ -761,7 +842,7 @@ function composeStatement(path, internal, isRoot) {
                             throw declaration.buildCodeFrameError(`Vasille: reactiveObject requires object expression as argument`);
                         }
                     }
-                    else if ((0, call_js_1.calls)(init, ["arrayModel"], internal)) {
+                    else if ((0, call_js_1.calls)(initPath, ["arrayModel"], internal)) {
                         const value = init.arguments[0];
                         if (kind !== "const") {
                             throw declaration.buildCodeFrameError(`Vasille: Array models must be must be declared as constants`);
@@ -773,15 +854,14 @@ function composeStatement(path, internal, isRoot) {
                             declaration.get("init").replaceWith((0, lib_js_1.arrayModel)(null, internal, idName()));
                         }
                     }
-                    else if ((0, call_js_1.calls)(init, ["mapModel", "setModel"], internal)) {
+                    else if ((callName = (0, call_js_1.calls)(initPath, ["mapModel", "setModel"], internal))) {
                         const args = init.arguments;
-                        const name = (0, call_js_1.calls)(init, ["mapModel", "setModel"], internal);
                         if (kind !== "const") {
-                            throw declaration.buildCodeFrameError(`Vasille: ${name === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
+                            throw declaration.buildCodeFrameError(`Vasille: ${callName === "mapModel" ? "Map" : "Set"} models must be declared as constants`);
                         }
                         declaration
                             .get("init")
-                            .replaceWith(name === "mapModel" ? (0, lib_js_1.mapModel)(args, internal, idName()) : (0, lib_js_1.setModel)(args, internal, idName()));
+                            .replaceWith(callName === "mapModel" ? (0, lib_js_1.mapModel)(args, internal, idName()) : (0, lib_js_1.setModel)(args, internal, idName()));
                     }
                     else if (t.isObjectExpression(init)) {
                         if (kind !== "const") {
@@ -829,10 +909,24 @@ function composeStatement(path, internal, isRoot) {
                         meshInit = !replaceWith;
                     }
                 }
+                else if (t.isObjectPattern(id)) {
+                    for (const prop of id.properties) {
+                        /* istanbul ignore else */
+                        if (t.isObjectProperty(prop) && t.isIdentifier(prop.value)) {
+                            internal.stack.set(prop.value.name, 2 /* VariableState.Reactive */);
+                        }
+                        else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                            internal.stack.set(prop.argument.name, 3 /* VariableState.ReactiveObject */);
+                        }
+                    }
+                }
                 if (meshInit) {
                     meshExpression(declaration.get("init"), internal);
                 }
             }
+            if (switchToConst && (kind === "let" || kind === "var")) {
+                _path.node.kind = "const";
+            }
             break;
         }
         case "WhileStatement": {
@@ -855,26 +949,50 @@ function composeStatement(path, internal, isRoot) {
             meshStatement(path, internal);
     }
 }
-function compose(path, internal, isInternalSlot) {
+function compose(path, internal, isInternalSlot, composeMethod) {
     internal.stack.push();
     const node = path.node;
     const params = node.params;
     const body = node.body;
+    const argsNumber = composeArgsNumber[composeMethod];
     if (t.isFunctionExpression(node) && node.id) {
         internal.stack.set(node.id.name, 1 /* VariableState.Ignored */);
     }
-    if (params.length > 1 && !isInternalSlot) {
-        throw path.get("params")[1].buildCodeFrameError("Vasille: JSX component must have no more then 1 parameter");
+    if (params.length > argsNumber && !isInternalSlot) {
+        throw path.get("params")[argsNumber].buildCodeFrameError("Vasille: Extra parameters are not allowed");
     }
+    const cumulativeFields = new Set();
+    const nonPropsFields = [];
+    let index = 0;
     for (const param of path.get("params")) {
         const node = param.node;
+        const isProps = index === composePropsIndex[composeMethod];
         if (t.isAssignmentPattern(node)) {
             throw param.buildCodeFrameError("Vasille: No default value allowed here");
         }
-        if (t.isIdentifier(node)) {
-            internal.stack.set(node.name, isInternalSlot ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+        if (argsNumber !== 1) {
+            if (t.isObjectPattern(node)) {
+                for (const prop of node.properties) {
+                    if (t.isObjectProperty(prop)) {
+                        const name = (0, utils_1.stringify)(prop.key);
+                        if (cumulativeFields.has(name)) {
+                            throw param.buildCodeFrameError(`Vasille: Field "${name}" is defined twice`);
+                        }
+                        cumulativeFields.add(name);
+                        if (!isProps) {
+                            nonPropsFields.push(name);
+                        }
+                    }
+                    else {
+                        throw param.buildCodeFrameError("Vasille: Rest element is not supported here");
+                    }
+                }
+            }
         }
-        else if (isInternalSlot && t.isObjectPattern(node)) {
+        if (t.isIdentifier(node) && argsNumber === 1) {
+            internal.stack.set(node.name, isInternalSlot || !isProps ? 1 /* VariableState.Ignored */ : 3 /* VariableState.ReactiveObject */);
+        }
+        else if ((isInternalSlot || !isProps) && t.isObjectPattern(node)) {
             ignoreObjectPattern(node, internal);
         }
         else if (t.isObjectPattern(node)) {
@@ -883,6 +1001,7 @@ function compose(path, internal, isInternalSlot) {
                 if (t.isObjectProperty(node)) {
                     const key = node.key;
                     let keyName = "";
+                    /* istanbul ignore else */
                     if (t.isIdentifier(node.value)) {
                         keyName = node.value.name;
                     }
@@ -906,14 +1025,27 @@ function compose(path, internal, isInternalSlot) {
             }
         }
         else {
-            throw param.buildCodeFrameError("Vasille: Expected identifier or object pattern");
+            throw param.buildCodeFrameError(argsNumber === 1 ? "Vasille: Expected identifier or object pattern" : "Vasille: Expected object pattern here");
         }
+        index++;
+    }
+    if (argsNumber !== 1) {
+        node.params = [
+            t.objectPattern([
+                ...params[0].properties,
+                ...params[1].properties,
+            ]),
+        ];
     }
+    internal.isComposing = true;
+    /* istanbul ignore else */
     if (t.isExpression(body)) {
         composeExpression(path.get("body"), internal, true);
     }
     else if (t.isBlockStatement(body)) {
         composeStatement(path.get("body"), internal, true);
     }
+    internal.isComposing = false;
     internal.stack.pop();
+    return nonPropsFields;
 }

package/lib-node/router.js

@@ -0,0 +1,41 @@
+"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.routerReplace = routerReplace;
+const t = __importStar(require("@babel/types"));
+const internal_1 = require("./internal");
+function routerReplace(path) {
+    path.replaceWith(t.memberExpression(t.memberExpression(internal_1.ctx, t.identifier("runner")), t.identifier("router")));
+}

package/lib-node/transformer.js

@@ -57,6 +57,9 @@ const ignoreMembers = new Set([
     "laptop",
     "prefersDark",
     "prefersLight",
+    "bridge",
+    "router",
+    "runOnDestroy",
 ]);
 function extractText(node) {
     // no case found for string literal
@@ -89,8 +92,10 @@ function trProgram(path, devMode) {
             if (name) {
                 internal.prefix = name;
                 for (const specifier of statement.specifiers) {
+                    /* istanbul ignore else */
                     if (t.isImportNamespaceSpecifier(specifier)) {
                         internal.global = specifier.local.name;
+                        /* istanbul ignore else */
                         if (statement.source.value === "vasille-web") {
                             stylesConnected = true;
                         }
@@ -134,6 +139,7 @@ function trProgram(path, devMode) {
         const statement = statementPath.node;
         statementPath.replaceWith(t.importDeclaration([
             ...statement.specifiers.filter(item => {
+                /* istanbul ignore else */
                 if (t.isImportSpecifier(item) && t.isIdentifier(item.local)) {
                     return statementPath.scope.bindings[item.local.name].referenced;
                 }

package/lib-node/utils.js

@@ -0,0 +1,50 @@
+"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.stringify = stringify;
+const t = __importStar(require("@babel/types"));
+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;
+}