@next-core/brick-utils 2.44.7 → 2.45.0

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import { uniq, get, cloneDeep, set, isEmpty, escapeRegExp, pull } from 'lodash';
+import { uniq, get, cloneDeep, set, isEmpty, escapeRegExp, remove } from 'lodash';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
@@ -600,271 +600,616 @@ function paramCase(input, options) {
 }
 
 // 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(_objectSpread({
+      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(_objectSpread({
+    type: "Brick",
+    raw: brick,
+    isUseBrick: options === null || options === void 0 ? void 0 : options.isUseBrick
+  }, options !== null && options !== void 0 && options.routesOnly ? null : _objectSpread(_objectSpread({
+    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 : uniq(bricks),
-    customApis: keepDuplicates ? customApis : 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;
@@ -882,11 +1227,9 @@ function scanBricksInStoryboard(storyboard) {
   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 ? uniq(result) : result;
+  return result;
 }
 
 class ExecutionContext {
@@ -21180,7 +21523,7 @@ options) {
       } 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;
@@ -22027,34 +22370,12 @@ function beforeVisitPermissionsFactory(collection) {
 
 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)) {
@@ -22064,17 +22385,12 @@ function collectRouteAliasInRouteConfs(routes, collection) {
 
         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";
@@ -23387,185 +23703,128 @@ function makeThrottledAggregation(namespace, request, select) {
  * `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;
     }
 
-    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 = 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] : {};
 
@@ -23583,8 +23842,8 @@ function computeConstantCondition(ifContainer) {
         } = 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;
           }
@@ -23658,5 +23917,5 @@ function isConstantLogical(node, expect, 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 };
+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$1 as isObject, isRouteNode, isSnippetNode, lint, loadScript, makeThrottledAggregation, mapCustomApisToNameAndNamespace, matchPath, normalizeBuilderNode, normalizeMenu, parseBrick, parseForAnalysis, parseRoutes, parseStoryboard, parseTemplate, parseTemplates, precook, precookFunction, preevaluate, prefetchScript, removeDeadConditions, removeDeadConditionsInTpl, resolveContextConcurrently, restoreDynamicTemplates, scanAppGetMenuInAny, scanAppGetMenuInStoryboard, scanBricksInBrickConf, scanBricksInStoryboard, scanCustomApisInStoryboard, scanI18NInAny, scanI18NInStoryboard, scanInstalledAppsInStoryboard, scanPermissionActionsInAny, scanPermissionActionsInStoryboard, scanProcessorsInAny, scanProcessorsInStoryboard, scanRouteAliasInStoryboard, scanStoryboard, scanStoryboardAst, scanTemplatesInBrick, scanTemplatesInStoryboard, shouldAllowRecursiveEvaluations, smartDisplayForEvaluableString, syncResolveContextConcurrently, toPath, tokTypes_1 as tokTypes, trackContext, trackState, trackUsedContext, trackUsedState, transform, transformAndInject, traverse, traverseStoryboard, visitStoryboardExpressions, visitStoryboardFunctions };
 //# sourceMappingURL=index.esm.js.map