@next-core/runtime 1.21.0 → 1.21.2

package/dist/esm/internal/Renderer.js

@@ -1,21 +1,22 @@
-import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 var _excluded = ["blockingList", "node", "menuRequests", "hasTrackingControls"],
   _excluded2 = ["if", "permissionsPreCheck"],
   _excluded3 = ["formData"],
   _excluded4 = ["src"],
   _excluded5 = ["href"];
-import { enqueueStableLoadBricks, loadBricksImperatively, loadProcessorsImperatively, loadScript, loadStyle } from "@next-core/loader";
+import { enqueueStableLoadBricks, flushStableLoadBricks, loadBricksImperatively, loadProcessorsImperatively, loadScript, loadStyle } from "@next-core/loader";
 import { isTrackAll } from "@next-core/cook";
 import { hasOwnProperty } from "@next-core/utils/general";
+import { strictCollectMemberUsage } from "@next-core/utils/storyboard";
 import { debounce } from "lodash";
 import { asyncCheckBrickIf } from "./compute/checkIf.js";
 import { asyncComputeRealPropertyEntries, constructAsyncProperties } from "./compute/computeRealProperties.js";
 import { resolveData } from "./data/resolveData.js";
 import { asyncComputeRealValue } from "./compute/computeRealValue.js";
 import { listenOnTrackingContext } from "./compute/listenOnTrackingContext.js";
-import { matchRoutes } from "./matchRoutes.js";
+import { matchRoute, matchRoutes } from "./matchRoutes.js";
 import { symbolForAsyncComputedPropsFromHost, symbolForTPlExternalForEachItem, symbolForTplStateStoreId } from "./CustomTemplates/constants.js";
 import { expandCustomTemplate } from "./CustomTemplates/expandCustomTemplate.js";
 import { getTagNameOfCustomTemplate, getTplStateStore } from "./CustomTemplates/utils.js";
@@ -28,12 +29,12 @@ import { FORM_RENDERER, symbolForFormStateStoreId } from "./FormRenderer/constan
 import { expandFormRenderer } from "./FormRenderer/expandFormRenderer.js";
 import { isPreEvaluated } from "./compute/evaluate.js";
 import { getPreEvaluatedRaw } from "./compute/evaluate.js";
-import { strictCollectMemberUsage } from "@next-core/utils/storyboard";
-export function renderRoutes(_x, _x2, _x3, _x4, _x5) {
+import { matchHomepage } from "./matchStoryboard.js";
+export function renderRoutes(_x, _x2, _x3, _x4, _x5, _x6, _x7) {
   return _renderRoutes.apply(this, arguments);
 }
 function _renderRoutes() {
-  _renderRoutes = _asyncToGenerator(function* (returnNode, routes, _runtimeContext, rendererContext, slotId) {
+  _renderRoutes = _asyncToGenerator(function* (returnNode, routes, _runtimeContext, rendererContext, parentRoutes, slotId, isIncremental) {
     var matched = yield matchRoutes(routes, _runtimeContext);
     var output = {
       blockingList: [],
@@ -52,7 +53,11 @@ function _renderRoutes() {
           var runtimeContext = _objectSpread(_objectSpread({}, _runtimeContext), {}, {
             match: matched.match
           });
-          runtimeContext.ctxStore.define(route.context, runtimeContext);
+          if (isIncremental) {
+            runtimeContext.ctxStore.disposeDataInRoutes(routes);
+          }
+          var routePath = parentRoutes.concat(route);
+          runtimeContext.ctxStore.define(route.context, runtimeContext, undefined, routePath);
           runtimeContext.pendingPermissionsPreCheck.push(hooks === null || hooks === void 0 || (_hooks$checkPermissio = hooks.checkPermissions) === null || _hooks$checkPermissio === void 0 ? void 0 : _hooks$checkPermissio.preCheckPermissionsForBrickOrRoute(route, value => asyncComputeRealValue(value, runtimeContext)));
 
           // Currently, this is only used for brick size-checking: these bricks
@@ -63,41 +68,39 @@ function _renderRoutes() {
           if (Array.isArray(preLoadBricks)) {
             output.blockingList.push(loadBricksImperatively(preLoadBricks, getBrickPackages()));
           }
-          switch (route.type) {
-            case "redirect":
-              {
-                var redirectTo;
-                if (typeof route.redirect === "string") {
-                  redirectTo = yield asyncComputeRealValue(route.redirect, runtimeContext);
-                } else {
-                  var resolved = yield resolveData(_objectSpread({
-                    transform: "redirect"
-                  }, route.redirect), runtimeContext);
-                  redirectTo = resolved.redirect;
-                }
-                if (typeof redirectTo !== "string") {
-                  // eslint-disable-next-line no-console
-                  console.error("Unexpected redirect result:", redirectTo);
-                  throw new Error("Unexpected type of redirect result: ".concat(typeof redirectTo));
-                }
-                output.redirect = {
-                  path: redirectTo
-                };
-                break;
-              }
-            case "routes":
-              {
-                output.menuRequests.push(loadMenu(route.menu, runtimeContext));
-                var newOutput = yield renderRoutes(returnNode, route.routes, runtimeContext, rendererContext, slotId);
-                mergeRenderOutput(output, newOutput);
-                break;
-              }
-            default:
-              {
-                output.menuRequests.push(loadMenu(route.menu, runtimeContext));
-                var _newOutput = yield renderBricks(returnNode, route.bricks, runtimeContext, rendererContext, slotId);
-                mergeRenderOutput(output, _newOutput);
-              }
+          if (route.type === "redirect") {
+            var redirectTo;
+            if (typeof route.redirect === "string") {
+              redirectTo = yield asyncComputeRealValue(route.redirect, runtimeContext);
+            } else {
+              var resolved = yield resolveData(_objectSpread({
+                transform: "redirect"
+              }, route.redirect), runtimeContext);
+              redirectTo = resolved.redirect;
+            }
+            if (typeof redirectTo !== "string") {
+              // eslint-disable-next-line no-console
+              console.error("Unexpected redirect result:", redirectTo);
+              throw new Error("Unexpected type of redirect result: ".concat(typeof redirectTo));
+            }
+            output.redirect = {
+              path: redirectTo
+            };
+          } else {
+            var menuRequest = loadMenu(route.menu, runtimeContext);
+            if (menuRequest) {
+              output.menuRequests.push(menuRequest);
+            }
+            if (route.type === "routes") {
+              var newOutput = yield renderRoutes(returnNode, route.routes, runtimeContext, rendererContext, routePath, slotId);
+              mergeRenderOutput(output, newOutput);
+            } else {
+              var _newOutput = yield renderBricks(returnNode, route.bricks, runtimeContext, rendererContext, routePath, slotId);
+              mergeRenderOutput(output, _newOutput);
+            }
+            if (returnNode.tag === RenderTag.BRICK) {
+              rendererContext.memoizeMenuRequests(route, output.menuRequests);
+            }
           }
         }
     }
@@ -105,22 +108,22 @@ function _renderRoutes() {
   });
   return _renderRoutes.apply(this, arguments);
 }
-export function renderBricks(_x6, _x7, _x8, _x9, _x10, _x11, _x12) {
+export function renderBricks(_x8, _x9, _x10, _x11, _x12, _x13, _x14, _x15) {
   return _renderBricks.apply(this, arguments);
 }
 function _renderBricks() {
-  _renderBricks = _asyncToGenerator(function* (returnNode, bricks, runtimeContext, rendererContext, slotId, tplStack, keyPath) {
+  _renderBricks = _asyncToGenerator(function* (returnNode, bricks, runtimeContext, rendererContext, parentRoutes, slotId, tplStack, keyPath) {
     var output = {
       blockingList: [],
       menuRequests: []
     };
     var kPath = keyPath !== null && keyPath !== void 0 ? keyPath : [];
     // 多个构件并行异步转换，但转换的结果按原顺序串行合并。
-    var rendered = yield Promise.all(bricks.map((brickConf, index) => renderBrick(returnNode, brickConf, runtimeContext, rendererContext, slotId, kPath.concat(index), tplStack && new Map(tplStack))));
+    var rendered = yield Promise.all(bricks.map((brickConf, index) => renderBrick(returnNode, brickConf, runtimeContext, rendererContext, parentRoutes, slotId, kPath.concat(index), tplStack && new Map(tplStack))));
     rendered.forEach((item, index) => {
       if (item.hasTrackingControls) {
         // Memoize a render node before it's been merged.
-        rendererContext.memoizeControlNode(slotId, kPath.concat(index), item.node, returnNode);
+        rendererContext.memoize(slotId, kPath.concat(index), item.node, returnNode);
       }
       mergeRenderOutput(output, item);
     });
@@ -128,14 +131,14 @@ function _renderBricks() {
   });
   return _renderBricks.apply(this, arguments);
 }
-export function renderBrick(_x13, _x14, _x15, _x16, _x17) {
+export function renderBrick(_x16, _x17, _x18, _x19, _x20, _x21) {
   return _renderBrick.apply(this, arguments);
 }
 function _renderBrick() {
-  _renderBrick = _asyncToGenerator(function* (returnNode, brickConf, _runtimeContext, rendererContext, slotId) {
+  _renderBrick = _asyncToGenerator(function* (returnNode, brickConf, _runtimeContext, rendererContext, parentRoutes, slotId) {
     var _hooks$checkPermissio2, _runtimeContext$app;
-    var keyPath = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
-    var tplStack = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Map();
+    var keyPath = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [];
+    var tplStack = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : new Map();
     var output = {
       blockingList: [],
       menuRequests: []
@@ -172,7 +175,7 @@ function _renderBrick() {
         }
       }, Object.getOwnPropertySymbols(brickConf).reduce((acc, symbol) => _objectSpread(_objectSpread({}, acc), {}, {
         [symbol]: brickConf[symbol]
-      }), {})), _runtimeContext, rendererContext, slotId, keyPath, tplStack);
+      }), {})), _runtimeContext, rendererContext, parentRoutes, slotId, keyPath, tplStack);
     }
     var tplStateStoreId = brickConf[symbolForTplStateStoreId];
     var formStateStoreId = brickConf[symbolForFormStateStoreId];
@@ -207,7 +210,7 @@ function _renderBrick() {
         dataSource
       } = brickConf;
       var renderControlNode = /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(function* () {
+        var _ref = _asyncToGenerator(function* (runtimeContext) {
           var _slots$slot;
           // First, compute the `dataSource`
           var computedDataSource = yield asyncComputeRealValue(dataSource, runtimeContext);
@@ -229,20 +232,20 @@ function _renderBrick() {
                 if (!Array.isArray(computedDataSource)) {
                   return output;
                 }
-                return renderForEach(returnNode, computedDataSource, bricks, runtimeContext, rendererContext, slotId, tplStack, keyPath);
+                return renderForEach(returnNode, computedDataSource, bricks, runtimeContext, rendererContext, parentRoutes, slotId, tplStack, keyPath);
               }
             case ":if":
             case ":switch":
               {
-                return renderBricks(returnNode, bricks, runtimeContext, rendererContext, slotId, tplStack, keyPath);
+                return renderBricks(returnNode, bricks, runtimeContext, rendererContext, parentRoutes, slotId, tplStack, keyPath);
               }
           }
         });
-        return function renderControlNode() {
+        return function renderControlNode(_x31) {
           return _ref.apply(this, arguments);
         };
       }();
-      var controlledOutput = yield renderControlNode();
+      var controlledOutput = yield renderControlNode(runtimeContext);
       var {
         contextNames,
         stateNames
@@ -253,12 +256,17 @@ function _renderBrick() {
         var listener = /*#__PURE__*/function () {
           var _ref2 = _asyncToGenerator(function* () {
             var currentRenderId = ++renderId;
-            var controlOutput = yield renderControlNode();
-            controlOutput.blockingList.push(...[...runtimeContext.tplStateStoreMap.values(), ...runtimeContext.formStateStoreMap.values()].map(store => store.waitForAll()), ...runtimeContext.pendingPermissionsPreCheck);
-            yield Promise.all(controlOutput.blockingList);
+            var [scopedRuntimeContext, tplStateStoreScope, formStateStoreScope] = createScopedRuntimeContext(runtimeContext);
+            var controlOutput = yield renderControlNode(scopedRuntimeContext);
+            var scopedStores = [...tplStateStoreScope, ...formStateStoreScope];
+            yield postAsyncRender(controlOutput, scopedRuntimeContext, scopedStores);
+
             // Ignore stale renders
             if (renderId === currentRenderId) {
-              rendererContext.rerenderControlNode(slotId, keyPath, controlOutput.node, returnNode);
+              rendererContext.reRender(slotId, keyPath, controlOutput.node, returnNode);
+              for (var store of scopedStores) {
+                store.mountAsyncData();
+              }
             }
           });
           return function listener() {
@@ -401,17 +409,91 @@ function _renderBrick() {
         if (!slots) {
           return;
         }
-        var rendered = yield Promise.all(Object.entries(slots).map(_ref6 => {
+        var routeSlotIndexes = new Set();
+        var rendered = yield Promise.all(Object.entries(slots).map((_ref6, index) => {
           var [childSlotId, slotConf] = _ref6;
-          return slotConf.type !== "routes" ? renderBricks(brick, slotConf.bricks, childRuntimeContext, rendererContext, childSlotId, tplStack) : renderRoutes(brick, slotConf.routes, childRuntimeContext, rendererContext, childSlotId);
+          if (slotConf.type !== "routes") {
+            return renderBricks(brick, slotConf.bricks, childRuntimeContext, rendererContext, parentRoutes, childSlotId, tplStack);
+          }
+          if (runtimeContext.flags["incremental-sub-route-rendering"]) {
+            routeSlotIndexes.add(index);
+            rendererContext.performIncrementalRender( /*#__PURE__*/function () {
+              var _ref7 = _asyncToGenerator(function* (location) {
+                var {
+                  homepage
+                } = childRuntimeContext.app;
+                var {
+                  pathname
+                } = location;
+                // Ignore if any one of homepage and parent routes not matched.
+                if (!matchHomepage(homepage, pathname) || !parentRoutes.every(route => matchRoute(route, homepage, pathname))) {
+                  return false;
+                }
+                var [scopedRuntimeContext, tplStateStoreScope, formStateStoreScope] = createScopedRuntimeContext(_objectSpread(_objectSpread({}, childRuntimeContext), {}, {
+                  location,
+                  query: new URLSearchParams(location.search)
+                }));
+                var failed = false;
+                var incrementalOutput;
+                var scopedStores = [];
+                try {
+                  incrementalOutput = yield renderRoutes(brick, slotConf.routes, scopedRuntimeContext, rendererContext, parentRoutes, childSlotId, true);
+
+                  // If all sub-routes are missed, ignore incremental rendering
+                  if (!incrementalOutput.route) {
+                    return false;
+                  }
+
+                  // Bailout if redirect or unauthenticated is set
+                  if (rendererContext.reBailout(incrementalOutput)) {
+                    return true;
+                  }
+                  scopedStores = [...tplStateStoreScope, ...formStateStoreScope];
+                  yield postAsyncRender(incrementalOutput, scopedRuntimeContext, [scopedRuntimeContext.ctxStore, ...scopedStores]);
+                  yield rendererContext.reMergeMenuRequests(slotConf.routes, incrementalOutput.route, incrementalOutput.menuRequests);
+                } catch (error) {
+                  // eslint-disable-next-line no-console
+                  console.error("Incremental sub-router failed:", error);
+                  var result = rendererContext.reCatch(error, brick);
+                  if (!result) {
+                    return true;
+                  }
+                  ({
+                    failed,
+                    output: incrementalOutput
+                  } = result);
+
+                  // Assert: no errors will be throw
+                  yield rendererContext.reMergeMenuRequests(slotConf.routes, incrementalOutput.route, incrementalOutput.menuRequests);
+                }
+                rendererContext.reRender(childSlotId, [], incrementalOutput.node, brick);
+                if (!failed) {
+                  scopedRuntimeContext.ctxStore.mountAsyncData(incrementalOutput.route);
+                  for (var store of scopedStores) {
+                    store.mountAsyncData();
+                  }
+                }
+                return true;
+              });
+              return function (_x32) {
+                return _ref7.apply(this, arguments);
+              };
+            }());
+          }
+          return renderRoutes(brick, slotConf.routes, childRuntimeContext, rendererContext, parentRoutes, childSlotId);
         }));
         var childrenOutput = _objectSpread(_objectSpread({}, output), {}, {
           node: undefined,
-          blockingList: []
+          blockingList: [],
+          menuRequests: []
         });
-        for (var item of rendered) {
+        rendered.forEach((item, index) => {
+          if (routeSlotIndexes.has(index)) {
+            // Memoize a render node before it's been merged.
+            rendererContext.memoize(slotId, [], item.node, brick);
+          }
           mergeRenderOutput(childrenOutput, item);
-        }
+        });
         if (childrenOutput.node) {
           brick.child = childrenOutput.node;
         }
@@ -439,11 +521,11 @@ function ensureValidControlBrick(brick) {
     throw new Error("Unknown storyboard control node: \"".concat(brick, "\""));
   }
 }
-function renderForEach(_x18, _x19, _x20, _x21, _x22, _x23, _x24, _x25) {
+function renderForEach(_x22, _x23, _x24, _x25, _x26, _x27, _x28, _x29, _x30) {
   return _renderForEach.apply(this, arguments);
 }
 function _renderForEach() {
-  _renderForEach = _asyncToGenerator(function* (returnNode, dataSource, bricks, runtimeContext, rendererContext, slotId, tplStack, keyPath) {
+  _renderForEach = _asyncToGenerator(function* (returnNode, dataSource, bricks, runtimeContext, rendererContext, parentRoutes, slotId, tplStack, keyPath) {
     var output = {
       blockingList: [],
       menuRequests: []
@@ -451,13 +533,13 @@ function _renderForEach() {
     var rows = dataSource.length;
     var rendered = yield Promise.all(dataSource.map((item, i) => Promise.all(bricks.map((brickConf, j) => renderBrick(returnNode, brickConf, _objectSpread(_objectSpread({}, runtimeContext), {}, {
       forEachItem: item
-    }), rendererContext, slotId, keyPath.concat(i * rows + j), tplStack && new Map(tplStack))))));
+    }), rendererContext, parentRoutes, slotId, keyPath.concat(i * rows + j), tplStack && new Map(tplStack))))));
 
     // 多层构件并行异步转换，但转换的结果按原顺序串行合并。
     rendered.flat().forEach((item, index) => {
       if (item.hasTrackingControls) {
         // Memoize a render node before it's been merged.
-        rendererContext.memoizeControlNode(slotId, keyPath.concat(index), item.node, returnNode);
+        rendererContext.memoize(slotId, keyPath.concat(index), item.node, returnNode);
       }
       mergeRenderOutput(output, item);
     });
@@ -465,6 +547,22 @@ function _renderForEach() {
   });
   return _renderForEach.apply(this, arguments);
 }
+export function getDataStores(runtimeContext) {
+  return [runtimeContext.ctxStore, ...runtimeContext.tplStateStoreMap.values(), ...runtimeContext.formStateStoreMap.values()];
+}
+export function postAsyncRender(output, runtimeContext, stores) {
+  flushStableLoadBricks();
+  return Promise.all([...output.blockingList, ...stores.map(store => store.waitForAll()), ...runtimeContext.pendingPermissionsPreCheck]);
+}
+export function createScopedRuntimeContext(runtimeContext) {
+  var tplStateStoreScope = [];
+  var formStateStoreScope = [];
+  var scopedRuntimeContext = _objectSpread(_objectSpread({}, runtimeContext), {}, {
+    tplStateStoreScope,
+    formStateStoreScope
+  });
+  return [scopedRuntimeContext, tplStateStoreScope, formStateStoreScope];
+}
 function loadMenu(menuConf, runtimeContext) {
   if (!menuConf) {
     return;