@ukhomeoffice/cop-react-form-renderer 2.2.0 → 2.6.1-alpha

package/dist/utils/Condition/meetsCondition.test.js

@@ -0,0 +1,302 @@
+"use strict";
+
+var _meetsCondition = _interopRequireDefault(require("./meetsCondition"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+describe('utils.Condition.meetsCondition', function () {
+  var getCondition = function getCondition(operator, val) {
+    if (['in', 'nin'].includes(operator)) {
+      return {
+        op: operator,
+        values: val
+      };
+    }
+
+    return {
+      op: operator,
+      value: val
+    };
+  };
+
+  var TEST_VALUES = ['a', 'b', 3, 4, null, undefined, true, false, 0];
+  describe('equality operators', function () {
+    ['eq', '='].forEach(function (op) {
+      describe("operator ".concat(op), function () {
+        // Should match...
+        it('should match two nulls', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, null);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two undefineds', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two identical strings', function () {
+          var VALUE = 'value';
+          var CONDITION = getCondition(op, 'value');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two empty strings', function () {
+          var VALUE = '';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two identical numbers', function () {
+          var VALUE = 3;
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two zeroes', function () {
+          var VALUE = 0;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two boolean trues', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, true);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match two boolean falses', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, false);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        }); // Should reject...
+
+        it('should reject a null and undefined', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a null and empty string', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject an undefined and empty string', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a string of just whitespace and empty string', function () {
+          var VALUE = ' ';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it("should reject the string number '3' and the number 3", function () {
+          var VALUE = '3';
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a boolean true and the number 1', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, 1);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject a boolean false and a zero', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+      });
+    });
+  });
+  describe('inequality operators', function () {
+    ['ne', 'neq', '!=', '<>'].forEach(function (op) {
+      describe("operator ".concat(op), function () {
+        // Should reject...
+        it('should reject two nulls', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, null);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two undefineds', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two identical strings', function () {
+          var VALUE = 'value';
+          var CONDITION = getCondition(op, 'value');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two empty strings', function () {
+          var VALUE = '';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two identical numbers', function () {
+          var VALUE = 3;
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two zeroes', function () {
+          var VALUE = 0;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two boolean trues', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, true);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        });
+        it('should reject two boolean falses', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, false);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+        }); // Should match...
+
+        it('should match a null and undefined', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, undefined);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a null and empty string', function () {
+          var VALUE = null;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match an undefined and empty string', function () {
+          var VALUE = undefined;
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a string of just whitespace and empty string', function () {
+          var VALUE = ' ';
+          var CONDITION = getCondition(op, '');
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it("should match the string number '3' and the number 3", function () {
+          var VALUE = '3';
+          var CONDITION = getCondition(op, 3);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a boolean true and the number 1', function () {
+          var VALUE = true;
+          var CONDITION = getCondition(op, 1);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+        it('should match a boolean false and a zero', function () {
+          var VALUE = false;
+          var CONDITION = getCondition(op, 0);
+          expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+        });
+      });
+    });
+  });
+  describe('operator in', function () {
+    var op = 'in'; // Should match...
+
+    it('should match a string that is in the values array', function () {
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should match a number that is in the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie', 4]);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    }); // Should reject...
+
+    it('should reject a string that is missing from the values array', function () {
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a number that is missing from the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject everything when the values array is empty', function () {
+      var CONDITION = getCondition(op, []);
+      ['a', 'b', 'c', 'd', 'e', 6, 7, 8, 9, 'ten'].forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+    it('should reject everything when the values array is null', function () {
+      var CONDITION = getCondition(op, null);
+      ['a', 'b', 'c', 'd', 'e', 6, 7, 8, 9, 'ten'].forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+  });
+  describe('operator nin', function () {
+    var op = 'nin'; // Should reject...
+
+    it('should reject a string that is in the values array', function () {
+      var VALUE = 'alpha';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    });
+    it('should reject a number that is in the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie', 4]);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeFalsy();
+    }); // Should match...
+
+    it('should match a string that is missing from the values array', function () {
+      var VALUE = 'delta';
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should match a number that is missing from the values array', function () {
+      var VALUE = 4;
+      var CONDITION = getCondition(op, ['alpha', 'bravo', 'charlie']);
+      expect((0, _meetsCondition.default)(CONDITION, VALUE)).toBeTruthy();
+    });
+    it('should match anything when the values array is empty', function () {
+      var CONDITION = getCondition(op, []);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeTruthy();
+      });
+    });
+    it('should match anything when the values array is null', function () {
+      var CONDITION = getCondition(op, null);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeTruthy();
+      });
+    });
+  });
+  describe('unknown operator', function () {
+    var op = 'definitely_not_a_real_operator';
+    it('should reject anything regardless of the value', function () {
+      var CONDITION = getCondition(op, 'a');
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+    it('should accept anything even with a null value', function () {
+      var CONDITION = getCondition(op, null);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+    it('should accept anything even with a undefined value', function () {
+      var CONDITION = getCondition(op, null);
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(CONDITION, value)).toBeFalsy();
+      });
+    });
+  });
+  describe('invalid condition', function () {
+    it('should accept anything when the condition is null', function () {
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(null, value)).toBeTruthy();
+      });
+    });
+    it('should accept anything when the condition is undefined', function () {
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)(undefined, value)).toBeTruthy();
+      });
+    });
+    it('should accept anything when the condition is not an object', function () {
+      TEST_VALUES.forEach(function (value) {
+        expect((0, _meetsCondition.default)('condition', value)).toBeTruthy();
+      });
+    });
+  });
+});

package/dist/utils/Condition/setupConditions.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Data = _interopRequireDefault(require("../Data"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var makeComponentFieldsAbsolute = function makeComponentFieldsAbsolute(component) {
+  if (component.show_when) {
+    var full_path = component.full_path;
+    var show_when = Array.isArray(component.show_when) ? component.show_when : [component.show_when];
+    return show_when.map(function (sw) {
+      var field = _Data.default.getDataPath(sw.field, full_path);
+
+      return _objectSpread(_objectSpread({}, sw), {}, {
+        field: field
+      });
+    });
+  }
+
+  return undefined;
+};
+
+var isCondition = function isCondition(options) {
+  return Array.isArray(options) || !!(options.field && options.op);
+};
+
+var setupConditions = function setupConditions(options) {
+  if (options && !isCondition(options)) {
+    return makeComponentFieldsAbsolute(options);
+  }
+
+  return options;
+};
+
+var _default = setupConditions;
+exports.default = _default;

package/dist/utils/Condition/setupConditions.test.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _setupConditions = _interopRequireDefault(require("./setupConditions"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('utils.Condition.setupConditions', function () {
+  it('should return an array of conditions directly', function () {
+    var OPTIONS = [{
+      field: 'alpha',
+      op: '=',
+      value: 'ALPHA'
+    }];
+    expect((0, _setupConditions.default)(OPTIONS)).toEqual(OPTIONS);
+  });
+  it('should return a condition directly', function () {
+    var OPTIONS = {
+      field: 'alpha',
+      op: '=',
+      value: 'ALPHA'
+    };
+    expect((0, _setupConditions.default)(OPTIONS)).toEqual(OPTIONS);
+  });
+  it('should return the options on a component with untouched absolute path fields', function () {
+    var OPTIONS = {
+      id: 'field',
+      show_when: {
+        field: 'alpha',
+        op: '=',
+        value: 'ALPHA'
+      }
+    };
+    expect((0, _setupConditions.default)(OPTIONS)).toEqual([OPTIONS.show_when]);
+  });
+});

package/dist/utils/Container/getEditableComponents.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _models = require("../../models");
+
+var _Component = _interopRequireDefault(require("../Component"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Local imports
+
+/**
+ * Gets all the editable components in a container.
+ * @param {object} container The container to consider.
+ * @returns An array of ONLY the editable components in a container.
+ */
+var getEditableComponents = function getEditableComponents(container) {
+  if (container && Array.isArray(container.components)) {
+    return container.components.flatMap(function (c) {
+      if (c.type === _models.ComponentTypes.CONTAINER) {
+        return getEditableComponents(c);
+      }
+
+      return _Component.default.editable(c) ? c : null;
+    }).filter(function (c) {
+      return !!c;
+    });
+  }
+
+  return [];
+};
+
+var _default = getEditableComponents;
+exports.default = _default;

package/dist/utils/Container/getEditableComponents.test.js

@@ -0,0 +1,157 @@
+"use strict";
+
+var _models = require("../../models");
+
+var _isEditable = require("../Component/isEditable");
+
+var _getEditableComponents = _interopRequireDefault(require("./getEditableComponents"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+describe('utils.Container.getEditableComponents', function () {
+  var HTML = {
+    type: 'html',
+    tagName: 'p',
+    content: 'Alpha'
+  };
+  var INSET_TEXT = {
+    type: 'inset-text',
+    content: 'Bravo'
+  };
+  var HEADING = {
+    type: 'heading',
+    size: 'm',
+    content: 'Charlie'
+  };
+  it('should return an empty array for a null container', function () {
+    expect((0, _getEditableComponents.default)(null)).toEqual([]);
+  });
+  it('should return an empty array for a container with no components', function () {
+    expect((0, _getEditableComponents.default)({
+      components: []
+    })).toEqual([]);
+  });
+  it('should return an empty array for a container with only non-editable components', function () {
+    var COMPONENTS = [HTML, INSET_TEXT, HEADING];
+    expect((0, _getEditableComponents.default)({
+      components: COMPONENTS
+    })).toEqual([]);
+  });
+  it('should return an empty array for a container that contains a container with only non-editable components', function () {
+    var COMPONENTS = [HTML, INSET_TEXT, HEADING];
+    var INNER_CONTAINER = {
+      type: _models.ComponentTypes.CONTAINER,
+      components: COMPONENTS
+    };
+    expect((0, _getEditableComponents.default)({
+      components: [INNER_CONTAINER]
+    })).toEqual([]);
+  });
+
+  _isEditable.EDITABLE_TYPES.forEach(function (type) {
+    it("should return just the \"".concat(type, "\" component if it exists in the components, but no non-editable ones"), function () {
+      var EDITABLE = {
+        type: type
+      };
+      var COMPONENTS = [HTML, EDITABLE, INSET_TEXT, HEADING];
+      expect((0, _getEditableComponents.default)({
+        components: COMPONENTS
+      })).toEqual([EDITABLE]);
+    });
+    it("should return just the \"".concat(type, "\" component if it exists inside an inner container's components, but no non-editable ones"), function () {
+      var EDITABLE = {
+        type: type
+      };
+      var COMPONENTS = [HTML, EDITABLE, INSET_TEXT, HEADING];
+      var INNER_CONTAINER = {
+        type: _models.ComponentTypes.CONTAINER,
+        components: COMPONENTS
+      };
+      expect((0, _getEditableComponents.default)({
+        components: [INNER_CONTAINER]
+      })).toEqual([EDITABLE]);
+    });
+    it("should return just all \"".concat(type, "\" components that exists at any nested level within the container, but no non-editable ones"), function () {
+      var EDITABLE = {
+        type: type
+      };
+      var COMPONENTS = [HTML, EDITABLE, INSET_TEXT, HEADING];
+      var INNER_INNER_CONTAINER = {
+        type: _models.ComponentTypes.CONTAINER,
+        components: COMPONENTS
+      };
+      var INNER_CONTAINER = {
+        type: _models.ComponentTypes.CONTAINER,
+        components: [].concat(COMPONENTS, [INNER_INNER_CONTAINER])
+      };
+      expect((0, _getEditableComponents.default)({
+        components: [EDITABLE, INNER_CONTAINER]
+      })).toEqual([EDITABLE, EDITABLE, EDITABLE]);
+    });
+  });
+
+  it('should return all editable components and no non-editable ones', function () {
+    var COMPONENTS = [HTML, INSET_TEXT, HEADING];
+
+    _isEditable.EDITABLE_TYPES.forEach(function (type) {
+      COMPONENTS.push({
+        type: type
+      });
+    });
+
+    var RESULT = (0, _getEditableComponents.default)({
+      components: COMPONENTS
+    });
+    expect(RESULT.length).toEqual(_isEditable.EDITABLE_TYPES.length);
+
+    _isEditable.EDITABLE_TYPES.forEach(function (type) {
+      expect(RESULT).toContainEqual({
+        type: type
+      });
+    });
+  });
+  it('should return all editable components and no non-editable ones, regardless of nesting level', function () {
+    var EDITABLE_COMPONENTS = _isEditable.EDITABLE_TYPES.map(function (type) {
+      return {
+        type: type
+      };
+    });
+
+    var NON_EDITABLE_COMPONENTS = [HTML, INSET_TEXT, HEADING];
+    var COMPONENTS = [].concat(_toConsumableArray(EDITABLE_COMPONENTS), NON_EDITABLE_COMPONENTS, [{
+      type: _models.ComponentTypes.CONTAINER,
+      id: 'inner',
+      components: [].concat(_toConsumableArray(EDITABLE_COMPONENTS), NON_EDITABLE_COMPONENTS, [{
+        type: _models.ComponentTypes.CONTAINER,
+        id: 'inner-inner',
+        components: [].concat(NON_EDITABLE_COMPONENTS, _toConsumableArray(EDITABLE_COMPONENTS))
+      }])
+    }]);
+    var RESULT = (0, _getEditableComponents.default)({
+      components: COMPONENTS
+    });
+    expect(RESULT.length).toEqual(_isEditable.EDITABLE_TYPES.length * 3); // 1 each at top, inner, and inner-inner levels.
+
+    _isEditable.EDITABLE_TYPES.forEach(function (type) {
+      expect(RESULT).toContainEqual({
+        type: type
+      });
+    });
+
+    expect(RESULT).not.toContainEqual(HTML);
+    expect(RESULT).not.toContainEqual(INSET_TEXT);
+    expect(RESULT).not.toContainEqual(HEADING);
+  });
+});

package/dist/utils/Container/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _getEditableComponents = _interopRequireDefault(require("./getEditableComponents"));
+
+var _setupNesting = _interopRequireDefault(require("./setupNesting"));
+
+var _showContainer = _interopRequireDefault(require("./showContainer"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Container = {
+  editableComponents: _getEditableComponents.default,
+  setup: _setupNesting.default,
+  show: _showContainer.default
+};
+var _default = Container;
+exports.default = _default;

package/dist/utils/Container/setupNesting.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _models = require("../../models");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var nestComponents = function nestComponents(container) {
+  var containerPath = container.full_path || container.fieldId;
+  return container.components.map(function (component) {
+    var full_path = containerPath ? "".concat(containerPath, ".").concat(component.fieldId) : component.fieldId;
+
+    var ret = _objectSpread(_objectSpread({}, component), {}, {
+      full_path: full_path
+    });
+
+    if (component.type === _models.ComponentTypes.CONTAINER) {
+      return setupNesting(ret);
+    }
+
+    return ret;
+  });
+};
+
+var setupNesting = function setupNesting(container) {
+  if (container) {
+    var components = nestComponents(container);
+    return _objectSpread(_objectSpread({}, container), {}, {
+      components: components
+    });
+  }
+
+  return container;
+};
+
+var _default = setupNesting;
+exports.default = _default;