@next-core/brick-utils 2.45.15 → 2.45.16

package/dist/index.bundle.js

@@ -19461,7 +19461,178 @@
     convertUnitValueByPrecision: convertValueByPrecision
   } = pipes.utils;
 
-  function resolveContextConcurrently(_x, _x2) {
+  /**
+   * Get tracking CTX for an evaluable expression in `track context` mode.
+   *
+   * A `track context` mode is an evaluable expression which is a sequence expression
+   * starting with the exact literal string expression of "track context".
+   *
+   * @param raw - A raw string, which must be checked by `isEvaluable` first.
+   *
+   * @returns
+   *
+   * Returns used CTXs if `track context` mode is enabled, or returns false if not enabled or
+   * no CTX found.
+   *
+   * @example
+   *
+   * ```js
+   * trackContext('<% "track context", [CTX.hello, CTX.world] %>');
+   * // => ["hello", "world"]
+   *
+   * trackContext('<% [CTX.hello, CTX.world] %>');
+   * // => false
+   *
+   * trackContext('<% "track context", DATA.any %>');
+   * // => false
+   * ```
+   */
+  function trackContext(raw) {
+    return track(raw, "track context", "CTX");
+  }
+  function trackState(raw) {
+    return track(raw, "track state", "STATE");
+  }
+  function trackFormState(raw) {
+    return track(raw, "track formstate", "FORM_STATE");
+  }
+  function trackUsedContext(data) {
+    return collectContextUsage(data, "CTX").usedContexts;
+  }
+  function trackUsedState(data) {
+    return collectContextUsage(data, "STATE").usedContexts;
+  }
+  function track(raw, trackText, variableName) {
+    if (raw.includes(trackText)) {
+      // const contexts = new Set<string>();
+      var usage = {
+        usedContexts: [],
+        includesComputed: false
+      };
+      var {
+        expression
+      } = preevaluate(raw, {
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal: beforeVisitContextFactory(usage, variableName)
+        }
+      });
+      // const contexts = usage
+      var trackCtxExp;
+      if (expression.type === "SequenceExpression" && (trackCtxExp = expression.expressions[0]) && trackCtxExp.type === "Literal" && trackCtxExp.value === trackText) {
+        if (usage.usedContexts.length > 0) {
+          return usage.usedContexts;
+        } else {
+          // eslint-disable-next-line no-console
+          console.warn("You are using \"".concat(trackText, "\" but no `").concat(variableName, "` usage found in your expression: ").concat(JSON.stringify(raw)));
+        }
+      }
+    }
+    return false;
+  }
+  function beforeVisitContextFactory(usage, variableName) {
+    return function beforeVisitContext(node, parent) {
+      if (node.name === variableName) {
+        var memberParent = parent[parent.length - 1];
+        if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
+          var memberNode = memberParent.node;
+          var used;
+          if (!memberNode.computed && memberNode.property.type === "Identifier") {
+            used = memberNode.property.name;
+          } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
+            used = memberNode.property.value;
+          } else {
+            usage.includesComputed = true;
+          }
+          if (used !== undefined && !usage.usedContexts.includes(used)) {
+            usage.usedContexts.push(used);
+          }
+        }
+      }
+    };
+  }
+  function collectContextUsage(data, variableName) {
+    var usage = {
+      usedContexts: [],
+      includesComputed: false
+    };
+    visitStoryboardExpressions(data, beforeVisitContextFactory(usage, variableName), variableName);
+    return usage;
+  }
+
+  function deferResolveContextConcurrently(contextConfs, resolveContext) {
+    var keyword = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "CTX";
+    var dependencyMap = getDependencyMapOfContext(contextConfs, keyword);
+    var pendingDeps = new Set(Array.from(dependencyMap.keys()).map(contextConf => contextConf.name));
+    var includesComputed = Array.from(dependencyMap.values()).some(stats => stats.includesComputed);
+    var processed = new WeakSet();
+    var deferredContexts = new Map();
+    var pendingContexts = new Map([...new Set(contextConfs.map(contextConf => contextConf.name))].map(contextName => [contextName, new Promise((resolve, reject) => {
+      deferredContexts.set(contextName, {
+        resolve,
+        reject
+      });
+    })]));
+    var wrapResolve = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator__default["default"](function* (contextConf) {
+        processed.add(contextConf);
+        var resolved = yield resolveContext(contextConf);
+        dependencyMap.delete(contextConf);
+        if (resolved) {
+          deferredContexts.get(contextConf.name).resolve();
+          if (!pendingDeps.delete(contextConf.name)) {
+            throw new Error("Duplicated context defined: ".concat(contextConf.name));
+          }
+        }
+        yield scheduleNext();
+      });
+      return function wrapResolve(_x) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+    var scheduleAsSerial = includesComputed;
+    function scheduleNext() {
+      return _scheduleNext.apply(this, arguments);
+    }
+    function _scheduleNext() {
+      _scheduleNext = _asyncToGenerator__default["default"](function* () {
+        var readyContexts = Array.from(dependencyMap.entries()).filter(predicateNextResolveFactory(pendingDeps, scheduleAsSerial)).map(entry => entry[0]).filter(contextConf => !processed.has(contextConf));
+        yield Promise.all(readyContexts.map(wrapResolve));
+      });
+      return _scheduleNext.apply(this, arguments);
+    }
+    var pendingResult = scheduleNext().then( /*#__PURE__*/_asyncToGenerator__default["default"](function* () {
+      // If there are still contexts left, it implies one of these situations:
+      //   - Circular contexts.
+      //     Such as: a depends on b, while b depends on a.
+      //   - Related contexts are all ignored.
+      //     Such as: a depends on b,
+      //     while both them are ignore by a falsy result of `if`.
+      if (dependencyMap.size > 0) {
+        // This will throw if circular contexts detected.
+        detectCircularContexts(dependencyMap, keyword);
+        scheduleAsSerial = true;
+        yield scheduleNext();
+      }
+      // There maybe ignored contexts which are still not fulfilled.
+      // We treat them as RESOLVED.
+      for (var deferred of deferredContexts.values()) {
+        deferred.resolve();
+      }
+    })).catch(error => {
+      // There maybe contexts left not fulfilled, when an error occurred.
+      // We treat them as REJECTED.
+      for (var deferred of deferredContexts.values()) {
+        deferred.reject(error);
+      }
+      throw error;
+    });
+    return {
+      pendingResult,
+      pendingContexts
+    };
+  }
+  function resolveContextConcurrently(_x2, _x3) {
     return _resolveContextConcurrently.apply(this, arguments);
   }
   function _resolveContextConcurrently() {
@@ -19472,7 +19643,7 @@
       var includesComputed = Array.from(dependencyMap.values()).some(stats => stats.includesComputed);
       var processed = new WeakSet();
       var wrapResolve = /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator__default["default"](function* (contextConf) {
+        var _ref3 = _asyncToGenerator__default["default"](function* (contextConf) {
           processed.add(contextConf);
           var resolved = yield resolveContext(contextConf);
           dependencyMap.delete(contextConf);
@@ -19483,20 +19654,20 @@
           }
           yield scheduleNext();
         });
-        return function wrapResolve(_x3) {
-          return _ref.apply(this, arguments);
+        return function wrapResolve(_x4) {
+          return _ref3.apply(this, arguments);
         };
       }();
       var scheduleAsSerial = includesComputed;
       function scheduleNext() {
-        return _scheduleNext.apply(this, arguments);
+        return _scheduleNext2.apply(this, arguments);
       }
-      function _scheduleNext() {
-        _scheduleNext = _asyncToGenerator__default["default"](function* () {
+      function _scheduleNext2() {
+        _scheduleNext2 = _asyncToGenerator__default["default"](function* () {
           var readyContexts = Array.from(dependencyMap.entries()).filter(predicateNextResolveFactory(pendingDeps, scheduleAsSerial)).map(entry => entry[0]).filter(contextConf => !processed.has(contextConf));
           yield Promise.all(readyContexts.map(wrapResolve));
         });
-        return _scheduleNext.apply(this, arguments);
+        return _scheduleNext2.apply(this, arguments);
       }
       yield scheduleNext();
 
@@ -19556,51 +19727,24 @@
     // So make them process sequentially, keep the same behavior as before.
     scheduleAsSerial ? index === 0 :
     // A context is ready when it has no pending dependencies.
-    !entry[1].dependencies.some(dep => pendingDeps.has(dep));
+    !entry[1].usedContexts.some(dep => pendingDeps.has(dep));
   }
   function getDependencyMapOfContext(contextConfs) {
     var keyword = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "CTX";
     var depsMap = new Map();
     for (var _contextConf2 of contextConfs) {
-      var stats = {
-        dependencies: [],
-        includesComputed: false
-      };
-      if (!_contextConf2.property) {
-        visitStoryboardExpressions([_contextConf2.if, _contextConf2.value, _contextConf2.resolve], beforeVisitContextFactory$1(stats, keyword), keyword);
-      }
+      var stats = collectContextUsage(_contextConf2.property ? null : [_contextConf2.if, _contextConf2.value, _contextConf2.resolve], keyword);
       depsMap.set(_contextConf2, stats);
     }
     return depsMap;
   }
-  function beforeVisitContextFactory$1(stats, keyword) {
-    return function beforeVisitContext(node, parent) {
-      if (node.name === keyword) {
-        var memberParent = parent[parent.length - 1];
-        if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
-          var memberNode = memberParent.node;
-          var dep;
-          if (!memberNode.computed && memberNode.property.type === "Identifier") {
-            dep = memberNode.property.name;
-          } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
-            dep = memberNode.property.value;
-          } else {
-            stats.includesComputed = true;
-          }
-          if (dep !== undefined && !stats.dependencies.includes(dep)) {
-            stats.dependencies.push(dep);
-          }
-        }
-      }
-    };
-  }
   function detectCircularContexts(dependencyMap, keyword) {
     var duplicatedMap = new Map(dependencyMap);
     var pendingDeps = new Set(Array.from(duplicatedMap.keys()).map(contextConf => contextConf.name));
     var next = () => {
       var processedAtLeastOne = false;
       for (var [_contextConf3, stats] of duplicatedMap.entries()) {
-        if (!stats.dependencies.some(dep => pendingDeps.has(dep))) {
+        if (!stats.usedContexts.some(dep => pendingDeps.has(dep))) {
           duplicatedMap.delete(_contextConf3);
           pendingDeps.delete(_contextConf3.name);
           processedAtLeastOne = true;
@@ -19843,91 +19987,6 @@
     return Object.freeze(object);
   }
 
-  /**
-   * Get tracking CTX for an evaluable expression in `track context` mode.
-   *
-   * A `track context` mode is an evaluable expression which is a sequence expression
-   * starting with the exact literal string expression of "track context".
-   *
-   * @param raw - A raw string, which must be checked by `isEvaluable` first.
-   *
-   * @returns
-   *
-   * Returns used CTXs if `track context` mode is enabled, or returns false if not enabled or
-   * no CTX found.
-   *
-   * @example
-   *
-   * ```js
-   * trackContext('<% "track context", [CTX.hello, CTX.world] %>');
-   * // => ["hello", "world"]
-   *
-   * trackContext('<% [CTX.hello, CTX.world] %>');
-   * // => false
-   *
-   * trackContext('<% "track context", DATA.any %>');
-   * // => false
-   * ```
-   */
-  function trackContext(raw) {
-    return track(raw, "track context", "CTX");
-  }
-  function trackState(raw) {
-    return track(raw, "track state", "STATE");
-  }
-  function trackFormState(raw) {
-    return track(raw, "track formstate", "FORM_STATE");
-  }
-  function trackUsedContext(data) {
-    return trackUsed(data, "CTX");
-  }
-  function trackUsedState(data) {
-    return trackUsed(data, "STATE");
-  }
-  function track(raw, trackText, variableName) {
-    if (raw.includes(trackText)) {
-      var contexts = new Set();
-      var {
-        expression
-      } = preevaluate(raw, {
-        withParent: true,
-        hooks: {
-          beforeVisitGlobal: beforeVisitContextFactory(contexts, variableName)
-        }
-      });
-      var trackCtxExp;
-      if (expression.type === "SequenceExpression" && (trackCtxExp = expression.expressions[0]) && trackCtxExp.type === "Literal" && trackCtxExp.value === trackText) {
-        if (contexts.size > 0) {
-          return Array.from(contexts);
-        } else {
-          // eslint-disable-next-line no-console
-          console.warn("You are using \"".concat(trackText, "\" but no `").concat(variableName, "` usage found in your expression: ").concat(JSON.stringify(raw)));
-        }
-      }
-    }
-    return false;
-  }
-  function trackUsed(data, variableName) {
-    var contexts = new Set();
-    visitStoryboardExpressions(data, beforeVisitContextFactory(contexts, variableName), variableName);
-    return Array.from(contexts);
-  }
-  function beforeVisitContextFactory(contexts, variableName) {
-    return function beforeVisitContext(node, parent) {
-      if (node.name === variableName) {
-        var memberParent = parent[parent.length - 1];
-        if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
-          var memberNode = memberParent.node;
-          if (!memberNode.computed && memberNode.property.type === "Identifier") {
-            contexts.add(memberNode.property.name);
-          } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
-            contexts.add(memberNode.property.value);
-          }
-        }
-      }
-    };
-  }
-
   // The debounce function receives our function as a parameter
   function debounceByAnimationFrame(fn) {
     // This holds the requestAnimationFrame reference, so we can cancel it if we wish
@@ -20242,6 +20301,7 @@
   exports.asyncProcessBrick = asyncProcessBrick;
   exports.asyncProcessStoryboard = asyncProcessStoryboard;
   exports.collectBricksByCustomTemplates = collectBricksByCustomTemplates;
+  exports.collectContextUsage = collectContextUsage;
   exports.computeConstantCondition = computeConstantCondition;
   exports.computeRealRoutePath = computeRealRoutePath;
   exports.convertValueByPrecision = convertValueByPrecision;
@@ -20249,6 +20309,7 @@
   exports.createProviderClass = createProviderClass;
   exports.debounceByAnimationFrame = debounceByAnimationFrame;
   exports.deepFreeze = deepFreeze;
+  exports.deferResolveContextConcurrently = deferResolveContextConcurrently;
   exports.formatValue = formatValue;
   exports.getDependencyMapOfContext = getDependencyMapOfContext;
   exports.getDepsOfTemplates = getDepsOfTemplates;