@next-core/brick-utils 2.30.3 → 2.31.0

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.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)
+
+
+### Features
+
+* scan i18n in storyboard functions ([e0f68fb](https://github.com/easyops-cn/next-core/commit/e0f68fb456e12f62b4f68b380d66e3a535aaef56))
+
+
+
+
+
 ## [2.30.3](https://github.com/easyops-cn/next-core/compare/@next-core/brick-utils@2.30.2...@next-core/brick-utils@2.30.3) (2021-11-25)
 
 **Note:** Version bump only for package @next-core/brick-utils

package/dist/index.bundle.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@next-core/pipes'), require('@babel/runtime/helpers/objectWithoutProperties'), require('js-yaml')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@next-core/pipes', '@babel/runtime/helpers/objectWithoutProperties', 'js-yaml'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global.pipes, global._objectWithoutProperties, global.yaml));
-})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, pipes, _objectWithoutProperties, yaml) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/objectWithoutProperties'), require('@next-core/pipes'), require('js-yaml')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/objectWithoutProperties', '@next-core/pipes', 'js-yaml'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global._objectWithoutProperties, global.pipes, global.yaml));
+})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, _objectWithoutProperties, pipes, yaml) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -18528,7 +18528,7 @@
           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);
@@ -18537,11 +18537,10 @@
         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;
@@ -18808,9 +18807,9 @@
           }
         }
 
-        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, "`"));
         }
@@ -18996,93 +18995,100 @@
         }
       });
     } 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;
           }
 
         }
@@ -20061,39 +20067,45 @@
 
   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
           }
         });
       }
@@ -20107,16 +20119,37 @@
 
       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) {