@next-core/brick-utils 2.30.3 → 2.31.0

package/dist/index.esm.js

@@ -2,9 +2,9 @@ import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import { uniq, get, cloneDeep, set, isEmpty, escapeRegExp } from 'lodash';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import { processPipes, utils } from '@next-core/pipes';
 export { pipes } from '@next-core/pipes';
-import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import yaml from 'js-yaml';
 
 var cache$1 = new Map();
@@ -18523,7 +18523,7 @@ function precook(rootAst) {
         Evaluate(n);
       }
     } else if (node) {
-      var _hooks$beforeVisit; // `node` maybe `null` in some cases.
+      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);
@@ -18532,11 +18532,10 @@ function precook(rootAst) {
       switch (node.type) {
         case "Identifier":
           if (!ResolveBinding(node.name)) {
-            attemptToVisitGlobals.add(node.name);
+            var _hooks$beforeVisitGlo;
 
-            if (visitors && hasOwnProperty(visitors, "__GlobalVariable")) {
-              visitors.__GlobalVariable(node);
-            }
+            (_hooks$beforeVisitGlo = hooks.beforeVisitGlobal) === null || _hooks$beforeVisitGlo === void 0 ? void 0 : _hooks$beforeVisitGlo.call(hooks, node);
+            attemptToVisitGlobals.add(node.name);
           }
 
           return;
@@ -18803,9 +18802,9 @@ function precook(rootAst) {
         }
       }
 
-      if (visitors && hasOwnProperty(visitors, "__UnknownNode")) {
-        visitors.__UnknownNode(node);
-      } else {
+      var silent = (_hooks$beforeVisitUnk = hooks.beforeVisitUnknown) === null || _hooks$beforeVisitUnk === void 0 ? void 0 : _hooks$beforeVisitUnk.call(hooks, node);
+
+      if (!silent) {
         // eslint-disable-next-line no-console
         console.warn("Unsupported node type `".concat(node.type, "`"));
       }
@@ -18991,93 +18990,100 @@ function lint(source) {
       }
     });
   } else {
-    var FunctionVisitor = node => {
-      if (node.async || node.generator) {
-        errors.push({
-          type: "SyntaxError",
-          message: "".concat(node.async ? "Async" : "Generator", " function is not allowed"),
-          loc: node.loc
-        });
-      }
-    };
-
     precook(func, {
-      visitors: {
-        ArrowFunctionExpression: FunctionVisitor,
-        FunctionDeclaration: FunctionVisitor,
-        FunctionExpression: FunctionVisitor,
-
-        Literal(node) {
-          if (node.regex) {
-            if (node.value === null) {
-              errors.push({
-                type: "SyntaxError",
-                message: "Invalid regular expression",
-                loc: node.loc
-              });
-            } else if (node.regex.flags.includes("u")) {
-              errors.push({
-                type: "SyntaxError",
-                message: "Unsupported unicode flag in regular expression",
-                loc: node.loc
-              });
-            }
-          }
-        },
-
-        ObjectExpression(node) {
-          for (var prop of node.properties) {
-            if (prop.type === "Property") {
-              if (prop.kind !== "init") {
+      hooks: {
+        beforeVisit(node) {
+          switch (node.type) {
+            case "ArrowFunctionExpression":
+            case "FunctionDeclaration":
+            case "FunctionExpression":
+              if (node.async || node.generator) {
                 errors.push({
                   type: "SyntaxError",
-                  message: "Unsupported object getter/setter property",
-                  loc: prop.loc
+                  message: "".concat(node.async ? "Async" : "Generator", " function is not allowed"),
+                  loc: node.loc
                 });
-              } else if (!prop.computed && prop.key.type === "Identifier" && prop.key.name === "__proto__") {
+              }
+
+              break;
+
+            case "Literal":
+              if (node.regex) {
+                if (node.value === null) {
+                  errors.push({
+                    type: "SyntaxError",
+                    message: "Invalid regular expression",
+                    loc: node.loc
+                  });
+                } else if (node.regex.flags.includes("u")) {
+                  errors.push({
+                    type: "SyntaxError",
+                    message: "Unsupported unicode flag in regular expression",
+                    loc: node.loc
+                  });
+                }
+              }
+
+              break;
+
+            case "ObjectExpression":
+              for (var prop of node.properties) {
+                if (prop.type === "Property") {
+                  if (prop.kind !== "init") {
+                    errors.push({
+                      type: "SyntaxError",
+                      message: "Unsupported object getter/setter property",
+                      loc: prop.loc
+                    });
+                  } else if (!prop.computed && prop.key.type === "Identifier" && prop.key.name === "__proto__") {
+                    errors.push({
+                      type: "TypeError",
+                      message: "Setting '__proto__' property is not allowed",
+                      loc: prop.key.loc
+                    });
+                  }
+                }
+              }
+
+              break;
+
+            case "VariableDeclaration":
+              if (node.kind === "var" && rules !== null && rules !== void 0 && rules.noVar) {
                 errors.push({
-                  type: "TypeError",
-                  message: "Setting '__proto__' property is not allowed",
-                  loc: prop.key.loc
+                  type: "SyntaxError",
+                  message: "Var declaration is not recommended, use `let` or `const` instead",
+                  loc: {
+                    start: node.loc.start,
+                    end: {
+                      line: node.loc.end.line,
+                      // Only decorate the "var".
+                      column: node.loc.start.column + 3
+                    }
+                  }
                 });
               }
-            }
+
+              break;
           }
         },
 
-        VariableDeclaration(node) {
-          if (node.kind === "var" && rules !== null && rules !== void 0 && rules.noVar) {
+        beforeVisitGlobal(node) {
+          if (node.name === "arguments") {
             errors.push({
               type: "SyntaxError",
-              message: "Var declaration is not recommended, use `let` or `const` instead",
-              loc: {
-                start: node.loc.start,
-                end: {
-                  line: node.loc.end.line,
-                  // Only decorate the "var".
-                  column: node.loc.start.column + 3
-                }
-              }
+              message: "Use the rest parameters instead of 'arguments'",
+              loc: node.loc
             });
           }
         },
 
-        __UnknownNode(node) {
+        beforeVisitUnknown(node) {
           errors.push({
             type: "SyntaxError",
             message: "Unsupported syntax: `".concat(node.type, "`"),
             loc: node.loc
           });
-        },
-
-        __GlobalVariable(node) {
-          if (node.name === "arguments") {
-            errors.push({
-              type: "SyntaxError",
-              message: "Use the rest parameters instead of 'arguments'",
-              loc: node.loc
-            });
-          }
+          return true;
         }
 
       }
@@ -20056,39 +20062,45 @@ function collectRouteAliasInRouteConfs(routes, collection) {
 
 var I18N = "I18N";
 function scanI18NInStoryboard(storyboard) {
-  // Notice: `menus` may contain evaluations of I18N too.
-  return scanI18NInAny([storyboard.routes, storyboard.meta && [storyboard.meta.customTemplates, storyboard.meta.menus]]);
+  var _storyboard$meta;
+
+  var collection = new Map();
+  var beforeVisit = beforeVisitFactory(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);
+
+  if (Array.isArray(functions)) {
+    for (var fn of functions) {
+      precookFunction(fn.source, {
+        typescript: fn.typescript,
+        hooks: {
+          beforeVisit
+        }
+      });
+    }
+  }
+
+  return collection;
 }
 function scanI18NInAny(data) {
   var collection = new Map();
-  collectI18N(data, collection);
+  collectI18N(data, beforeVisitFactory(collection));
   return collection;
 }
 
-function collectI18N(data, collection) {
+function collectI18N(data, beforeVisit) {
   var memo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
 
   if (typeof data === "string") {
     if (data.includes(I18N) && isEvaluable(data)) {
       preevaluate(data, {
-        visitors: {
-          CallExpression(node) {
-            var [keyNode, defaultNode] = node.arguments;
-
-            if (node.callee.type === "Identifier" && node.callee.name === I18N && 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);
-              }
-            }
-          }
-
+        hooks: {
+          beforeVisit
         }
       });
     }
@@ -20102,16 +20114,37 @@ function collectI18N(data, collection) {
 
     if (Array.isArray(data)) {
       for (var item of data) {
-        collectI18N(item, collection, memo);
+        collectI18N(item, beforeVisit, memo);
       }
     } else {
       for (var _item of Object.values(data)) {
-        collectI18N(_item, collection, memo);
+        collectI18N(_item, beforeVisit, memo);
       }
     }
   }
 }
 
+function beforeVisitFactory(collection) {
+  return function beforeVisit(node) {
+    if (node.type === "CallExpression") {
+      var [keyNode, defaultNode] = node.arguments;
+
+      if (node.callee.type === "Identifier" && node.callee.name === I18N && 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);
+        }
+      }
+    }
+  };
+}
+
 var LexicalStatus;
 
 (function (LexicalStatus) {