@next-core/brick-utils 2.31.0 → 2.31.1

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.31.1](https://github.com/easyops-cn/next-core/compare/@next-core/brick-utils@2.31.0...@next-core/brick-utils@2.31.1) (2021-11-29)
+
+
+### Bug Fixes
+
+* refine scanning global usage in expressions and functions ([1808401](https://github.com/easyops-cn/next-core/commit/1808401383ac2c7db8fc2335b4600b00b13c97bf))
+
+
+
+
+
 # [2.31.0](https://github.com/easyops-cn/next-core/compare/@next-core/brick-utils@2.30.3...@next-core/brick-utils@2.31.0) (2021-11-26)
 
 

package/dist/index.bundle.js

@@ -18502,6 +18502,7 @@
     var {
       expressionOnly,
       visitors,
+      withParent,
       hooks = {}
     } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var attemptToVisitGlobals = new Set();
@@ -18522,16 +18523,27 @@
       }
     }
 
-    function Evaluate(node) {
+    function EvaluateChildren(node, keys, parent) {
+      for (var key of keys) {
+        Evaluate(node[key], parent === null || parent === void 0 ? void 0 : parent.concat({
+          node,
+          key
+        }));
+      }
+    }
+
+    function Evaluate(node, parent) {
       if (Array.isArray(node)) {
-        for (var n of node) {
-          Evaluate(n);
-        }
+        node.forEach((n, index) => {
+          Evaluate(n, parent ? parent.slice(0, -1).concat(_objectSpread__default["default"](_objectSpread__default["default"]({}, parent[parent.length - 1]), {}, {
+            index
+          })) : parent);
+        });
       } else if (node) {
         var _hooks$beforeVisit, _hooks$beforeVisitUnk; // `node` maybe `null` in some cases.
 
 
-        (_hooks$beforeVisit = hooks.beforeVisit) === null || _hooks$beforeVisit === void 0 ? void 0 : _hooks$beforeVisit.call(hooks, node);
+        (_hooks$beforeVisit = hooks.beforeVisit) === null || _hooks$beforeVisit === void 0 ? void 0 : _hooks$beforeVisit.call(hooks, node, parent);
         visitors && visit(node); // Expressions:
 
         switch (node.type) {
@@ -18539,7 +18551,7 @@
             if (!ResolveBinding(node.name)) {
               var _hooks$beforeVisitGlo;
 
-              (_hooks$beforeVisitGlo = hooks.beforeVisitGlobal) === null || _hooks$beforeVisitGlo === void 0 ? void 0 : _hooks$beforeVisitGlo.call(hooks, node);
+              (_hooks$beforeVisitGlo = hooks.beforeVisitGlobal) === null || _hooks$beforeVisitGlo === void 0 ? void 0 : _hooks$beforeVisitGlo.call(hooks, node, parent);
               attemptToVisitGlobals.add(node.name);
             }
 
@@ -18547,76 +18559,71 @@
 
           case "ArrayExpression":
           case "ArrayPattern":
-            Evaluate(node.elements);
+            EvaluateChildren(node, ["elements"], parent);
             return;
 
           case "ArrowFunctionExpression":
             {
               var env = getRunningContext().LexicalEnvironment;
               var closure = OrdinaryFunctionCreate(node, env);
-              CallFunction(closure);
+              CallFunction(closure, parent);
               return;
             }
 
           case "AssignmentPattern":
           case "BinaryExpression":
           case "LogicalExpression":
-            Evaluate(node.left);
-            Evaluate(node.right);
+            EvaluateChildren(node, ["left", "right"], parent);
             return;
 
           case "CallExpression":
           case "NewExpression":
-            Evaluate(node.callee);
-            Evaluate(node.arguments);
+            EvaluateChildren(node, ["callee", "arguments"], parent);
             return;
 
           case "ChainExpression":
-            Evaluate(node.expression);
+            EvaluateChildren(node, ["expression"], parent);
             return;
 
           case "ConditionalExpression":
-            Evaluate(node.test);
-            Evaluate(node.consequent);
-            Evaluate(node.alternate);
+            EvaluateChildren(node, ["test", "consequent", "alternate"], parent);
             return;
 
           case "MemberExpression":
-            Evaluate(node.object);
+            EvaluateChildren(node, ["object"], parent);
 
             if (node.computed) {
-              Evaluate(node.property);
+              EvaluateChildren(node, ["property"], parent);
             }
 
             return;
 
           case "ObjectExpression":
           case "ObjectPattern":
-            Evaluate(node.properties);
+            EvaluateChildren(node, ["properties"], parent);
             return;
 
           case "Property":
             if (node.computed) {
-              Evaluate(node.key);
+              EvaluateChildren(node, ["key"], parent);
             }
 
-            Evaluate(node.value);
+            EvaluateChildren(node, ["value"], parent);
             return;
 
           case "RestElement":
           case "SpreadElement":
           case "UnaryExpression":
-            Evaluate(node.argument);
+            EvaluateChildren(node, ["argument"], parent);
             return;
 
           case "SequenceExpression":
           case "TemplateLiteral":
-            Evaluate(node.expressions);
+            EvaluateChildren(node, ["expressions"], parent);
             return;
 
           case "TaggedTemplateExpression":
-            Evaluate(node.tag);
-            Evaluate(node.quasi);
+            EvaluateChildren(node, ["tag", "quasi"], parent);
             return;
 
           case "Literal":
@@ -18627,8 +18634,7 @@
           // Statements and assignments:
           switch (node.type) {
             case "AssignmentExpression":
-              Evaluate(node.right);
-              Evaluate(node.left);
+              EvaluateChildren(node, ["right", "left"], parent);
               return;
 
             case "BlockStatement":
@@ -18642,7 +18648,7 @@
                 var blockEnv = new AnalysisEnvironment(oldEnv);
                 BlockDeclarationInstantiation(node.body, blockEnv);
                 runningContext.LexicalEnvironment = blockEnv;
-                Evaluate(node.body);
+                EvaluateChildren(node, ["body"], parent);
                 runningContext.LexicalEnvironment = oldEnv;
                 return;
               }
@@ -18660,20 +18666,18 @@
                 var catchEnv = new AnalysisEnvironment(_oldEnv);
                 BoundNamesInstantiation(node.param, catchEnv);
                 _runningContext.LexicalEnvironment = catchEnv;
-                Evaluate(node.param);
-                Evaluate(node.body);
+                EvaluateChildren(node, ["param", "body"], parent);
                 _runningContext.LexicalEnvironment = _oldEnv;
                 return;
               }
 
             case "DoWhileStatement":
-              Evaluate(node.body);
-              Evaluate(node.test);
+              EvaluateChildren(node, ["body", "test"], parent);
               return;
 
             case "ExpressionStatement":
             case "TSAsExpression":
-              Evaluate(node.expression);
+              EvaluateChildren(node, ["expression"], parent);
               return;
 
             case "ForInStatement":
@@ -18692,7 +18696,7 @@
                   _runningContext2.LexicalEnvironment = newEnv;
                 }
 
-                Evaluate(node.right);
+                EvaluateChildren(node, ["right"], parent);
                 _runningContext2.LexicalEnvironment = _oldEnv2; // ForIn/OfBodyEvaluation
 
                 if (lexicalBinding) {
@@ -18701,8 +18705,7 @@
                   _runningContext2.LexicalEnvironment = iterationEnv;
                 }
 
-                Evaluate(node.left);
-                Evaluate(node.body);
+                EvaluateChildren(node, ["left", "body"], parent);
                 _runningContext2.LexicalEnvironment = _oldEnv2;
                 return;
               }
@@ -18723,10 +18726,7 @@
                   _runningContext3.LexicalEnvironment = loopEnv;
                 }
 
-                Evaluate(node.init);
-                Evaluate(node.test);
-                Evaluate(node.body);
-                Evaluate(node.update);
+                EvaluateChildren(node, ["init", "test", "body", "update"], parent);
                 _runningContext3.LexicalEnvironment = _oldEnv3;
                 return;
               }
@@ -18739,7 +18739,7 @@
 
                 _env.CreateBinding(fn);
 
-                CallFunction(fo);
+                CallFunction(fo, parent);
                 return;
               }
 
@@ -18747,30 +18747,27 @@
               {
                 var _closure = InstantiateOrdinaryFunctionExpression(node);
 
-                CallFunction(_closure);
+                CallFunction(_closure, parent);
                 return;
               }
 
             case "IfStatement":
-              Evaluate(node.test);
-              Evaluate(node.consequent);
-              Evaluate(node.alternate);
+              EvaluateChildren(node, ["test", "consequent", "alternate"], parent);
               return;
 
             case "ReturnStatement":
             case "ThrowStatement":
             case "UpdateExpression":
-              Evaluate(node.argument);
+              EvaluateChildren(node, ["argument"], parent);
               return;
 
             case "SwitchCase":
-              Evaluate(node.test);
-              Evaluate(node.consequent);
+              EvaluateChildren(node, ["test", "consequent"], parent);
               return;
 
             case "SwitchStatement":
               {
-                Evaluate(node.discriminant);
+                EvaluateChildren(node, ["discriminant"], parent);
 
                 var _runningContext4 = getRunningContext();
 
@@ -18780,34 +18777,30 @@
 
                 BlockDeclarationInstantiation(node.cases, _blockEnv);
                 _runningContext4.LexicalEnvironment = _blockEnv;
-                Evaluate(node.cases);
+                EvaluateChildren(node, ["cases"], parent);
                 _runningContext4.LexicalEnvironment = _oldEnv4;
                 return;
               }
 
             case "TryStatement":
-              Evaluate(node.block);
-              Evaluate(node.handler);
-              Evaluate(node.finalizer);
+              EvaluateChildren(node, ["block", "handler", "finalizer"], parent);
               return;
 
             case "VariableDeclaration":
-              Evaluate(node.declarations);
+              EvaluateChildren(node, ["declarations"], parent);
               return;
 
             case "VariableDeclarator":
-              Evaluate(node.id);
-              Evaluate(node.init);
+              EvaluateChildren(node, ["id", "init"], parent);
               return;
 
             case "WhileStatement":
-              Evaluate(node.test);
-              Evaluate(node.body);
+              EvaluateChildren(node, ["test", "body"], parent);
               return;
           }
         }
 
-        var silent = (_hooks$beforeVisitUnk = hooks.beforeVisitUnknown) === null || _hooks$beforeVisitUnk === void 0 ? void 0 : _hooks$beforeVisitUnk.call(hooks, node);
+        var silent = (_hooks$beforeVisitUnk = hooks.beforeVisitUnknown) === null || _hooks$beforeVisitUnk === void 0 ? void 0 : _hooks$beforeVisitUnk.call(hooks, node, parent);
 
         if (!silent) {
           // eslint-disable-next-line no-console
@@ -18839,10 +18832,16 @@
       BoundNamesInstantiation(declarations, env);
     }
 
-    function CallFunction(closure) {
+    function CallFunction(closure, parent) {
       PrepareOrdinaryCall(closure);
-      FunctionDeclarationInstantiation(closure);
-      Evaluate(closure.ECMAScriptCode);
+      FunctionDeclarationInstantiation(closure, parent);
+      Evaluate(closure.ECMAScriptCode, parent === null || parent === void 0 ? void 0 : parent.concat({
+        node: closure.Function,
+        key: "body"
+      }).concat(closure.Function.body.type === "BlockStatement" ? {
+        node: closure.Function.body,
+        key: "body"
+      } : []));
       analysisContextStack.pop();
     }
 
@@ -18854,7 +18853,7 @@
       analysisContextStack.push(calleeContext);
     }
 
-    function FunctionDeclarationInstantiation(func) {
+    function FunctionDeclarationInstantiation(func, parent) {
       var calleeContext = getRunningContext();
       var code = func.ECMAScriptCode;
       var formals = func.FormalParameters;
@@ -18866,7 +18865,10 @@
       var varNames = collectBoundNames(varDeclarations);
       var env = calleeContext.LexicalEnvironment;
       BoundNamesInstantiation(formals, env);
-      Evaluate(formals);
+      Evaluate(formals, parent === null || parent === void 0 ? void 0 : parent.concat({
+        node: func.Function,
+        key: "params"
+      }));
       var varEnv;
 
       if (!hasParameterExpressions) {
@@ -18911,19 +18913,16 @@
       return OrdinaryFunctionCreate(functionExpression, funcEnv);
     }
 
-    function OrdinaryFunctionCreate(_ref, scope) {
-      var {
-        params,
-        body
-      } = _ref;
+    function OrdinaryFunctionCreate(func, scope) {
       return {
-        FormalParameters: params,
-        ECMAScriptCode: body.type === "BlockStatement" ? body.body : body,
+        Function: func,
+        FormalParameters: func.params,
+        ECMAScriptCode: func.body.type === "BlockStatement" ? func.body.body : func.body,
         Environment: scope
       };
     }
 
-    Evaluate(rootAst);
+    Evaluate(rootAst, withParent ? [] : undefined);
     return attemptToVisitGlobals;
   }
 
@@ -19183,12 +19182,16 @@
     if (typeof data === "string") {
       if (data.includes(PROCESSORS) && isEvaluable(data)) {
         preevaluate(data, {
-          visitors: {
-            MemberExpression(node) {
-              var accessNamespace = node.object;
+          withParent: true,
+          hooks: {
+            beforeVisitGlobal(node, parent) {
+              if (node.name === PROCESSORS) {
+                var memberParent = parent[parent.length - 1];
+                var outerMemberParent = parent[parent.length - 2];
 
-              if (!node.computed && node.property.type === "Identifier" && accessNamespace.type === "MemberExpression" && !accessNamespace.computed && accessNamespace.object.type === "Identifier" && accessNamespace.object.name === PROCESSORS && accessNamespace.property.type === "Identifier") {
-                collection.push("".concat(accessNamespace.property.name, ".").concat(node.property.name));
+                if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object" && !memberParent.node.computed && memberParent.node.property.type === "Identifier" && (outerMemberParent === null || outerMemberParent === void 0 ? void 0 : outerMemberParent.node.type) === "MemberExpression" && outerMemberParent.key === "object" && !outerMemberParent.node.computed && outerMemberParent.node.property.type === "Identifier") {
+                  collection.push("".concat(memberParent.node.property.name, ".").concat(outerMemberParent.node.property.name));
+                }
               }
             }
 
@@ -19979,12 +19982,18 @@
     if (typeof data === "string") {
       if (data.includes(PERMISSIONS) && isEvaluable(data)) {
         preevaluate(data, {
-          visitors: {
-            CallExpression(node) {
-              if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === PERMISSIONS && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === check) {
-                for (var arg of node.arguments) {
-                  if (arg.type === "Literal" && typeof arg.value === "string") {
-                    collection.add(arg.value);
+          withParent: true,
+          hooks: {
+            beforeVisitGlobal(node, parent) {
+              if (node.name === PERMISSIONS) {
+                var memberParent = parent[parent.length - 1];
+                var callParent = parent[parent.length - 2];
+
+                if ((callParent === null || callParent === void 0 ? void 0 : callParent.node.type) === "CallExpression" && (callParent === null || callParent === void 0 ? void 0 : callParent.key) === "callee" && (memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object" && !memberParent.node.computed && memberParent.node.property.type === "Identifier" && memberParent.node.property.name === check) {
+                  for (var arg of callParent.node.arguments) {
+                    if (arg.type === "Literal" && typeof arg.value === "string") {
+                      collection.add(arg.value);
+                    }
                   }
                 }
               }
@@ -20070,21 +20079,22 @@
     var _storyboard$meta;
 
     var collection = new Map();
-    var beforeVisit = beforeVisitFactory(collection); // Notice: `menus` may contain evaluations of I18N too.
+    var beforeVisitGlobal = beforeVisitGlobalFactory(collection); // Notice: `menus` may contain evaluations of I18N too.
 
     var {
       customTemplates,
       menus,
       functions
     } = (_storyboard$meta = storyboard.meta) !== null && _storyboard$meta !== void 0 ? _storyboard$meta : {};
-    collectI18N([storyboard.routes, customTemplates, menus], beforeVisit);
+    collectI18N([storyboard.routes, customTemplates, menus], beforeVisitGlobal);
 
     if (Array.isArray(functions)) {
       for (var fn of functions) {
         precookFunction(fn.source, {
           typescript: fn.typescript,
+          withParent: true,
           hooks: {
-            beforeVisit
+            beforeVisitGlobal
           }
         });
       }
@@ -20094,18 +20104,19 @@
   }
   function scanI18NInAny(data) {
     var collection = new Map();
-    collectI18N(data, beforeVisitFactory(collection));
+    collectI18N(data, beforeVisitGlobalFactory(collection));
     return collection;
   }
 
-  function collectI18N(data, beforeVisit) {
+  function collectI18N(data, beforeVisitGlobal) {
     var memo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
 
     if (typeof data === "string") {
       if (data.includes(I18N) && isEvaluable(data)) {
         preevaluate(data, {
+          withParent: true,
           hooks: {
-            beforeVisit
+            beforeVisitGlobal
           }
         });
       }
@@ -20119,31 +20130,35 @@
 
       if (Array.isArray(data)) {
         for (var item of data) {
-          collectI18N(item, beforeVisit, memo);
+          collectI18N(item, beforeVisitGlobal, memo);
         }
       } else {
         for (var _item of Object.values(data)) {
-          collectI18N(_item, beforeVisit, memo);
+          collectI18N(_item, beforeVisitGlobal, memo);
         }
       }
     }
   }
 
-  function beforeVisitFactory(collection) {
-    return function beforeVisit(node) {
-      if (node.type === "CallExpression") {
-        var [keyNode, defaultNode] = node.arguments;
+  function beforeVisitGlobalFactory(collection) {
+    return function beforeVisitGlobal(node, parent) {
+      if (node.name === I18N) {
+        var callParent = parent[parent.length - 1];
 
-        if (node.callee.type === "Identifier" && node.callee.name === I18N && keyNode && keyNode.type === "Literal" && typeof keyNode.value === "string") {
-          var valueSet = collection.get(keyNode.value);
+        if ((callParent === null || callParent === void 0 ? void 0 : callParent.node.type) === "CallExpression" && callParent.key === "callee") {
+          var [keyNode, defaultNode] = callParent.node.arguments;
 
-          if (!valueSet) {
-            valueSet = new Set();
-            collection.set(keyNode.value, valueSet);
-          }
+          if (keyNode && keyNode.type === "Literal" && typeof keyNode.value === "string") {
+            var valueSet = collection.get(keyNode.value);
+
+            if (!valueSet) {
+              valueSet = new Set();
+              collection.set(keyNode.value, valueSet);
+            }
 
-          if (defaultNode && defaultNode.type === "Literal" && typeof defaultNode.value === "string") {
-            valueSet.add(defaultNode.value);
+            if (defaultNode && defaultNode.type === "Literal" && typeof defaultNode.value === "string") {
+              valueSet.add(defaultNode.value);
+            }
           }
         }
       }
@@ -20820,23 +20835,35 @@
 
     return depsMap;
   }
-  var CTX = "CTX";
+  var CTX$1 = "CTX";
 
   function collectContexts(data, stats) {
     var memo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
 
     if (typeof data === "string") {
-      if (data.includes(CTX) && isEvaluable(data)) {
+      if (data.includes(CTX$1) && isEvaluable(data)) {
         preevaluate(data, {
-          visitors: {
-            MemberExpression(node) {
-              if (node.object.type === "Identifier" && node.object.name === CTX) {
-                if (!node.computed && node.property.type === "Identifier") {
-                  if (!stats.dependencies.includes(node.property.name)) {
-                    stats.dependencies.push(node.property.name);
+          withParent: true,
+          hooks: {
+            beforeVisitGlobal(node, parent) {
+              if (node.name === CTX$1) {
+                var memberParent = parent[parent.length - 1];
+
+                if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
+                  var memberNode = memberParent.node;
+                  var dep;
+
+                  if (!memberNode.computed && memberNode.property.type === "Identifier") {
+                    dep = memberNode.property.name;
+                  } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
+                    dep = memberNode.property.value;
+                  } else {
+                    stats.includesComputed = true;
+                  }
+
+                  if (dep !== undefined && !stats.dependencies.includes(dep)) {
+                    stats.dependencies.push(dep);
                   }
-                } else {
-                  stats.includesComputed = true;
                 }
               }
             }
@@ -21134,6 +21161,7 @@
   }
 
   var TRACK_CONTEXT = "track context";
+  var CTX = "CTX";
   /**
    * Get tracking CTX for an evaluable expression in `track context` mode.
    *
@@ -21167,13 +21195,20 @@
       var {
         expression
       } = preevaluate(raw, {
-        visitors: {
-          MemberExpression(node) {
-            if (node.object.type === "Identifier" && node.object.name === "CTX") {
-              if (!node.computed && node.property.type === "Identifier") {
-                contexts.add(node.property.name);
-              } else if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
-                contexts.add(node.property.value);
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal(node, parent) {
+            if (node.name === CTX) {
+              var memberParent = parent[parent.length - 1];
+
+              if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
+                var memberNode = memberParent.node;
+
+                if (!memberNode.computed && memberNode.property.type === "Identifier") {
+                  contexts.add(memberNode.property.name);
+                } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
+                  contexts.add(memberNode.property.value);
+                }
               }
             }
           }