@next-core/brick-utils 2.31.0 → 2.31.1

package/dist/index.esm.js

@@ -18497,6 +18497,7 @@ function precook(rootAst) {
   var {
     expressionOnly,
     visitors,
+    withParent,
     hooks = {}
   } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var attemptToVisitGlobals = new Set();
@@ -18517,16 +18518,27 @@ function precook(rootAst) {
     }
   }
 
-  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(_objectSpread({}, 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) {
@@ -18534,7 +18546,7 @@ function precook(rootAst) {
           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);
           }
 
@@ -18542,76 +18554,71 @@ function precook(rootAst) {
 
         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":
@@ -18622,8 +18629,7 @@ function precook(rootAst) {
         // Statements and assignments:
         switch (node.type) {
           case "AssignmentExpression":
-            Evaluate(node.right);
-            Evaluate(node.left);
+            EvaluateChildren(node, ["right", "left"], parent);
             return;
 
           case "BlockStatement":
@@ -18637,7 +18643,7 @@ function precook(rootAst) {
               var blockEnv = new AnalysisEnvironment(oldEnv);
               BlockDeclarationInstantiation(node.body, blockEnv);
               runningContext.LexicalEnvironment = blockEnv;
-              Evaluate(node.body);
+              EvaluateChildren(node, ["body"], parent);
               runningContext.LexicalEnvironment = oldEnv;
               return;
             }
@@ -18655,20 +18661,18 @@ function precook(rootAst) {
               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":
@@ -18687,7 +18691,7 @@ function precook(rootAst) {
                 _runningContext2.LexicalEnvironment = newEnv;
               }
 
-              Evaluate(node.right);
+              EvaluateChildren(node, ["right"], parent);
               _runningContext2.LexicalEnvironment = _oldEnv2; // ForIn/OfBodyEvaluation
 
               if (lexicalBinding) {
@@ -18696,8 +18700,7 @@ function precook(rootAst) {
                 _runningContext2.LexicalEnvironment = iterationEnv;
               }
 
-              Evaluate(node.left);
-              Evaluate(node.body);
+              EvaluateChildren(node, ["left", "body"], parent);
               _runningContext2.LexicalEnvironment = _oldEnv2;
               return;
             }
@@ -18718,10 +18721,7 @@ function precook(rootAst) {
                 _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;
             }
@@ -18734,7 +18734,7 @@ function precook(rootAst) {
 
               _env.CreateBinding(fn);
 
-              CallFunction(fo);
+              CallFunction(fo, parent);
               return;
             }
 
@@ -18742,30 +18742,27 @@ function precook(rootAst) {
             {
               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();
 
@@ -18775,34 +18772,30 @@ function precook(rootAst) {
 
               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
@@ -18834,10 +18827,16 @@ function precook(rootAst) {
     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();
   }
 
@@ -18849,7 +18848,7 @@ function precook(rootAst) {
     analysisContextStack.push(calleeContext);
   }
 
-  function FunctionDeclarationInstantiation(func) {
+  function FunctionDeclarationInstantiation(func, parent) {
     var calleeContext = getRunningContext();
     var code = func.ECMAScriptCode;
     var formals = func.FormalParameters;
@@ -18861,7 +18860,10 @@ function precook(rootAst) {
     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) {
@@ -18906,19 +18908,16 @@ function precook(rootAst) {
     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;
 }
 
@@ -19178,12 +19177,16 @@ function collectProcessors(data, collection) {
   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));
+              }
             }
           }
 
@@ -19974,12 +19977,18 @@ function collectPermissionActions(data, collection) {
   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);
+                  }
                 }
               }
             }
@@ -20065,21 +20074,22 @@ function scanI18NInStoryboard(storyboard) {
   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
         }
       });
     }
@@ -20089,18 +20099,19 @@ function scanI18NInStoryboard(storyboard) {
 }
 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
         }
       });
     }
@@ -20114,31 +20125,35 @@ function collectI18N(data, beforeVisit) {
 
     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);
+          }
         }
       }
     }
@@ -20815,23 +20830,35 @@ function getDependencyMapOfContext(contextConfs) {
 
   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;
               }
             }
           }
@@ -21129,6 +21156,7 @@ function deepFreeze(object) {
 }
 
 var TRACK_CONTEXT = "track context";
+var CTX = "CTX";
 /**
  * Get tracking CTX for an evaluable expression in `track context` mode.
  *
@@ -21162,13 +21190,20 @@ function trackContext(raw) {
     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);
+              }
             }
           }
         }