@catladder/pipeline/dist/variables/VariableValueContainingReferences.js

Panter workflow for cloud CI/CD and DevOps

"use strict";

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
    r,
    ar = [],
    e;
  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }
  return ar;
};
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createVariableValueContainingReferencesFromString = exports.VariableValueContainingReferences = exports.VariableReference = exports.UnresolvableReference = void 0;
var BashExpression_1 = require("../bash/BashExpression");
var bashEscape_1 = require("../bash/bashEscape");
var UnresolvableReference = /** @class */function () {
  function UnresolvableReference(reference) {
    this.reference = reference;
  }
  UnresolvableReference.prototype.toString = function () {
    return "Unresolvable reference: ".concat(this.reference.toString());
  };
  return UnresolvableReference;
}();
exports.UnresolvableReference = UnresolvableReference;
var VariableReference = /** @class */function () {
  function VariableReference(componentName, variableName) {
    this.componentName = componentName;
    this.variableName = variableName;
  }
  VariableReference.prototype.toString = function () {
    return "${".concat(this.componentName, ":").concat(this.variableName, "}");
  };
  return VariableReference;
}();
exports.VariableReference = VariableReference;
var VariableValueContainingReferences = /** @class */function () {
  function VariableValueContainingReferences(parts) {
    this.parts = (Array.isArray(parts) ? parts : [parts]).flatMap(function (part) {
      return part instanceof VariableValueContainingReferences ? part.parts : part === "" ? [] : [part];
    });
  }
  VariableValueContainingReferences.prototype.toString = function (options) {
    if (options === void 0) {
      options = {
        quotes: false
      };
    }
    return this.parts.map(function (part) {
      if (typeof part === "string") {
        return (0, bashEscape_1.escapeString)(part, options);
      } else if (part instanceof BashExpression_1.BashExpression) {
        return (0, bashEscape_1.escapeBashExpression)(part, options);
      } else {
        return part.toString();
      }
    }).join("");
  };
  return VariableValueContainingReferences;
}();
exports.VariableValueContainingReferences = VariableValueContainingReferences;
// regex to resolve references in catladder variables
// those expressions have the pattern ${componentName:variableName}
var REGEX = /\$\{(([^:}]+):)?([^}]+)}/gm;
var createVariableValueContainingReferencesFromString = function (value, options) {
  var parts = [];
  var match;
  var lastIndex = 0;
  while ((match = REGEX.exec(value)) !== null) {
    var _a = __read(match, 4),
      fullMatch = _a[0],
      _1 = _a[1],
      otherComponentName = _a[2],
      variableName = _a[3];
    parts.push(value.slice(lastIndex, match.index));
    parts.push(new VariableReference(otherComponentName || options.componentName, variableName));
    lastIndex = REGEX.lastIndex;
  }
  parts.push(value.slice(lastIndex));
  return new VariableValueContainingReferences(parts);
};
exports.createVariableValueContainingReferencesFromString = createVariableValueContainingReferencesFromString;