@next-core/brick-utils 2.44.7 → 2.45.0

package/dist/index.bundle.js

@@ -605,271 +605,616 @@
   }
 
   // Ref https://github.com/lodash/lodash/blob/4.17.11/lodash.js#L11744
-  function isObject(value) {
+  function isObject$1(value) {
     var type = typeof value;
     return value != null && (type == "object" || type == "function");
   }
 
-  /**
-   * Scan bricks and custom apis in storyboard.
-   *
-   * @param storyboard - Storyboard.
-   * @param options - If options is a boolean, it means `isUniq` or `de-duplicate`.
-   */
-  function scanStoryboard(storyboard) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var {
-      keepDuplicates,
-      ignoreBricksInUnusedCustomTemplates
-    } = isObject(options) ? options : {
-      keepDuplicates: !options
+  /** Parse storyboard as AST. */
+
+  function parseStoryboard(storyboard) {
+    var _storyboard$meta;
+
+    return {
+      type: "Root",
+      raw: storyboard,
+      routes: parseRoutes(storyboard.routes),
+      templates: parseTemplates((_storyboard$meta = storyboard.meta) === null || _storyboard$meta === void 0 ? void 0 : _storyboard$meta.customTemplates)
     };
-    var collection = [];
-    collectBricksInRouteConfs(storyboard.routes, collection);
-    var selfDefined = new Set(["form-renderer.form-renderer"]);
+  }
+  /** Parse storyboard routes as AST. */
 
-    if (ignoreBricksInUnusedCustomTemplates) {
-      var _storyboard$meta;
+  function parseRoutes(routes, options) {
+    if (Array.isArray(routes)) {
+      return routes.map(route => _objectSpread__default["default"](_objectSpread__default["default"]({
+        type: "Route",
+        raw: route
+      }, options !== null && options !== void 0 && options.routesOnly ? null : {
+        context: parseContext(route.context),
+        redirect: parseResolvable(route.redirect),
+        menu: parseMenu(route.menu),
+        providers: parseRouteProviders(route.providers),
+        defineResolves: Array.isArray(route.defineResolves) ? route.defineResolves.map(item => parseResolvable(item)).filter(Boolean) : undefined
+      }), {}, {
+        children: route.type === "routes" ? parseRoutes(route.routes, options) : parseBricks(route.bricks, options)
+      }));
+    }
+
+    return [];
+  }
+  /** Parse storyboard templates as AST. */
 
-      // Only collect bricks in used custom templates.
-      var collectionByTpl = collectBricksByCustomTemplates((_storyboard$meta = storyboard.meta) === null || _storyboard$meta === void 0 ? void 0 : _storyboard$meta.customTemplates);
+  function parseTemplates(templates) {
+    if (Array.isArray(templates)) {
+      return templates.map(parseTemplate);
+    }
 
-      for (var item of collection) {
-        if (collectionByTpl.has(item) && !selfDefined.has(item)) {
-          selfDefined.add(item);
-          collection.push(...collectionByTpl.get(item));
-        }
-      }
-    } else {
-      var _storyboard$meta2;
+    return [];
+  }
+  /** Parse a storyboard template as AST. */
 
-      collectBricksInCustomTemplates((_storyboard$meta2 = storyboard.meta) === null || _storyboard$meta2 === void 0 ? void 0 : _storyboard$meta2.customTemplates, collection, selfDefined);
+  function parseTemplate(tpl) {
+    return {
+      type: "Template",
+      raw: tpl,
+      bricks: parseBricks(tpl.bricks),
+      context: parseContext(tpl.state)
+    };
+  }
+
+  function parseBricks(bricks, options) {
+    if (Array.isArray(bricks)) {
+      return bricks.map(brick => parseBrick(brick, options));
     }
 
-    var bricks = [];
-    var customApis = [];
-    collection.forEach(item => {
-      if (item.includes("@")) {
-        customApis.push(item);
-      } else {
-        if (item.includes("-") && !selfDefined.has(item)) {
-          bricks.push(item);
-        }
-      }
+    return [];
+  }
+  /** Parse a storyboard brick as AST. */
+
+
+  function parseBrick(brick, options) {
+    return _objectSpread__default["default"](_objectSpread__default["default"]({
+      type: "Brick",
+      raw: brick,
+      isUseBrick: options === null || options === void 0 ? void 0 : options.isUseBrick
+    }, options !== null && options !== void 0 && options.routesOnly ? null : _objectSpread__default["default"](_objectSpread__default["default"]({
+      if: parseCondition(brick.if),
+      events: parseEvents(brick.events),
+      lifeCycle: parseLifeCycles(brick.lifeCycle)
+    }, parseBrickProperties(brick.properties)), {}, {
+      context: parseContext(brick.context)
+    })), {}, {
+      children: parseSlots(brick.slots, options)
     });
+  }
+
+  function parseCondition(condition) {
+    if (isObject(condition)) {
+      return {
+        type: "ResolvableCondition",
+        resolve: parseResolvable(condition)
+      };
+    }
+
     return {
-      bricks: keepDuplicates ? bricks : lodash.uniq(bricks),
-      customApis: keepDuplicates ? customApis : lodash.uniq(customApis)
+      type: "LiteralCondition"
     };
   }
-  function collectBricksInBrickConf(brickConf, collection) {
-    if (brickConf.brick) {
-      collection.push(brickConf.brick);
-    }
 
-    if (brickConf.slots) {
-      Object.values(brickConf.slots).forEach(slotConf => {
-        if (slotConf.type === "routes") {
-          collectBricksInRouteConfs(slotConf.routes, collection);
+  function parseBrickProperties(props) {
+    var useBrick = [];
+    var useBackend = [];
+
+    function walkBrickProperties(value) {
+      if (Array.isArray(value)) {
+        for (var item of value) {
+          walkBrickProperties(item);
+        }
+      } else if (isObject(value)) {
+        if (value.useBrick || value.useBackend) {
+          var _value$useBackend;
+
+          if (value.useBrick) {
+            useBrick.push({
+              type: "UseBrickEntry",
+              rawContainer: value,
+              rawKey: "useBrick",
+              children: parseBricks([].concat(value.useBrick), {
+                isUseBrick: true
+              })
+            });
+          }
+
+          var provider = (_value$useBackend = value.useBackend) === null || _value$useBackend === void 0 ? void 0 : _value$useBackend.provider;
+
+          if (typeof provider === "string") {
+            useBackend.push({
+              type: "UseBackendEntry",
+              rawContainer: value,
+              rawKey: "useBackend",
+              children: [parseBrick({
+                brick: provider
+              })]
+            });
+          }
         } else {
-          collectBricksInBrickConfs(slotConf.bricks, collection);
+          for (var _item of Object.values(value)) {
+            walkBrickProperties(_item);
+          }
+        }
+      }
+    }
+
+    walkBrickProperties(props);
+    return {
+      useBrick,
+      useBackend
+    };
+  }
+
+  function parseLifeCycles(lifeCycle) {
+    if (isObject(lifeCycle)) {
+      return Object.entries(lifeCycle).map(_ref => {
+        var [name, conf] = _ref;
+
+        switch (name) {
+          case "useResolves":
+            return {
+              type: "ResolveLifeCycle",
+              rawContainer: lifeCycle,
+              rawKey: name,
+              resolves: Array.isArray(conf) ? conf.map(item => parseResolvable(item, true)).filter(Boolean) : undefined
+            };
+
+          case "onPageLoad":
+          case "onPageLeave":
+          case "onAnchorLoad":
+          case "onAnchorUnload":
+          case "onMessageClose":
+          case "onBeforePageLoad":
+          case "onBeforePageLeave":
+          case "onMediaChange":
+            return {
+              type: "SimpleLifeCycle",
+              name,
+              rawContainer: lifeCycle,
+              rawKey: name,
+              handlers: parseEventHandlers(conf)
+            };
+
+          case "onMessage":
+          case "onScrollIntoView":
+            return {
+              type: "ConditionalLifeCycle",
+              name,
+              events: [].concat(conf).filter(Boolean).map(item => ({
+                type: "ConditionalEvent",
+                rawContainer: item,
+                rawKey: "handlers",
+                handlers: parseEventHandlers(item.handlers)
+              }))
+            };
+
+          default:
+            return {
+              type: "UnknownLifeCycle"
+            };
         }
       });
     }
+  }
 
-    if (Array.isArray(brickConf.internalUsedBricks)) {
-      brickConf.internalUsedBricks.forEach(brick => {
-        collection.push(brick);
+  function parseSlots(slots, options) {
+    if (isObject(slots)) {
+      return Object.entries(slots).map(_ref2 => {
+        var [slot, conf] = _ref2;
+        return {
+          type: "Slot",
+          raw: conf,
+          slot,
+          childrenType: conf.type === "routes" ? "Route" : "Brick",
+          children: conf.type === "routes" ? parseRoutes(conf.routes, options) : parseBricks(conf.bricks, options)
+        };
       });
     }
 
-    if (brickConf.lifeCycle) {
-      var {
-        useResolves,
-        onPageLoad,
-        onPageLeave,
-        onAnchorLoad,
-        onAnchorUnload,
-        onMessage,
-        onMessageClose,
-        onBeforePageLoad,
-        onBeforePageLeave,
-        onMediaChange,
-        onScrollIntoView
-      } = brickConf.lifeCycle;
-
-      if (Array.isArray(useResolves)) {
-        useResolves.forEach(useResolve => {
-          var useProvider = useResolve.useProvider;
-
-          if (useProvider) {
-            collection.push(useProvider);
-          }
-        });
-      }
+    return [];
+  }
 
-      var specialHandlers = [].concat(onMessage, onScrollIntoView).filter(Boolean).reduce((previousValue, currentValue) => previousValue.concat(currentValue.handlers), []);
-      collectUsedBricksInEventHandlers({
-        onPageLoad,
-        onPageLeave,
-        onAnchorLoad,
-        onAnchorUnload,
-        onMessageClose,
-        onBeforePageLoad,
-        onBeforePageLeave,
-        onMediaChange,
-        specialHandlers
-      }, collection);
+  function parseEvents(events) {
+    if (isObject(events)) {
+      return Object.entries(events).map(_ref3 => {
+        var [eventType, handlers] = _ref3;
+        return {
+          type: "Event",
+          rawContainer: events,
+          rawKey: eventType,
+          handlers: parseEventHandlers(handlers)
+        };
+      });
     }
-
-    collectUsedBricksInEventHandlers(brickConf.events, collection);
-    collectBricksInResolvable(brickConf.if, collection);
-    collectBricksInContext(brickConf.context, collection);
-    collectUsedBricksInProperties(brickConf.properties, collection);
   }
 
-  function collectBricksInResolvable(resolvable, collection) {
-    if (isObject(resolvable) && resolvable.useProvider) {
-      collection.push(resolvable.useProvider);
+  function parseContext(contexts) {
+    if (Array.isArray(contexts)) {
+      return contexts.map(context => ({
+        type: "Context",
+        raw: context,
+        resolve: parseResolvable(context.resolve),
+        onChange: parseEventHandlers(context.onChange)
+      }));
     }
   }
 
-  function collectBricksInContext(context, collection) {
-    if (Array.isArray(context)) {
-      for (var ctx of context) {
-        collectBricksInResolvable(ctx.resolve, collection);
+  function parseMenu(menu) {
+    if (menu === false) {
+      return {
+        type: "FalseMenu"
+      };
+    }
 
-        if (ctx.onChange) {
-          collectUsedBricksInEventHandlers({
-            onChange: ctx.onChange
-          }, collection);
-        }
-      }
+    if (!menu) {
+      return;
+    }
+
+    switch (menu.type) {
+      case "brick":
+        return {
+          type: "BrickMenu",
+          raw: menu,
+          brick: parseBrick(menu)
+        };
+
+      case "resolve":
+        return {
+          type: "ResolvableMenu",
+          resolve: parseResolvable(menu.resolve)
+        };
+
+      default:
+        return {
+          type: "StaticMenu"
+        };
     }
   }
 
-  function collectUsedBricksInEventHandlers(events, collection) {
-    if (isObject(events)) {
-      Object.values(events).filter(Boolean).forEach(handlers => {
-        [].concat(handlers).forEach(handler => {
-          if (handler.useProvider) {
-            collection.push(handler.useProvider);
-          }
+  function parseResolvable(resolve, isConditional) {
+    if (isObject(resolve)) {
+      return {
+        type: "Resolvable",
+        raw: resolve,
+        isConditional
+      };
+    }
+  }
 
-          if (handler.callback) {
-            collectUsedBricksInEventHandlers(handler.callback, collection);
-          }
-        });
+  function parseEventHandlers(handlers) {
+    return [].concat(handlers).filter(Boolean).map(handler => ({
+      type: "EventHandler",
+      callback: parseEventCallback(handler.callback),
+      raw: handler
+    }));
+  }
+
+  function parseEventCallback(callback) {
+    if (isObject(callback)) {
+      return Object.entries(callback).map(_ref4 => {
+        var [callbackType, handlers] = _ref4;
+        return {
+          type: "EventCallback",
+          rawContainer: callback,
+          rawKey: callbackType,
+          handlers: parseEventHandlers(handlers)
+        };
       });
     }
   }
 
-  function collectUsedBricksInProperties(value, collection) {
-    if (Array.isArray(value)) {
-      value.forEach(item => {
-        collectUsedBricksInProperties(item, collection);
-      });
-    } else if (isObject(value)) {
-      if (value.useBrick || value.useBackend) {
-        if (value.useBrick) {
-          [].concat(value.useBrick).forEach(useBrickConf => {
-            if (typeof (useBrickConf === null || useBrickConf === void 0 ? void 0 : useBrickConf.brick) === "string") {
-              collection.push(useBrickConf.brick);
-              collectUsedBricksInProperties(useBrickConf.properties, collection);
-              collectUsedBricksInEventHandlers(useBrickConf.events, collection);
-
-              if (useBrickConf.slots) {
-                Object.values(useBrickConf.slots).forEach(slotConf => {
-                  collectBricksInBrickConfs(slotConf.bricks, collection);
-                });
-              }
-            }
-          });
-        }
+  function parseRouteProviders(providers) {
+    if (Array.isArray(providers)) {
+      return providers.map(provider => parseBrick(typeof provider === "string" ? {
+        brick: provider
+      } : provider));
+    }
+  } // Ref https://github.com/lodash/lodash/blob/4.17.11/lodash.js#L11744
 
-        if (value.useBackend) {
-          var _value$useBackend;
 
-          if (typeof ((_value$useBackend = value.useBackend) === null || _value$useBackend === void 0 ? void 0 : _value$useBackend.provider) === "string") {
-            var _value$useBackend2;
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == "object" || type == "function");
+  }
 
-            collection.push((_value$useBackend2 = value.useBackend) === null || _value$useBackend2 === void 0 ? void 0 : _value$useBackend2.provider);
-          }
-        }
-      } else {
-        Object.values(value).forEach(item => {
-          collectUsedBricksInProperties(item, collection);
-        });
-      }
+  /** Traverse a storyboard AST. */
+  function traverseStoryboard(ast, callback) {
+    traverseNode(ast, callback);
+  }
+  /** Traverse any node(s) in storyboard AST. */
+
+  function traverse(nodeOrNodes, callback) {
+    if (Array.isArray(nodeOrNodes)) {
+      traverseNodes(nodeOrNodes, callback);
+    } else {
+      traverseNode(nodeOrNodes, callback);
     }
   }
 
-  function collectBricksInBrickConfs(bricks, collection) {
-    if (Array.isArray(bricks)) {
-      bricks.forEach(brickConf => {
-        collectBricksInBrickConf(brickConf, collection);
-      });
+  function traverseNodes(nodes, callback) {
+    if (!nodes) {
+      return;
+    }
+
+    for (var _node of nodes) {
+      traverseNode(_node, callback);
     }
   }
 
-  function scanBricksInProviderConfs(providers, collection) {
-    if (Array.isArray(providers)) {
-      providers.forEach(providerConf => {
-        collection.push(typeof providerConf === "string" ? providerConf : providerConf.brick);
-      });
+  function traverseNode(node, callback) {
+    if (!node) {
+      return;
+    }
+
+    callback(node);
+
+    switch (node.type) {
+      case "Root":
+        traverseNodes(node.routes, callback);
+        traverseNodes(node.templates, callback);
+        break;
+
+      case "Route":
+        traverseNodes(node.context, callback);
+        traverseNode(node.redirect, callback);
+        traverseNode(node.menu, callback);
+        traverseNodes(node.providers, callback);
+        traverseNodes(node.defineResolves, callback);
+        traverseNodes(node.children, callback);
+        break;
+
+      case "Template":
+        traverseNodes(node.bricks, callback);
+        traverseNodes(node.context, callback);
+        break;
+
+      case "Brick":
+        traverseNode(node.if, callback);
+        traverseNodes(node.events, callback);
+        traverseNodes(node.lifeCycle, callback);
+        traverseNodes(node.useBrick, callback);
+        traverseNodes(node.useBackend, callback);
+        traverseNodes(node.context, callback);
+        traverseNodes(node.children, callback);
+        break;
+
+      case "Slot":
+      case "UseBrickEntry":
+      case "UseBackendEntry":
+        traverseNodes(node.children, callback);
+        break;
+
+      case "Context":
+        traverseNode(node.resolve, callback);
+        traverseNodes(node.onChange, callback);
+        break;
+
+      case "ResolvableCondition":
+      case "ResolvableMenu":
+        traverseNode(node.resolve, callback);
+        break;
+
+      case "ResolveLifeCycle":
+        traverseNodes(node.resolves, callback);
+        break;
+
+      case "Event":
+      case "EventCallback":
+      case "SimpleLifeCycle":
+      case "ConditionalEvent":
+        traverseNodes(node.handlers, callback);
+        break;
+
+      case "EventHandler":
+        traverseNodes(node.callback, callback);
+        break;
+
+      case "ConditionalLifeCycle":
+        traverseNodes(node.events, callback);
+        break;
+
+      case "BrickMenu":
+        traverseNode(node.brick, callback);
+        break;
+
+      case "Resolvable":
+      case "FalseMenu":
+      case "StaticMenu":
+      case "UnknownLifeCycle":
+      case "LiteralCondition":
+        break;
+
+      default:
+        // istanbul ignore if
+        if (process.env.NODE_ENV === "development") {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-expect-error
+          throw new Error("Unhandled storyboard node type: ".concat(node.type));
+        }
+
     }
   }
 
-  function collectBricksInRouteConfs(routes, collection) {
-    if (Array.isArray(routes)) {
-      routes.forEach(routeConf => {
-        scanBricksInProviderConfs(routeConf.providers, collection);
-        collectBricksInContext(routeConf.context, collection);
-        collectBricksInResolvable(routeConf.redirect, collection);
+  /**
+   * Scan bricks and custom apis in storyboard.
+   *
+   * @param storyboard - Storyboard.
+   * @param options - If options is a boolean, it means `isUniq` or `de-duplicate`.
+   */
+  function scanStoryboard(storyboard) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var ast = parseStoryboard(storyboard);
+    return scanStoryboardAst(ast, options);
+  }
+  /**
+   * Scan bricks and custom apis in storyboard.
+   *
+   * @param storyboard - Storyboard.
+   * @param options - If options is a boolean, it means `isUniq` or `de-duplicate`.
+   */
+
+  function scanStoryboardAst(ast) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    var {
+      keepDuplicates,
+      ignoreBricksInUnusedCustomTemplates
+    } = isObject$1(options) ? options : {
+      keepDuplicates: !options
+    };
+    var selfDefined = new Set(["form-renderer.form-renderer"]);
+    var collection;
+
+    if (ignoreBricksInUnusedCustomTemplates) {
+      collection = collect(ast.routes, keepDuplicates);
+
+      if (Array.isArray(ast.templates)) {
+        var tplMap = new Map();
+
+        for (var tpl of ast.templates) {
+          tplMap.set(tpl.raw.name, tpl);
+        }
+
+        for (var _item of collection) {
+          if (tplMap.has(_item) && !selfDefined.has(_item)) {
+            selfDefined.add(_item);
+            var collectionByTpl = collect(tplMap.get(_item));
+
+            if (keepDuplicates) {
+              collection.push(_item);
+              collection.push(...collectionByTpl);
+            } else {
+              collection.add(_item);
 
-        if (Array.isArray(routeConf.defineResolves)) {
-          for (var def of routeConf.defineResolves) {
-            collectBricksInResolvable(def, collection);
+              for (var i of collectionByTpl) {
+                collection.add(i);
+              }
+            }
           }
         }
+      }
+    } else {
+      collection = collect(ast, keepDuplicates, selfDefined);
+    }
 
-        if (routeConf.type === "routes") {
-          collectBricksInRouteConfs(routeConf.routes, collection);
+    if (keepDuplicates) {
+      var bricks = [];
+      var customApis = [];
+
+      for (var _item2 of collection) {
+        if (_item2.includes("@")) {
+          customApis.push(_item2);
         } else {
-          collectBricksInBrickConfs(routeConf.bricks, collection);
+          if (_item2.includes("-") && !selfDefined.has(_item2)) {
+            bricks.push(_item2);
+          }
         }
+      }
 
-        if (routeConf.menu) {
-          if (routeConf.menu.type === "brick" && routeConf.menu.brick) {
-            collection.push(routeConf.menu.brick);
-          } else if (routeConf.menu.type === "resolve") {
-            collectBricksInResolvable(routeConf.menu.resolve, collection);
+      return {
+        bricks,
+        customApis
+      };
+    } else {
+      var _bricks = new Set();
+
+      var _customApis = new Set();
+
+      for (var _item3 of collection) {
+        if (_item3.includes("@")) {
+          _customApis.add(_item3);
+        } else {
+          if (_item3.includes("-") && !selfDefined.has(_item3)) {
+            _bricks.add(_item3);
           }
         }
-      });
+      }
+
+      return {
+        bricks: [..._bricks],
+        customApis: [..._customApis]
+      };
     }
   }
 
-  function collectBricksInCustomTemplates(customTemplates, collection, selfDefined) {
-    if (Array.isArray(customTemplates)) {
-      customTemplates.forEach(tpl => {
-        selfDefined.add(tpl.name);
-        collectBricksInBrickConfs(tpl.bricks, collection);
-        collectBricksInContext(tpl.state, collection);
-      });
+  function collect(nodeOrNodes, keepDuplicates, definedTemplates) {
+    var collection;
+    var add;
+
+    if (keepDuplicates) {
+      collection = [];
+
+      add = item => {
+        collection.push(item);
+      };
+    } else {
+      collection = new Set();
+
+      add = item => {
+        collection.add(item);
+      };
     }
+
+    traverse(nodeOrNodes, node => {
+      switch (node.type) {
+        case "Brick":
+          if (node.raw.brick) {
+            add(node.raw.brick);
+          }
+
+          break;
+
+        case "Resolvable":
+          {
+            var _node$raw;
+
+            var useProvider = (_node$raw = node.raw) === null || _node$raw === void 0 ? void 0 : _node$raw.useProvider;
+
+            if (useProvider) {
+              add(useProvider);
+            }
+
+            break;
+          }
+
+        case "EventHandler":
+          {
+            var _node$raw2;
+
+            var _useProvider = (_node$raw2 = node.raw) === null || _node$raw2 === void 0 ? void 0 : _node$raw2.useProvider;
+
+            if (_useProvider) {
+              add(_useProvider);
+            }
+
+            break;
+          }
+
+        case "Template":
+          definedTemplates === null || definedTemplates === void 0 ? void 0 : definedTemplates.add(node.raw.name);
+          break;
+      }
+    });
+    return collection;
   }
 
+  function collectBricksInBrickConf(brickConf) {
+    var node = parseBrick(brickConf);
+    return [...collect(node)];
+  }
   function collectBricksByCustomTemplates(customTemplates) {
     var collectionByTpl = new Map();
+    var templates = parseTemplates(customTemplates);
 
-    if (Array.isArray(customTemplates)) {
-      customTemplates.forEach(tpl => {
-        var collection = [];
-        collectionByTpl.set(tpl.name, collection);
-        collectBricksInBrickConfs(tpl.bricks, collection);
-        collectBricksInContext(tpl.state, collection);
-      });
+    for (var tpl of templates) {
+      var collection = collect(tpl, false);
+      collectionByTpl.set(tpl.raw.name, [...collection]);
     }
 
     return collectionByTpl;
@@ -887,11 +1232,9 @@
     return scanStoryboard(storyboard, options).bricks;
   }
   function scanBricksInBrickConf(brickConf) {
-    var isUniq = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var collection = [];
-    collectBricksInBrickConf(brickConf, collection);
+    var collection = collectBricksInBrickConf(brickConf);
     var result = collection.filter(item => !item.includes("@") && item.includes("-"));
-    return isUniq ? lodash.uniq(result) : result;
+    return result;
   }
 
   class ExecutionContext {
@@ -21185,7 +21528,7 @@
         } else {
           visitNonExpressionString === null || visitNonExpressionString === void 0 ? void 0 : visitNonExpressionString(value);
         }
-      } else if (isObject(value)) {
+      } else if (isObject$1(value)) {
         // Avoid call stack overflow.
         if (memo.has(value)) {
           return;
@@ -22032,34 +22375,12 @@
 
   function scanRouteAliasInStoryboard(storyboard) {
     var collection = new Map();
-    collectRouteAliasInRouteConfs(storyboard.routes, collection);
-    return collection;
-  }
-
-  function collectRouteAliasInBrickConf(brickConf, collection) {
-    if (brickConf.slots) {
-      Object.values(brickConf.slots).forEach(slotConf => {
-        if (slotConf.type === "bricks") {
-          collectRouteAliasInBrickConfs(slotConf.bricks, collection);
-        } else {
-          collectRouteAliasInRouteConfs(slotConf.routes, collection);
-        }
-      });
-    }
-  }
-
-  function collectRouteAliasInBrickConfs(bricks, collection) {
-    if (Array.isArray(bricks)) {
-      bricks.forEach(brickConf => {
-        collectRouteAliasInBrickConf(brickConf, collection);
-      });
-    }
-  }
-
-  function collectRouteAliasInRouteConfs(routes, collection) {
-    if (Array.isArray(routes)) {
-      routes.forEach(routeConf => {
-        var alias = routeConf.alias;
+    var routes = parseRoutes(storyboard.routes, {
+      routesOnly: true
+    });
+    traverse(routes, node => {
+      if (node.type === "Route") {
+        var alias = node.raw.alias;
 
         if (alias) {
           if (collection.has(alias)) {
@@ -22069,17 +22390,12 @@
 
           collection.set(alias, {
             alias,
-            path: routeConf.path
+            path: node.raw.path
           });
         }
-
-        if (routeConf.type === "routes") {
-          collectRouteAliasInRouteConfs(routeConf.routes, collection);
-        } else {
-          collectRouteAliasInBrickConfs(routeConf.bricks, collection);
-        }
-      });
-    }
+      }
+    });
+    return collection;
   }
 
   var I18N = "I18N";
@@ -23392,185 +23708,128 @@
    * `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);
-      }
-    }
-
+    var ast = parseStoryboard(storyboard);
+    removeDeadConditionsByAst(ast, 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 removeDeadConditionsByAst(ast, options) {
+    // First, we mark constant conditions.
+    traverse(ast, node => {
+      switch (node.type) {
+        case "Route":
+        case "Brick":
+        case "EventHandler":
+        case "Context":
+          computeConstantCondition(node.raw, options);
+          break;
 
-  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);
+        case "Resolvable":
+          if (node.isConditional) {
+            computeConstantCondition(node.raw, 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);
-        }
+          break;
       }
-    }
-  }
+    }); // Then, we remove dead conditions accordingly.
 
-  function removeDeadConditionsInUseBrick(useBrick, options) {
-    removeDeadConditionsInProperties(useBrick.properties, options);
-    removeDeadConditionsInEvents(useBrick.events, options);
+    traverse(ast, node => {
+      var rawContainer;
+      var conditionalNodes;
+      var rawKey;
+      var deleteEmptyArray = false;
 
-    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);
-      }
-    }
-  }
+      switch (node.type) {
+        case "Root":
+          conditionalNodes = node.routes;
+          rawContainer = node.raw;
+          rawKey = "routes";
+          break;
 
-  function removeDeadConditionsInEvent(events, eventType, options) {
-    var handlers = events[eventType];
+        case "Template":
+          conditionalNodes = node.bricks;
+          rawContainer = node.raw;
+          rawKey = "bricks";
+          break;
 
-    if (!handlers) {
-      return;
-    }
+        case "Route":
+        case "Slot":
+          conditionalNodes = node.children;
+          rawContainer = node.raw;
+          rawKey = node.raw.type === "routes" ? "routes" : "bricks";
+          break;
 
-    if (Array.isArray(handlers)) {
-      removeDeadConditionsInArray(handlers, options, handler => {
-        if (handler.callback) {
-          removeDeadConditionsInEvents(handler.callback, options);
-        }
-      });
-    } else {
-      computeConstantCondition(handlers, options);
+        case "Event":
+        case "EventCallback":
+        case "SimpleLifeCycle":
+        case "ConditionalEvent":
+          conditionalNodes = node.handlers;
+          rawContainer = node.rawContainer;
+          rawKey = node.rawKey;
+          deleteEmptyArray = true;
+          break;
 
-      if (handlers.if === false) {
-        delete events[eventType];
-        return;
-      }
+        case "ResolveLifeCycle":
+          conditionalNodes = node.resolves;
+          rawContainer = node.rawContainer;
+          rawKey = node.rawKey;
+          deleteEmptyArray = true;
+          break;
 
-      if (handlers.callback) {
-        removeDeadConditionsInEvents(handlers.callback, options);
+        case "UseBrickEntry":
+          conditionalNodes = node.children;
+          rawContainer = node.rawContainer;
+          rawKey = node.rawKey;
+          break;
       }
-    }
-  }
-
-  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);
+      shakeConditionalNodes(node, rawContainer, conditionalNodes, rawKey, deleteEmptyArray); // Remove unreachable context/state.
 
-        if (_item3.if === false) {
-          removes.push(_item3);
-          continue;
-        }
+      deleteEmptyArray = false;
 
-        callback === null || callback === void 0 ? void 0 : callback(_item3);
+      switch (node.type) {
+        case "Route":
+        case "Brick":
+        case "Template":
+          rawContainer = node.raw;
+          rawKey = node.type === "Template" ? "state" : "context";
+          conditionalNodes = node.context;
+          break;
       }
 
-      lodash.pull(list, ...removes);
-    }
+      shakeConditionalNodes(node, rawContainer, conditionalNodes, rawKey, deleteEmptyArray);
+    });
   }
 
-  function removeDeadConditionsInLifeCycle(lifeCycle, options) {
-    if (lifeCycle) {
-      removeDeadConditionsInArray(lifeCycle.useResolves, options);
+  function shakeConditionalNodes(node, rawContainer, conditionalNodes, rawKey, deleteEmptyArray) {
+    var removedNodes = lodash.remove(conditionalNodes, node => node.raw.if === false);
 
-      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);
-          }
-        }
+    if (removedNodes.length > 0) {
+      if (node.type === "UseBrickEntry" && !Array.isArray(rawContainer[rawKey])) {
+        rawContainer[rawKey] = {
+          brick: "div",
+          if: false
+        };
+      } else if (deleteEmptyArray && conditionalNodes.length === 0) {
+        delete rawContainer[rawKey];
+      } else {
+        rawContainer[rawKey] = conditionalNodes.map(node => node.raw);
       }
     }
   }
+  /**
+   * Like `removeDeadConditions` but applied to a custom template.
+   */
 
+
+  function removeDeadConditionsInTpl(tplConstructor, options) {
+    var ast = parseTemplate(tplConstructor);
+    removeDeadConditionsByAst(ast, options);
+  }
   function computeConstantCondition(ifContainer) {
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
@@ -23588,8 +23847,8 @@
           } = options;
           var hasDynamicVariables = false;
 
-          for (var _item4 of attemptToVisitGlobals) {
-            if (_item4 !== "undefined" && (!constantFeatureFlags || _item4 !== "FLAGS")) {
+          for (var item of attemptToVisitGlobals) {
+            if (item !== "undefined" && (!constantFeatureFlags || item !== "FLAGS")) {
               hasDynamicVariables = true;
               break;
             }
@@ -23692,7 +23951,7 @@
   exports.isBrickNode = isBrickNode;
   exports.isCustomTemplateNode = isCustomTemplateNode;
   exports.isEvaluable = isEvaluable;
-  exports.isObject = isObject;
+  exports.isObject = isObject$1;
   exports.isRouteNode = isRouteNode;
   exports.isSnippetNode = isSnippetNode;
   exports.lint = lint;
@@ -23702,7 +23961,12 @@
   exports.matchPath = matchPath;
   exports.normalizeBuilderNode = normalizeBuilderNode;
   exports.normalizeMenu = normalizeMenu;
+  exports.parseBrick = parseBrick;
   exports.parseForAnalysis = parseForAnalysis;
+  exports.parseRoutes = parseRoutes;
+  exports.parseStoryboard = parseStoryboard;
+  exports.parseTemplate = parseTemplate;
+  exports.parseTemplates = parseTemplates;
   exports.precook = precook;
   exports.precookFunction = precookFunction;
   exports.preevaluate = preevaluate;
@@ -23725,6 +23989,7 @@
   exports.scanProcessorsInStoryboard = scanProcessorsInStoryboard;
   exports.scanRouteAliasInStoryboard = scanRouteAliasInStoryboard;
   exports.scanStoryboard = scanStoryboard;
+  exports.scanStoryboardAst = scanStoryboardAst;
   exports.scanTemplatesInBrick = scanTemplatesInBrick;
   exports.scanTemplatesInStoryboard = scanTemplatesInStoryboard;
   exports.shouldAllowRecursiveEvaluations = shouldAllowRecursiveEvaluations;
@@ -23738,6 +24003,8 @@
   exports.trackUsedState = trackUsedState;
   exports.transform = transform;
   exports.transformAndInject = transformAndInject;
+  exports.traverse = traverse;
+  exports.traverseStoryboard = traverseStoryboard;
   exports.visitStoryboardExpressions = visitStoryboardExpressions;
   exports.visitStoryboardFunctions = visitStoryboardFunctions;