@next-core/brick-utils 2.33.1 → 2.34.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.34.0](https://github.com/easyops-cn/next-core/compare/@next-core/brick-utils@2.33.1...@next-core/brick-utils@2.34.0) (2022-02-14)
+
+
+### Features
+
+* support template scoped state ([d736f85](https://github.com/easyops-cn/next-core/commit/d736f8550b4b645851e2b0a99bb2f99eee4378a2))
+* support tpl-scoped context ([783b060](https://github.com/easyops-cn/next-core/commit/783b0605d3c74ac653120689d467384a71aaf79a))
+
+
+
+
+
 ## [2.33.1](https://github.com/easyops-cn/next-core/compare/@next-core/brick-utils@2.33.0...@next-core/brick-utils@2.33.1) (2022-01-28)
 
 **Note:** Version bump only for package @next-core/brick-utils

package/dist/index.bundle.js

@@ -21434,7 +21434,7 @@
     convertUnitValueByPrecision: convertValueByPrecision
   } = pipes.utils;
 
-  var CTX$1 = "CTX";
+  var CTX = "CTX";
   function resolveContextConcurrently(_x, _x2) {
     return _resolveContextConcurrently.apply(this, arguments);
   }
@@ -21474,10 +21474,7 @@
 
       function _scheduleNext() {
         _scheduleNext = _asyncToGenerator__default["default"](function* () {
-          var readyContexts = Array.from(dependencyMap.entries()).filter((entry, index) => // When contexts contain computed CTX accesses, it implies a dynamic dependency map.
-          // 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))).map(entry => entry[0]).filter(contextConf => !processed.has(contextConf));
+          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);
@@ -21500,20 +21497,66 @@
     return _resolveContextConcurrently.apply(this, arguments);
   }
 
+  function syncResolveContextConcurrently(contextConfs, resolveContext) {
+    var dependencyMap = getDependencyMapOfContext(contextConfs);
+    var pendingDeps = new Set(Array.from(dependencyMap.keys()).map(contextConf => contextConf.name));
+    var includesComputed = Array.from(dependencyMap.values()).some(stats => stats.includesComputed);
+    var scheduleAsSerial = includesComputed;
+
+    function scheduleNext() {
+      var dep = Array.from(dependencyMap.entries()).find(predicateNextResolveFactory(pendingDeps, scheduleAsSerial));
+
+      if (dep) {
+        var [_contextConf] = dep;
+        var resolved = resolveContext(_contextConf);
+        dependencyMap.delete(_contextConf);
+
+        if (resolved) {
+          if (!pendingDeps.delete(_contextConf.name)) {
+            throw new Error("Duplicated context defined: ".concat(_contextConf.name));
+          }
+        }
+
+        scheduleNext();
+      }
+    }
+
+    scheduleNext(); // 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);
+      scheduleAsSerial = true;
+      scheduleNext();
+    }
+  }
+
+  function predicateNextResolveFactory(pendingDeps, scheduleAsSerial) {
+    return (entry, index) => // When contexts contain computed CTX accesses, it implies a dynamic dependency map.
+    // 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));
+  }
+
   function getDependencyMapOfContext(contextConfs) {
     var depsMap = new Map();
 
-    for (var _contextConf of contextConfs) {
+    for (var _contextConf2 of contextConfs) {
       var stats = {
         dependencies: [],
         includesComputed: false
       };
 
-      if (!_contextConf.property) {
-        visitStoryboardExpressions([_contextConf.if, _contextConf.value, _contextConf.resolve], beforeVisitContextFactory(stats), CTX$1);
+      if (!_contextConf2.property) {
+        visitStoryboardExpressions([_contextConf2.if, _contextConf2.value, _contextConf2.resolve], beforeVisitContextFactory(stats), CTX);
       }
 
-      depsMap.set(_contextConf, stats);
+      depsMap.set(_contextConf2, stats);
     }
 
     return depsMap;
@@ -21521,7 +21564,7 @@
 
   function beforeVisitContextFactory(stats) {
     return function beforeVisitContext(node, parent) {
-      if (node.name === CTX$1) {
+      if (node.name === CTX) {
         var memberParent = parent[parent.length - 1];
 
         if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
@@ -21551,10 +21594,10 @@
     var next = () => {
       var processedAtLeastOne = false;
 
-      for (var [_contextConf2, stats] of duplicatedMap.entries()) {
+      for (var [_contextConf3, stats] of duplicatedMap.entries()) {
         if (!stats.dependencies.some(dep => pendingDeps.has(dep))) {
-          duplicatedMap.delete(_contextConf2);
-          pendingDeps.delete(_contextConf2.name);
+          duplicatedMap.delete(_contextConf3);
+          pendingDeps.delete(_contextConf3.name);
           processedAtLeastOne = true;
         }
       }
@@ -21813,8 +21856,6 @@
     return Object.freeze(object);
   }
 
-  var TRACK_CONTEXT = "track context";
-  var CTX = "CTX";
   /**
    * Get tracking CTX for an evaluable expression in `track context` mode.
    *
@@ -21843,7 +21884,14 @@
    */
 
   function trackContext(raw) {
-    if (raw.includes(TRACK_CONTEXT)) {
+    return track(raw, "track context", "CTX");
+  }
+  function trackState(raw) {
+    return track(raw, "track state", "STATE");
+  }
+
+  function track(raw, trackText, variableName) {
+    if (raw.includes(trackText)) {
       var contexts = new Set();
       var {
         expression
@@ -21851,7 +21899,7 @@
         withParent: true,
         hooks: {
           beforeVisitGlobal(node, parent) {
-            if (node.name === CTX) {
+            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") {
@@ -21870,12 +21918,12 @@
       });
       var trackCtxExp;
 
-      if (expression.type === "SequenceExpression" && (trackCtxExp = expression.expressions[0]) && trackCtxExp.type === "Literal" && trackCtxExp.value === TRACK_CONTEXT) {
+      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(TRACK_CONTEXT, "\" but no CTX usage found in your expression: \"").concat(raw, "\""));
+          console.warn("You are using \"".concat(trackText, "\" but no `").concat(variableName, "` usage found in your expression: ").concat(JSON.stringify(raw)));
         }
       }
     }
@@ -21940,9 +21988,11 @@
   exports.scanTemplatesInStoryboard = scanTemplatesInStoryboard;
   exports.shouldAllowRecursiveEvaluations = shouldAllowRecursiveEvaluations;
   exports.smartDisplayForEvaluableString = smartDisplayForEvaluableString;
+  exports.syncResolveContextConcurrently = syncResolveContextConcurrently;
   exports.toPath = toPath;
   exports.tokTypes = tokTypes_1;
   exports.trackContext = trackContext;
+  exports.trackState = trackState;
   exports.transform = transform;
   exports.transformAndInject = transformAndInject;
   exports.visitStoryboardExpressions = visitStoryboardExpressions;