@devops-flow/devops-flow-pipeline-detail 0.0.37

package/es/components/PipelineFlowEdit/FlowDocument/DefService.js

@@ -0,0 +1,409 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { monacoYamlCompletionItemDescMark } from "../utils";
+import { fetchWithCache } from "./cache";
+import { has } from 'lodash';
+
+/** 处理 hidden & hiddenInYaml, hiddenInYaml 在 PAC 覆盖 hidden */
+import intl from "../../../locale";
+function isHiddenItem(defItem) {
+  if (has(defItem, 'hiddenInYaml')) {
+    return defItem.hiddenInYaml;
+  }
+  return defItem.hidden;
+}
+export var DefService = /*#__PURE__*/function () {
+  function DefService(def) {
+    this.def = def;
+    // this.generateNodeSchema();
+  }
+  // 不关心 json schema
+  var _proto = DefService.prototype;
+  _proto.fieldService =
+  /*#__PURE__*/
+  function () {
+    var _fieldService = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      var fieldOptions, enabledFieldKeys, _loop, _iterator, _step;
+      return _regeneratorRuntime.wrap(function _callee4$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            fieldOptions = {};
+            enabledFieldKeys = [];
+            _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
+              var defItem, name, dataSource, defDataSource, fixedDataSource, _dataSource, _defDataSource, _fixedDataSource, supported, getDataSource, _getDataSource;
+              return _regeneratorRuntime.wrap(function _loop$(_context4) {
+                while (1) switch (_context4.prev = _context4.next) {
+                  case 0:
+                    defItem = _step.value;
+                    name = defItem.nameAlias || defItem.name;
+                    if (!(isHiddenItem(defItem) || defItem.type === 'tip')) {
+                      _context4.next = 4;
+                      break;
+                    }
+                    return _context4.abrupt("return", 1);
+                  case 4:
+                    enabledFieldKeys.push({
+                      name: name,
+                      label: defItem.label,
+                      desc: defItem.description
+                    });
+                    _context4.t0 = defItem.type;
+                    _context4.next = _context4.t0 === 'radio_group' ? 8 : _context4.t0 === 'select' ? 13 : _context4.t0 === 'dropdown' ? 13 : _context4.t0 === 'machine_group_select_new' ? 32 : _context4.t0 === 'add_steps' ? 37 : 37;
+                    break;
+                  case 8:
+                    dataSource = [];
+                    defDataSource = defItem.datasource;
+                    if (Array.isArray(defDataSource)) {
+                      fixedDataSource = defDataSource.map(function (v) {
+                        return {
+                          label: v.label,
+                          value: v.valueAlias || v.value
+                        };
+                      });
+                      dataSource = fixedDataSource;
+                    }
+                    fieldOptions[name] = dataSource;
+                    // result[name] = {
+                    //   oneOf: dataSource.map((optionData) => {
+                    //     // "oneOf" item
+                    //     return {
+                    //       const: optionData.value,
+                    //       description: optionData.label,
+                    //       // key: dataItem[defItem.datasource.label],
+                    //     };
+                    //   }),
+                    // };
+                    return _context4.abrupt("break", 37);
+                  case 13:
+                    _dataSource = [];
+                    _defDataSource = defItem.datasource;
+                    if (!Array.isArray(_defDataSource)) {
+                      _context4.next = 20;
+                      break;
+                    }
+                    _fixedDataSource = _defDataSource.map(function (v) {
+                      return {
+                        label: v.label,
+                        value: v.valueAlias || v.value
+                      };
+                    });
+                    _dataSource = _fixedDataSource;
+                    _context4.next = 30;
+                    break;
+                  case 20:
+                    if (!(_defDataSource.type === 'remote')) {
+                      _context4.next = 29;
+                      break;
+                    }
+                    // eslint-disable-next-line no-inner-declarations
+                    supported = function supported(defItem) {
+                      var _defItem$datasource;
+                      var api = defItem === null || defItem === void 0 ? void 0 : (_defItem$datasource = defItem.datasource) === null || _defItem$datasource === void 0 ? void 0 : _defItem$datasource.api;
+                      return (api === null || api === void 0 ? void 0 : api.includes('credential/service/connection/list')) || (api === null || api === void 0 ? void 0 : api.includes('/deploy/machine/group/search')) || (api === null || api === void 0 ? void 0 : api.includes('/execution-component/buildNodeGroups'));
+                    };
+                    if (!supported(defItem)) {
+                      _context4.next = 27;
+                      break;
+                    }
+                    // eslint-disable-next-line no-inner-declarations
+                    getDataSource = /*#__PURE__*/function () {
+                      var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+                        var resp, options, _defItem$datasource$a, url;
+                        return _regeneratorRuntime.wrap(function _callee$(_context) {
+                          while (1) switch (_context.prev = _context.next) {
+                            case 0:
+                              options = [];
+                              _context.prev = 1;
+                              url = defItem.datasource.api.replace('?buildNodeGroup=${buildNodeGroup}', '');
+                              if ((_defItem$datasource$a = defItem.datasource.api) !== null && _defItem$datasource$a !== void 0 && _defItem$datasource$a.includes('credential/service/connection/list?scType=docker_register_aliyun')) {
+                                url += '&version=v2';
+                              }
+                              _context.next = 6;
+                              return fetchWithCache({
+                                // todo yamlAPI
+                                url: url,
+                                crossOrigin: true,
+                                withCredentials: true
+                              });
+                            case 6:
+                              resp = _context.sent;
+                              options = resp.object.map(function (dataItem) {
+                                return {
+                                  label: dataItem[defItem.datasource.label],
+                                  value: dataItem.uuid || dataItem.runsOnUid || dataItem[defItem.datasource.value]
+                                };
+                              });
+                              _context.next = 13;
+                              break;
+                            case 10:
+                              _context.prev = 10;
+                              _context.t0 = _context["catch"](1);
+                              console.error('pac completion request error: ', _context.t0);
+                            case 13:
+                              return _context.abrupt("return", options);
+                            case 14:
+                            case "end":
+                              return _context.stop();
+                          }
+                        }, _callee, null, [[1, 10]]);
+                      }));
+                      return function getDataSource() {
+                        return _ref.apply(this, arguments);
+                      };
+                    }();
+                    _context4.next = 26;
+                    return getDataSource();
+                  case 26:
+                    _dataSource = _context4.sent;
+                  case 27:
+                    _context4.next = 30;
+                    break;
+                  case 29:
+                    console.error('def datasource error');
+                  case 30:
+                    fieldOptions[name] = _dataSource;
+
+                    // result[defItem.nameAlias || defItem.name] = {
+                    //   oneOf: dataSource.map((optionData) => {
+                    //     // "oneOf" item
+                    //     return {
+                    //       const: optionData.value,
+                    //       description: optionData.label,
+                    //       // key: dataItem[defItem.datasource.label],
+                    //     };
+                    //   }),
+                    // };
+                    return _context4.abrupt("break", 37);
+                  case 32:
+                    // eslint-disable-next-line no-inner-declarations
+                    _getDataSource = /*#__PURE__*/function () {
+                      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+                        var resp, options, req, _req;
+                        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+                          while (1) switch (_context3.prev = _context3.next) {
+                            case 0:
+                              _req = function _req3() {
+                                _req = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+                                  return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                                    while (1) switch (_context2.prev = _context2.next) {
+                                      case 0:
+                                        _context2.next = 2;
+                                        return fetchWithCache({
+                                          url: defItem.datasource.api,
+                                          crossOrigin: true,
+                                          withCredentials: true,
+                                          data: {
+                                            pageSize: 999
+                                          }
+                                        });
+                                      case 2:
+                                        return _context2.abrupt("return", _context2.sent);
+                                      case 3:
+                                      case "end":
+                                        return _context2.stop();
+                                    }
+                                  }, _callee2);
+                                }));
+                                return _req.apply(this, arguments);
+                              };
+                              req = function _req2() {
+                                return _req.apply(this, arguments);
+                              };
+                              options = []; // eslint-disable-next-line no-inner-declarations
+                              _context3.prev = 3;
+                              _context3.next = 6;
+                              return req();
+                            case 6:
+                              resp = _context3.sent;
+                              options = resp.object.map(function (dataItem) {
+                                return {
+                                  label: dataItem[defItem.datasource.label],
+                                  value: dataItem['uuid']
+                                };
+                              });
+                              return _context3.abrupt("return", options);
+                            case 11:
+                              _context3.prev = 11;
+                              _context3.t0 = _context3["catch"](3);
+                              console.error('pac completion request error: ', _context3.t0);
+                            case 14:
+                            case "end":
+                              return _context3.stop();
+                          }
+                        }, _callee3, null, [[3, 11]]);
+                      }));
+                      return function _getDataSource() {
+                        return _ref2.apply(this, arguments);
+                      };
+                    }();
+                    _context4.next = 35;
+                    return _getDataSource();
+                  case 35:
+                    fieldOptions[name] = _context4.sent;
+                    return _context4.abrupt("break", 37);
+                  case 37:
+                  case "end":
+                    return _context4.stop();
+                }
+              }, _loop);
+            });
+            _iterator = _createForOfIteratorHelperLoose(this.def.items);
+          case 4:
+            if ((_step = _iterator()).done) {
+              _context5.next = 10;
+              break;
+            }
+            return _context5.delegateYield(_loop(), "t0", 6);
+          case 6:
+            if (!_context5.t0) {
+              _context5.next = 8;
+              break;
+            }
+            return _context5.abrupt("continue", 8);
+          case 8:
+            _context5.next = 4;
+            break;
+          case 10:
+            return _context5.abrupt("return", {
+              fieldOptions: fieldOptions,
+              enabledFieldKeys: enabledFieldKeys,
+              requiredFieldKeys: []
+            });
+          case 11:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee4, this);
+    }));
+    function fieldService() {
+      return _fieldService.apply(this, arguments);
+    }
+    return fieldService;
+  }();
+  _proto.generateSchema = /*#__PURE__*/function () {
+    var _generateSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+      var serviceResult, defObjectPropertiesSchema, _loop2, _iterator2, _step2;
+      return _regeneratorRuntime.wrap(function _callee5$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return this.fieldService();
+          case 2:
+            serviceResult = _context7.sent;
+            defObjectPropertiesSchema = {};
+            _loop2 = /*#__PURE__*/_regeneratorRuntime.mark(function _loop2() {
+              var _step2$value, name, label, desc, itemSchema, options, oneOfs, splited, parent, child, parentSchema;
+              return _regeneratorRuntime.wrap(function _loop2$(_context6) {
+                while (1) switch (_context6.prev = _context6.next) {
+                  case 0:
+                    _step2$value = _step2.value, name = _step2$value.name, label = _step2$value.label, desc = _step2$value.desc;
+                    options = serviceResult.fieldOptions[name];
+                    if (options) {
+                      oneOfs = options.map(function (optionData) {
+                        // "oneOf" item
+                        return _extends({}, typeof optionData.value === 'string' ? {
+                          type: 'string'
+                        } : {}, {
+                          "const": optionData.value,
+                          title: label,
+                          description: monacoYamlCompletionItemDescMark(optionData.label)
+                          // sortText: `${i}`, // 没用
+                        });
+                      });
+                      itemSchema = {
+                        title: label,
+                        description: desc,
+                        oneOf: oneOfs
+                      };
+                      // 给个类型，补全出来的才有冒号
+                      if (oneOfs.every(function (item) {
+                        return typeof item["const"] === 'string';
+                      })) {
+                        itemSchema.type = 'string';
+                      }
+                    } else {
+                      itemSchema = {
+                        title: label,
+                        description: desc
+                      };
+                    }
+                    if (!name.includes('.')) {
+                      _context6.next = 14;
+                      break;
+                    }
+                    /**
+                     * 点号语法，支持多个条目组成一个对象
+                     * 当 name 含有点号的情况，会创建一个父对象，多个条目会挂到父对象下的 properties 上。
+                     * e.g. nameAlias: certificate.serviceConnection
+                     * */
+                    splited = name.split('.');
+                    if (!(splited.length > 2)) {
+                      _context6.next = 8;
+                      break;
+                    }
+                    console.error(intl.get({
+                      id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.DefService.StepJobYamlTheField',
+                      defaultMessage: '步骤/job yaml 字段名最多只允许一个点号'
+                    }));
+                    return _context6.abrupt("return", 1);
+                  case 8:
+                    parent = splited[0], child = splited[1];
+                    parentSchema = defObjectPropertiesSchema[parent] || {
+                      type: 'object',
+                      properties: {}
+                    };
+                    parentSchema.properties[child] = itemSchema;
+                    defObjectPropertiesSchema[parent] = parentSchema;
+                    _context6.next = 16;
+                    break;
+                  case 14:
+                    // 先针对 validatorAppstackRoles 去掉校验，后续再接着优化
+                    if (name === 'validatorAppstackRoles') {
+                      delete itemSchema.oneOf;
+                      delete itemSchema.type;
+                    }
+                    defObjectPropertiesSchema[name] = itemSchema;
+                  case 16:
+                  case "end":
+                    return _context6.stop();
+                }
+              }, _loop2);
+            });
+            _iterator2 = _createForOfIteratorHelperLoose(serviceResult.enabledFieldKeys);
+          case 6:
+            if ((_step2 = _iterator2()).done) {
+              _context7.next = 12;
+              break;
+            }
+            return _context7.delegateYield(_loop2(), "t0", 8);
+          case 8:
+            if (!_context7.t0) {
+              _context7.next = 10;
+              break;
+            }
+            return _context7.abrupt("continue", 10);
+          case 10:
+            _context7.next = 6;
+            break;
+          case 12:
+            return _context7.abrupt("return", {
+              type: 'object',
+              properties: defObjectPropertiesSchema
+            });
+          case 13:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee5, this);
+    }));
+    function generateSchema() {
+      return _generateSchema.apply(this, arguments);
+    }
+    return generateSchema;
+  }();
+  return DefService;
+}();

package/es/components/PipelineFlowEdit/FlowDocument/EditingDocument.d.ts

@@ -0,0 +1,14 @@
+import { FlowNode } from './FlowNodeBase';
+export declare class EditingDocument extends FlowNode {
+    model: any;
+    ingredientsContextValue: any;
+    startTime: number;
+    constructor(model: any, astNode: any, ingredientsContextValue: any);
+    initChildren(): void;
+    setYamlSchema(): Promise<void>;
+    generateCptSchema(list: any): {
+        type: string;
+        oneOf: any;
+    };
+    generateCptStepListSchema(): Promise<void>;
+}

package/es/components/PipelineFlowEdit/FlowDocument/EditingDocument.js

@@ -0,0 +1,151 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { isMap } from 'yaml';
+import { FlowNode } from "./FlowNodeBase";
+import { FlowDocument } from "./FlowDocument";
+import { getComponentName, monacoYamlCompletionItemDescMark } from "../utils";
+import { isDevEnv } from "../../../utils";
+import { monaco } from 'react-monaco-editor';
+import { toMarkerData } from 'monaco-languageserver-types';
+export var EditingDocument = /*#__PURE__*/function (_FlowNode) {
+  function EditingDocument(model, astNode, ingredientsContextValue) {
+    var _this;
+    _this = _FlowNode.call(this, astNode) || this;
+    _this.model = void 0;
+    _this.ingredientsContextValue = void 0;
+    _this.startTime = void 0;
+    _this.startTime = Date.now();
+    _this.model = model;
+    _this.ingredientsContextValue = ingredientsContextValue;
+    _this.generateCptStepListSchema();
+    _this.initChildren();
+    return _this;
+  }
+  _inheritsLoose(EditingDocument, _FlowNode);
+  var _proto = EditingDocument.prototype;
+  _proto.initChildren = function initChildren() {
+    if (isMap(this.astNode)) {
+      this.children = new FlowDocument(this.astNode, this, this.ingredientsContextValue);
+    }
+  };
+  _proto.setYamlSchema = /*#__PURE__*/function () {
+    var _setYamlSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var schema, worker, diagnostics, markers;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            isDevEnv && console.log('root schema', schema);
+            isDevEnv && console.log('schema generation time: ', Date.now() - this.startTime + "ms");
+            _context.next = 4;
+            return window.yamlWorkerMgr.getWorker();
+          case 4:
+            worker = _context.sent;
+            if (this.children) {
+              _context.next = 9;
+              break;
+            }
+            schema = {};
+            _context.next = 12;
+            break;
+          case 9:
+            _context.next = 11;
+            return this.children.getSchema();
+          case 11:
+            schema = _context.sent;
+          case 12:
+            worker.modifySchemaContent({
+              schema: 'http://example.com/schema-pac-dynamic.json',
+              action: 1,
+              path: '',
+              key: 'properties',
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              content: schema
+            });
+            worker.modifySchemaContent({
+              schema: 'http://example.com/schema-pac.json',
+              action: 1,
+              path: 'properties/stages/patternProperties/.*/properties/jobs/patternProperties/.*/properties/component',
+              key: 'oneOf',
+              content: []
+            });
+
+            // "monaco-marker-data-provider" 默认在 onChange 500ms 后校验，但是可能新的schema还没生成。
+            // 这里schema已经更新，可以重新校验。
+            _context.next = 16;
+            return worker.doValidation(String(this.model.uri));
+          case 16:
+            diagnostics = _context.sent;
+            markers = diagnostics === null || diagnostics === void 0 ? void 0 : diagnostics.map(function (diagnostic) {
+              return toMarkerData(diagnostic);
+            });
+            monaco.editor.setModelMarkers(this.model, 'yaml', markers);
+            isDevEnv && console.log('schema updated');
+          case 20:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function setYamlSchema() {
+      return _setYamlSchema.apply(this, arguments);
+    }
+    return setYamlSchema;
+  }();
+  _proto.generateCptSchema = function generateCptSchema(list) {
+    var _this2 = this;
+    return {
+      type: 'string',
+      oneOf: list.map(function (item) {
+        var name = getComponentName(item, _this2.ingredientsContextValue.stepsList);
+        if (!name) {
+          return null;
+        }
+        return {
+          "const": item.sign,
+          title: name,
+          description: monacoYamlCompletionItemDescMark(name)
+        };
+      }).filter(Boolean)
+    };
+  };
+  _proto.generateCptStepListSchema = /*#__PURE__*/function () {
+    var _generateCptStepListSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var userUseableSteps, generateStepSchema, userUseableStepsVisible;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            generateStepSchema = function _generateStepSchema(list, ver) {
+              return {
+                type: 'string',
+                oneOf: list === null || list === void 0 ? void 0 : list.filter(function (s) {
+                  var _s$apiVersion, _s$apiVersion2, _s$apiVersion3;
+                  var matchingVersion = ver === 'v2' ? (_s$apiVersion = s.apiVersion) === null || _s$apiVersion === void 0 ? void 0 : _s$apiVersion.toLowerCase().includes('v2') : !((_s$apiVersion2 = s.apiVersion) !== null && _s$apiVersion2 !== void 0 && _s$apiVersion2.toLowerCase().includes('v2'));
+                  return !((_s$apiVersion3 = s.apiVersion) !== null && _s$apiVersion3 !== void 0 && _s$apiVersion3.includes('agentless') || 'ComponentJob' == s.kind) && matchingVersion;
+                }).map(function (step) {
+                  return {
+                    "const": step.sign,
+                    description: monacoYamlCompletionItemDescMark(step.name)
+                  };
+                })
+              };
+            };
+            userUseableSteps = this.ingredientsContextValue.userUseableSteps;
+            userUseableStepsVisible = userUseableSteps.filter(function (i) {
+              return i.visible;
+            });
+            this.stepListV1Schema = generateStepSchema(userUseableStepsVisible, 'v1');
+            this.stepListV2Schema = generateStepSchema(userUseableStepsVisible, 'v2');
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function generateCptStepListSchema() {
+      return _generateCptStepListSchema.apply(this, arguments);
+    }
+    return generateCptStepListSchema;
+  }();
+  return EditingDocument;
+}(FlowNode);

package/es/components/PipelineFlowEdit/FlowDocument/FlowDocument.d.ts

@@ -0,0 +1,8 @@
+import { FlowNode } from './FlowNodeBase';
+import { JSONSchemaMap } from './jsonSchema';
+export declare class FlowDocument extends FlowNode {
+    children: any[];
+    constructor(astNode: any, parent: any, ingredientsContextValue: any);
+    initChildren(): void;
+    getSchema(): Promise<JSONSchemaMap>;
+}

package/es/components/PipelineFlowEdit/FlowDocument/FlowDocument.js

@@ -0,0 +1,84 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { isMap } from 'yaml';
+import { FlowNode } from "./FlowNodeBase";
+import { FlowStages } from "./FlowStages";
+import { FlowSources } from "./FlowSources";
+import { FlowVariableGroups } from "./FlowVariableGroups";
+export var FlowDocument = /*#__PURE__*/function (_FlowNode) {
+  function FlowDocument(astNode, parent, ingredientsContextValue) {
+    var _this;
+    _this = _FlowNode.call(this, astNode, parent, ingredientsContextValue) || this;
+    _this.children = [];
+    _this.initChildren();
+    return _this;
+  }
+  _inheritsLoose(FlowDocument, _FlowNode);
+  var _proto = FlowDocument.prototype;
+  _proto.initChildren = function initChildren() {
+    var _this2 = this;
+    if (!isMap(this.astNode)) {
+      console.warn('unexpected type');
+    } else {
+      this.children = this.astNode.items.map(function (astPairNode) {
+        switch (astPairNode.key.value) {
+          case 'stages':
+            return new FlowStages(astPairNode, _this2, _this2.ingredientsContextValue);
+          case 'sources':
+            return new FlowSources(astPairNode, _this2);
+          case 'variableGroups':
+            return new FlowVariableGroups(astPairNode, _this2);
+          default:
+            return null;
+        }
+      }).filter(Boolean);
+    }
+  };
+  _proto.getSchema = /*#__PURE__*/function () {
+    var _getSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var schemasP, properties, _iterator, _step, schemaP;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            schemasP = this.children.map(function (v) {
+              return v.getSchema();
+            });
+            properties = {};
+            _iterator = _createForOfIteratorHelperLoose(schemasP);
+          case 3:
+            if ((_step = _iterator()).done) {
+              _context.next = 14;
+              break;
+            }
+            schemaP = _step.value;
+            _context.t0 = _extends;
+            _context.t1 = {};
+            _context.t2 = properties;
+            _context.next = 10;
+            return schemaP;
+          case 10:
+            _context.t3 = _context.sent;
+            properties = (0, _context.t0)(_context.t1, _context.t2, _context.t3);
+          case 12:
+            _context.next = 3;
+            break;
+          case 14:
+            return _context.abrupt("return", properties);
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getSchema() {
+      return _getSchema.apply(this, arguments);
+    }
+    return getSchema;
+  }();
+  return FlowDocument;
+}(FlowNode);