@next-core/runtime 1.44.2 → 1.44.3

package/dist/esm/internal/data/DataStore.js

@@ -1,5 +1,3 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { hasOwnProperty, isObject } from "@next-core/utils/general";
 import { strictCollectMemberUsage } from "@next-core/utils/storyboard";
@@ -14,7 +12,7 @@ import { computePropertyValue } from "../compute/computeRealProperties.js";
 import { _internalApiGetRenderId } from "../Runtime.js";
 import { callRealTimeDataInspectHooks, realTimeDataInspectRoot } from "./realTimeDataInspect.js";
 import { isStrictMode } from "../../isStrictMode.js";
-var supportContextResolveTriggerBrickLifeCycle = ["onBeforePageLoad", "onPageLoad", "onBeforePageLeave", "onPageLeave", "onAnchorLoad", "onAnchorUnload"];
+const supportContextResolveTriggerBrickLifeCycle = ["onBeforePageLoad", "onPageLoad", "onBeforePageLeave", "onPageLeave", "onAnchorLoad", "onAnchorUnload"];
 export class DataStore {
   // 把 `rendererContext` 放在参数列表的最后，并作为可选，以减少测试文件的调整
   constructor(type, hostBrick, rendererContext, stateStoreId) {
@@ -36,7 +34,7 @@ export class DataStore {
   }
   getAllValues() {
     return Object.fromEntries([...this.data.entries()].map(_ref => {
-      var [name, {
+      let [name, {
         value
       }] = _ref;
       return [name, value];
@@ -48,7 +46,7 @@ export class DataStore {
   }
   notifyRealTimeDataChange(name, value) {
     if (realTimeDataInspectRoot) {
-      var {
+      const {
         tplStateStoreId
       } = realTimeDataInspectRoot;
       if (tplStateStoreId ? this.type === "STATE" && this.stateStoreId === tplStateStoreId : this.type === "CTX") {
@@ -64,10 +62,10 @@ export class DataStore {
     }
   }
   getAffectListByContext(name) {
-    var affectNames = [name];
+    const affectNames = [name];
     this.data.forEach((value, key) => {
       if (value.deps) {
-        var isInDeps = value.deps.some(item => affectNames.includes(item));
+        const isInDeps = value.deps.some(item => affectNames.includes(item));
         isInDeps && affectNames.push(key) && affectNames.push(...this.getAffectListByContext(key));
       }
     });
@@ -78,29 +76,29 @@ export class DataStore {
     this.batchUpdate = true;
     this.batchUpdateContextsNames = values.map(item => item.name);
     if ([...new Set(this.batchUpdateContextsNames)].length !== this.batchUpdateContextsNames.length) {
-      throw new Error("Batch update not allow to update same item");
+      throw new Error(`Batch update not allow to update same item`);
     }
-    var updateContexts = {};
-    var affectContexts = {};
-    var affectDepsContextNames = [];
+    const updateContexts = {};
+    const affectContexts = {};
+    const affectDepsContextNames = [];
     values.forEach(arg => {
-      var {
+      const {
         name,
         value
       } = argsFactory([arg]);
-      var updateContextItem = this.data.get(name);
+      const updateContextItem = this.data.get(name);
       affectDepsContextNames.push(...this.getAffectListByContext(name));
       updateContextItem && (updateContexts[name] = updateContextItem);
       this.updateValue(name, value, method);
     });
     affectDepsContextNames.filter(item => !updateContexts[item]).forEach(name => {
-      var affectContextItem = this.data.get(name);
+      const affectContextItem = this.data.get(name);
       affectContextItem && (affectContexts[name] = affectContextItem);
     });
-    var triggerEvent = contexts => {
-      for (var key in contexts) {
+    const triggerEvent = contexts => {
+      for (const key in contexts) {
         var _context$eventTarget;
-        var context = contexts[key];
+        const context = contexts[key];
         (_context$eventTarget = context.eventTarget) === null || _context$eventTarget === void 0 || _context$eventTarget.dispatchEvent(new CustomEvent(this.changeEventType, {
           detail: context.value
         }));
@@ -112,15 +110,15 @@ export class DataStore {
     return;
   }
   updateValue(name, value, method, callback, callbackRuntimeContext) {
-    var item = this.data.get(name);
+    const item = this.data.get(name);
     if (!item) {
-      throw new Error("".concat(this.type, " '").concat(name, "' is not defined"));
+      throw new Error(`${this.type} '${name}' is not defined`);
     }
     if (method === "refresh" || method === "load") {
       if (!item.useResolve) {
-        throw new Error("You can not ".concat(method, " \"").concat(this.type, ".").concat(name, "\" which is not using resolve"));
+        throw new Error(`You can not ${method} "${this.type}.${name}" which is not using resolve`);
       }
-      var promise;
+      let promise;
       if (method === "load") {
         // Try to reuse previous request when calling `load`.
         if (item.loaded) {
@@ -129,19 +127,20 @@ export class DataStore {
           promise = item.loading;
         }
       }
-      var shouldDismiss = error => {
+      const shouldDismiss = error => {
         var _this$rendererContext;
         // If render twice immediately, flow API contracts maybe cleared before
         // the second rendering, while the page load handlers of the first
         // rendering can't be cancelled, which throws `FlowApiNotFoundError`.
         // So we ignore error reporting for this case.
-        var renderId;
+        let renderId;
         return (error === null || error === void 0 ? void 0 : error.name) === "FlowApiNotFoundError" && !!(renderId = (_this$rendererContext = this.rendererContext) === null || _this$rendererContext === void 0 ? void 0 : _this$rendererContext.renderId) && renderId !== _internalApiGetRenderId();
       };
       if (!promise) {
-        promise = item.loading = item.load(_objectSpread({
-          cache: method === "load" ? "default" : "reload"
-        }, value));
+        promise = item.loading = item.load({
+          cache: method === "load" ? "default" : "reload",
+          ...value
+        });
         // Do not use the chained promise, since the callbacks need the original promise.
         promise.then(val => {
           this.finishLoad(item, val);
@@ -153,7 +152,7 @@ export class DataStore {
         });
       }
       if (callback) {
-        var callbackFactory = eventCallbackFactory(callback, callbackRuntimeContext);
+        const callbackFactory = eventCallbackFactory(callback, callbackRuntimeContext);
         promise.then(val => {
           callbackFactory("success")({
             value: val
@@ -175,7 +174,7 @@ export class DataStore {
         Object.assign(item.value, value);
       } else {
         // eslint-disable-next-line no-console
-        console.warn("Non-object current value of \"".concat(this.type, ".").concat(name, "\" for \"context.assign\", try \"context.replace\" instead."));
+        console.warn(`Non-object current value of "${this.type}.${name}" for "context.assign", try "context.replace" instead.`);
         item.value = value;
       }
     }
@@ -199,7 +198,7 @@ export class DataStore {
   }
   define(dataConfs, runtimeContext, asyncHostPropertyEntries, routePath) {
     if (Array.isArray(dataConfs) && dataConfs.length > 0) {
-      var pending = resolveDataStore(dataConfs, dataConf => this.resolve(dataConf, runtimeContext, asyncHostPropertyEntries, routePath), this.type, isStrictMode(runtimeContext));
+      const pending = resolveDataStore(dataConfs, dataConf => this.resolve(dataConf, runtimeContext, asyncHostPropertyEntries, routePath), this.type, isStrictMode(runtimeContext));
       this.pendingStack.push(pending);
     }
   }
@@ -207,41 +206,32 @@ export class DataStore {
     var _this$data$get2;
     (_this$data$get2 = this.data.get(dataName)) === null || _this$data$get2 === void 0 || _this$data$get2.eventTarget.addEventListener(this.changeEventType, listener);
   }
-  waitFor(dataNames) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      var _loop = function* (pendingContexts) {
-        yield Promise.all([...dataNames].map(ctx => {
-          var p = pendingContexts.get(ctx);
-          return p;
-        }));
-      };
-      for (var {
-        pendingContexts
-      } of _this.pendingStack) {
-        yield* _loop(pendingContexts);
-      }
-    })();
+  async waitFor(dataNames) {
+    for (const {
+      pendingContexts
+    } of this.pendingStack) {
+      await Promise.all([...dataNames].map(ctx => {
+        const p = pendingContexts.get(ctx);
+        return p;
+      }));
+    }
   }
-  waitForAll() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      // Silent each pending contexts, since the error is handled by batched `pendingResult`
-      for (var {
-        pendingContexts
-      } of _this2.pendingStack) {
-        for (var p of pendingContexts.values()) {
-          p.catch(() => {
-            /* No-op */
-          });
-        }
-      }
-      for (var {
-        pendingResult
-      } of _this2.pendingStack) {
-        yield pendingResult;
+  async waitForAll() {
+    // Silent each pending contexts, since the error is handled by batched `pendingResult`
+    for (const {
+      pendingContexts
+    } of this.pendingStack) {
+      for (const p of pendingContexts.values()) {
+        p.catch(() => {
+          /* No-op */
+        });
       }
-    })();
+    }
+    for (const {
+      pendingResult
+    } of this.pendingStack) {
+      await pendingResult;
+    }
   }
 
   /**
@@ -256,7 +246,7 @@ export class DataStore {
         // istanbul ignore next
         if (item.asyncMounted) {
           // eslint-disable-next-line no-console
-          console.error("Async data \"".concat(item.name, "\" already mounted. This is a bug of Brick Next, please report it."));
+          console.error(`Async data "${item.name}" already mounted. This is a bug of Brick Next, please report it.`);
           return;
         }
         item.asyncMounted = true;
@@ -268,132 +258,126 @@ export class DataStore {
       }
     });
   }
-  resolve(dataConf, runtimeContext, asyncHostPropertyEntries, routePath) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (!(yield asyncCheckIf(dataConf, runtimeContext))) {
-        return false;
-      }
-      var value;
-      if (asyncHostPropertyEntries && (_this3.type === "STATE" ? dataConf.expose : _this3.type === "FORM_STATE")) {
-        value = yield computePropertyValue(asyncHostPropertyEntries, dataConf.name);
-      }
-      var load;
-      var loading;
-      var useResolve;
-      var trackConditionalResolve;
-      var resolvePolicy;
-      if (value === undefined) {
-        if (dataConf.resolve) {
-          var hasFallbackValue = hasOwnProperty(dataConf, "value");
-          // Track conditional resolve only if all matches:
-          //   - Track enabled
-          //   - Has fallback value
-          //   - Referencing other data in `resolve.if`
-          trackConditionalResolve = dataConf.track && hasFallbackValue && hasOwnProperty(dataConf.resolve, "if") && strictCollectMemberUsage(dataConf.resolve.if, _this3.type).size > 0;
-          var resolveConf = _objectSpread({
-            transform: "value"
-          }, dataConf.resolve);
-          useResolve = yield asyncCheckIf(dataConf.resolve, runtimeContext);
-          if (useResolve || trackConditionalResolve) {
-            load = /*#__PURE__*/function () {
-              var _ref2 = _asyncToGenerator(function* (options) {
-                var _this3$rendererContex;
-                return (yield resolveData(resolveConf, runtimeContext, _objectSpread(_objectSpread({}, options), {}, {
-                  renderId: (_this3$rendererContex = _this3.rendererContext) === null || _this3$rendererContex === void 0 ? void 0 : _this3$rendererContex.renderId
-                }))).value;
-              });
-              return function load(_x) {
-                return _ref2.apply(this, arguments);
-              };
-            }();
-          }
-          if (useResolve) {
-            // `async` take precedence over `lazy`
-            resolvePolicy = dataConf.resolve.async ? "async" : dataConf.resolve.lazy ? "lazy" : "eager";
-            if (resolvePolicy === "eager") {
-              value = yield load();
-            } else if (resolvePolicy === "async") {
-              loading = load();
-            }
-          } else if (!hasFallbackValue) {
-            return false;
-          }
-        }
-        if ((!useResolve || resolvePolicy !== "eager") && dataConf.value !== undefined) {
-          // If the context has no resolve, just use its `value`.
-          // Or if the resolve is ignored or lazy, use its `value` as a fallback.
-          value = yield asyncComputeRealValue(dataConf.value, runtimeContext);
+  async resolve(dataConf, runtimeContext, asyncHostPropertyEntries, routePath) {
+    if (!(await asyncCheckIf(dataConf, runtimeContext))) {
+      return false;
+    }
+    let value;
+    if (asyncHostPropertyEntries && (this.type === "STATE" ? dataConf.expose : this.type === "FORM_STATE")) {
+      value = await computePropertyValue(asyncHostPropertyEntries, dataConf.name);
+    }
+    let load;
+    let loading;
+    let useResolve;
+    let trackConditionalResolve;
+    let resolvePolicy;
+    if (value === undefined) {
+      if (dataConf.resolve) {
+        const hasFallbackValue = hasOwnProperty(dataConf, "value");
+        // Track conditional resolve only if all matches:
+        //   - Track enabled
+        //   - Has fallback value
+        //   - Referencing other data in `resolve.if`
+        trackConditionalResolve = dataConf.track && hasFallbackValue && hasOwnProperty(dataConf.resolve, "if") && strictCollectMemberUsage(dataConf.resolve.if, this.type).size > 0;
+        const resolveConf = {
+          transform: "value",
+          ...dataConf.resolve
+        };
+        useResolve = await asyncCheckIf(dataConf.resolve, runtimeContext);
+        if (useResolve || trackConditionalResolve) {
+          load = async options => {
+            var _this$rendererContext2;
+            return (await resolveData(resolveConf, runtimeContext, {
+              ...options,
+              renderId: (_this$rendererContext2 = this.rendererContext) === null || _this$rendererContext2 === void 0 ? void 0 : _this$rendererContext2.renderId
+            })).value;
+          };
         }
-      }
-      if (_this3.data.has(dataConf.name)) {
-        throw new Error("".concat(_this3.type, " '").concat(dataConf.name, "' has already been declared"));
-      }
-      var newData = {
-        name: dataConf.name,
-        value,
-        // This is required for tracking context, even if no `onChange` is specified.
-        eventTarget: new EventTarget(),
-        useResolve,
-        load,
-        loaded: resolvePolicy === "eager",
-        loading,
-        async: resolvePolicy === "async",
-        deps: []
-      };
-      if (resolvePolicy === "lazy") {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        var {
-          trigger
-        } = dataConf.resolve;
-        if (trigger && supportContextResolveTriggerBrickLifeCycle.includes(trigger)) {
-          var _this3$rendererContex2;
-          (_this3$rendererContex2 = _this3.rendererContext) === null || _this3$rendererContex2 === void 0 || _this3$rendererContex2.registerArbitraryLifeCycle(trigger, () => {
-            _this3.updateValue(dataConf.name, undefined, "load");
-          });
+        if (useResolve) {
+          // `async` take precedence over `lazy`
+          resolvePolicy = dataConf.resolve.async ? "async" : dataConf.resolve.lazy ? "lazy" : "eager";
+          if (resolvePolicy === "eager") {
+            value = await load();
+          } else if (resolvePolicy === "async") {
+            loading = load();
+          }
+        } else if (!hasFallbackValue) {
+          return false;
         }
       }
-      if (dataConf.onChange) {
-        newData.eventTarget.addEventListener(_this3.changeEventType, listenerFactory(dataConf.onChange, runtimeContext));
+      if ((!useResolve || resolvePolicy !== "eager") && dataConf.value !== undefined) {
+        // If the context has no resolve, just use its `value`.
+        // Or if the resolve is ignored or lazy, use its `value` as a fallback.
+        value = await asyncComputeRealValue(dataConf.value, runtimeContext);
       }
-      if (dataConf.track) {
-        var deps = strictCollectMemberUsage(trackConditionalResolve ? [dataConf.resolve, dataConf.value] : load ? dataConf.resolve : dataConf.value, _this3.type);
-        !load && (newData.deps = [...deps]);
-        for (var dep of deps) {
-          _this3.onChange(dep, _this3.batchAddListener(() => {
-            newData.useResolve = trackConditionalResolve ? checkIf(dataConf.resolve, runtimeContext) : !!load;
-            if (newData.useResolve) {
-              _this3.updateValue(dataConf.name, {
-                cache: "default"
-              }, "refresh");
-            } else {
-              _this3.updateValue(dataConf.name, computeRealValue(dataConf.value, runtimeContext), "replace");
-            }
-          }, dataConf));
-        }
+    }
+    if (this.data.has(dataConf.name)) {
+      throw new Error(`${this.type} '${dataConf.name}' has already been declared`);
+    }
+    const newData = {
+      name: dataConf.name,
+      value,
+      // This is required for tracking context, even if no `onChange` is specified.
+      eventTarget: new EventTarget(),
+      useResolve,
+      load,
+      loaded: resolvePolicy === "eager",
+      loading,
+      async: resolvePolicy === "async",
+      deps: []
+    };
+    if (resolvePolicy === "lazy") {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const {
+        trigger
+      } = dataConf.resolve;
+      if (trigger && supportContextResolveTriggerBrickLifeCycle.includes(trigger)) {
+        var _this$rendererContext3;
+        (_this$rendererContext3 = this.rendererContext) === null || _this$rendererContext3 === void 0 || _this$rendererContext3.registerArbitraryLifeCycle(trigger, () => {
+          this.updateValue(dataConf.name, undefined, "load");
+        });
       }
-      newData.eventTarget.addEventListener(_this3.changeEventType, e => {
-        _this3.notifyRealTimeDataChange(dataConf.name, e.detail);
-      });
-      _this3.data.set(dataConf.name, newData);
-      if (Array.isArray(routePath)) {
-        for (var route of routePath) {
-          var names = _this3.routeMap.get(route);
-          if (names) {
-            names.add(dataConf.name);
+    }
+    if (dataConf.onChange) {
+      newData.eventTarget.addEventListener(this.changeEventType, listenerFactory(dataConf.onChange, runtimeContext));
+    }
+    if (dataConf.track) {
+      const deps = strictCollectMemberUsage(trackConditionalResolve ? [dataConf.resolve, dataConf.value] : load ? dataConf.resolve : dataConf.value, this.type);
+      !load && (newData.deps = [...deps]);
+      for (const dep of deps) {
+        this.onChange(dep, this.batchAddListener(() => {
+          newData.useResolve = trackConditionalResolve ? checkIf(dataConf.resolve, runtimeContext) : !!load;
+          if (newData.useResolve) {
+            this.updateValue(dataConf.name, {
+              cache: "default"
+            }, "refresh");
           } else {
-            _this3.routeMap.set(route, new Set([dataConf.name]));
+            this.updateValue(dataConf.name, computeRealValue(dataConf.value, runtimeContext), "replace");
           }
+        }, dataConf));
+      }
+    }
+    newData.eventTarget.addEventListener(this.changeEventType, e => {
+      this.notifyRealTimeDataChange(dataConf.name, e.detail);
+    });
+    this.data.set(dataConf.name, newData);
+    if (Array.isArray(routePath)) {
+      for (const route of routePath) {
+        const names = this.routeMap.get(route);
+        if (names) {
+          names.add(dataConf.name);
+        } else {
+          this.routeMap.set(route, new Set([dataConf.name]));
         }
       }
-      return true;
-    })();
+    }
+    return true;
   }
   disposeDataInRoutes(routes) {
-    for (var route of routes) {
-      var names = this.routeMap.get(route);
+    for (const route of routes) {
+      const names = this.routeMap.get(route);
       if (names !== undefined) {
-        for (var name of names) {
+        for (const name of names) {
           this.data.delete(name);
         }
       }