@catladder/pipeline 0.0.0-node16-ddfae617 → 0.0.0-refactor-env-context-9e652b63

package/dist/context/resolveReferences.js

@@ -1,5 +1,146 @@
 "use strict";
 
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function () {
+      if (t[0] & 1) throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  },
+      f,
+      y,
+      t,
+      g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+
+    while (_) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+
+        case 7:
+          op = _.ops.pop();
+
+          _.trys.pop();
+
+          continue;
+
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+
+            _.ops.push(op);
+
+            break;
+          }
+
+          if (t[2]) _.ops.pop();
+
+          _.trys.pop();
+
+          continue;
+      }
+
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+
 var __read = this && this.__read || function (o, n) {
   var m = typeof Symbol === "function" && o[Symbol.iterator];
   if (!m) return o;
@@ -25,11 +166,19 @@ var __read = this && this.__read || function (o, n) {
   return ar;
 };
 
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+
 exports.__esModule = true;
 exports.translateLegacyFromComponents = exports.resolveReferences = void 0;
 
 var lodash_1 = require("lodash");
 
+var string_replace_async_1 = __importDefault(require("string-replace-async"));
+
 var REGEX = /\$\{(([^:]+):)?([^}]+)}/gm;
 
 var resolveReferences = function (vars, getOtherVariables, alreadyVisitedBase) {
@@ -37,39 +186,139 @@ var resolveReferences = function (vars, getOtherVariables, alreadyVisitedBase) {
     alreadyVisitedBase = {};
   }
 
-  var replaceSingleValue = function (value, alreadyVisited) {
-    if (alreadyVisited === void 0) {
-      alreadyVisited = alreadyVisitedBase;
-    }
+  return __awaiter(void 0, void 0, void 0, function () {
+    var replaceSingleValue, _a, _b;
 
-    if (REGEX.test(value)) {
-      return value.replace(REGEX, function (match, _, componentName, variableName) {
-        var _a, _b;
+    return __generator(this, function (_c) {
+      switch (_c.label) {
+        case 0:
+          replaceSingleValue = function (value, alreadyVisited) {
+            if (alreadyVisited === void 0) {
+              alreadyVisited = alreadyVisitedBase;
+            }
 
-        var _c, _d;
+            return __awaiter(void 0, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                switch (_a.label) {
+                  case 0:
+                    if (!REGEX.test(value)) return [3
+                    /*break*/
+                    , 2];
+                    return [4
+                    /*yield*/
+                    , (0, string_replace_async_1["default"])(value, REGEX, function (match, _, componentName, variableName) {
+                      return __awaiter(void 0, void 0, void 0, function () {
+                        var newAlreadyVisited, result, _a, replaced, _b;
 
-        if ((_c = alreadyVisited[componentName]) === null || _c === void 0 ? void 0 : _c[variableName]) {
-          return match; // prevent endless loop
-        }
+                        var _c, _d;
 
-        var newAlreadyVisited = (0, lodash_1.merge)({}, alreadyVisited, (_a = {}, _a[componentName] = (_b = {}, _b[variableName] = true, _b), _a));
-        var result = componentName ? (_d = getOtherVariables === null || getOtherVariables === void 0 ? void 0 : getOtherVariables(componentName, variableName, newAlreadyVisited)) !== null && _d !== void 0 ? _d : null : vars[variableName]; // is self reference
+                        var _e, _f;
 
-        var replaced = result !== null && result !== undefined ? replaceSingleValue(result, newAlreadyVisited) : match;
-        return replaced;
-      });
-    } else {
-      return value;
-    }
-  };
+                        return __generator(this, function (_g) {
+                          switch (_g.label) {
+                            case 0:
+                              if ((_e = alreadyVisited[componentName]) === null || _e === void 0 ? void 0 : _e[variableName]) {
+                                return [2
+                                /*return*/
+                                , match]; // prevent endless loop
+                              }
 
-  return Object.fromEntries(Object.entries(vars).map(function (_a) {
-    var _b = __read(_a, 2),
-        key = _b[0],
-        value = _b[1];
+                              newAlreadyVisited = (0, lodash_1.merge)({}, alreadyVisited, (_c = {}, _c[componentName] = (_d = {}, _d[variableName] = true, _d), _c));
+                              if (!componentName) return [3
+                              /*break*/
+                              , 2];
+                              return [4
+                              /*yield*/
+                              , getOtherVariables === null || getOtherVariables === void 0 ? void 0 : getOtherVariables(componentName, variableName, newAlreadyVisited)];
 
-    return [key, replaceSingleValue(value)];
-  }));
+                            case 1:
+                              _a = (_f = _g.sent()) !== null && _f !== void 0 ? _f : null;
+                              return [3
+                              /*break*/
+                              , 3];
+
+                            case 2:
+                              _a = vars[variableName];
+                              _g.label = 3;
+
+                            case 3:
+                              result = _a;
+                              if (!(result !== null && result !== undefined)) return [3
+                              /*break*/
+                              , 5];
+                              return [4
+                              /*yield*/
+                              , replaceSingleValue(result, newAlreadyVisited)];
+
+                            case 4:
+                              _b = _g.sent();
+                              return [3
+                              /*break*/
+                              , 6];
+
+                            case 5:
+                              _b = match;
+                              _g.label = 6;
+
+                            case 6:
+                              replaced = _b;
+                              return [2
+                              /*return*/
+                              , replaced];
+                          }
+                        });
+                      });
+                    })];
+
+                  case 1:
+                    return [2
+                    /*return*/
+                    , _a.sent()];
+
+                  case 2:
+                    return [2
+                    /*return*/
+                    , value];
+                }
+              });
+            });
+          };
+
+          _b = (_a = Object).fromEntries;
+          return [4
+          /*yield*/
+          , Promise.all(Object.entries(vars).map(function (_a) {
+            var _b = __read(_a, 2),
+                key = _b[0],
+                value = _b[1];
+
+            return __awaiter(void 0, void 0, void 0, function () {
+              var _c;
+
+              return __generator(this, function (_d) {
+                switch (_d.label) {
+                  case 0:
+                    _c = [key];
+                    return [4
+                    /*yield*/
+                    , replaceSingleValue(value)];
+
+                  case 1:
+                    return [2
+                    /*return*/
+                    , _c.concat([_d.sent()])];
+                }
+              });
+            });
+          }))];
+
+        case 1:
+          return [2
+          /*return*/
+          , _b.apply(_a, [_c.sent()])];
+      }
+    });
+  });
 };
 
 exports.resolveReferences = resolveReferences;