@next-core/brick-utils 2.43.6 → 2.43.8

package/dist/index.bundle.js

@@ -691,7 +691,11 @@
         onAnchorLoad,
         onAnchorUnload,
         onMessage,
-        onMessageClose
+        onMessageClose,
+        onBeforePageLoad,
+        onBeforePageLeave,
+        onMediaChange,
+        onScrollIntoView
       } = brickConf.lifeCycle;
 
       if (Array.isArray(useResolves)) {
@@ -704,14 +708,17 @@
         });
       }
 
-      var messageLifeCycleHandlers = [].concat(onMessage).filter(Boolean).reduce((previousValue, currentValue) => previousValue.concat(currentValue.handlers), []);
+      var specialHandlers = [].concat(onMessage, onScrollIntoView).filter(Boolean).reduce((previousValue, currentValue) => previousValue.concat(currentValue.handlers), []);
       collectUsedBricksInEventHandlers({
         onPageLoad,
         onPageLeave,
         onAnchorLoad,
         onAnchorUnload,
         onMessageClose,
-        onMessage: messageLifeCycleHandlers
+        onBeforePageLoad,
+        onBeforePageLeave,
+        onMediaChange,
+        specialHandlers
       }, collection);
     }
 
@@ -23380,6 +23387,280 @@
     };
   }
 
+  /**
+   * Remove dead conditions in storyboard like `if: '<% FLAGS["your-feature-flag"] %>'` when
+   * `FLAGS["your-feature-flag"]` is falsy.
+   */
+  function removeDeadConditions(storyboard, options) {
+    var _storyboard$meta;
+
+    if (storyboard.$$deadConditionsRemoved) {
+      return;
+    }
+
+    removeDeadConditionsInRoutes(storyboard.routes, options);
+    var {
+      customTemplates
+    } = (_storyboard$meta = storyboard.meta) !== null && _storyboard$meta !== void 0 ? _storyboard$meta : {};
+
+    if (Array.isArray(customTemplates)) {
+      for (var tpl of customTemplates) {
+        removeDeadConditionsInTpl(tpl, options);
+      }
+    }
+
+    storyboard.$$deadConditionsRemoved = true;
+  }
+  /**
+   * Like `removeDeadConditions` but applied to a custom template.
+   */
+
+  function removeDeadConditionsInTpl(tplConstructor, options) {
+    removeDeadConditionsInBricks(tplConstructor.bricks, options);
+  }
+
+  function removeDeadConditionsInRoutes(routes, options) {
+    removeDeadConditionsInArray(routes, options, route => {
+      removeDeadConditionsInContext(route.context, options);
+
+      if (route.type === "routes") {
+        removeDeadConditionsInRoutes(route.routes, options);
+      } else {
+        removeDeadConditionsInBricks(route.bricks, options);
+      }
+    });
+  }
+
+  function removeDeadConditionsInBricks(bricks, options) {
+    removeDeadConditionsInArray(bricks, options, brick => {
+      if (brick.slots) {
+        for (var slot of Object.values(brick.slots)) {
+          if (slot.type === "routes") {
+            removeDeadConditionsInRoutes(slot.routes, options);
+          } else {
+            removeDeadConditionsInBricks(slot.bricks, options);
+          }
+        }
+      }
+
+      removeDeadConditionsInLifeCycle(brick.lifeCycle, options);
+      removeDeadConditionsInEvents(brick.events, options);
+      removeDeadConditionsInContext(brick.context, options);
+      removeDeadConditionsInProperties(brick.properties, options);
+    });
+  }
+
+  function removeDeadConditionsInProperties(value, options) {
+    if (Array.isArray(value)) {
+      for (var _item of value) {
+        removeDeadConditionsInProperties(_item, options);
+      }
+    } else if (isObject(value)) {
+      if (value.useBrick) {
+        if (Array.isArray(value.useBrick)) {
+          // For useBrick as array, just remove dead items.
+          removeDeadConditionsInArray(value.useBrick, options, useBrick => {
+            removeDeadConditionsInUseBrick(useBrick, options);
+          });
+        } else {
+          // For useBrick as single one, we have to keep it,
+          // and we change it to an empty <div>.
+          computeConstantCondition(value.useBrick, options);
+
+          if (value.useBrick.if === false) {
+            value.useBrick = {
+              brick: "div",
+              if: false
+            };
+          } else {
+            removeDeadConditionsInUseBrick(value.useBrick, options);
+          }
+        }
+      } else {
+        for (var _item2 of Object.values(value)) {
+          removeDeadConditionsInProperties(_item2, options);
+        }
+      }
+    }
+  }
+
+  function removeDeadConditionsInUseBrick(useBrick, options) {
+    removeDeadConditionsInProperties(useBrick.properties, options);
+    removeDeadConditionsInEvents(useBrick.events, options);
+
+    if (useBrick.slots) {
+      for (var slot of Object.values(useBrick.slots)) {
+        removeDeadConditionsInBricks(slot.bricks, options);
+      }
+    }
+  }
+
+  function removeDeadConditionsInEvents(events, options) {
+    if (isObject(events)) {
+      for (var eventType of Object.keys(events)) {
+        removeDeadConditionsInEvent(events, eventType, options);
+      }
+    }
+  }
+
+  function removeDeadConditionsInEvent(events, eventType, options) {
+    var handlers = events[eventType];
+
+    if (!handlers) {
+      return;
+    }
+
+    if (Array.isArray(handlers)) {
+      removeDeadConditionsInArray(handlers, options, handler => {
+        if (handler.callback) {
+          removeDeadConditionsInEvents(handler.callback, options);
+        }
+      });
+    } else {
+      computeConstantCondition(handlers, options);
+
+      if (handlers.if === false) {
+        delete events[eventType];
+        return;
+      }
+
+      if (handlers.callback) {
+        removeDeadConditionsInEvents(handlers.callback, options);
+      }
+    }
+  }
+
+  function removeDeadConditionsInContext(context, options) {
+    removeDeadConditionsInArray(context, options);
+  }
+
+  function removeDeadConditionsInArray(list, options, callback) {
+    if (Array.isArray(list)) {
+      var removes = [];
+
+      for (var _item3 of list) {
+        computeConstantCondition(_item3, options);
+
+        if (_item3.if === false) {
+          removes.push(_item3);
+          continue;
+        }
+
+        callback === null || callback === void 0 ? void 0 : callback(_item3);
+      }
+
+      lodash.pull(list, ...removes);
+    }
+  }
+
+  function removeDeadConditionsInLifeCycle(lifeCycle, options) {
+    if (lifeCycle) {
+      removeDeadConditionsInArray(lifeCycle.useResolves, options);
+
+      for (var key of ["onPageLoad", "onPageLeave", "onAnchorLoad", "onAnchorUnload", "onMessageClose", "onBeforePageLoad", "onBeforePageLeave", "onMediaChange"]) {
+        removeDeadConditionsInEvent(lifeCycle, key, options);
+      }
+
+      for (var _key of ["onMessage", "onScrollIntoView"]) {
+        for (var withHandlers of [].concat(lifeCycle[_key])) {
+          if (withHandlers) {
+            removeDeadConditionsInEvent(withHandlers, "handlers", options);
+          }
+        }
+      }
+    }
+  }
+
+  function computeConstantCondition(ifContainer) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    if (hasOwnProperty$1(ifContainer, "if")) {
+      if (typeof ifContainer.if === "string" && isEvaluable(ifContainer.if)) {
+        try {
+          var {
+            expression,
+            attemptToVisitGlobals,
+            source
+          } = preevaluate(ifContainer.if);
+          var hasOtherThanFlags = false;
+
+          for (var _item4 of attemptToVisitGlobals) {
+            if (_item4 !== "undefined" && _item4 !== "FLAGS") {
+              hasOtherThanFlags = true;
+              break;
+            }
+          }
+
+          if (hasOtherThanFlags) {
+            if (isConstantLogical(expression, false, options)) {
+              if (process.env.NODE_ENV === "development") {
+                // eslint-disable-next-line no-console
+                console.warn("[removed dead if]:", ifContainer.if, ifContainer);
+              }
+
+              ifContainer.if = false;
+            }
+
+            return;
+          }
+
+          var {
+            constantFeatureFlags,
+            featureFlags
+          } = options;
+
+          if (constantFeatureFlags) {
+            var originalIf = ifContainer.if;
+            ifContainer.if = !!cook(expression, source, {
+              globalVariables: {
+                undefined: undefined,
+                FLAGS: featureFlags
+              }
+            });
+
+            if (process.env.NODE_ENV === "development" && ifContainer.if === false) {
+              // eslint-disable-next-line no-console
+              console.warn("[removed dead if]:", originalIf, ifContainer);
+            }
+          }
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error("Parse storyboard expression failed:", error);
+        }
+      } else if (!ifContainer.if && ifContainer.if !== false) {
+        // eslint-disable-next-line no-console
+        console.warn("[potential dead if]:", typeof ifContainer.if, ifContainer.if, ifContainer);
+      }
+    }
+  }
+  /**
+   * We can safely remove the code for the following use cases,
+   * even though they contain runtime variables such as CTX:
+   *
+   * - if: '<% false && CTX.any %>'
+   * - if: '<% FLAGS["disabled"] && CTX.any %>'
+   * - if: '<% !FLAGS["enabled"] && CTX.any %>'
+   * - if: '<% !(FLAGS["enabled"] || CTX.any) %>'
+   *
+   * Since these logics will always get a falsy result.
+   *
+   * Here we simply only consider these kinds of AST node:
+   *
+   * - LogicalExpression: with operator of '||' or '&&'
+   * - UnaryExpression: with operator of '!'
+   * - Literal: such as boolean/number/string/null/regex
+   * - MemberExpression: of 'FLAGS["disabled"]' or 'FLAGS.disabled'
+   * - Identifier: of 'undefined'
+   */
+
+  function isConstantLogical(node, expect, options) {
+    var {
+      constantFeatureFlags,
+      featureFlags
+    } = options;
+    return node.type === "LogicalExpression" ? node.operator === (expect ? "||" : "&&") && [node.left, node.right].some(item => isConstantLogical(item, expect, options)) : node.type === "UnaryExpression" ? node.operator === "!" && isConstantLogical(node.argument, !expect, options) : node.type === "Literal" ? !!node.value === expect : node.type === "Identifier" ? node.name === "undefined" ? !expect : false : constantFeatureFlags && node.type === "MemberExpression" && node.object.type === "Identifier" && node.object.name === "FLAGS" && (node.computed ? node.property.type === "Literal" && typeof node.property.value === "string" && !!featureFlags[node.property.value] === expect : node.property.type === "Identifier" && !!featureFlags[node.property.name] === expect);
+  }
+
   Object.defineProperty(exports, 'pipes', {
     enumerable: true,
     get: function () { return pipes.pipes; }
@@ -23390,6 +23671,7 @@
   exports.asyncProcessBrick = asyncProcessBrick;
   exports.asyncProcessStoryboard = asyncProcessStoryboard;
   exports.collectBricksByCustomTemplates = collectBricksByCustomTemplates;
+  exports.computeConstantCondition = computeConstantCondition;
   exports.computeRealRoutePath = computeRealRoutePath;
   exports.convertValueByPrecision = convertValueByPrecision;
   exports.cook = cook;
@@ -23423,6 +23705,8 @@
   exports.precookFunction = precookFunction;
   exports.preevaluate = preevaluate;
   exports.prefetchScript = prefetchScript;
+  exports.removeDeadConditions = removeDeadConditions;
+  exports.removeDeadConditionsInTpl = removeDeadConditionsInTpl;
   exports.resolveContextConcurrently = resolveContextConcurrently;
   exports.restoreDynamicTemplates = restoreDynamicTemplates;
   exports.scanAppGetMenuInAny = scanAppGetMenuInAny;