@ukhomeoffice/cop-react-form-renderer 5.0.0-alpha → 5.0.0

package/dist/utils/CollectionPage/mergeCollectionPages.js

@@ -4,28 +4,37 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _showFormPageCYA = _interopRequireDefault(require("../FormPage/showFormPageCYA"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable no-param-reassign */
+
 var createMasterPage = function createMasterPage(page) {
-  return _objectSpread(_objectSpread({}, page), {}, {
-    title: page.collection.name.charAt(0).toUpperCase() + page.collection.name.slice(1)
-  });
+  return {
+    id: page.id,
+    name: page.name,
+    collection: _objectSpread({
+      masterPage: true
+    }, page.collection),
+    formData: _objectSpread({}, page.formData),
+    collectionPages: [page]
+  };
 };
 var mergeIntoMasterPage = function mergeIntoMasterPage(page, masterPage) {
   masterPage.collection = _objectSpread(_objectSpread({}, masterPage.collection), page.collection);
-  masterPage.components = [].concat(masterPage.components, page.components);
-  masterPage.formData = _objectSpread({}, page.formData);
+  masterPage.formData = _objectSpread(_objectSpread({}, masterPage.formData), page.formData);
+  masterPage.collectionPages = [].concat(masterPage.collectionPages, [page]);
 };
 
 /**
  * Loop over an array of pages, merging any CollectionPages into a
  * single master page for that collection. A master page is created
  * for each unique collection.name that exists.
- * These master pages contain all the fields needed to represent an
- * entry in the collection. 
+ * These master pages contain all the pages that are needed to
+ * represent an item in that collection.
  * The master page for each collection is positioned at the index
  * of the first CollectionPage in that collection.
  * @param { array } pages Array of pages in the form.
@@ -35,19 +44,18 @@ var mergeCollectionPages = function mergeCollectionPages(pages) {
   var masterPages = {};
   return pages.map(function (page) {
     var _page$collection;
-    if ((_page$collection = page.collection) !== null && _page$collection !== void 0 && _page$collection.name && (0, _showFormPageCYA.default)(page, page.formData)) {
+    if (page !== null && page !== void 0 && (_page$collection = page.collection) !== null && _page$collection !== void 0 && _page$collection.name) {
       if (!masterPages[page.collection.name]) {
         // If no master page exists for this collection.name, then
         // we kick one off using this page as a template.
         masterPages[page.collection.name] = createMasterPage(page);
         return masterPages[page.collection.name];
-      } else {
-        // If a master page already exists for this collection.name
-        // then we just merge this page into it and remove this page
-        // from the array.
-        mergeIntoMasterPage(page, masterPages[page.collection.name]);
-        return null;
       }
+      // If a master page already exists for this collection.name
+      // then we just merge this page into it and remove this page
+      // from the array.
+      mergeIntoMasterPage(page, masterPages[page.collection.name]);
+      return null;
     }
     return page;
   }).filter(function (page) {

package/dist/utils/CollectionPage/mergeCollectionPages.test.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _mergeCollectionPages = _interopRequireDefault(require("./mergeCollectionPages"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Local imports
+
+describe('utils.CollectionPage.mergeCollectionPages', function () {
+  var TEXT_COMP = {
+    id: 'testText',
+    fieldId: 'testText',
+    type: 'text'
+  };
+  var DATE_COMP = {
+    id: 'testDate',
+    fieldId: 'testDate',
+    type: 'date'
+  };
+  it('should return the same array if no pages belong to collections', function () {
+    var PAGES = [{
+      id: 'page1'
+    }, {
+      id: 'page2'
+    }];
+    expect((0, _mergeCollectionPages.default)(PAGES)).toEqual(PAGES);
+  });
+  it('should merge pages from the same collection into a single page', function () {
+    var PAGES = [{
+      id: 'page1',
+      collection: {
+        name: 'collection'
+      },
+      components: [TEXT_COMP]
+    }, {
+      id: 'page2',
+      collection: {
+        name: 'collection'
+      },
+      components: [DATE_COMP]
+    }];
+    var RESULT = (0, _mergeCollectionPages.default)(PAGES);
+    expect(RESULT.length).toEqual(1);
+    expect(RESULT[0]).toMatchObject({
+      id: 'page1',
+      collection: {
+        name: 'collection',
+        masterPage: true
+      },
+      formData: {},
+      collectionPages: PAGES
+    });
+  });
+  it('should leave non-collection pages unaffected', function () {
+    var PAGES = [{
+      id: 'page1',
+      collection: {
+        name: 'collection'
+      },
+      components: [TEXT_COMP]
+    }, {
+      id: 'page2',
+      collection: {
+        name: 'collection'
+      },
+      components: [DATE_COMP]
+    }, {
+      id: 'page3'
+    }];
+    var RESULT = (0, _mergeCollectionPages.default)(PAGES);
+    expect(RESULT.length).toEqual(2);
+    expect(RESULT[0]).toEqual({
+      id: 'page1',
+      collection: {
+        name: 'collection',
+        masterPage: true
+      },
+      formData: {},
+      collectionPages: [PAGES[0], PAGES[1]]
+    });
+    expect(RESULT[1]).toEqual({
+      id: 'page3'
+    });
+  });
+  it('should handle multiple collections', function () {
+    var PAGES = [{
+      id: 'page1',
+      collection: {
+        name: 'collection1'
+      },
+      components: []
+    }, {
+      id: 'page2',
+      collection: {
+        name: 'collection1'
+      },
+      components: []
+    }, {
+      id: 'page3',
+      collection: {
+        name: 'collection2'
+      },
+      components: []
+    }, {
+      id: 'page4',
+      collection: {
+        name: 'collection2'
+      },
+      components: []
+    }];
+    var RESULT = (0, _mergeCollectionPages.default)(PAGES);
+    expect(RESULT.length).toEqual(2);
+    expect(RESULT[0]).toEqual({
+      id: 'page1',
+      collection: {
+        name: 'collection1',
+        masterPage: true
+      },
+      formData: {},
+      collectionPages: [PAGES[0], PAGES[1]]
+    });
+    expect(RESULT[1]).toEqual({
+      id: 'page3',
+      collection: {
+        name: 'collection2',
+        masterPage: true
+      },
+      formData: {},
+      collectionPages: [PAGES[2], PAGES[3]]
+    });
+  });
+});

package/dist/utils/Component/addShowWhen.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * Adds a show_when to a component.
+ * If the component has no show_when, then an array is created
+ * with condition as the only entry.
+ * If the component has existing show_whens then condition is
+ * appended to the existing array.
+ * @param {*} component The component to add the show_when to.
+ * @param {*} condition The show_when condition to add.
+ * @returns The component with the new show_when added.
+ *          null if component or condition are invalid.
+ */
+var addShowWhen = function addShowWhen(component, condition) {
+  if (!component) {
+    return null;
+  }
+  if (!condition) {
+    return component;
+  }
+  var result = _objectSpread({}, component);
+  if (result.show_when) {
+    if (Array.isArray(condition)) {
+      result.show_when = Array.isArray(result.show_when) ? [].concat(condition, result.show_when) : [].concat(condition, [result.show_when]);
+    } else {
+      result.show_when = Array.isArray(result.show_when) ? [].concat(result.show_when, [condition]) : [result.show_when, condition];
+    }
+  } else {
+    result.show_when = condition;
+  }
+  return result;
+};
+var _default = addShowWhen;
+exports.default = _default;

package/dist/utils/Component/addShowWhen.test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+var _addShowWhen = _interopRequireDefault(require("./addShowWhen"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Local imports
+
+describe('utils.Component.addShowWhen', function () {
+  var NEW_SHOW_WHEN = {
+    field: 'field',
+    op: '=',
+    value: 'value'
+  };
+  it('should return null when component is undefined', function () {
+    var result = (0, _addShowWhen.default)(undefined, {});
+    expect(result).toEqual(null);
+  });
+  it('should return null when component is null', function () {
+    var result = (0, _addShowWhen.default)(null, {});
+    expect(result).toEqual(null);
+  });
+  it('should return component when condition is undefined', function () {
+    var COMPONENT = {
+      alpha: 'bravo'
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, undefined);
+    expect(result).toEqual({
+      alpha: 'bravo'
+    });
+  });
+  it('should return component when condition is null', function () {
+    var COMPONENT = {
+      alpha: 'bravo'
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, null);
+    expect(result).toEqual({
+      alpha: 'bravo'
+    });
+  });
+  it('should add the show_when to a component with no existing show_whens', function () {
+    var COMPONENT = {
+      alpha: 'bravo'
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, NEW_SHOW_WHEN);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: NEW_SHOW_WHEN
+    });
+  });
+  it('should add the array type show_when to a component with no existing show_whens', function () {
+    var NEW_ARRAY_SHOW_WHEN = [{
+      field: 'abc',
+      op: '=',
+      value: 'bcd'
+    }, {
+      field: 'cde',
+      op: '=',
+      value: 'efg'
+    }];
+    var COMPONENT = {
+      alpha: 'bravo'
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, NEW_ARRAY_SHOW_WHEN);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: NEW_ARRAY_SHOW_WHEN
+    });
+  });
+  it('should add the show_when to a component with a single show_when', function () {
+    var COMPONENT = {
+      alpha: 'bravo',
+      show_when: {
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, NEW_SHOW_WHEN);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: [{
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }, NEW_SHOW_WHEN]
+    });
+  });
+  it('should add the show_when to a component with an array of show_whens', function () {
+    var COMPONENT = {
+      alpha: 'bravo',
+      show_when: [{
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }, {
+        field: 'cde',
+        op: '=',
+        value: 'efg'
+      }]
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, NEW_SHOW_WHEN);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: [{
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }, {
+        field: 'cde',
+        op: '=',
+        value: 'efg'
+      }, NEW_SHOW_WHEN]
+    });
+  });
+  it('should add the or type show_when to a component with no existing show_whens in an object not an array', function () {
+    var COMPONENT = {
+      alpha: 'bravo'
+    };
+    var SHOW_WHEN_OR = {
+      type: 'or',
+      condition: [{
+        field: 'field1',
+        op: '=',
+        values: 1
+      }, {
+        field: 'field2',
+        op: '=',
+        value: 2
+      }]
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, SHOW_WHEN_OR);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: SHOW_WHEN_OR
+    });
+  });
+  it('should add an array of show_whens to a component with an array of show_whens', function () {
+    var NEW_ARRAY_SHOW_WHEN = [{
+      field: 'hij',
+      op: '=',
+      value: 'klm'
+    }, {
+      field: 'nop',
+      op: '=',
+      value: 'qrs'
+    }];
+    var COMPONENT = {
+      alpha: 'bravo',
+      show_when: [{
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }, {
+        field: 'cde',
+        op: '=',
+        value: 'efg'
+      }]
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, NEW_ARRAY_SHOW_WHEN);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: [{
+        field: 'hij',
+        op: '=',
+        value: 'klm'
+      }, {
+        field: 'nop',
+        op: '=',
+        value: 'qrs'
+      }, {
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }, {
+        field: 'cde',
+        op: '=',
+        value: 'efg'
+      }]
+    });
+  });
+  it('should add an array of show_whens to a component with a single show_when', function () {
+    var NEW_ARRAY_SHOW_WHEN = [{
+      field: 'hij',
+      op: '=',
+      value: 'klm'
+    }, {
+      field: 'nop',
+      op: '=',
+      value: 'qrs'
+    }];
+    var COMPONENT = {
+      alpha: 'bravo',
+      show_when: {
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }
+    };
+    var result = (0, _addShowWhen.default)(COMPONENT, NEW_ARRAY_SHOW_WHEN);
+    expect(result).toEqual({
+      alpha: 'bravo',
+      show_when: [{
+        field: 'hij',
+        op: '=',
+        value: 'klm'
+      }, {
+        field: 'nop',
+        op: '=',
+        value: 'qrs'
+      }, {
+        field: 'abc',
+        op: '=',
+        value: 'bcd'
+      }]
+    });
+  });
+});

package/dist/utils/Component/applyToComponentTree.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _models = require("../../models");
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * Call a callback on a component and all of its child/nested components.
+ * At each stage, the value of the component is set to the returned value
+ * from the callback.
+ * 
+ * @param {*} root The root component to call the callback on.
+ * @param {*} callback The callback to call. It should take a single
+ *                     component as an argument and return the new
+ *                     desired value for that component.
+ * @returns The result of calling callback on root.
+ *          null if root is not valid.
+ *          root if callback is not valid. 
+ */
+var applyToComponentTree = function applyToComponentTree(root, callback) {
+  var _root$data;
+  if (!root) {
+    return null;
+  }
+  if (!callback) {
+    return root;
+  }
+  var result = _objectSpread({}, root);
+  switch (root.type) {
+    case _models.ComponentTypes.CONTAINER:
+      result.components.forEach(function (c, index, containerArray) {
+        var array = containerArray;
+        array[index] = applyToComponentTree(c, callback);
+      });
+      break;
+    case _models.ComponentTypes.COLLECTION:
+      result.item.forEach(function (c, index, collectionArray) {
+        var array = collectionArray;
+        array[index] = applyToComponentTree(c, callback);
+      });
+      break;
+    case _models.ComponentTypes.CHECKBOXES:
+    case _models.ComponentTypes.RADIOS:
+      if (!((_root$data = root.data) !== null && _root$data !== void 0 && _root$data.options)) {
+        break;
+      }
+      result.data = _objectSpread({}, root.data);
+      result.data.options = root.data.options.map(function (option) {
+        var newOption = _objectSpread({}, option);
+        if (option.nested) {
+          newOption.nested = option.nested.map(function (c) {
+            return applyToComponentTree(c, callback);
+          });
+        }
+        return newOption;
+      });
+      break;
+    default:
+      break;
+  }
+  return callback(result);
+};
+var _default = applyToComponentTree;
+exports.default = _default;

package/dist/utils/Component/applyToComponentTree.test.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _applyToComponentTree = _interopRequireDefault(require("./applyToComponentTree"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+describe('utils.Component.applyToComponentTree', function () {
+  var SINGLE_COMP = {
+    type: 'text',
+    label: 'alpha'
+  };
+  var CONTAINER = {
+    type: 'container',
+    label: 'bravo',
+    components: [{
+      type: 'text',
+      label: 'charlie'
+    }]
+  };
+  var COLLECTION = {
+    type: 'collection',
+    label: 'delta',
+    item: [{
+      type: 'text',
+      label: 'echo'
+    }]
+  };
+  var COMP_WITH_NESTED = {
+    type: 'radios',
+    label: 'foxtrot',
+    data: {
+      options: [{
+        nested: [{
+          type: 'text',
+          label: 'golf'
+        }]
+      }, {
+        nested: [{
+          type: 'text',
+          label: 'hotel'
+        }]
+      }]
+    }
+  };
+  var CALLBACK = function CALLBACK(component) {
+    return _objectSpread(_objectSpread({}, component), {}, {
+      label: component.label.toUpperCase()
+    });
+  };
+  it('should return null when root is undefined', function () {
+    var result = (0, _applyToComponentTree.default)(undefined, CALLBACK);
+    expect(result).toEqual(null);
+  });
+  it('should return null when root is null', function () {
+    var result = (0, _applyToComponentTree.default)(null, CALLBACK);
+    expect(result).toEqual(null);
+  });
+  it('should return root when callback is undefined', function () {
+    var result = (0, _applyToComponentTree.default)({
+      type: 'text'
+    }, undefined);
+    expect(result).toEqual({
+      type: 'text'
+    });
+  });
+  it('should return root when callback is null', function () {
+    var result = (0, _applyToComponentTree.default)({
+      type: 'text'
+    }, null);
+    expect(result).toEqual({
+      type: 'text'
+    });
+  });
+  it('should correctly call callback on a single component', function () {
+    var result = (0, _applyToComponentTree.default)(SINGLE_COMP, CALLBACK);
+    expect(result).toEqual({
+      type: 'text',
+      label: 'ALPHA'
+    });
+  });
+  it('should correctly call callback on a container component', function () {
+    var result = (0, _applyToComponentTree.default)(CONTAINER, CALLBACK);
+    expect(result).toEqual({
+      type: 'container',
+      label: 'BRAVO',
+      components: [{
+        type: 'text',
+        label: 'CHARLIE'
+      }]
+    });
+  });
+  it('should correctly call callback on a collection component', function () {
+    var result = (0, _applyToComponentTree.default)(COLLECTION, CALLBACK);
+    expect(result).toEqual({
+      type: 'collection',
+      label: 'DELTA',
+      item: [{
+        type: 'text',
+        label: 'ECHO'
+      }]
+    });
+  });
+  it('should correctly call callback on a component with nested components', function () {
+    var result = (0, _applyToComponentTree.default)(COMP_WITH_NESTED, CALLBACK);
+    expect(result).toEqual({
+      type: 'radios',
+      label: 'FOXTROT',
+      data: {
+        options: [{
+          nested: [{
+            type: 'text',
+            label: 'GOLF'
+          }]
+        }, {
+          nested: [{
+            type: 'text',
+            label: 'HOTEL'
+          }]
+        }]
+      }
+    });
+  });
+});