@next-core/brick-utils 2.43.7 → 2.44.0

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import { uniq, get, cloneDeep, set, isEmpty, escapeRegExp } from 'lodash';
+import { uniq, get, cloneDeep, set, isEmpty, escapeRegExp, pull } from 'lodash';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
@@ -686,7 +686,11 @@ function collectBricksInBrickConf(brickConf, collection) {
       onAnchorLoad,
       onAnchorUnload,
       onMessage,
-      onMessageClose
+      onMessageClose,
+      onBeforePageLoad,
+      onBeforePageLeave,
+      onMediaChange,
+      onScrollIntoView
     } = brickConf.lifeCycle;
 
     if (Array.isArray(useResolves)) {
@@ -699,14 +703,17 @@ function collectBricksInBrickConf(brickConf, collection) {
       });
     }
 
-    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);
   }
 
@@ -23375,5 +23382,281 @@ function makeThrottledAggregation(namespace, request, select) {
   };
 }
 
-export { JsonStorage, PrecookFunctionVisitor, PrecookVisitor, asyncProcessBrick, asyncProcessStoryboard, collectBricksByCustomTemplates, computeRealRoutePath, convertValueByPrecision, cook, createProviderClass, debounceByAnimationFrame, deepFreeze, formatValue, getDependencyMapOfContext, getDepsOfTemplates, getDllAndDepsByResource, getDllAndDepsOfBricks, getDllAndDepsOfStoryboard, getTemplateDepsOfStoryboard, hasOwnProperty$1 as hasOwnProperty, inject, isBrickNode, isCustomTemplateNode, isEvaluable, isObject, isRouteNode, isSnippetNode, lint, loadScript, makeThrottledAggregation, mapCustomApisToNameAndNamespace, matchPath, normalizeBuilderNode, normalizeMenu, parseForAnalysis, precook, precookFunction, preevaluate, prefetchScript, resolveContextConcurrently, restoreDynamicTemplates, scanAppGetMenuInAny, scanAppGetMenuInStoryboard, scanBricksInBrickConf, scanBricksInStoryboard, scanCustomApisInStoryboard, scanI18NInAny, scanI18NInStoryboard, scanInstalledAppsInStoryboard, scanPermissionActionsInAny, scanPermissionActionsInStoryboard, scanProcessorsInAny, scanProcessorsInStoryboard, scanRouteAliasInStoryboard, scanStoryboard, scanTemplatesInBrick, scanTemplatesInStoryboard, shouldAllowRecursiveEvaluations, smartDisplayForEvaluableString, syncResolveContextConcurrently, toPath, tokTypes_1 as tokTypes, trackContext, trackState, trackUsedContext, trackUsedState, transform, transformAndInject, visitStoryboardExpressions, visitStoryboardFunctions };
+/**
+ * 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);
+    }
+
+    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 {
+          constantFeatureFlags,
+          featureFlags
+        } = options;
+        var hasDynamicVariables = false;
+
+        for (var _item4 of attemptToVisitGlobals) {
+          if (_item4 !== "undefined" && (!constantFeatureFlags || _item4 !== "FLAGS")) {
+            hasDynamicVariables = true;
+            break;
+          }
+        }
+
+        if (hasDynamicVariables) {
+          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 originalIf = ifContainer.if;
+        var globalVariables = {
+          undefined: undefined
+        };
+
+        if (constantFeatureFlags) {
+          globalVariables.FLAGS = featureFlags;
+        }
+
+        ifContainer.if = !!cook(expression, source, {
+          globalVariables
+        });
+
+        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);
+}
+
+export { JsonStorage, PrecookFunctionVisitor, PrecookVisitor, asyncProcessBrick, asyncProcessStoryboard, collectBricksByCustomTemplates, computeConstantCondition, computeRealRoutePath, convertValueByPrecision, cook, createProviderClass, debounceByAnimationFrame, deepFreeze, formatValue, getDependencyMapOfContext, getDepsOfTemplates, getDllAndDepsByResource, getDllAndDepsOfBricks, getDllAndDepsOfStoryboard, getTemplateDepsOfStoryboard, hasOwnProperty$1 as hasOwnProperty, inject, isBrickNode, isCustomTemplateNode, isEvaluable, isObject, isRouteNode, isSnippetNode, lint, loadScript, makeThrottledAggregation, mapCustomApisToNameAndNamespace, matchPath, normalizeBuilderNode, normalizeMenu, parseForAnalysis, precook, precookFunction, preevaluate, prefetchScript, removeDeadConditions, removeDeadConditionsInTpl, resolveContextConcurrently, restoreDynamicTemplates, scanAppGetMenuInAny, scanAppGetMenuInStoryboard, scanBricksInBrickConf, scanBricksInStoryboard, scanCustomApisInStoryboard, scanI18NInAny, scanI18NInStoryboard, scanInstalledAppsInStoryboard, scanPermissionActionsInAny, scanPermissionActionsInStoryboard, scanProcessorsInAny, scanProcessorsInStoryboard, scanRouteAliasInStoryboard, scanStoryboard, scanTemplatesInBrick, scanTemplatesInStoryboard, shouldAllowRecursiveEvaluations, smartDisplayForEvaluableString, syncResolveContextConcurrently, toPath, tokTypes_1 as tokTypes, trackContext, trackState, trackUsedContext, trackUsedState, transform, transformAndInject, visitStoryboardExpressions, visitStoryboardFunctions };
 //# sourceMappingURL=index.esm.js.map