pastebin - collaborative debugging tool
kpaste.net RSS


formio
Posted by Anonymous on Fri 14th Feb 2020 20:35
raw | new post

  1. function customOperation(operation,param){
  2.   switch(operation){
  3.     ////
  4.     case 'sortSelectDropDown':
  5.     var component;
  6.     if(param.type == "getItems"){ //initial dropdown load mode
  7.       component = param.component
  8.     }
  9.     else if(param.type == "_searchChoices"){ //dropdown data filter mode
  10.       component = param.componentDomElement.component;
  11.     }
  12.     if(component){
  13.       var currentItems = param.items;
  14.         if(component.properties.sort !== undefined && component.properties.sort !== null){ //user-chosen sort type ?
  15.           if(component.properties.sort != "none"){ //custom sort exists?
  16.             if(component.properties.sort == "asc"){ //ascending sort?
  17.               currentItems = currentItems.sort(function(a,b){
  18.                 if(typeof(a) == 'string'){
  19.                   return(a >= b? 1: -1);
  20.                 }
  21.                 else if(typeof(a) == 'object'){
  22.                   return(a.label >= b.label? 1: -1);
  23.                 }
  24.               });
  25.             }
  26.             else if(component.properties.sort == "desc"){ //descending sort?
  27.               currentItems = currentItems.sort(function(a,b){
  28.                 if(typeof(a) == 'string'){
  29.                   return(a <= b? 1: -1);
  30.                 }
  31.                 else if(typeof(a) == 'object'){
  32.                   return(a.label <= b.label? 1: -1);
  33.                 }
  34.               });
  35.             }
  36.           }
  37.         }
  38.         else
  39.         { //default asc sort
  40.           currentItems = currentItems.sort(function(a,b){
  41.             if(typeof(a) == 'string'){
  42.               return(a >= b? 1: -1);
  43.             }
  44.             else if(typeof(a) == 'object'){
  45.               return(a.label >= b.label? 1: -1);
  46.             }
  47.           });
  48.         }
  49.     }
  50.     //adapt the result sorted list to the formio workflow for 'sorting select dropdowns' by making the items list in the form of [{items: Object}]
  51.     if(param.type == "_searchChoices"){ //dropdown data filter mode
  52.       currentItems = currentItems.map(function(el){
  53.         return {item: el}
  54.       });
  55.     }
  56.     return currentItems;
  57.     break;
  58.     ////
  59.     case 'filterSelectDropDown':
  60.     var currentItems = param.items;
  61.     currentItems = currentItems.filter(function(el){
  62.       return (el.label.toUpperCase().indexOf(param.needle.toUpperCase()) !== -1);
  63.     });
  64.     return currentItems;
  65.     break;
  66.   }
  67. }
  68. ////////////
  69. (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
  70. 'use strict';
  71.  
  72. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  73.  
  74. Object.defineProperty(exports, "__esModule", {
  75.   value: true
  76. });
  77. exports.FormioComponents = undefined;
  78.  
  79. var _createClass = function () {
  80.   function defineProperties(target, props) {
  81.     for (var i = 0; i < props.length; i++) {
  82.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  83.     }
  84.   }return function (Constructor, protoProps, staticProps) {
  85.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  86.   };
  87. }();
  88.  
  89. var _get = function get(object, property, receiver) {
  90.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  91.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  92.       return undefined;
  93.     } else {
  94.       return get(parent, property, receiver);
  95.     }
  96.   } else if ("value" in desc) {
  97.     return desc.value;
  98.   } else {
  99.     var getter = desc.get;if (getter === undefined) {
  100.       return undefined;
  101.     }return getter.call(receiver);
  102.   }
  103. };
  104.  
  105. var _lodash = require('lodash');
  106.  
  107. var _lodash2 = _interopRequireDefault(_lodash);
  108.  
  109. var _nativePromiseOnly = require('native-promise-only');
  110.  
  111. var _nativePromiseOnly2 = _interopRequireDefault(_nativePromiseOnly);
  112.  
  113. var _index = require('../utils/index');
  114.  
  115. var _index2 = _interopRequireDefault(_index);
  116.  
  117. var _Base = require('./base/Base');
  118.  
  119. function _interopRequireDefault(obj) {
  120.   return obj && obj.__esModule ? obj : { default: obj };
  121. }
  122.  
  123. function _classCallCheck(instance, Constructor) {
  124.   if (!(instance instanceof Constructor)) {
  125.     throw new TypeError("Cannot call a class as a function");
  126.   }
  127. }
  128.  
  129. function _possibleConstructorReturn(self, call) {
  130.   if (!self) {
  131.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  132.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  133. }
  134.  
  135. function _inherits(subClass, superClass) {
  136.   if (typeof superClass !== "function" && superClass !== null) {
  137.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  138.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  139. }
  140.  
  141. var FormioComponents = exports.FormioComponents = function (_BaseComponent) {
  142.   _inherits(FormioComponents, _BaseComponent);
  143.  
  144.   function FormioComponents(component, options, data) {
  145.     _classCallCheck(this, FormioComponents);
  146.  
  147.     var _this = _possibleConstructorReturn(this, (FormioComponents.__proto__ || Object.getPrototypeOf(FormioComponents)).call(this, component, options, data));
  148.  
  149.     _this.type = 'components';
  150.     _this.components = [];
  151.     _this.hidden = [];
  152.     return _this;
  153.   }
  154.  
  155.   _createClass(FormioComponents, [{
  156.     key: 'build',
  157.     value: function build() {
  158.       this.createElement();
  159.       this.addComponents();
  160.     }
  161.   }, {
  162.     key: 'getComponents',
  163.     value: function getComponents() {
  164.       return this.components;
  165.     }
  166.  
  167.     /**
  168.      * Perform a deep iteration over every component, including those
  169.      * within other container based components.
  170.      *
  171.      * @param {function} fn - Called for every component.
  172.      */
  173.  
  174.   }, {
  175.     key: 'everyComponent',
  176.     value: function everyComponent(fn) {
  177.       var components = this.getComponents();
  178.       _lodash2.default.each(components, function (component, index) {
  179.         if (component.type === 'components') {
  180.           if (component.everyComponent(fn) === false) {
  181.             return false;
  182.           }
  183.         } else if (fn(component, components, index) === false) {
  184.           return false;
  185.         }
  186.       });
  187.     }
  188.  
  189.     /**
  190.      * Perform an iteration over each component within this container component.
  191.      *
  192.      * @param {function} fn - Called for each component
  193.      */
  194.  
  195.   }, {
  196.     key: 'eachComponent',
  197.     value: function eachComponent(fn) {
  198.       _lodash2.default.each(this.getComponents(), function (component, index) {
  199.         if (fn(component, index) === false) {
  200.           return false;
  201.         }
  202.       });
  203.     }
  204.  
  205.     /**
  206.      * Returns a component provided a key. This performs a deep search within the
  207.      * component tree.
  208.      *
  209.      * @param {string} key - The key of the component to retrieve.
  210.      * @param {function} fn - Called with the component once found.
  211.      * @return {Object} - The component that is located.
  212.      */
  213.  
  214.   }, {
  215.     key: 'getComponent',
  216.     value: function getComponent(key, fn) {
  217.       var comp = null;
  218.       this.everyComponent(function (component, components) {
  219.         if (component.component.key === key) {
  220.           comp = component;
  221.           if (fn) {
  222.             fn(component, components);
  223.           }
  224.           return false;
  225.         }
  226.       });
  227.       return comp;
  228.     }
  229.  
  230.     /**
  231.      * Return a component provided the Id of the component.
  232.      *
  233.      * @param {string} id - The Id of the component.
  234.      * @param {function} fn - Called with the component once it is retrieved.
  235.      * @return {Object} - The component retrieved.
  236.      */
  237.  
  238.   }, {
  239.     key: 'getComponentById',
  240.     value: function getComponentById(id, fn) {
  241.       var comp = null;
  242.       this.everyComponent(function (component, components) {
  243.         if (component.id === id) {
  244.           comp = component;
  245.           if (fn) {
  246.             fn(component, components);
  247.           }
  248.           return false;
  249.         }
  250.       });
  251.       return comp;
  252.     }
  253.  
  254.     /**
  255.      * Create a new component and add it to the components array.
  256.      *
  257.      * @param component
  258.      * @param data
  259.      */
  260.  
  261.   }, {
  262.     key: 'createComponent',
  263.     value: function createComponent(component, options, data) {
  264.       if (!this.options.components) {
  265.         this.options.components = require('./index');
  266.         _lodash2.default.assign(this.options.components, FormioComponents.customComponents);
  267.       }
  268.       var comp = this.options.components.create(component, options, data, true);
  269.       comp.parent = this;
  270.       comp.root = this.root || this;
  271.       comp.build();
  272.       comp.isBuilt = true;
  273.       this.components.push(comp);
  274.       return comp;
  275.     }
  276.  
  277.     /**
  278.      * Add a new component to the components array.
  279.      *
  280.      * @param {Object} component - The component JSON schema to add.
  281.      * @param {HTMLElement} element - The DOM element to append this child to.
  282.      * @param {Object} data - The submission data object to house the data for this component.
  283.      * @return {BaseComponent} - The created component instance.
  284.      */
  285.  
  286.   }, {
  287.     key: 'addComponent',
  288.     value: function addComponent(component, element, data) {
  289.       element = element || this.element;
  290.       data = data || this.data;
  291.       component.row = this.row;
  292.       var comp = this.createComponent(component, this.options, data);
  293.       this.setHidden(comp);
  294.       element.appendChild(comp.getElement());
  295.       return comp;
  296.     }
  297.  
  298.     /**
  299.      * Remove a component from the components array.
  300.      *
  301.      * @param {BaseComponent} component - The component to remove from the components.
  302.      * @param {Array<BaseComponent>} components - An array of components to remove this component from.
  303.      */
  304.  
  305.   }, {
  306.     key: 'removeComponent',
  307.     value: function removeComponent(component, components) {
  308.       component.destroy();
  309.       var element = component.getElement();
  310.       if (element && element.parentNode) {
  311.         this.removeChildFrom(element, element.parentNode);
  312.       }
  313.       _lodash2.default.remove(components, { id: component.id });
  314.     }
  315.  
  316.     /**
  317.      * Removes a component provided the API key of that component.
  318.      *
  319.      * @param {string} key - The API key of the component to remove.
  320.      * @param {function} fn - Called once the component is removed.
  321.      * @return {null}
  322.      */
  323.  
  324.   }, {
  325.     key: 'removeComponentByKey',
  326.     value: function removeComponentByKey(key, fn) {
  327.       var _this2 = this;
  328.  
  329.       var comp = this.getComponent(key, function (component, components) {
  330.         _this2.removeComponent(component, components);
  331.         if (fn) {
  332.           fn(component, components);
  333.         }
  334.       });
  335.       if (!comp) {
  336.         if (fn) {
  337.           fn(null);
  338.         }
  339.         return null;
  340.       }
  341.     }
  342.  
  343.     /**
  344.      * Removes a component provided the Id of the component.
  345.      *
  346.      * @param {string} id - The Id of the component to remove.
  347.      * @param {function} fn - Called when the component is removed.
  348.      * @return {null}
  349.      */
  350.  
  351.   }, {
  352.     key: 'removeComponentById',
  353.     value: function removeComponentById(id, fn) {
  354.       var _this3 = this;
  355.  
  356.       var comp = this.getComponentById(id, function (component, components) {
  357.         _this3.removeComponent(component, components);
  358.         if (fn) {
  359.           fn(component, components);
  360.         }
  361.       });
  362.       if (!comp) {
  363.         if (fn) {
  364.           fn(null);
  365.         }
  366.         return null;
  367.       }
  368.     }
  369.  
  370.     /**
  371.      *
  372.      * @param element
  373.      * @param data
  374.      */
  375.  
  376.   }, {
  377.     key: 'addComponents',
  378.     value: function addComponents(element, data) {
  379.       var _this4 = this;
  380.  
  381.       element = element || this.element;
  382.       data = data || this.data;
  383.       _lodash2.default.each(this.component.components, function (component) {
  384.         return _this4.addComponent(component, element, data);
  385.       });
  386.     }
  387.   }, {
  388.     key: 'updateValue',
  389.     value: function updateValue(flags) {
  390.       var changed = false;
  391.       _lodash2.default.each(this.components, function (comp) {
  392.         changed |= comp.updateValue(flags);
  393.       });
  394.       return changed;
  395.     }
  396.   }, {
  397.     key: 'hasChanged',
  398.     value: function hasChanged() {
  399.       return false;
  400.     }
  401.  
  402.     /**
  403.      * A more performant way to check the conditions, calculations, and validity of
  404.      * a submission once it has been changed.
  405.      *
  406.      * @param data
  407.      * @param flags
  408.      */
  409.  
  410.   }, {
  411.     key: 'checkData',
  412.     value: function checkData(data, flags) {
  413.       flags = flags || {};
  414.       var valid = true;
  415.       if (flags.noCheck) {
  416.         return;
  417.       }
  418.  
  419.       // Update the value.
  420.       var changed = this.updateValue({
  421.         noUpdateEvent: true
  422.       });
  423.  
  424.       // Iterate through all components and check conditions, and calculate values.
  425.       _lodash2.default.each(this.getComponents(), function (comp) {
  426.         changed |= comp.calculateValue(data, {
  427.           noUpdateEvent: true
  428.         });
  429.         comp.checkConditions(data);
  430.         if (!flags.noValidate) {
  431.           valid &= comp.checkValidity(data);
  432.         }
  433.       });
  434.  
  435.       // Trigger the change if the values changed.
  436.       if (changed) {
  437.         this.triggerChange(flags);
  438.       }
  439.  
  440.       // Return if the value is valid.
  441.       return valid;
  442.     }
  443.   }, {
  444.     key: 'checkConditions',
  445.     value: function checkConditions(data) {
  446.       this.getComponents().forEach(function (comp) {
  447.         return comp.checkConditions(data);
  448.       });
  449.       return _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'checkConditions', this).call(this, data);
  450.     }
  451.   }, {
  452.     key: 'clearOnHide',
  453.     value: function clearOnHide(show) {
  454.       _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'clearOnHide', this).call(this, show);
  455.       this.getComponents().forEach(function (component) {
  456.         return component.clearOnHide(show);
  457.       });
  458.     }
  459.  
  460.     /**
  461.      * Allow components to hook into the next page trigger to perform their own logic.
  462.      *
  463.      * @return {*}
  464.      */
  465.  
  466.   }, {
  467.     key: 'beforeNext',
  468.     value: function beforeNext() {
  469.       var ops = [];
  470.       _lodash2.default.each(this.getComponents(), function (comp) {
  471.         return ops.push(comp.beforeNext());
  472.       });
  473.       return _nativePromiseOnly2.default.all(ops);
  474.     }
  475.  
  476.     /**
  477.      * Allow components to hook into the submission to provide their own async data.
  478.      *
  479.      * @return {*}
  480.      */
  481.  
  482.   }, {
  483.     key: 'beforeSubmit',
  484.     value: function beforeSubmit() {
  485.       var ops = [];
  486.       _lodash2.default.each(this.getComponents(), function (comp) {
  487.         return ops.push(comp.beforeSubmit());
  488.       });
  489.       return _nativePromiseOnly2.default.all(ops);
  490.     }
  491.   }, {
  492.     key: 'onResize',
  493.     value: function onResize(scale) {
  494.       _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'onResize', this).call(this, scale);
  495.       _lodash2.default.each(this.getComponents(), function (comp) {
  496.         return comp.onResize(scale);
  497.       });
  498.     }
  499.   }, {
  500.     key: 'calculateValue',
  501.     value: function calculateValue(data, flags) {
  502.       var changed = _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'calculateValue', this).call(this, data, flags);
  503.       _lodash2.default.each(this.getComponents(), function (comp) {
  504.         changed |= comp.calculateValue(data, flags);
  505.       });
  506.       return changed;
  507.     }
  508.   }, {
  509.     key: 'isValid',
  510.     value: function isValid(data, dirty) {
  511.       var valid = _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'isValid', this).call(this, data, dirty);
  512.       _lodash2.default.each(this.getComponents(), function (comp) {
  513.         valid &= comp.isValid(data, dirty);
  514.       });
  515.       return valid;
  516.     }
  517.   }, {
  518.     key: 'checkValidity',
  519.     value: function checkValidity(data, dirty) {
  520.       if (!_index2.default.checkCondition(this.component, data, this.data)) {
  521.         return true;
  522.       }
  523.  
  524.       var check = _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'checkValidity', this).call(this, data, dirty);
  525.       _lodash2.default.each(this.getComponents(), function (comp) {
  526.         check &= comp.checkValidity(data, dirty);
  527.       });
  528.       return check;
  529.     }
  530.   }, {
  531.     key: 'setPristine',
  532.     value: function setPristine(pristine) {
  533.       _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'setPristine', this).call(this, pristine);
  534.       _lodash2.default.each(this.getComponents(), function (comp) {
  535.         return comp.setPristine(pristine);
  536.       });
  537.     }
  538.   }, {
  539.     key: 'destroy',
  540.     value: function destroy(all) {
  541.       var _this5 = this;
  542.  
  543.       _get(FormioComponents.prototype.__proto__ || Object.getPrototypeOf(FormioComponents.prototype), 'destroy', this).call(this, all);
  544.       this.empty(this.getElement());
  545.       var components = _lodash2.default.clone(this.components);
  546.       _lodash2.default.each(components, function (comp) {
  547.         return _this5.removeComponent(comp, _this5.components);
  548.       });
  549.       this.components = [];
  550.       this.hidden = [];
  551.     }
  552.   }, {
  553.     key: 'setHidden',
  554.     value: function setHidden(component) {
  555.       if (component.components && component.components.length) {
  556.         component.hideComponents(this.hidden);
  557.       } else if (component.component.hidden) {
  558.         component.visible = false;
  559.       } else {
  560.         component.visible = !this.hidden || !(this.hidden.indexOf(component.component.key) !== -1);
  561.       }
  562.     }
  563.   }, {
  564.     key: 'hideComponents',
  565.     value: function hideComponents(hidden) {
  566.       var _this6 = this;
  567.  
  568.       this.hidden = hidden;
  569.       this.eachComponent(function (component) {
  570.         return _this6.setHidden(component);
  571.       });
  572.     }
  573.   }, {
  574.     key: 'getValue',
  575.     value: function getValue() {
  576.       return this.data;
  577.     }
  578.   }, {
  579.     key: 'whenReady',
  580.     value: function whenReady() {
  581.       var promises = [];
  582.       _lodash2.default.each(this.getComponents(), function (component) {
  583.         promises.push(component.whenReady());
  584.       });
  585.       return _nativePromiseOnly2.default.all(promises);
  586.     }
  587.   }, {
  588.     key: 'setValue',
  589.     value: function setValue(value, flags) {
  590.       if (!value) {
  591.         return false;
  592.       }
  593.       flags = this.getFlags.apply(this, arguments);
  594.       var changed = false;
  595.       this.getComponents().forEach(function (component) {
  596.         if (component.type === 'button') {
  597.           return;
  598.         }
  599.  
  600.         if (component.type === 'components') {
  601.           changed |= component.setValue(value, flags);
  602.         } else if (value && value.hasOwnProperty(component.component.key)) {
  603.           changed |= component.setValue(_lodash2.default.get(value, component.component.key), flags);
  604.         } else {
  605.           flags.noValidate = true;
  606.           changed |= component.setValue(component.defaultValue, flags);
  607.         }
  608.       });
  609.       return changed;
  610.     }
  611.   }, {
  612.     key: 'disabled',
  613.     set: function set(disabled) {
  614.       _lodash2.default.each(this.components, function (component) {
  615.         return component.disabled = disabled;
  616.       });
  617.     }
  618.   }, {
  619.     key: 'errors',
  620.     get: function get() {
  621.       var errors = [];
  622.       _lodash2.default.each(this.getComponents(), function (comp) {
  623.         var compErrors = comp.errors;
  624.         if (compErrors.length) {
  625.           errors = errors.concat(compErrors);
  626.         }
  627.       });
  628.       return errors;
  629.     }
  630.   }, {
  631.     key: 'value',
  632.     get: function get() {
  633.       return this.data;
  634.     }
  635.   }]);
  636.  
  637.   return FormioComponents;
  638. }(_Base.BaseComponent);
  639.  
  640. FormioComponents.customComponents = {};
  641.  
  642. },{"../utils/index":56,"./base/Base":4,"./index":23,"lodash":79,"native-promise-only":81}],2:[function(require,module,exports){
  643. 'use strict';
  644.  
  645. Object.defineProperty(exports, "__esModule", {
  646.   value: true
  647. });
  648. exports.Validator = undefined;
  649.  
  650. var _lodash = require('lodash');
  651.  
  652. var _lodash2 = _interopRequireDefault(_lodash);
  653.  
  654. var _utils = require('../utils');
  655.  
  656. var _utils2 = _interopRequireDefault(_utils);
  657.  
  658. function _interopRequireDefault(obj) {
  659.   return obj && obj.__esModule ? obj : { default: obj };
  660. }
  661.  
  662. var Validator = exports.Validator = {
  663.   get: _lodash2.default.get,
  664.   each: _lodash2.default.each,
  665.   has: _lodash2.default.has,
  666.   checkValidator: function checkValidator(component, validator, setting, value, data) {
  667.     var result = validator.check.call(this, component, setting, value, data);
  668.     if (typeof result === 'string') {
  669.       return result;
  670.     }
  671.     if (!result) {
  672.       return validator.message.call(this, component, setting);
  673.     }
  674.     return '';
  675.   },
  676.   validate: function validate(component, validator, value, data) {
  677.     if (validator.key && _lodash2.default.has(component.component, validator.key)) {
  678.       var setting = this.get(component.component, validator.key);
  679.       return this.checkValidator(component, validator, setting, value, data);
  680.     }
  681.     return this.checkValidator(component, validator, null, value, data);
  682.   },
  683.   check: function check(component, data) {
  684.     var _this = this;
  685.  
  686.     var result = '';
  687.     var value = component.validationValue;
  688.     data = data || component.data;
  689.     _lodash2.default.each(component.validators, function (name) {
  690.       if (_this.validators.hasOwnProperty(name)) {
  691.         var validator = _this.validators[name];
  692.         if (component.validateMultiple(value)) {
  693.           _lodash2.default.each(value, function (val) {
  694.             result = _this.validate(component, validator, val, data);
  695.             if (result) {
  696.               return false;
  697.             }
  698.           });
  699.         } else {
  700.           result = _this.validate(component, validator, value, data);
  701.         }
  702.         if (result) {
  703.           return false;
  704.         }
  705.       }
  706.     });
  707.  
  708.     var validateCustom = _lodash2.default.get(component, 'component.validate.custom');
  709.     var customErrorMessage = _lodash2.default.get(component, 'component.validate.customMessage');
  710.  
  711.     if (result && (customErrorMessage || validateCustom)) {
  712.  
  713.       result = component.t(customErrorMessage || result, {
  714.  
  715.         data: component.data
  716.  
  717.       });
  718.     }
  719.  
  720.     return result;
  721.   },
  722.  
  723.   validators: {
  724.     required: {
  725.       key: 'validate.required',
  726.       message: function message(component) {
  727.         return component.t(component.errorMessage('required'), {
  728.           field: component.errorLabel,
  729.           data: component.data
  730.         });
  731.       },
  732.       check: function check(component, setting, value) {
  733.         if (!_utils2.default.boolValue(setting)) {
  734.           return true;
  735.         }
  736.         return !component.isEmpty(value);
  737.       }
  738.     },
  739.     min: {
  740.       key: 'validate.min',
  741.       message: function message(component, setting) {
  742.         return component.t(component.errorMessage('min'), {
  743.           field: component.errorLabel,
  744.           min: parseFloat(setting),
  745.           data: component.data
  746.         });
  747.       },
  748.       check: function check(component, setting, value) {
  749.         var min = parseFloat(setting);
  750.         if (!min || !_lodash2.default.isNumber(value)) {
  751.           return true;
  752.         }
  753.         return parseFloat(value) >= min;
  754.       }
  755.     },
  756.     max: {
  757.       key: 'validate.max',
  758.       message: function message(component, setting) {
  759.         return component.t(component.errorMessage('max'), {
  760.           field: component.errorLabel,
  761.           max: parseFloat(setting),
  762.           data: component.data
  763.         });
  764.       },
  765.       check: function check(component, setting, value) {
  766.         var max = parseFloat(setting);
  767.         if (!max || !_lodash2.default.isNumber(value)) {
  768.           return true;
  769.         }
  770.         return parseFloat(value) <= max;
  771.       }
  772.     },
  773.     minLength: {
  774.       key: 'validate.minLength',
  775.       message: function message(component, setting) {
  776.         return component.t(component.errorMessage('minLength'), {
  777.           field: component.errorLabel,
  778.           length: setting - 1,
  779.           data: component.data
  780.         });
  781.       },
  782.       check: function check(component, setting, value) {
  783.         var minLength = parseInt(setting, 10);
  784.         if (!minLength || typeof value !== 'string') {
  785.           return true;
  786.         }
  787.         return value.length >= minLength;
  788.       }
  789.     },
  790.     maxLength: {
  791.       key: 'validate.maxLength',
  792.       message: function message(component, setting) {
  793.         return component.t(component.errorMessage('maxLength'), {
  794.           field: component.errorLabel,
  795.           length: setting + 1,
  796.           data: component.data
  797.         });
  798.       },
  799.       check: function check(component, setting, value) {
  800.         var maxLength = parseInt(setting, 10);
  801.         if (!maxLength || typeof value !== 'string') {
  802.           return true;
  803.         }
  804.         return value.length <= maxLength;
  805.       }
  806.     },
  807.     email: {
  808.       message: function message(component) {
  809.         return component.t(component.errorMessage('invalid_email'), {
  810.           field: component.errorLabel,
  811.           data: component.data
  812.         });
  813.       },
  814.       check: function check(component, setting, value) {
  815.         // From http://stackoverflow.com/questions/46155/validate-email-address-in-javascript
  816.         var re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
  817.  
  818.         // Allow emails to be valid if the component is pristine and no value is provided.
  819.         return !value || re.test(value);
  820.       }
  821.     },
  822.     date: {
  823.       message: function message(component) {
  824.         return component.t(component.errorMessage('invalid_date'), {
  825.           field: component.errorLabel,
  826.           data: component.data
  827.         });
  828.       },
  829.       check: function check(component, setting, value) {
  830.         return value !== 'Invalid date';
  831.       }
  832.     },
  833.     pattern: {
  834.       key: 'validate.pattern',
  835.       message: function message(component, setting) {
  836.         return component.t(_lodash2.default.get(component, 'component.validate.patternMessage', component.errorMessage('pattern'), {
  837.           field: component.errorLabel,
  838.           pattern: setting,
  839.           data: component.data
  840.         }));
  841.       },
  842.       check: function check(component, setting, value) {
  843.         var pattern = setting;
  844.         if (!pattern) {
  845.           return true;
  846.         }
  847.         var regexStr = '^' + pattern + '$';
  848.         var regex = new RegExp(regexStr);
  849.         return regex.test(value);
  850.       }
  851.     },
  852.     json: {
  853.       key: 'validate.json',
  854.       check: function check(component, setting, value, data) {
  855.         if (!setting) {
  856.           return true;
  857.         }
  858.         var valid = true;
  859.         try {
  860.           valid = _utils2.default.jsonLogic.apply(setting, {
  861.             data: data,
  862.             row: component.data,
  863.             _: _lodash2.default
  864.           });
  865.         } catch (err) {
  866.           valid = err.message;
  867.         }
  868.         return valid;
  869.       }
  870.     },
  871.     mask: {
  872.       message: function message(component) {
  873.         return component.t(component.errorMessage('mask'), {
  874.           field: component.errorLabel,
  875.           data: component.data
  876.         });
  877.       },
  878.       check: function check(component, setting, value) {
  879.         if (value && component._inputMask) {
  880.           return _utils2.default.matchInputMask(value, component._inputMask);
  881.         }
  882.  
  883.         return true;
  884.       }
  885.     },
  886.     custom: {
  887.       key: 'validate.custom',
  888.       message: function message(component) {
  889.         return component.t(component.errorMessage('custom'), {
  890.           field: component.errorLabel,
  891.           data: component.data
  892.         });
  893.       },
  894.       check: function check(component, setting, value, data) {
  895.         if (!setting) {
  896.           return true;
  897.         }
  898.         var custom = setting;
  899.  
  900.         custom = custom.replace(/({{\s+(.*)\s+}})/, function (match, $1, $2) {
  901.           if ($2.indexOf('data.') === 0) {
  902.             return _lodash2.default.get(data, $2.replace('data.', ''));
  903.           } else if ($2.indexOf('row.') === 0) {
  904.             return _lodash2.default.get(component.data, $2.replace('row.', ''));
  905.           }
  906.  
  907.           // Support legacy...
  908.           return _lodash2.default.get(data, $2);
  909.         });
  910.  
  911.         /* jshint evil: true */
  912.         return new Function('row', 'data', 'component', 'input', 'var valid = true; ' + custom + '; return valid;')(component.data, data, component, value);
  913.       }
  914.     }
  915.   }
  916. };
  917.  
  918. },{"../utils":56,"lodash":79}],3:[function(require,module,exports){
  919. 'use strict';
  920.  
  921. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  922.  
  923. Object.defineProperty(exports, "__esModule", {
  924.   value: true
  925. });
  926. exports.AddressComponent = undefined;
  927.  
  928. var _createClass = function () {
  929.   function defineProperties(target, props) {
  930.     for (var i = 0; i < props.length; i++) {
  931.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  932.     }
  933.   }return function (Constructor, protoProps, staticProps) {
  934.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  935.   };
  936. }();
  937.  
  938. var _get = function get(object, property, receiver) {
  939.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  940.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  941.       return undefined;
  942.     } else {
  943.       return get(parent, property, receiver);
  944.     }
  945.   } else if ("value" in desc) {
  946.     return desc.value;
  947.   } else {
  948.     var getter = desc.get;if (getter === undefined) {
  949.       return undefined;
  950.     }return getter.call(receiver);
  951.   }
  952. };
  953.  
  954. var _lodash = require('lodash');
  955.  
  956. var _lodash2 = _interopRequireDefault(_lodash);
  957.  
  958. var _TextField = require('../textfield/TextField');
  959.  
  960. var _Base = require('../base/Base');
  961.  
  962. function _interopRequireDefault(obj) {
  963.   return obj && obj.__esModule ? obj : { default: obj };
  964. }
  965.  
  966. function _classCallCheck(instance, Constructor) {
  967.   if (!(instance instanceof Constructor)) {
  968.     throw new TypeError("Cannot call a class as a function");
  969.   }
  970. }
  971.  
  972. function _possibleConstructorReturn(self, call) {
  973.   if (!self) {
  974.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  975.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  976. }
  977.  
  978. function _inherits(subClass, superClass) {
  979.   if (typeof superClass !== "function" && superClass !== null) {
  980.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  981.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  982. } /* globals google */
  983.  
  984. var AddressComponent = exports.AddressComponent = function (_TextFieldComponent) {
  985.   _inherits(AddressComponent, _TextFieldComponent);
  986.  
  987.   function AddressComponent(component, options, data) {
  988.     _classCallCheck(this, AddressComponent);
  989.  
  990.     var _this = _possibleConstructorReturn(this, (AddressComponent.__proto__ || Object.getPrototypeOf(AddressComponent)).call(this, component, options, data));
  991.  
  992.     var src = 'https://maps.googleapis.com/maps/api/js?v=3&libraries=places&callback=googleMapsCallback';
  993.     if (component.map && component.map.key) {
  994.       src += '&key=' + component.map.key;
  995.     }
  996.     if (component.map && component.map.region) {
  997.       src += '&region=' + component.map.region;
  998.     }
  999.     _Base.BaseComponent.requireLibrary('googleMaps', 'google.maps.places', src);
  1000.  
  1001.     // Keep track of the full addresses.
  1002.     _this.addresses = [];
  1003.     return _this;
  1004.   }
  1005.  
  1006.   _createClass(AddressComponent, [{
  1007.     key: 'setValueAt',
  1008.     value: function setValueAt(index, value) {
  1009.       if (value === null || value === undefined) {
  1010.         value = this.defaultValue;
  1011.       }
  1012.       this.addresses[index] = value;
  1013.       if (value && value.formatted_address) {
  1014.         this.inputs[index].value = value.formatted_address;
  1015.       }
  1016.     }
  1017.   }, {
  1018.     key: 'getValueAt',
  1019.     value: function getValueAt(index) {
  1020.       return this.addresses[index];
  1021.     }
  1022.  
  1023.     /**
  1024.      * Start the autocomplete and the input listeners
  1025.      *
  1026.      * @param input
  1027.      *   The input field
  1028.      * @param autoCompleteOptions
  1029.      *   The default option for the autocompletion
  1030.      */
  1031.  
  1032.   }, {
  1033.     key: 'autoCompleteInit',
  1034.     value: function autoCompleteInit(input, autoCompleteOptions) {
  1035.       var _this2 = this;
  1036.  
  1037.       // Set attribute autoComplete to off
  1038.       input.setAttribute('autocomplete', 'off');
  1039.  
  1040.       // Init suggestions list
  1041.       this.autoCompleteSuggestions = [];
  1042.  
  1043.       // Start Google AutocompleteService
  1044.       var autoComplete = new google.maps.places.AutocompleteService();
  1045.  
  1046.       // Create suggestions container
  1047.       var suggestionContainer = document.createElement('div');
  1048.       suggestionContainer.classList.add('pac-container', 'pac-logo');
  1049.       input.parentNode.appendChild(suggestionContainer);
  1050.  
  1051.       // Add listener on input field for input event
  1052.       this.addEventListener(input, 'input', function () {
  1053.         if (input.value) {
  1054.           var options = {
  1055.             input: input.value
  1056.           };
  1057.           autoComplete.getPlacePredictions(_lodash2.default.defaultsDeep(options, autoCompleteOptions), function (suggestions, status) {
  1058.             _this2.autoCompleteDisplaySuggestions(suggestions, status, suggestionContainer, input);
  1059.           });
  1060.         } else {
  1061.           _this2.autoCompleteCleanSuggestions(suggestionContainer);
  1062.           suggestionContainer.style.display = 'none';
  1063.         }
  1064.       });
  1065.       // Add listener on input field for blur event
  1066.       this.addEventListener(input, 'blur', function () {
  1067.         // Delay to allow click on suggestion list
  1068.         _lodash2.default.delay(function () {
  1069.           suggestionContainer.style.display = 'none';
  1070.         }, 100);
  1071.       });
  1072.       // Add listener on input field for focus event
  1073.       this.addEventListener(input, 'focus', function () {
  1074.         if (suggestionContainer.childElementCount) {
  1075.           suggestionContainer.style.display = 'block';
  1076.         }
  1077.       });
  1078.       // Add listener on input field for focus event
  1079.       this.addEventListener(window, 'resize', function () {
  1080.         // Set the same width as input field
  1081.         suggestionContainer.style.width = input.offsetWidth + 'px';
  1082.       });
  1083.       // Add listiner on input field for key event
  1084.       this.autoCompleteKeyboardListener(suggestionContainer, input);
  1085.     }
  1086.  
  1087.     /**
  1088.      * Add listiner on input field for key event
  1089.      *
  1090.      * @param suggestionContainer
  1091.      *   Suggestions container
  1092.      * @param input
  1093.      *   Input field to listen
  1094.      */
  1095.  
  1096.   }, {
  1097.     key: 'autoCompleteKeyboardListener',
  1098.     value: function autoCompleteKeyboardListener(suggestionContainer, input) {
  1099.       var _this3 = this;
  1100.  
  1101.       this.autoCompleteKeyCodeListener = function (event) {
  1102.         if (input.value) {
  1103.           switch (event.keyCode) {
  1104.             case 38:
  1105.               // UP
  1106.               _this3.autoCompleteKeyUpInteraction(suggestionContainer, input);
  1107.               break;
  1108.  
  1109.             case 40:
  1110.               // DOWN
  1111.               _this3.autoCompleteKeyDownInteraction(suggestionContainer, input);
  1112.               break;
  1113.  
  1114.             case 9:
  1115.               // TAB
  1116.               _this3.autoCompleteKeyValidationInteraction(suggestionContainer, input);
  1117.               break;
  1118.  
  1119.             case 13:
  1120.               // ENTER
  1121.               _this3.autoCompleteKeyValidationInteraction(suggestionContainer, input);
  1122.               break;
  1123.           }
  1124.         }
  1125.       };
  1126.  
  1127.       this.addEventListener(input, 'keydown', this.autoCompleteKeyCodeListener);
  1128.     }
  1129.  
  1130.     /**
  1131.      * Action when key up is trigger
  1132.      *
  1133.      * @param suggestionContainer
  1134.      *   Suggestions container
  1135.      * @param input
  1136.      *   Input field to listen
  1137.      */
  1138.  
  1139.   }, {
  1140.     key: 'autoCompleteKeyUpInteraction',
  1141.     value: function autoCompleteKeyUpInteraction(suggestionContainer, input) {
  1142.       var elementSelected = document.querySelector('.pac-item-selected');
  1143.       if (!elementSelected) {
  1144.         // Returns the bottom of the list.
  1145.         return this.autoCompleteListDecorator(suggestionContainer.lastChild, input);
  1146.       } else {
  1147.         // Transverse the list in reverse order.
  1148.         var previousSibling = elementSelected.previousSibling;
  1149.         if (previousSibling) {
  1150.           this.autoCompleteListDecorator(previousSibling, input);
  1151.         } else {
  1152.           // Return to input value
  1153.           elementSelected.classList.remove('pac-item-selected');
  1154.           input.value = this.autoCompleteInputValue;
  1155.         }
  1156.       }
  1157.     }
  1158.  
  1159.     /**
  1160.      * Action when key down is trigger
  1161.      *
  1162.      * @param suggestionContainer
  1163.      *   Suggestions container
  1164.      * @param input
  1165.      *   Input field to listen
  1166.      */
  1167.  
  1168.   }, {
  1169.     key: 'autoCompleteKeyDownInteraction',
  1170.     value: function autoCompleteKeyDownInteraction(suggestionContainer, input) {
  1171.       var elementSelected = document.querySelector('.pac-item-selected');
  1172.       if (!elementSelected) {
  1173.         // Start at the top of the list.
  1174.         if (suggestionContainer.firstChild) {
  1175.           return this.autoCompleteListDecorator(suggestionContainer.firstChild, input);
  1176.         }
  1177.       } else {
  1178.         // Transverse the list from top down.
  1179.         var nextSibling = elementSelected.nextSibling;
  1180.         if (nextSibling) {
  1181.           this.autoCompleteListDecorator(nextSibling, input);
  1182.         } else {
  1183.           // Return to input value
  1184.           elementSelected.classList.remove('pac-item-selected');
  1185.           input.value = this.autoCompleteInputValue;
  1186.         }
  1187.       }
  1188.     }
  1189.  
  1190.     /**
  1191.      * Action when validation is trigger
  1192.      *
  1193.      * @param suggestionContainer
  1194.      *   Suggestions container
  1195.      * @param input
  1196.      *   Input field to listen
  1197.      */
  1198.  
  1199.   }, {
  1200.     key: 'autoCompleteKeyValidationInteraction',
  1201.     value: function autoCompleteKeyValidationInteraction(suggestionContainer, input) {
  1202.       var elementSelected = document.querySelector('.pac-item-selected');
  1203.       if (elementSelected) {
  1204.         var _iteratorNormalCompletion = true;
  1205.         var _didIteratorError = false;
  1206.         var _iteratorError = undefined;
  1207.  
  1208.         try {
  1209.           for (var _iterator = this.autoCompleteSuggestions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
  1210.             var suggestion = _step.value;
  1211.  
  1212.             var content = elementSelected.textContent || elementSelected.innerText;
  1213.             if (content === suggestion.description) {
  1214.               this.autoCompleteServiceListener(suggestion, suggestionContainer, input);
  1215.             }
  1216.           }
  1217.         } catch (err) {
  1218.           _didIteratorError = true;
  1219.           _iteratorError = err;
  1220.         } finally {
  1221.           try {
  1222.             if (!_iteratorNormalCompletion && _iterator.return) {
  1223.               _iterator.return();
  1224.             }
  1225.           } finally {
  1226.             if (_didIteratorError) {
  1227.               throw _iteratorError;
  1228.             }
  1229.           }
  1230.         }
  1231.  
  1232.         elementSelected.classList.remove('pac-item-selected');
  1233.       }
  1234.     }
  1235.  
  1236.     /**
  1237.      * Highlight suggestion selected
  1238.      *
  1239.      * @param item
  1240.      *   Item selected in suggestions container
  1241.      * @param input
  1242.      *   Input field to listen
  1243.      */
  1244.  
  1245.   }, {
  1246.     key: 'autoCompleteListDecorator',
  1247.     value: function autoCompleteListDecorator(item, input) {
  1248.       var elementSelected = document.querySelector('.pac-item-selected');
  1249.       if (elementSelected) {
  1250.         elementSelected.classList.remove('pac-item-selected');
  1251.       }
  1252.       input.value = item.textContent;
  1253.       item.classList.add('pac-item-selected');
  1254.     }
  1255.  
  1256.     /**
  1257.      * Filter method to return if the suggestion should be displayed
  1258.      *
  1259.      * @param data
  1260.      *   Data to check
  1261.      * @returns {Boolean}
  1262.      */
  1263.  
  1264.   }, {
  1265.     key: 'autoCompleteFilterSuggestion',
  1266.     value: function autoCompleteFilterSuggestion(data) {
  1267.       try {
  1268.         var result = new Function('data', 'var show = true; ' + this.component.map.autoCompleteFilter.toString() + '; return show;')(data);
  1269.         return result.toString() === 'true';
  1270.       } catch (e) {
  1271.         console.warn('An error occurred in a custom autoComplete filter statement for component ' + this.component.key, e);
  1272.         return true;
  1273.       }
  1274.     }
  1275.  
  1276.     /**
  1277.      * Clean suggestions list
  1278.      *
  1279.      * @param suggestionContainer
  1280.      *   Container tag
  1281.      */
  1282.  
  1283.   }, {
  1284.     key: 'autoCompleteCleanSuggestions',
  1285.     value: function autoCompleteCleanSuggestions(suggestionContainer) {
  1286.       // Clean click listener
  1287.       var _iteratorNormalCompletion2 = true;
  1288.       var _didIteratorError2 = false;
  1289.       var _iteratorError2 = undefined;
  1290.  
  1291.       try {
  1292.         for (var _iterator2 = this.autoCompleteSuggestions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
  1293.           var suggestion = _step2.value;
  1294.  
  1295.           suggestion.item.removeEventListener('click', suggestion.clickListener);
  1296.         }
  1297.       } catch (err) {
  1298.         _didIteratorError2 = true;
  1299.         _iteratorError2 = err;
  1300.       } finally {
  1301.         try {
  1302.           if (!_iteratorNormalCompletion2 && _iterator2.return) {
  1303.             _iterator2.return();
  1304.           }
  1305.         } finally {
  1306.           if (_didIteratorError2) {
  1307.             throw _iteratorError2;
  1308.           }
  1309.         }
  1310.       }
  1311.  
  1312.       this.autoCompleteSuggestions = [];
  1313.  
  1314.       // Delete current suggestion list
  1315.       while (suggestionContainer.firstChild) {
  1316.         suggestionContainer.removeChild(suggestionContainer.firstChild);
  1317.       }
  1318.     }
  1319.  
  1320.     /**
  1321.      * Display suggestions when API returns value
  1322.      *
  1323.      * @param suggestions
  1324.      *   Suggestions returned
  1325.      * @param status
  1326.      *   State returned
  1327.      * @param suggestionContainer
  1328.      *   Suggestions container
  1329.      * @param input
  1330.      *   Input field to listen
  1331.      */
  1332.  
  1333.   }, {
  1334.     key: 'autoCompleteDisplaySuggestions',
  1335.     value: function autoCompleteDisplaySuggestions(suggestions, status, suggestionContainer, input) {
  1336.       // Set the same width as input field
  1337.       suggestionContainer.style.width = input.offsetWidth + 'px';
  1338.  
  1339.       // Set the default input value
  1340.       this.autoCompleteInputValue = input.value;
  1341.  
  1342.       this.autoCompleteCleanSuggestions(suggestionContainer);
  1343.       if (status !== google.maps.places.PlacesServiceStatus.OK) {
  1344.         suggestionContainer.style.display = 'none';
  1345.         return;
  1346.       }
  1347.  
  1348.       var _iteratorNormalCompletion3 = true;
  1349.       var _didIteratorError3 = false;
  1350.       var _iteratorError3 = undefined;
  1351.  
  1352.       try {
  1353.         for (var _iterator3 = suggestions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
  1354.           var suggestion = _step3.value;
  1355.  
  1356.           if (this.autoCompleteFilterSuggestion(suggestion)) {
  1357.             this.autoCompleteSuggestions.push(suggestion);
  1358.             this.autoCompleteSuggestionBuilder(suggestion, suggestionContainer, input);
  1359.           }
  1360.         }
  1361.       } catch (err) {
  1362.         _didIteratorError3 = true;
  1363.         _iteratorError3 = err;
  1364.       } finally {
  1365.         try {
  1366.           if (!_iteratorNormalCompletion3 && _iterator3.return) {
  1367.             _iterator3.return();
  1368.           }
  1369.         } finally {
  1370.           if (_didIteratorError3) {
  1371.             throw _iteratorError3;
  1372.           }
  1373.         }
  1374.       }
  1375.  
  1376.       if (!suggestionContainer.childElementCount) {
  1377.         this.autoCompleteCleanSuggestions(suggestionContainer);
  1378.         suggestionContainer.style.display = 'none';
  1379.       } else {
  1380.         suggestionContainer.style.display = 'block';
  1381.       }
  1382.     }
  1383.  
  1384.     /**
  1385.      * Draw a suggestion in the list
  1386.      *
  1387.      * @param suggestion
  1388.      *   Suggestion to draw
  1389.      * @param suggestionContainer
  1390.      *   Suggestions container
  1391.      * @param input
  1392.      *   Input field to listen
  1393.      */
  1394.  
  1395.   }, {
  1396.     key: 'autoCompleteSuggestionBuilder',
  1397.     value: function autoCompleteSuggestionBuilder(suggestion, suggestionContainer, input) {
  1398.       var _this4 = this;
  1399.  
  1400.       var item = document.createElement('div');
  1401.       item.classList.add('pac-item');
  1402.  
  1403.       var itemLogo = document.createElement('span');
  1404.       itemLogo.classList.add('pac-icon', 'pac-icon-marker');
  1405.       item.appendChild(itemLogo);
  1406.  
  1407.       // Draw Main part
  1408.       var itemMain = document.createElement('span');
  1409.       itemMain.classList.add('pac-item-query');
  1410.       if (suggestion.structured_formatting.main_text_matched_substrings) {
  1411.         var matches = suggestion.structured_formatting.main_text_matched_substrings;
  1412.         for (var k in matches) {
  1413.           var part = matches[k];
  1414.           if (k === 0 && part.offset > 0) {
  1415.             itemMain.appendChild(document.createTextNode(suggestion.structured_formatting.main_text.substring(0, part.offset)));
  1416.           }
  1417.  
  1418.           var itemBold = document.createElement('span');
  1419.           itemBold.classList.add('pac-matched');
  1420.           itemBold.appendChild(document.createTextNode(suggestion.structured_formatting.main_text.substring(part.offset, part.offset + part.length)));
  1421.           itemMain.appendChild(itemBold);
  1422.  
  1423.           if (k === matches.length - 1) {
  1424.             var content = suggestion.structured_formatting.main_text.substring(part.offset + part.length);
  1425.             if (content.length > 0) {
  1426.               itemMain.appendChild(document.createTextNode(content));
  1427.             }
  1428.           }
  1429.         }
  1430.       } else {
  1431.         itemMain.appendChild(document.createTextNode(suggestion.structured_formatting.main_text));
  1432.       }
  1433.       item.appendChild(itemMain);
  1434.  
  1435.       // Draw secondary part
  1436.       if (suggestion.structured_formatting.secondary_text) {
  1437.         var itemSecondary = document.createElement('span');
  1438.         if (suggestion.structured_formatting.secondary_text_matched_substrings) {
  1439.           var _matches = suggestion.structured_formatting.secondary_text_matched_substrings;
  1440.           for (var _k in _matches) {
  1441.             var _part = _matches[_k];
  1442.             if (_k === 0 && _part.offset > 0) {
  1443.               itemSecondary.appendChild(document.createTextNode(suggestion.structured_formatting.secondary_text.substring(0, _part.offset)));
  1444.             }
  1445.  
  1446.             var _itemBold = document.createElement('span');
  1447.             _itemBold.classList.add('pac-matched');
  1448.             _itemBold.appendChild(document.createTextNode(suggestion.structured_formatting.secondary_text.substring(_part.offset, _part.offset + _part.length)));
  1449.             itemSecondary.appendChild(_itemBold);
  1450.  
  1451.             if (_k === _matches.length - 1) {
  1452.               var _content = suggestion.structured_formatting.secondary_text.substring(_part.offset + _part.length);
  1453.               if (_content.length > 0) {
  1454.                 itemSecondary.appendChild(document.createTextNode(_content));
  1455.               }
  1456.             }
  1457.           }
  1458.         } else {
  1459.           itemSecondary.appendChild(document.createTextNode(suggestion.structured_formatting.secondary_text));
  1460.         }
  1461.         item.appendChild(itemSecondary);
  1462.       }
  1463.  
  1464.       suggestionContainer.appendChild(item);
  1465.  
  1466.       var clickListener = function clickListener() {
  1467.         input.value = suggestion.description;
  1468.         _this4.autoCompleteInputValue = suggestion.description;
  1469.         _this4.autoCompleteServiceListener(suggestion, suggestionContainer, input);
  1470.       };
  1471.       suggestion.clickListener = clickListener;
  1472.       suggestion.item = item;
  1473.       if ('addEventListener' in item) {
  1474.         item.addEventListener('click', clickListener, false);
  1475.       } else if ('attachEvent' in item) {
  1476.         item.attachEvent('onclick', clickListener);
  1477.       }
  1478.     }
  1479.  
  1480.     /**
  1481.      * Get detailed information and set it as value
  1482.      *
  1483.      * @param suggestion
  1484.      *   Suggestion to draw
  1485.      * @param suggestionContainer
  1486.      *   Suggestions container
  1487.      * @param input
  1488.      *   Input field to listen
  1489.      */
  1490.  
  1491.   }, {
  1492.     key: 'autoCompleteServiceListener',
  1493.     value: function autoCompleteServiceListener(suggestion, suggestionContainer, input) {
  1494.       var _this5 = this;
  1495.  
  1496.       var service = new google.maps.places.PlacesService(input);
  1497.       service.getDetails({
  1498.         placeId: suggestion.place_id
  1499.       }, function (place, status) {
  1500.         if (status === google.maps.places.PlacesServiceStatus.OK) {
  1501.           _this5.setValue(place);
  1502.         }
  1503.       });
  1504.     }
  1505.   }, {
  1506.     key: 'addInput',
  1507.     value: function addInput(input, container) {
  1508.       var _this6 = this;
  1509.  
  1510.       _get(AddressComponent.prototype.__proto__ || Object.getPrototypeOf(AddressComponent.prototype), 'addInput', this).call(this, input, container);
  1511.       _Base.BaseComponent.libraryReady('googleMaps').then(function () {
  1512.         var autoCompleteOptions = {};
  1513.         if (_this6.component.map) {
  1514.           autoCompleteOptions = _this6.component.map.autoCompleteOptions || {};
  1515.           if (autoCompleteOptions.location) {
  1516.             var _autoCompleteOptions$ = autoCompleteOptions.location,
  1517.                 lat = _autoCompleteOptions$.lat,
  1518.                 lng = _autoCompleteOptions$.lng;
  1519.  
  1520.             autoCompleteOptions.location = new google.maps.LatLng(lat, lng);
  1521.           }
  1522.         }
  1523.  
  1524.         if (_this6.component.map && _this6.component.map.autoCompleteFilter) {
  1525.           // Call custom autoComplete to filter suggestions
  1526.           _this6.autoCompleteInit(input, autoCompleteOptions);
  1527.         } else {
  1528.           var autocomplete = new google.maps.places.Autocomplete(input);
  1529.           autocomplete.addListener('place_changed', function () {
  1530.             return _this6.setValue(autocomplete.getPlace());
  1531.           });
  1532.         }
  1533.       });
  1534.     }
  1535.   }, {
  1536.     key: 'elementInfo',
  1537.     value: function elementInfo() {
  1538.       var info = _get(AddressComponent.prototype.__proto__ || Object.getPrototypeOf(AddressComponent.prototype), 'elementInfo', this).call(this);
  1539.       info.attr.class += ' address-search';
  1540.       return info;
  1541.     }
  1542.   }, {
  1543.     key: 'getView',
  1544.     value: function getView(value) {
  1545.       return _lodash2.default.get(value, 'formatted_address', '');
  1546.     }
  1547.   }]);
  1548.  
  1549.   return AddressComponent;
  1550. }(_TextField.TextFieldComponent);
  1551.  
  1552. },{"../base/Base":4,"../textfield/TextField":36,"lodash":79}],4:[function(require,module,exports){
  1553. 'use strict';
  1554.  
  1555. Object.defineProperty(exports, "__esModule", {
  1556.   value: true
  1557. });
  1558. exports.BaseComponent = undefined;
  1559.  
  1560. var _createClass = function () {
  1561.   function defineProperties(target, props) {
  1562.     for (var i = 0; i < props.length; i++) {
  1563.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  1564.     }
  1565.   }return function (Constructor, protoProps, staticProps) {
  1566.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  1567.   };
  1568. }();
  1569.  
  1570. var _vanillaTextMask = require('vanilla-text-mask');
  1571.  
  1572. var _vanillaTextMask2 = _interopRequireDefault(_vanillaTextMask);
  1573.  
  1574. var _nativePromiseOnly = require('native-promise-only');
  1575.  
  1576. var _nativePromiseOnly2 = _interopRequireDefault(_nativePromiseOnly);
  1577.  
  1578. var _lodash = require('lodash');
  1579.  
  1580. var _lodash2 = _interopRequireDefault(_lodash);
  1581.  
  1582. var _tooltip = require('tooltip.js');
  1583.  
  1584. var _tooltip2 = _interopRequireDefault(_tooltip);
  1585.  
  1586. var _i18next = require('i18next');
  1587.  
  1588. var _i18next2 = _interopRequireDefault(_i18next);
  1589.  
  1590. var _utils = require('../../utils');
  1591.  
  1592. var _utils2 = _interopRequireDefault(_utils);
  1593.  
  1594. var _Validator = require('../Validator');
  1595.  
  1596. function _interopRequireDefault(obj) {
  1597.   return obj && obj.__esModule ? obj : { default: obj };
  1598. }
  1599.  
  1600. function _classCallCheck(instance, Constructor) {
  1601.   if (!(instance instanceof Constructor)) {
  1602.     throw new TypeError("Cannot call a class as a function");
  1603.   }
  1604. }
  1605.  
  1606. /**
  1607.  * This is the BaseComponent class which all elements within the FormioForm derive from.
  1608.  */
  1609. var BaseComponent = function () {
  1610.   /**
  1611.    * Initialize a new BaseComponent.
  1612.    *
  1613.    * @param {Object} component - The component JSON you wish to initialize.
  1614.    * @param {Object} options - The options for this component.
  1615.    * @param {Object} data - The global data submission object this component will belong.
  1616.    */
  1617.   function BaseComponent(component, options, data) {
  1618.     _classCallCheck(this, BaseComponent);
  1619.  
  1620.     this.originalComponent = _lodash2.default.cloneDeep(component);
  1621.     /**
  1622.      * The ID of this component. This value is auto-generated when the component is created, but
  1623.      * can also be provided from the component.id value passed into the constructor.
  1624.      * @type {string}
  1625.      */
  1626.     this.id = component && component.id ? component.id : Math.random().toString(36).substring(7);
  1627.  
  1628.     /**
  1629.      * The options for this component.
  1630.      * @type {{}}
  1631.      */
  1632.     this.options = _lodash2.default.defaults(_lodash2.default.clone(options), {
  1633.       language: 'en',
  1634.       highlightErrors: true
  1635.     });
  1636.  
  1637.     // Use the i18next that is passed in, otherwise use the global version.
  1638.     this.i18next = this.options.i18next || _i18next2.default;
  1639.  
  1640.     /**
  1641.      * Determines if this component has a condition assigned to it.
  1642.      * @type {null}
  1643.      * @private
  1644.      */
  1645.     this._hasCondition = null;
  1646.  
  1647.     /**
  1648.      * The events that are triggered for the whole FormioForm object.
  1649.      */
  1650.     this.events = this.options.events;
  1651.  
  1652.     /**
  1653.      * The data object in which this component resides.
  1654.      * @type {*}
  1655.      */
  1656.     this.data = data || {};
  1657.  
  1658.     /**
  1659.      * The Form.io component JSON schema.
  1660.      * @type {*}
  1661.      */
  1662.     this.component = component || {};
  1663.  
  1664.     /**
  1665.      * The bounding HTML Element which this component is rendered.
  1666.      * @type {null}
  1667.      */
  1668.     this.element = null;
  1669.  
  1670.     /**
  1671.      * The HTML Element for the table body. This is relevant for the "multiple" flag on inputs.
  1672.      * @type {null}
  1673.      */
  1674.     this.tbody = null;
  1675.  
  1676.     /**
  1677.      * The HTMLElement that is assigned to the label of this component.
  1678.      * @type {null}
  1679.      */
  1680.     this.labelElement = null;
  1681.  
  1682.     /**
  1683.      * The HTMLElement for which the errors are rendered for this component (usually underneath the component).
  1684.      * @type {null}
  1685.      */
  1686.     this.errorElement = null;
  1687.  
  1688.     /**
  1689.      * The existing error that this component has.
  1690.      * @type {string}
  1691.      */
  1692.     this.error = '';
  1693.  
  1694.     /**
  1695.      * An array of all of the input HTML Elements that have been added to this component.
  1696.      * @type {Array}
  1697.      */
  1698.     this.inputs = [];
  1699.  
  1700.     /**
  1701.      * The basic component information which tells the BaseComponent how to render the input element of the components that derive from this class.
  1702.      * @type {null}
  1703.      */
  1704.     this.info = null;
  1705.  
  1706.     /**
  1707.      * The row path of this component.
  1708.      * @type {number}
  1709.      */
  1710.     this.row = component ? component.row : '';
  1711.     this.row = this.row || '';
  1712.  
  1713.     /**
  1714.      * Determines if this component is disabled, or not.
  1715.      *
  1716.      * @type {boolean}
  1717.      */
  1718.     this._disabled = false;
  1719.  
  1720.     /**
  1721.      * Determines if this component is visible, or not.
  1722.      */
  1723.     this._visible = true;
  1724.  
  1725.     /**
  1726.      * If this input has been input and provided value.
  1727.      *
  1728.      * @type {boolean}
  1729.      */
  1730.     this.pristine = true;
  1731.  
  1732.     /**
  1733.      * Points to the parent component.
  1734.      *
  1735.      * @type {BaseComponent}
  1736.      */
  1737.     this.parent = null;
  1738.  
  1739.     /**
  1740.      * Points to the root component, usually the FormComponent.
  1741.      *
  1742.      * @type {BaseComponent}
  1743.      */
  1744.     this.root = this;
  1745.  
  1746.     this.options.name = this.options.name || 'data';
  1747.  
  1748.     /**
  1749.      * The validators that are assigned to this component.
  1750.      * @type {[string]}
  1751.      */
  1752.     this.validators = ['required', 'minLength', 'maxLength', 'custom', 'pattern', 'json', 'mask'];
  1753.  
  1754.     /**
  1755.      * Used to trigger a new change in this component.
  1756.      * @type {function} - Call to trigger a change in this component.
  1757.      */
  1758.     this.triggerChange = _lodash2.default.debounce(this.onChange.bind(this), 100);
  1759.  
  1760.     /**
  1761.      * An array of event handlers so that the destry command can deregister them.
  1762.      * @type {Array}
  1763.      */
  1764.     this.eventHandlers = [];
  1765.  
  1766.     // To force this component to be invalid.
  1767.     this.invalid = false;
  1768.  
  1769.     // Determine if the component has been built.
  1770.     this.isBuilt = false;
  1771.  
  1772.     /**
  1773.      * An array of the event listeners so that the destroy command can deregister them.
  1774.      * @type {Array}
  1775.      */
  1776.     this.eventListeners = [];
  1777.  
  1778.     if (this.component) {
  1779.       this.type = this.component.type;
  1780.       if (this.hasInput && this.component.key) {
  1781.         this.options.name += '[' + this.component.key + ']';
  1782.       }
  1783.  
  1784.       /**
  1785.        * The element information for creating the input element.
  1786.        * @type {*}
  1787.        */
  1788.       this.info = this.elementInfo();
  1789.     }
  1790.   }
  1791.  
  1792.   _createClass(BaseComponent, [{
  1793.     key: 't',
  1794.  
  1795.     /**
  1796.      * Translate a text using the i18n system.
  1797.      *
  1798.      * @param {string} text - The i18n identifier.
  1799.      * @param {Object} params - The i18n parameters to use for translation.
  1800.      */
  1801.     value: function t(text, params) {
  1802.       params = params || {};
  1803.       params.data = this.root ? this.root.data : this.data;
  1804.       params.row = this.data;
  1805.       params.component = this.component;
  1806.       params.nsSeparator = '::';
  1807.       params.keySeparator = '.|.';
  1808.       params.pluralSeparator = '._.';
  1809.       params.contextSeparator = '._.';
  1810.       var translated = this.i18next.t(text, params);
  1811.       return translated || text;
  1812.     }
  1813.  
  1814.     /**
  1815.      * Register for a new event within this component.
  1816.      *
  1817.      * @example
  1818.      * let component = new BaseComponent({
  1819.      *   type: 'textfield',
  1820.      *   label: 'First Name',
  1821.      *   key: 'firstName'
  1822.      * });
  1823.      * component.on('componentChange', (changed) => {
  1824.      *   console.log('this element is changed.');
  1825.      * });
  1826.      *
  1827.      *
  1828.      * @param {string} event - The event you wish to register the handler for.
  1829.      * @param {function} cb - The callback handler to handle this event.
  1830.      * @param {boolean} internal - This is an internal event handler.
  1831.      */
  1832.  
  1833.   }, {
  1834.     key: 'on',
  1835.     value: function on(event, cb, internal) {
  1836.       if (!this.events) {
  1837.         return;
  1838.       }
  1839.       var type = 'formio.' + event;
  1840.       this.eventListeners.push({
  1841.         type: type,
  1842.         listener: cb,
  1843.         internal: internal
  1844.       });
  1845.       return this.events.on(type, cb);
  1846.     }
  1847.  
  1848.     /**
  1849.      * Emit a new event.
  1850.      *
  1851.      * @param {string} event - The event to emit.
  1852.      * @param {Object} data - The data to emit with the handler.
  1853.      */
  1854.  
  1855.   }, {
  1856.     key: 'emit',
  1857.     value: function emit(event, data) {
  1858.       this.events.emit('formio.' + event, data);
  1859.     }
  1860.  
  1861.     /**
  1862.      * Returns an HTMLElement icon element.
  1863.      *
  1864.      * @param {string} name - The name of the icon to retrieve.
  1865.      * @returns {HTMLElement} - The icon element.
  1866.      */
  1867.  
  1868.   }, {
  1869.     key: 'getIcon',
  1870.     value: function getIcon(name) {
  1871.       return this.ce('i', {
  1872.         class: this.iconClass(name)
  1873.       });
  1874.     }
  1875.   }, {
  1876.     key: 'getBrowserLanguage',
  1877.     value: function getBrowserLanguage() {
  1878.       var nav = window.navigator;
  1879.       var browserLanguagePropertyKeys = ['language', 'browserLanguage', 'systemLanguage', 'userLanguage'];
  1880.       var language = void 0;
  1881.  
  1882.       // support for HTML 5.1 "navigator.languages"
  1883.       if (Array.isArray(nav.languages)) {
  1884.         for (var i = 0; i < nav.languages.length; i++) {
  1885.           language = nav.languages[i];
  1886.           if (language && language.length) {
  1887.             return language;
  1888.           }
  1889.         }
  1890.       }
  1891.  
  1892.       // support for other well known properties in browsers
  1893.       for (var _i = 0; _i < browserLanguagePropertyKeys.length; _i++) {
  1894.         language = nav[browserLanguagePropertyKeys[_i]];
  1895.         if (language && language.length) {
  1896.           return language;
  1897.         }
  1898.       }
  1899.  
  1900.       return null;
  1901.     }
  1902.  
  1903.     /**
  1904.      * Called before a next page is triggered allowing the components
  1905.      * to perform special functions.
  1906.      *
  1907.      * @return {*}
  1908.      */
  1909.  
  1910.   }, {
  1911.     key: 'beforeNext',
  1912.     value: function beforeNext() {
  1913.       return _nativePromiseOnly2.default.resolve(true);
  1914.     }
  1915.  
  1916.     /**
  1917.      * Called before a submission is triggered allowing the components
  1918.      * to perform special async functions.
  1919.      *
  1920.      * @return {*}
  1921.      */
  1922.  
  1923.   }, {
  1924.     key: 'beforeSubmit',
  1925.     value: function beforeSubmit() {
  1926.       return _nativePromiseOnly2.default.resolve(true);
  1927.     }
  1928.   }, {
  1929.     key: 'build',
  1930.  
  1931.     /**
  1932.      * Builds the component.
  1933.      */
  1934.     value: function build() {
  1935.       if (this.viewOnly) {
  1936.         this.viewOnlyBuild();
  1937.       } else {
  1938.         this.createElement();
  1939.  
  1940.         var labelAtTheBottom = this.component.labelPosition === 'bottom';
  1941.         if (!labelAtTheBottom) {
  1942.           this.createLabel(this.element);
  1943.         }
  1944.         if (!this.createWrapper()) {
  1945.           this.createInput(this.element);
  1946.         }
  1947.         if (labelAtTheBottom) {
  1948.           this.createLabel(this.element);
  1949.         }
  1950.         this.createDescription(this.element);
  1951.  
  1952.         // Disable if needed.
  1953.         if (this.shouldDisable) {
  1954.           this.disabled = true;
  1955.         }
  1956.  
  1957.         // Restore the value.
  1958.         this.restoreValue();
  1959.  
  1960.         this.autofocus();
  1961.       }
  1962.     }
  1963.   }, {
  1964.     key: 'viewOnlyBuild',
  1965.     value: function viewOnlyBuild() {
  1966.       this.createViewOnlyElement();
  1967.       this.createViewOnlyLabel(this.element);
  1968.       this.createViewOnlyValue(this.element);
  1969.     }
  1970.   }, {
  1971.     key: 'createViewOnlyElement',
  1972.     value: function createViewOnlyElement() {
  1973.       this.element = this.ce('dl', {
  1974.         id: this.id
  1975.       });
  1976.  
  1977.       if (this.element) {
  1978.         // Ensure you can get the component info from the element.
  1979.         this.element.component = this.component;
  1980.       }
  1981.  
  1982.       return this.element;
  1983.     }
  1984.   }, {
  1985.     key: 'createViewOnlyLabel',
  1986.     value: function createViewOnlyLabel(container) {
  1987.       if (this.labelIsHidden()) {
  1988.         return;
  1989.       }
  1990.  
  1991.       this.labelElement = this.ce('dt');
  1992.       this.labelElement.appendChild(this.text(this.component.label));
  1993.       this.createTooltip(this.labelElement);
  1994.       container.appendChild(this.labelElement);
  1995.     }
  1996.   }, {
  1997.     key: 'createViewOnlyValue',
  1998.     value: function createViewOnlyValue(container) {
  1999.       this.valueElement = this.ce('dd');
  2000.       this.setupValueElement(this.valueElement);
  2001.       container.appendChild(this.valueElement);
  2002.     }
  2003.   }, {
  2004.     key: 'setupValueElement',
  2005.     value: function setupValueElement(element) {
  2006.       var value = this.getValue();
  2007.       value = this.isEmpty(value) ? this.defaultViewOnlyValue : this.getView(value);
  2008.       element.innerHTML = value;
  2009.     }
  2010.   }, {
  2011.     key: 'getView',
  2012.     value: function getView(value) {
  2013.       if (!value) {
  2014.         return '';
  2015.       }
  2016.       if (Array.isArray(value)) {
  2017.         return value.join(', ');
  2018.       }
  2019.  
  2020.       return value.toString();
  2021.     }
  2022.   }, {
  2023.     key: 'updateViewOnlyValue',
  2024.     value: function updateViewOnlyValue() {
  2025.       if (!this.valueElement) {
  2026.         return;
  2027.       }
  2028.  
  2029.       this.setupValueElement(this.valueElement);
  2030.     }
  2031.   }, {
  2032.     key: 'empty',
  2033.     value: function empty(element) {
  2034.       if (element) {
  2035.         while (element.firstChild) {
  2036.           element.removeChild(element.firstChild);
  2037.         }
  2038.       }
  2039.     }
  2040.  
  2041.     /**
  2042.      * Retrieves the CSS class name of this component.
  2043.      * @returns {string} - The class name of this component.
  2044.      */
  2045.  
  2046.   }, {
  2047.     key: 'getElement',
  2048.  
  2049.     /**
  2050.      * Returns the outside wrapping element of this component.
  2051.      * @returns {HTMLElement}
  2052.      */
  2053.     value: function getElement() {
  2054.       return this.element;
  2055.     }
  2056.  
  2057.     /**
  2058.      * Create the outside wrapping element for this component.
  2059.      * @returns {HTMLElement}
  2060.      */
  2061.  
  2062.   }, {
  2063.     key: 'createElement',
  2064.     value: function createElement() {
  2065.       // If the element is already created, don't recreate.
  2066.       if (this.element) {
  2067.         return this.element;
  2068.       }
  2069.  
  2070.       this.element = this.ce('div', {
  2071.         id: this.id,
  2072.         class: this.className,
  2073.         style: this.customStyle
  2074.       });
  2075.  
  2076.       // Ensure you can get the component info from the element.
  2077.       this.element.component = this.component;
  2078.  
  2079.       return this.element;
  2080.     }
  2081.  
  2082.     /**
  2083.      * Create the input wrapping element. For multiple, this may be the table wrapper for the elements.
  2084.      * @returns {boolean}
  2085.      */
  2086.  
  2087.   }, {
  2088.     key: 'createWrapper',
  2089.     value: function createWrapper() {
  2090.       if (!this.component.multiple) {
  2091.         return false;
  2092.       } else {
  2093.         var table = this.ce('table', {
  2094.           class: 'table table-bordered'
  2095.         });
  2096.         this.tbody = this.ce('tbody');
  2097.         table.appendChild(this.tbody);
  2098.  
  2099.         // Add a default value.
  2100.         var dataValue = this.dataValue;
  2101.         if (!dataValue || !dataValue.length) {
  2102.           this.addNewValue();
  2103.         }
  2104.  
  2105.         // Build the rows.
  2106.         this.buildRows();
  2107.  
  2108.         this.setInputStyles(table);
  2109.  
  2110.         // Add the table to the element.
  2111.         this.append(table);
  2112.         return true;
  2113.       }
  2114.     }
  2115.   }, {
  2116.     key: 'setPristine',
  2117.  
  2118.     /**
  2119.      * Sets the pristine flag for this component.
  2120.      *
  2121.      * @param pristine {boolean} - TRUE to make pristine, FALSE not pristine.
  2122.      */
  2123.     value: function setPristine(pristine) {
  2124.       this.pristine = pristine;
  2125.     }
  2126.  
  2127.     /**
  2128.      * Adds a new empty value to the data array.
  2129.      */
  2130.  
  2131.   }, {
  2132.     key: 'addNewValue',
  2133.     value: function addNewValue() {
  2134.       var dataValue = this.dataValue || [];
  2135.       if (!Array.isArray(dataValue)) {
  2136.         dataValue = [dataValue];
  2137.       }
  2138.  
  2139.       var defaultValue = this.defaultValue;
  2140.       if (Array.isArray(defaultValue)) {
  2141.         dataValue = dataValue.concat(defaultValue);
  2142.       } else {
  2143.         dataValue.push(defaultValue);
  2144.       }
  2145.       this.dataValue = dataValue;
  2146.     }
  2147.  
  2148.     /**
  2149.      * Adds a new empty value to the data array, and add a new row to contain it.
  2150.      */
  2151.  
  2152.   }, {
  2153.     key: 'addValue',
  2154.     value: function addValue() {
  2155.       this.addNewValue();
  2156.       this.buildRows();
  2157.           console.log('this.root = ', this.root);
  2158.           console.log('this.root.data = ', this.root.data);
  2159.           console.log('this.data = ', this.data);
  2160.       this.checkConditions(this.root ? this.root.data : this.data);
  2161.       this.restoreValue();
  2162.       if (this.root) {
  2163.         this.root.onChange();
  2164.       }
  2165.     }
  2166.  
  2167.     /**
  2168.      * Removes a value out of the data array and rebuild the rows.
  2169.      * @param {number} index - The index of the data element to remove.
  2170.      */
  2171.  
  2172.   }, {
  2173.     key: 'removeValue',
  2174.     value: function removeValue(index) {
  2175.       this.splice(index);
  2176.       this.buildRows();
  2177.       this.restoreValue();
  2178.       if (this.root) {
  2179.         this.root.onChange();
  2180.       }
  2181.     }
  2182.  
  2183.     /**
  2184.      * Rebuild the rows to contain the values of this component.
  2185.      */
  2186.  
  2187.   }, {
  2188.     key: 'buildRows',
  2189.     value: function buildRows() {
  2190.       var _this = this;
  2191.  
  2192.       if (!this.tbody) {
  2193.         return;
  2194.       }
  2195.       this.inputs = [];
  2196.       this.tbody.innerHTML = '';
  2197.       _lodash2.default.each(this.dataValue, function (value, index) {
  2198.         var tr = _this.ce('tr');
  2199.         var td = _this.ce('td');
  2200.         var input = _this.createInput(td);
  2201.         input.value = value;
  2202.         tr.appendChild(td);
  2203.  
  2204.         if (!_this.shouldDisable) {
  2205.           var tdAdd = _this.ce('td');
  2206.           tdAdd.appendChild(_this.removeButton(index));
  2207.           tr.appendChild(tdAdd);
  2208.         }
  2209.  
  2210.         _this.tbody.appendChild(tr);
  2211.       });
  2212.  
  2213.       if (!this.shouldDisable) {
  2214.         var tr = this.ce('tr');
  2215.         var td = this.ce('td', {
  2216.           colspan: '2'
  2217.         });
  2218.         td.appendChild(this.addButton());
  2219.         tr.appendChild(td);
  2220.         this.tbody.appendChild(tr);
  2221.       }
  2222.  
  2223.       if (this.shouldDisable) {
  2224.         this.disabled = true;
  2225.       }
  2226.     }
  2227.   }, {
  2228.     key: 'bootstrap4Theme',
  2229.     value: function bootstrap4Theme(name) {
  2230.       return name === 'default' ? 'secondary' : name;
  2231.     }
  2232.   }, {
  2233.     key: 'iconClass',
  2234.     value: function iconClass(name, spinning) {
  2235.       if (!this.options.icons || this.options.icons === 'glyphicon') {
  2236.         return spinning ? 'glyphicon glyphicon-' + name + ' glyphicon-spin' : 'glyphicon glyphicon-' + name;
  2237.       }
  2238.       switch (name) {
  2239.         case 'zoom-in':
  2240.           return 'fa fa-search-plus';
  2241.         case 'zoom-out':
  2242.           return 'fa fa-search-minus';
  2243.         case 'question-sign':
  2244.           return 'fa fa-question-circle';
  2245.         case 'remove-circle':
  2246.           return 'fa fa-times-circle-o';
  2247.         default:
  2248.           return spinning ? 'fa fa-' + name + ' fa-spin' : 'fa fa-' + name;
  2249.       }
  2250.     }
  2251.  
  2252.     /**
  2253.      * Adds a new button to add new rows to the multiple input elements.
  2254.      * @returns {HTMLElement} - The "Add New" button html element.
  2255.      */
  2256.  
  2257.   }, {
  2258.     key: 'addButton',
  2259.     value: function addButton(justIcon) {
  2260.       var _this2 = this;
  2261.  
  2262.       var addButton = this.ce('button', {
  2263.         class: 'btn btn-primary'
  2264.       });
  2265.       this.addEventListener(addButton, 'click', function (event) {
  2266.         event.preventDefault();
  2267.         _this2.addValue();
  2268.       });
  2269.  
  2270.       var addIcon = this.ce('i', {
  2271.         class: this.iconClass('plus')
  2272.       });
  2273.  
  2274.       if (justIcon) {
  2275.         addButton.appendChild(addIcon);
  2276.         return addButton;
  2277.       } else {
  2278.         addButton.appendChild(addIcon);
  2279.         addButton.appendChild(this.text(this.component.addAnother || ' Add Another'));
  2280.         return addButton;
  2281.       }
  2282.     }
  2283.  
  2284.     /**
  2285.      * The readible name for this component.
  2286.      * @returns {string} - The name of the component.
  2287.      */
  2288.  
  2289.   }, {
  2290.     key: 'errorMessage',
  2291.  
  2292.     /**
  2293.      * Get the error message provided a certain type of error.
  2294.      * @param type
  2295.      * @return {*}
  2296.      */
  2297.     value: function errorMessage(type) {
  2298.       return this.component.errors && this.component.errors[type] ? this.component.errors[type] : type;
  2299.     }
  2300.  
  2301.     /**
  2302.      * Creates a new "remove" row button and returns the html element of that button.
  2303.      * @param {number} index - The index of the row that should be removed.
  2304.      * @returns {HTMLElement} - The html element of the remove button.
  2305.      */
  2306.  
  2307.   }, {
  2308.     key: 'removeButton',
  2309.     value: function removeButton(index) {
  2310.       var _this3 = this;
  2311.  
  2312.       var removeButton = this.ce('button', {
  2313.         type: 'button',
  2314.         class: 'btn btn-default btn-secondary'
  2315.       });
  2316.  
  2317.       this.addEventListener(removeButton, 'click', function (event) {
  2318.         event.preventDefault();
  2319.         _this3.removeValue(index);
  2320.       });
  2321.  
  2322.       var removeIcon = this.ce('i', {
  2323.         class: this.iconClass('remove-circle')
  2324.       });
  2325.       removeButton.appendChild(removeIcon);
  2326.       return removeButton;
  2327.     }
  2328.   }, {
  2329.     key: 'labelOnTheLeft',
  2330.     value: function labelOnTheLeft(position) {
  2331.       return ['left-left', 'left-right'].indexOf(position) !== -1;
  2332.     }
  2333.   }, {
  2334.     key: 'labelOnTheRight',
  2335.     value: function labelOnTheRight(position) {
  2336.       return ['right-left', 'right-right'].indexOf(position) !== -1;
  2337.     }
  2338.   }, {
  2339.     key: 'rightAlignedLabel',
  2340.     value: function rightAlignedLabel(position) {
  2341.       return ['left-right', 'right-right'].indexOf(position) !== -1;
  2342.     }
  2343.   }, {
  2344.     key: 'labelOnTheLeftOrRight',
  2345.     value: function labelOnTheLeftOrRight(position) {
  2346.       return this.labelOnTheLeft(position) || this.labelOnTheRight(position);
  2347.     }
  2348.   }, {
  2349.     key: 'getLabelWidth',
  2350.     value: function getLabelWidth() {
  2351.       if (_lodash2.default.isUndefined(this.component.labelWidth)) {
  2352.         this.component.labelWidth = 30;
  2353.       }
  2354.  
  2355.       return this.component.labelWidth;
  2356.     }
  2357.   }, {
  2358.     key: 'getLabelMargin',
  2359.     value: function getLabelMargin() {
  2360.       if (_lodash2.default.isUndefined(this.component.labelMargin)) {
  2361.         this.component.labelMargin = 3;
  2362.       }
  2363.  
  2364.       return this.component.labelMargin;
  2365.     }
  2366.   }, {
  2367.     key: 'setInputStyles',
  2368.     value: function setInputStyles(input) {
  2369.       if (this.labelIsHidden()) {
  2370.         return;
  2371.       }
  2372.  
  2373.       if (this.labelOnTheLeftOrRight(this.component.labelPosition)) {
  2374.         var totalLabelWidth = this.getLabelWidth() + this.getLabelMargin();
  2375.         input.style.width = 100 - totalLabelWidth + '%';
  2376.  
  2377.         if (this.labelOnTheLeft(this.component.labelPosition)) {
  2378.           input.style.marginLeft = totalLabelWidth + '%';
  2379.         } else {
  2380.           input.style.marginRight = totalLabelWidth + '%';
  2381.         }
  2382.       }
  2383.     }
  2384.   }, {
  2385.     key: 'labelIsHidden',
  2386.     value: function labelIsHidden() {
  2387.       return !this.component.label || this.component.hideLabel || this.options.inputsOnly;
  2388.     }
  2389.  
  2390.     /**
  2391.      * Create the HTML element for the label of this component.
  2392.      * @param {HTMLElement} container - The containing element that will contain this label.
  2393.      */
  2394.  
  2395.   }, {
  2396.     key: 'createLabel',
  2397.     value: function createLabel(container) {
  2398.       if (this.labelIsHidden()) {
  2399.         return;
  2400.       }
  2401.       var className = 'control-label';
  2402.       var style = '';
  2403.  
  2404.       var labelPosition = this.component.labelPosition;
  2405.  
  2406.       // Determine label styles/classes depending on position.
  2407.  
  2408.       if (labelPosition === 'bottom') {
  2409.         className += ' control-label--bottom';
  2410.       } else if (labelPosition && labelPosition !== 'top') {
  2411.         var labelWidth = this.getLabelWidth();
  2412.         var labelMargin = this.getLabelMargin();
  2413.  
  2414.         // Label is on the left or right.
  2415.         if (this.labelOnTheLeft(labelPosition)) {
  2416.           style += 'float: left; width: ' + labelWidth + '%; margin-right: ' + labelMargin + '%; ';
  2417.         } else if (this.labelOnTheRight(labelPosition)) {
  2418.           style += 'float: right; width: ' + labelWidth + '%; margin-left: ' + labelMargin + '%; ';
  2419.         }
  2420.         if (this.rightAlignedLabel(labelPosition)) {
  2421.           style += 'text-align: right; ';
  2422.         }
  2423.       }
  2424.  
  2425.       if (this.hasInput && this.component.validate && this.component.validate.required) {
  2426.         className += ' field-required';
  2427.       }
  2428.       this.labelElement = this.ce('label', {
  2429.         class: className,
  2430.         style: style
  2431.       });
  2432.       if (this.info.attr.id) {
  2433.         this.labelElement.setAttribute('for', this.info.attr.id);
  2434.       }
  2435.       this.labelElement.appendChild(this.text(this.component.label));
  2436.       this.createTooltip(this.labelElement);
  2437.       container.appendChild(this.labelElement);
  2438.     }
  2439.   }, {
  2440.     key: 'addShortcutToLabel',
  2441.     value: function addShortcutToLabel(label, shortcut) {
  2442.       if (!label) {
  2443.         label = this.component.label;
  2444.       }
  2445.  
  2446.       if (!shortcut) {
  2447.         shortcut = this.component.shortcut;
  2448.       }
  2449.  
  2450.       if (!shortcut || !/^[A-Za-z]$/.test(shortcut)) {
  2451.         return label;
  2452.       }
  2453.  
  2454.       var match = label.match(new RegExp(shortcut, 'i'));
  2455.  
  2456.       if (!match) {
  2457.         return label;
  2458.       }
  2459.  
  2460.       var index = match.index + 1;
  2461.       var lowLineCombinator = "\u0332";
  2462.  
  2463.       return label.substring(0, index) + lowLineCombinator + label.substring(index);
  2464.     }
  2465.   }, {
  2466.     key: 'addShortcut',
  2467.     value: function addShortcut(element, shortcut) {
  2468.       // Avoid infinite recursion.
  2469.       if (this.root === this) {
  2470.         return;
  2471.       }
  2472.  
  2473.       if (!element) {
  2474.         element = this.labelElement;
  2475.       }
  2476.  
  2477.       if (!shortcut) {
  2478.         shortcut = this.component.shortcut;
  2479.       }
  2480.  
  2481.       this.root.addShortcut(element, shortcut);
  2482.     }
  2483.   }, {
  2484.     key: 'removeShortcut',
  2485.     value: function removeShortcut(element, shortcut) {
  2486.       // Avoid infinite recursion.
  2487.       if (this.root === this) {
  2488.         return;
  2489.       }
  2490.  
  2491.       if (!element) {
  2492.         element = this.labelElement;
  2493.       }
  2494.  
  2495.       if (!shortcut) {
  2496.         shortcut = this.component.shortcut;
  2497.       }
  2498.  
  2499.       this.root.removeShortcut(element, shortcut);
  2500.     }
  2501.  
  2502.     /**
  2503.      * Create the HTML element for the tooltip of this component.
  2504.      * @param {HTMLElement} container - The containing element that will contain this tooltip.
  2505.      */
  2506.  
  2507.   }, {
  2508.     key: 'createTooltip',
  2509.     value: function createTooltip(container, component, classes) {
  2510.       component = component || this.component;
  2511.       classes = classes || this.iconClass('question-sign') + ' text-muted';
  2512.       if (!component.tooltip) {
  2513.         return;
  2514.       }
  2515.       this.tooltip = this.ce('i', {
  2516.         class: classes
  2517.       });
  2518.       container.appendChild(this.text(' '));
  2519.       container.appendChild(this.tooltip);
  2520.       new _tooltip2.default(this.tooltip, {
  2521.         delay: {
  2522.           hide: 100
  2523.         },
  2524.         placement: 'right',
  2525.         html: true,
  2526.         title: component.tooltip.replace(/(?:\r\n|\r|\n)/g, '<br />')
  2527.       });
  2528.     }
  2529.  
  2530.     /**
  2531.      * Creates the description block for this input field.
  2532.      * @param container
  2533.      */
  2534.  
  2535.   }, {
  2536.     key: 'createDescription',
  2537.     value: function createDescription(container) {
  2538.       if (!this.component.description) {
  2539.         return;
  2540.       }
  2541.       this.description = this.ce('div', {
  2542.         class: 'help-block'
  2543.       });
  2544.       this.description.innerHTML = this.t(this.component.description);
  2545.       container.appendChild(this.description);
  2546.     }
  2547.  
  2548.     /**
  2549.      * Creates a new error element to hold the errors of this element.
  2550.      */
  2551.  
  2552.   }, {
  2553.     key: 'createErrorElement',
  2554.     value: function createErrorElement() {
  2555.       if (!this.errorContainer) {
  2556.         return;
  2557.       }
  2558.       this.errorElement = this.ce('div', {
  2559.         class: 'formio-errors invalid-feedback'
  2560.       });
  2561.       this.errorContainer.appendChild(this.errorElement);
  2562.     }
  2563.  
  2564.     /**
  2565.      * Adds a prefix html element.
  2566.      *
  2567.      * @param {HTMLElement} input - The input element.
  2568.      * @param {HTMLElement} inputGroup - The group that will hold this prefix.
  2569.      * @returns {HTMLElement} - The html element for this prefix.
  2570.      */
  2571.  
  2572.   }, {
  2573.     key: 'addPrefix',
  2574.     value: function addPrefix(input, inputGroup) {
  2575.       var prefix = null;
  2576.       if (this.component.prefix) {
  2577.         prefix = this.ce('div', {
  2578.           class: 'input-group-addon'
  2579.         });
  2580.         prefix.appendChild(this.text(this.component.prefix));
  2581.         inputGroup.appendChild(prefix);
  2582.       }
  2583.       return prefix;
  2584.     }
  2585.  
  2586.     /**
  2587.      * Adds a suffix html element.
  2588.      *
  2589.      * @param {HTMLElement} input - The input element.
  2590.      * @param {HTMLElement} inputGroup - The group that will hold this suffix.
  2591.      * @returns {HTMLElement} - The html element for this suffix.
  2592.      */
  2593.  
  2594.   }, {
  2595.     key: 'addSuffix',
  2596.     value: function addSuffix(input, inputGroup) {
  2597.       var suffix = null;
  2598.       if (this.component.suffix) {
  2599.         suffix = this.ce('div', {
  2600.           class: 'input-group-addon'
  2601.         });
  2602.         suffix.appendChild(this.text(this.component.suffix));
  2603.         inputGroup.appendChild(suffix);
  2604.       }
  2605.       return suffix;
  2606.     }
  2607.  
  2608.     /**
  2609.      * Adds a new input group to hold the input html elements.
  2610.      *
  2611.      * @param {HTMLElement} input - The input html element.
  2612.      * @param {HTMLElement} container - The containing html element for this group.
  2613.      * @returns {HTMLElement} - The input group element.
  2614.      */
  2615.  
  2616.   }, {
  2617.     key: 'addInputGroup',
  2618.     value: function addInputGroup(input, container) {
  2619.       var inputGroup = null;
  2620.       if (this.component.prefix || this.component.suffix) {
  2621.         inputGroup = this.ce('div', {
  2622.           class: 'input-group'
  2623.         });
  2624.         container.appendChild(inputGroup);
  2625.       }
  2626.       return inputGroup;
  2627.     }
  2628.  
  2629.     /**
  2630.      * Creates a new input mask placeholder.
  2631.      * @param {HTMLElement} mask - The input mask.
  2632.      * @returns {string} - The placeholder that will exist within the input as they type.
  2633.      */
  2634.  
  2635.   }, {
  2636.     key: 'maskPlaceholder',
  2637.     value: function maskPlaceholder(mask) {
  2638.       return mask.map(function (char) {
  2639.         return char instanceof RegExp ? '_' : char;
  2640.       }).join('');
  2641.     }
  2642.  
  2643.     /**
  2644.      * Sets the input mask for an input.
  2645.      * @param {HTMLElement} input - The html input to apply the mask to.
  2646.      */
  2647.  
  2648.   }, {
  2649.     key: 'setInputMask',
  2650.     value: function setInputMask(input) {
  2651.       if (input && this.component.inputMask) {
  2652.         var mask = _utils2.default.getInputMask(this.component.inputMask);
  2653.         this._inputMask = mask;
  2654.         input.mask = (0, _vanillaTextMask2.default)({
  2655.           inputElement: input,
  2656.           mask: mask
  2657.         });
  2658.         if (mask.numeric) {
  2659.           input.setAttribute('pattern', '\\d*');
  2660.         }
  2661.         if (!this.component.placeholder) {
  2662.           input.setAttribute('placeholder', this.maskPlaceholder(mask));
  2663.         }
  2664.       }
  2665.     }
  2666.  
  2667.     /**
  2668.      * Creates a new input element.
  2669.      * @param {HTMLElement} container - The container which should hold this new input element.
  2670.      * @returns {HTMLElement} - Either the input or the group that contains the input.
  2671.      */
  2672.  
  2673.   }, {
  2674.     key: 'createInput',
  2675.     value: function createInput(container) {
  2676.       var input = this.ce(this.info.type, this.info.attr);
  2677.       this.setInputMask(input);
  2678.       var inputGroup = this.addInputGroup(input, container);
  2679.       this.addPrefix(input, inputGroup);
  2680.       this.addInput(input, inputGroup || container);
  2681.       this.addSuffix(input, inputGroup);
  2682.       this.errorContainer = container;
  2683.       this.setInputStyles(inputGroup || input);
  2684.       return inputGroup || input;
  2685.     }
  2686.  
  2687.     /**
  2688.      * Wrapper method to add an event listener to an HTML element.
  2689.      *
  2690.      * @param obj
  2691.      *   The DOM element to add the event to.
  2692.      * @param evt
  2693.      *   The event name to add.
  2694.      * @param func
  2695.      *   The callback function to be executed when the listener is triggered.
  2696.      */
  2697.  
  2698.   }, {
  2699.     key: 'addEventListener',
  2700.     value: function addEventListener(obj, evt, func) {
  2701.       this.eventHandlers.push({ type: evt, func: func });
  2702.       if ('addEventListener' in obj) {
  2703.         obj.addEventListener(evt, func, false);
  2704.       } else if ('attachEvent' in obj) {
  2705.         obj.attachEvent('on' + evt, func);
  2706.       }
  2707.     }
  2708.   }, {
  2709.     key: 'redraw',
  2710.     value: function redraw() {
  2711.       // Don't bother if we have not built yet.
  2712.       if (!this.isBuilt) {
  2713.         return;
  2714.       }
  2715.       this.clear();
  2716.       this.build();
  2717.     }
  2718.  
  2719.     /**
  2720.      * Remove all event handlers.
  2721.      */
  2722.  
  2723.   }, {
  2724.     key: 'destroy',
  2725.     value: function destroy(all) {
  2726.       var _this4 = this;
  2727.  
  2728.       _lodash2.default.each(this.eventListeners, function (listener) {
  2729.         if (all || listener.internal) {
  2730.           _this4.events.off(listener.type, listener.listener);
  2731.         }
  2732.       });
  2733.       _lodash2.default.each(this.eventHandlers, function (handler) {
  2734.         if (handler.event) {
  2735.           window.removeEventListener(handler.event, handler.func);
  2736.         }
  2737.       });
  2738.       _lodash2.default.each(this.inputs, function (input) {
  2739.         if (input.mask) {
  2740.           input.mask.destroy();
  2741.         }
  2742.       });
  2743.       this.inputs = [];
  2744.     }
  2745.  
  2746.     /**
  2747.      * Render a template string into html.
  2748.      *
  2749.      * @param template
  2750.      * @param data
  2751.      * @param actions
  2752.      *
  2753.      * @return {HTMLElement} - The created element.
  2754.      */
  2755.  
  2756.   }, {
  2757.     key: 'renderTemplate',
  2758.     value: function renderTemplate(template, data) {
  2759.       var actions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
  2760.  
  2761.       // Create a container div.
  2762.       var div = this.ce('div');
  2763.  
  2764.       // Interpolate the template and populate
  2765.       div.innerHTML = _utils2.default.interpolate(template, data);
  2766.  
  2767.       // Add actions to matching elements.
  2768.       actions.forEach(function (action) {
  2769.         var elements = div.getElementsByClassName(action.class);
  2770.         Array.prototype.forEach.call(elements, function (element) {
  2771.           element.addEventListener(action.event, action.action);
  2772.         });
  2773.       });
  2774.  
  2775.       return div;
  2776.     }
  2777.  
  2778.     /**
  2779.      * Append different types of children.
  2780.      *
  2781.      * @param child
  2782.      */
  2783.  
  2784.   }, {
  2785.     key: 'appendChild',
  2786.     value: function appendChild(element, child) {
  2787.       var _this5 = this;
  2788.  
  2789.       if (Array.isArray(child)) {
  2790.         child.forEach(function (oneChild) {
  2791.           _this5.appendChild(element, oneChild);
  2792.         });
  2793.       } else if (child instanceof HTMLElement || child instanceof Text) {
  2794.         element.appendChild(child);
  2795.       } else if (child) {
  2796.         element.appendChild(this.text(child.toString()));
  2797.       }
  2798.     }
  2799.  
  2800.     /**
  2801.      * Alias for document.createElement.
  2802.      *
  2803.      * @param {string} type - The type of element to create
  2804.      * @param {Object} attr - The element attributes to add to the created element.
  2805.      * @param {Various} children - Child elements. Can be a DOM Element, string or array of both.
  2806.      * @param {Object} events
  2807.      *
  2808.      * @return {HTMLElement} - The created element.
  2809.      */
  2810.  
  2811.   }, {
  2812.     key: 'ce',
  2813.     value: function ce(type, attr) {
  2814.       var children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  2815.  
  2816.       // Create the element.
  2817.       var element = document.createElement(type);
  2818.  
  2819.       // Add attributes.
  2820.       if (attr) {
  2821.         this.attr(element, attr);
  2822.       }
  2823.  
  2824.       // Append the children.
  2825.       this.appendChild(element, children);
  2826.       return element;
  2827.     }
  2828.  
  2829.     /**
  2830.      * Alias to create a text node.
  2831.      * @param text
  2832.      * @returns {Text}
  2833.      */
  2834.  
  2835.   }, {
  2836.     key: 'text',
  2837.     value: function text(_text) {
  2838.       return document.createTextNode(this.t(_text));
  2839.     }
  2840.  
  2841.     /**
  2842.      * Adds an object of attributes onto an element.
  2843.      * @param {HtmlElement} element - The element to add the attributes to.
  2844.      * @param {Object} attr - The attributes to add to the input element.
  2845.      */
  2846.  
  2847.   }, {
  2848.     key: 'attr',
  2849.     value: function attr(element, _attr) {
  2850.       var _this6 = this;
  2851.  
  2852.       _lodash2.default.each(_attr, function (value, key) {
  2853.         if (typeof value !== 'undefined') {
  2854.           if (key.indexOf('on') === 0) {
  2855.             // If this is an event, add a listener.
  2856.             _this6.addEventListener(element, key.substr(2).toLowerCase(), value);
  2857.           } else {
  2858.             // Otherwise it is just an attribute.
  2859.             element.setAttribute(key, value);
  2860.           }
  2861.         }
  2862.       });
  2863.     }
  2864.  
  2865.     /**
  2866.      * Adds a class to a DOM element.
  2867.      *
  2868.      * @param element
  2869.      *   The element to add a class to.
  2870.      * @param className
  2871.      *   The name of the class to add.
  2872.      */
  2873.  
  2874.   }, {
  2875.     key: 'addClass',
  2876.     value: function addClass(element, className) {
  2877.       var classes = element.getAttribute('class');
  2878.       if (!classes || classes.indexOf(className) === -1) {
  2879.         element.setAttribute('class', classes + ' ' + className);
  2880.       }
  2881.     }
  2882.  
  2883.     /**
  2884.      * Remove a class from a DOM element.
  2885.      *
  2886.      * @param element
  2887.      *   The DOM element to remove the class from.
  2888.      * @param className
  2889.      *   The name of the class that is to be removed.
  2890.      */
  2891.  
  2892.   }, {
  2893.     key: 'removeClass',
  2894.     value: function removeClass(element, className) {
  2895.       var cls = element.getAttribute('class');
  2896.       if (cls) {
  2897.         cls = cls.replace(new RegExp(className, 'g'), '');
  2898.         element.setAttribute('class', cls);
  2899.       }
  2900.     }
  2901.  
  2902.     /**
  2903.      * Determines if this component has a condition defined.
  2904.      *
  2905.      * @return {null}
  2906.      */
  2907.  
  2908.   }, {
  2909.     key: 'hasCondition',
  2910.     value: function hasCondition() {
  2911.       if (this._hasCondition !== null) {
  2912.         return this._hasCondition;
  2913.       }
  2914.  
  2915.       this._hasCondition = _utils2.default.hasCondition(this.component);
  2916.       return this._hasCondition;
  2917.     }
  2918.  
  2919.     /**
  2920.      * Check for conditionals and hide/show the element based on those conditions.
  2921.      */
  2922.  
  2923.   }, {
  2924.     key: 'checkConditions',
  2925.     value: function checkConditions(data) {
  2926.       // Check advanced conditions
  2927.       var result = void 0;
  2928.  
  2929.       if (!this.hasCondition()) {
  2930.         result = this.show(true);
  2931.       } else {
  2932.         result = this.show(_utils2.default.checkCondition(this.component, this.data, data));
  2933.       }
  2934.  
  2935.       if (this.fieldLogic(data)) {
  2936.         this.redraw();
  2937.       }
  2938.  
  2939.       return result;
  2940.     }
  2941.  
  2942.     /**
  2943.      * Check all triggers and apply necessary actions.
  2944.      *
  2945.      * @param data
  2946.      */
  2947.  
  2948.   }, {
  2949.     key: 'fieldLogic',
  2950.     value: function fieldLogic(data) {
  2951.       var _this7 = this;
  2952.  
  2953.       var logics = this.component.logic || [];
  2954.  
  2955.       // If there aren't logic, don't go further.
  2956.       if (logics.length === 0) {
  2957.         return;
  2958.       }
  2959.  
  2960.       var newComponent = _lodash2.default.cloneDeep(this.originalComponent);
  2961.  
  2962.       var changed = logics.reduce(function (changed, logic) {
  2963.         var result = _utils2.default.checkTrigger(newComponent, logic.trigger, _this7.data, data);
  2964.  
  2965.         if (result) {
  2966.           changed |= logic.actions.reduce(function (changed, action) {
  2967.             switch (action.type) {
  2968.               case 'property':
  2969.                 _utils2.default.setActionProperty(newComponent, action, _this7.data, data, newComponent, result);
  2970.                 break;
  2971.               case 'value':
  2972.                 {
  2973.                   var newValue = new Function('row', 'data', 'component', 'result', action.value)(_this7.data, data, newComponent, result);
  2974.                   if (!_lodash2.default.isEqual(_this7.getValue(), newValue)) {
  2975.                     _this7.setValue(newValue);
  2976.                     changed = true;
  2977.                   }
  2978.                   break;
  2979.                 }
  2980.               case 'validation':
  2981.                 // TODO
  2982.                 break;
  2983.             }
  2984.             return changed;
  2985.           }, false);
  2986.         }
  2987.         return changed;
  2988.       }, false);
  2989.  
  2990.       // If component definition changed, replace and mark as changed.
  2991.       if (!_lodash2.default.isEqual(this.component, newComponent)) {
  2992.         this.component = newComponent;
  2993.         changed = true;
  2994.       }
  2995.  
  2996.       return changed;
  2997.     }
  2998.  
  2999.     /**
  3000.      * Add a new input error to this element.
  3001.      *
  3002.      * @param message
  3003.      * @param dirty
  3004.      */
  3005.  
  3006.   }, {
  3007.     key: 'addInputError',
  3008.     value: function addInputError(message, dirty) {
  3009.       var _this8 = this;
  3010.  
  3011.       if (!message) {
  3012.         return;
  3013.       }
  3014.  
  3015.       if (this.errorElement) {
  3016.         var errorMessage = this.ce('p', {
  3017.           class: 'help-block'
  3018.         });
  3019.         errorMessage.appendChild(this.text(message));
  3020.         this.errorElement.appendChild(errorMessage);
  3021.       }
  3022.  
  3023.       // Add error classes
  3024.       this.addClass(this.element, 'has-error');
  3025.       this.inputs.forEach(function (input) {
  3026.         return _this8.addClass(input, 'is-invalid');
  3027.       });
  3028.       if (dirty && this.options.highlightErrors) {
  3029.         this.addClass(this.element, 'alert alert-danger');
  3030.       }
  3031.     }
  3032.  
  3033.     /**
  3034.      * Hide or Show an element.
  3035.      *
  3036.      * @param show
  3037.      */
  3038.  
  3039.   }, {
  3040.     key: 'show',
  3041.     value: function show(_show) {
  3042.       // Execute only if visibility changes.
  3043.       if (!_show === !this._visible) {
  3044.         return _show;
  3045.       }
  3046.  
  3047.       this._visible = _show;
  3048.       this.showElement(_show && !this.component.hidden);
  3049.       this.clearOnHide(_show);
  3050.       return _show;
  3051.     }
  3052.  
  3053.     /**
  3054.      * Show or hide the root element of this component.
  3055.      *
  3056.      * @param element
  3057.      * @param show
  3058.      */
  3059.  
  3060.   }, {
  3061.     key: 'showElement',
  3062.     value: function showElement(element, show) {
  3063.       if (typeof element === 'boolean') {
  3064.         show = element;
  3065.         element = this.getElement();
  3066.       }
  3067.  
  3068.       if (element) {
  3069.         if (show) {
  3070.           element.removeAttribute('hidden');
  3071.           element.style.visibility = 'visible';
  3072.           element.style.position = 'relative';
  3073.         } else {
  3074.           element.setAttribute('hidden', true);
  3075.           element.style.visibility = 'hidden';
  3076.           element.style.position = 'absolute';
  3077.         }
  3078.       }
  3079.       return show;
  3080.     }
  3081.   }, {
  3082.     key: 'clearOnHide',
  3083.     value: function clearOnHide(show) {
  3084.       // clearOnHide defaults to true for old forms (without the value set) so only trigger if the value is false.
  3085.       if (this.component.clearOnHide !== false) {
  3086.         if (!show) {
  3087.           this.deleteValue();
  3088.         } else if (!this.hasValue) {
  3089.           // If shown, ensure the default is set.
  3090.           this.setValue(this.defaultValue, {
  3091.             noUpdateEvent: true
  3092.           });
  3093.         }
  3094.       }
  3095.     }
  3096.   }, {
  3097.     key: 'onResize',
  3098.     value: function onResize() {}
  3099.  
  3100.     /**
  3101.      * Allow for options to hook into the functionality of this renderer.
  3102.      * @return {*}
  3103.      */
  3104.  
  3105.   }, {
  3106.     key: 'hook',
  3107.     value: function hook() {
  3108.       var name = arguments[0];
  3109.       var fn = typeof arguments[arguments.length - 1] === 'function' ? arguments[arguments.length - 1] : null;
  3110.       if (this.options && this.options.hooks && this.options.hooks[name]) {
  3111.         return this.options.hooks[name].apply(this, Array.prototype.slice.call(arguments, 1));
  3112.       } else {
  3113.         // If this is an async hook instead of a sync.
  3114.         if (fn) {
  3115.           return fn(null, arguments[1]);
  3116.         } else {
  3117.           return arguments[1];
  3118.         }
  3119.       }
  3120.     }
  3121.   }, {
  3122.     key: 'onChange',
  3123.     value: function onChange(flags, fromRoot) {
  3124.       flags = flags || {};
  3125.       if (!flags.noValidate) {
  3126.         this.pristine = false;
  3127.       }
  3128.  
  3129.       // Set the changed variable.
  3130.       var changed = {
  3131.         component: this.component,
  3132.         value: this.dataValue,
  3133.         flags: flags
  3134.       };
  3135.  
  3136.       // Emit the change.
  3137.       this.emit('componentChange', changed);
  3138.  
  3139.       // Bubble this change up to the top.
  3140.       if (this.root && !fromRoot) {
  3141.         this.root.triggerChange(flags, changed);
  3142.       }
  3143.     }
  3144.   }, {
  3145.     key: 'addInputSubmitListener',
  3146.     value: function addInputSubmitListener(input) {
  3147.       var _this9 = this;
  3148.  
  3149.       if (!this.options.submitOnEnter) {
  3150.         return;
  3151.       }
  3152.       this.addEventListener(input, 'keypress', function (event) {
  3153.         var key = event.keyCode || event.which;
  3154.         if (key === 13) {
  3155.           event.preventDefault();
  3156.           event.stopPropagation();
  3157.           _this9.emit('submitButton');
  3158.         }
  3159.       });
  3160.     }
  3161.  
  3162.     /**
  3163.      * Add new input element listeners.
  3164.      *
  3165.      * @param input
  3166.      */
  3167.  
  3168.   }, {
  3169.     key: 'addInputEventListener',
  3170.     value: function addInputEventListener(input) {
  3171.       var _this10 = this;
  3172.  
  3173.       this.addEventListener(input, this.info.changeEvent, function () {
  3174.         return _this10.updateValue({ changed: true });
  3175.       });
  3176.     }
  3177.  
  3178.     /**
  3179.      * Add a new input to this comonent.
  3180.      *
  3181.      * @param input
  3182.      * @param container
  3183.      * @param noSet
  3184.      */
  3185.  
  3186.   }, {
  3187.     key: 'addInput',
  3188.     value: function addInput(input, container) {
  3189.       if (input && container) {
  3190.         this.inputs.push(input);
  3191.         input = container.appendChild(input);
  3192.       }
  3193.       this.hook('input', input, container);
  3194.       this.addInputEventListener(input);
  3195.       this.addInputSubmitListener(input);
  3196.     }
  3197.  
  3198.     /**
  3199.      * The empty value for this component.
  3200.      *
  3201.      * @return {null}
  3202.      */
  3203.  
  3204.   }, {
  3205.     key: 'splice',
  3206.  
  3207.     /**
  3208.      * Splice a value from the dataValue.
  3209.      *
  3210.      * @param index
  3211.      */
  3212.     value: function splice(index) {
  3213.       if (this.hasValue) {
  3214.         var dataValue = this.dataValue || [];
  3215.         if (_lodash2.default.isArray(dataValue) && dataValue.hasOwnProperty(index)) {
  3216.           dataValue.splice(index, 1);
  3217.           this.dataValue = dataValue;
  3218.           this.triggerChange();
  3219.         }
  3220.       }
  3221.     }
  3222.  
  3223.     /**
  3224.      * Deletes the value of the component.
  3225.      */
  3226.  
  3227.   }, {
  3228.     key: 'deleteValue',
  3229.     value: function deleteValue() {
  3230.       this.setValue(null);
  3231.       _lodash2.default.unset(this.data, this.component.key);
  3232.     }
  3233.  
  3234.     /**
  3235.      * Get the value at a specific index.
  3236.      *
  3237.      * @param index
  3238.      * @returns {*}
  3239.      */
  3240.  
  3241.   }, {
  3242.     key: 'getValueAt',
  3243.     value: function getValueAt(index) {
  3244.       return this.inputs[index].value;
  3245.     }
  3246.  
  3247.     /**
  3248.      * Get the input value of this component.
  3249.      *
  3250.      * @return {*}
  3251.      */
  3252.  
  3253.   }, {
  3254.     key: 'getValue',
  3255.     value: function getValue() {
  3256.       if (!this.hasInput) {
  3257.         return;
  3258.       }
  3259.       if (this.viewOnly) {
  3260.         return this.dataValue;
  3261.       }
  3262.       var values = [];
  3263.       for (var i in this.inputs) {
  3264.         if (this.inputs.hasOwnProperty(i)) {
  3265.           if (!this.component.multiple) {
  3266.             return this.getValueAt(i);
  3267.           }
  3268.           values.push(this.getValueAt(i));
  3269.         }
  3270.       }
  3271.       return values;
  3272.     }
  3273.  
  3274.     /**
  3275.      * Determine if the value of this component has changed.
  3276.      *
  3277.      * @param before
  3278.      * @param after
  3279.      * @return {boolean}
  3280.      */
  3281.  
  3282.   }, {
  3283.     key: 'hasChanged',
  3284.     value: function hasChanged(before, after) {
  3285.       if ((before === undefined || before === null) && (after === undefined || after === null)) {
  3286.         return false;
  3287.       }
  3288.       return !_lodash2.default.isEqual(before, after);
  3289.     }
  3290.  
  3291.     /**
  3292.      * Update the value on change.
  3293.      *
  3294.      * @param flags
  3295.      * @param changed
  3296.      */
  3297.  
  3298.   }, {
  3299.     key: 'updateOnChange',
  3300.     value: function updateOnChange(flags, changed) {
  3301.       delete flags.changed;
  3302.       if (!flags.noUpdateEvent && changed) {
  3303.         this.triggerChange(flags);
  3304.         return true;
  3305.       }
  3306.       return false;
  3307.     }
  3308.  
  3309.     /**
  3310.      * Update a value of this component.
  3311.      *
  3312.      * @param flags
  3313.      */
  3314.  
  3315.   }, {
  3316.     key: 'updateValue',
  3317.     value: function updateValue(flags) {
  3318.       if (!this.hasInput) {
  3319.         return false;
  3320.       }
  3321.  
  3322.       flags = flags || {};
  3323.       var value = this.getValue(flags);
  3324.       var changed = flags.changed || this.hasChanged(value, this.dataValue);
  3325.       this.dataValue = value;
  3326.       if (this.viewOnly) {
  3327.         this.updateViewOnlyValue(value);
  3328.       }
  3329.  
  3330.       this.updateOnChange(flags, changed);
  3331.       return changed;
  3332.     }
  3333.  
  3334.     /**
  3335.      * Restore the value of a control.
  3336.      */
  3337.  
  3338.   }, {
  3339.     key: 'restoreValue',
  3340.     value: function restoreValue() {
  3341.       if (this.hasValue) {
  3342.         this.setValue(this.dataValue, {
  3343.           noUpdateEvent: true
  3344.         });
  3345.       } else {
  3346.         var defaultValue = this.defaultValue;
  3347.         if (defaultValue) {
  3348.           this.setValue(defaultValue, {
  3349.             noUpdateEvent: true
  3350.           });
  3351.         }
  3352.       }
  3353.     }
  3354.  
  3355.     /**
  3356.      * Perform a calculated value operation.
  3357.      *
  3358.      * @param data - The global data object.
  3359.      *
  3360.      * @return {boolean} - If the value changed during calculation.
  3361.      */
  3362.  
  3363.   }, {
  3364.     key: 'calculateValue',
  3365.     value: function calculateValue(data, flags) {
  3366.       if (!this.component.calculateValue) {
  3367.         return false;
  3368.       }
  3369.  
  3370.       flags = flags || {};
  3371.       flags.noCheck = true;
  3372.       var changed = false;
  3373.  
  3374.       if (typeof this.component.calculateValue === 'string') {
  3375.         try {
  3376.           var value = new Function('component', 'row', 'data', 'value = []; ' + this.component.calculateValue + '; return value;')(this, this.data, data);
  3377.           changed = this.setValue(value, flags);
  3378.         } catch (err) {
  3379.           /* eslint-disable no-console */
  3380.           console.warn('An error occurred calculating a value for ' + this.component.key, err);
  3381.           changed = false;
  3382.           /* eslint-enable no-console */
  3383.         }
  3384.       } else {
  3385.         try {
  3386.           var val = _utils2.default.jsonLogic.apply(this.component.calculateValue, {
  3387.             data: data,
  3388.             row: this.data,
  3389.             _: _lodash2.default
  3390.           });
  3391.           changed = this.setValue(val, flags);
  3392.         } catch (err) {
  3393.           /* eslint-disable no-console */
  3394.           console.warn('An error occurred calculating a value for ' + this.component.key, err);
  3395.           changed = false;
  3396.           /* eslint-enable no-console */
  3397.         }
  3398.       }
  3399.  
  3400.       return changed;
  3401.     }
  3402.  
  3403.     /**
  3404.      * Get this component's label text.
  3405.      *
  3406.      */
  3407.  
  3408.   }, {
  3409.     key: 'getRoot',
  3410.  
  3411.     /**
  3412.      * Get FormioForm element at the root of this component tree.
  3413.      *
  3414.      */
  3415.     value: function getRoot() {
  3416.       return this.root;
  3417.     }
  3418.  
  3419.     /**
  3420.      * Returns the invalid message, or empty string if the component is valid.
  3421.      *
  3422.      * @param data
  3423.      * @param dirty
  3424.      * @return {*}
  3425.      */
  3426.  
  3427.   }, {
  3428.     key: 'invalidMessage',
  3429.     value: function invalidMessage(data, dirty) {
  3430.       // No need to check for errors if there is no input or if it is pristine.
  3431.       if (!this.hasInput || !dirty && this.pristine) {
  3432.         return '';
  3433.       }
  3434.  
  3435.       return _Validator.Validator.check(this, data);
  3436.     }
  3437.  
  3438.     /**
  3439.      * Returns if the component is valid or not.
  3440.      *
  3441.      * @param data
  3442.      * @param dirty
  3443.      * @return {boolean}
  3444.      */
  3445.  
  3446.   }, {
  3447.     key: 'isValid',
  3448.     value: function isValid(data, dirty) {
  3449.       return !this.invalidMessage(data, dirty);
  3450.     }
  3451.   }, {
  3452.     key: 'checkValidity',
  3453.     value: function checkValidity(data, dirty) {
  3454.       // Force valid if component is conditionally hidden.
  3455.       if (!_utils2.default.checkCondition(this.component, data, this.data)) {
  3456.         return true;
  3457.       }
  3458.  
  3459.       var message = this.invalid || this.invalidMessage(data, dirty);
  3460.       this.setCustomValidity(message, dirty);
  3461.       return message ? false : true;
  3462.     }
  3463.   }, {
  3464.     key: 'getRawValue',
  3465.     value: function getRawValue() {
  3466.       console.warn('component.getRawValue() has been deprecated. Use component.validationValue or component.dataValue instead.');
  3467.       return this.validationValue;
  3468.     }
  3469.   }, {
  3470.     key: 'isEmpty',
  3471.     value: function isEmpty(value) {
  3472.       return value == null || value.length === 0;
  3473.     }
  3474.  
  3475.     /**
  3476.      * Check if a component is eligible for multiple validation
  3477.      *
  3478.      * @return {boolean}
  3479.      */
  3480.  
  3481.   }, {
  3482.     key: 'validateMultiple',
  3483.     value: function validateMultiple(value) {
  3484.       return this.component.multiple && Array.isArray(value);
  3485.     }
  3486.   }, {
  3487.     key: 'interpolate',
  3488.     value: function interpolate(string, data) {
  3489.       return _utils2.default.interpolate(string, data);
  3490.     }
  3491.   }, {
  3492.     key: 'setCustomValidity',
  3493.     value: function setCustomValidity(message, dirty) {
  3494.       var _this11 = this;
  3495.  
  3496.       if (this.errorElement && this.errorContainer) {
  3497.         this.errorElement.innerHTML = '';
  3498.         this.removeChildFrom(this.errorElement, this.errorContainer);
  3499.       }
  3500.       this.removeClass(this.element, 'has-error');
  3501.       this.inputs.forEach(function (input) {
  3502.         return _this11.removeClass(input, 'is-invalid');
  3503.       });
  3504.       if (this.options.highlightErrors) {
  3505.         this.removeClass(this.element, 'alert alert-danger');
  3506.       }
  3507.       if (message) {
  3508.         this.error = {
  3509.           component: this.component,
  3510.           message: message
  3511.         };
  3512.         this.emit('componentError', this.error);
  3513.         this.createErrorElement();
  3514.         this.addInputError(message, dirty);
  3515.       } else {
  3516.         this.error = null;
  3517.       }
  3518.       _lodash2.default.each(this.inputs, function (input) {
  3519.         if (typeof input.setCustomValidity === 'function') {
  3520.           input.setCustomValidity(message, dirty);
  3521.         }
  3522.       });
  3523.     }
  3524.  
  3525.     /**
  3526.      * Set the value at a specific index.
  3527.      *
  3528.      * @param index
  3529.      * @param value
  3530.      */
  3531.  
  3532.   }, {
  3533.     key: 'setValueAt',
  3534.     value: function setValueAt(index, value) {
  3535.       if (value === null || value === undefined) {
  3536.         value = this.defaultValue;
  3537.       }
  3538.       if (this.inputs[index].mask) {
  3539.         this.inputs[index].mask.textMaskInputElement.update(value);
  3540.       } else {
  3541.         this.inputs[index].value = value;
  3542.       }
  3543.     }
  3544.   }, {
  3545.     key: 'getFlags',
  3546.     value: function getFlags() {
  3547.       return typeof arguments[1] === 'boolean' ? {
  3548.         noUpdateEvent: arguments[1],
  3549.         noValidate: arguments[2]
  3550.       } : arguments[1] || {};
  3551.     }
  3552.   }, {
  3553.     key: 'whenReady',
  3554.     value: function whenReady() {
  3555.       return _nativePromiseOnly2.default.resolve();
  3556.     }
  3557.  
  3558.     /**
  3559.      * Set the value of this component.
  3560.      *
  3561.      * @param value
  3562.      * @param flags
  3563.      *
  3564.      * @return {boolean} - If the value changed.
  3565.      */
  3566.  
  3567.   }, {
  3568.     key: 'setValue',
  3569.     value: function setValue(value, flags) {
  3570.       flags = this.getFlags.apply(this, arguments);
  3571.       if (!this.hasInput) {
  3572.         return false;
  3573.       }
  3574.       if (this.component.multiple && !Array.isArray(value)) {
  3575.         value = [value];
  3576.       }
  3577.       this.buildRows();
  3578.       var isArray = Array.isArray(value);
  3579.       for (var i in this.inputs) {
  3580.         if (this.inputs.hasOwnProperty(i)) {
  3581.           this.setValueAt(i, isArray ? value[i] : value);
  3582.         }
  3583.       }
  3584.       return this.updateValue(flags);
  3585.     }
  3586.  
  3587.     /**
  3588.      * Prints out the value of this component as a string value.
  3589.      */
  3590.  
  3591.   }, {
  3592.     key: 'asString',
  3593.     value: function asString(value) {
  3594.       value = value || this.getValue();
  3595.       return Array.isArray(value) ? value.join(', ') : value.toString();
  3596.     }
  3597.  
  3598.     /**
  3599.      * Return if the component is disabled.
  3600.      * @return {boolean}
  3601.      */
  3602.  
  3603.   }, {
  3604.     key: 'setDisabled',
  3605.     value: function setDisabled(element, disabled) {
  3606.       element.disabled = disabled;
  3607.       if (disabled) {
  3608.         element.setAttribute('disabled', 'disabled');
  3609.       } else {
  3610.         element.removeAttribute('disabled');
  3611.       }
  3612.     }
  3613.   }, {
  3614.     key: 'setLoading',
  3615.     value: function setLoading(element, loading) {
  3616.       if (element.loading === loading) {
  3617.         return;
  3618.       }
  3619.  
  3620.       element.loading = loading;
  3621.       if (!element.loader && loading) {
  3622.         element.loader = this.ce('i', {
  3623.           class: this.iconClass('refresh', true) + ' button-icon-right'
  3624.         });
  3625.       }
  3626.       if (element.loader) {
  3627.         if (loading) {
  3628.           this.appendTo(element.loader, element);
  3629.         } else {
  3630.           this.removeChildFrom(element.loader, element);
  3631.         }
  3632.       }
  3633.     }
  3634.   }, {
  3635.     key: 'selectOptions',
  3636.     value: function selectOptions(select, tag, options, defaultValue) {
  3637.       var _this12 = this;
  3638.  
  3639.       _lodash2.default.each(options, function (option) {
  3640.         var attrs = {
  3641.           value: option.value
  3642.         };
  3643.         if (defaultValue !== undefined && option.value === defaultValue) {
  3644.           attrs.selected = 'selected';
  3645.         }
  3646.         var optionElement = _this12.ce('option', attrs);
  3647.         optionElement.appendChild(_this12.text(option.label));
  3648.         select.appendChild(optionElement);
  3649.       });
  3650.     }
  3651.   }, {
  3652.     key: 'setSelectValue',
  3653.     value: function setSelectValue(select, value) {
  3654.       var options = select.querySelectorAll('option');
  3655.       _lodash2.default.each(options, function (option) {
  3656.         if (option.value === value) {
  3657.           option.setAttribute('selected', 'selected');
  3658.         } else {
  3659.           option.removeAttribute('selected');
  3660.         }
  3661.       });
  3662.       if (select.onchange) {
  3663.         select.onchange();
  3664.       }
  3665.       if (select.onselect) {
  3666.         select.onchange();
  3667.       }
  3668.     }
  3669.   }, {
  3670.     key: 'clear',
  3671.     value: function clear() {
  3672.       this.destroy();
  3673.       this.empty(this.getElement());
  3674.     }
  3675.   }, {
  3676.     key: 'appendTo',
  3677.     value: function appendTo(element, container) {
  3678.       if (container) {
  3679.         container.appendChild(element);
  3680.       }
  3681.     }
  3682.   }, {
  3683.     key: 'append',
  3684.     value: function append(element) {
  3685.       this.appendTo(element, this.element);
  3686.     }
  3687.   }, {
  3688.     key: 'prependTo',
  3689.     value: function prependTo(element, container) {
  3690.       if (container) {
  3691.         if (container.firstChild) {
  3692.           try {
  3693.             container.insertBefore(element, container.firstChild);
  3694.           } catch (err) {
  3695.             console.warn(err);
  3696.             container.appendChild(element);
  3697.           }
  3698.         } else {
  3699.           container.appendChild(element);
  3700.         }
  3701.       }
  3702.     }
  3703.   }, {
  3704.     key: 'prepend',
  3705.     value: function prepend(element) {
  3706.       this.prependTo(element, this.element);
  3707.     }
  3708.   }, {
  3709.     key: 'removeChildFrom',
  3710.     value: function removeChildFrom(element, container) {
  3711.       if (container && container.contains(element)) {
  3712.         try {
  3713.           container.removeChild(element);
  3714.         } catch (err) {
  3715.           console.warn(err);
  3716.         }
  3717.       }
  3718.     }
  3719.   }, {
  3720.     key: 'removeChild',
  3721.     value: function removeChild(element) {
  3722.       this.removeChildFrom(element, this.element);
  3723.     }
  3724.  
  3725.     /**
  3726.      * Get the element information.
  3727.      */
  3728.  
  3729.   }, {
  3730.     key: 'elementInfo',
  3731.     value: function elementInfo() {
  3732.       var attributes = {
  3733.         name: this.options.name,
  3734.         type: this.component.inputType || 'text',
  3735.         class: 'form-control',
  3736.         lang: this.options.language
  3737.       };
  3738.  
  3739.       if (this.component.placeholder) {
  3740.         attributes.placeholder = this.t(this.component.placeholder);
  3741.       }
  3742.  
  3743.       if (this.component.tabindex) {
  3744.         attributes.tabindex = this.component.tabindex;
  3745.       }
  3746.  
  3747.       return {
  3748.         type: 'input',
  3749.         component: this.component,
  3750.         changeEvent: 'change',
  3751.         attr: attributes
  3752.       };
  3753.     }
  3754.   }, {
  3755.     key: 'autofocus',
  3756.     value: function autofocus() {
  3757.       var _this13 = this;
  3758.  
  3759.       if (this.component.autofocus) {
  3760.         this.on('render', function () {
  3761.           return _this13.focus();
  3762.         }, true);
  3763.       }
  3764.     }
  3765.   }, {
  3766.     key: 'focus',
  3767.     value: function focus() {
  3768.       var input = this.inputs[0];
  3769.       if (input) {
  3770.         input.focus();
  3771.       }
  3772.     }
  3773.   }, {
  3774.     key: 'hasInput',
  3775.     get: function get() {
  3776.       return this.component.input || this.inputs.length;
  3777.     }
  3778.   }, {
  3779.     key: 'shouldDisable',
  3780.     get: function get() {
  3781.       return (this.options.readOnly || this.component.disabled) && !this.component.alwaysEnabled;
  3782.     }
  3783.   }, {
  3784.     key: 'viewOnly',
  3785.     get: function get() {
  3786.       return this.options.readOnly && this.options.viewAsHtml;
  3787.     }
  3788.   }, {
  3789.     key: 'defaultViewOnlyValue',
  3790.     get: function get() {
  3791.       return '-';
  3792.     }
  3793.   }, {
  3794.     key: 'className',
  3795.     get: function get() {
  3796.       var className = this.hasInput ? 'form-group has-feedback ' : '';
  3797.       className += 'formio-component formio-component-' + this.component.type + ' ';
  3798.       if (this.component.key) {
  3799.         className += 'formio-component-' + this.component.key + ' ';
  3800.       }
  3801.       if (this.component.customClass) {
  3802.         className += this.component.customClass;
  3803.       }
  3804.       if (this.hasInput && this.component.validate && this.component.validate.required) {
  3805.         className += ' required';
  3806.       }
  3807.       return className;
  3808.     }
  3809.  
  3810.     /**
  3811.      * Build the custom style from the layout values
  3812.      * @return {string} - The custom style
  3813.      */
  3814.  
  3815.   }, {
  3816.     key: 'customStyle',
  3817.     get: function get() {
  3818.       var customCSS = '';
  3819.       _lodash2.default.each(this.component.style, function (value, key) {
  3820.         if (value !== '') {
  3821.           customCSS += key + ':' + value + ';';
  3822.         }
  3823.       });
  3824.       return customCSS;
  3825.     }
  3826.   }, {
  3827.     key: 'defaultValue',
  3828.     get: function get() {
  3829.       var defaultValue = this.emptyValue;
  3830.       if (this.component.defaultValue) {
  3831.         defaultValue = this.component.defaultValue;
  3832.       } else if (this.component.customDefaultValue) {
  3833.         if (typeof this.component.customDefaultValue === 'string') {
  3834.           try {
  3835.             defaultValue = new Function('component', 'row', 'data', 'var value = \'\'; ' + this.component.customDefaultValue + '; return value;')(this, this.data, this.data);
  3836.           } catch (e) {
  3837.             defaultValue = null;
  3838.             /* eslint-disable no-console */
  3839.             console.warn('An error occurred getting default value for ' + this.component.key, e);
  3840.             /* eslint-enable no-console */
  3841.           }
  3842.         } else {
  3843.           try {
  3844.             defaultValue = _utils2.default.jsonLogic.apply(this.component.customDefaultValue, {
  3845.               data: this.data,
  3846.               row: this.data,
  3847.               _: _lodash2.default
  3848.             });
  3849.           } catch (err) {
  3850.             defaultValue = null;
  3851.             /* eslint-disable no-console */
  3852.             console.warn('An error occurred calculating a value for ' + this.component.key, err);
  3853.             /* eslint-enable no-console */
  3854.           }
  3855.         }
  3856.       }
  3857.  
  3858.       if (this._inputMask) {
  3859.         defaultValue = (0, _vanillaTextMask.conformToMask)(defaultValue, this._inputMask).conformedValue;
  3860.         if (!_utils2.default.matchInputMask(defaultValue, this._inputMask)) {
  3861.           defaultValue = '';
  3862.         }
  3863.       }
  3864.  
  3865.       // Clone so that it creates a new instance.
  3866.       return _lodash2.default.clone(defaultValue);
  3867.     }
  3868.   }, {
  3869.     key: 'name',
  3870.     get: function get() {
  3871.       return this.t(this.component.label || this.component.placeholder || this.component.key);
  3872.     }
  3873.  
  3874.     /**
  3875.      * Returns the error label for this component.
  3876.      * @return {*}
  3877.      */
  3878.  
  3879.   }, {
  3880.     key: 'errorLabel',
  3881.     get: function get() {
  3882.       return this.t(this.component.errorLabel || this.component.label || this.component.placeholder || this.component.key);
  3883.     }
  3884.   }, {
  3885.     key: 'visible',
  3886.     set: function set(visible) {
  3887.       this.show(visible);
  3888.     },
  3889.     get: function get() {
  3890.       return this._visible;
  3891.     }
  3892.   }, {
  3893.     key: 'emptyValue',
  3894.     get: function get() {
  3895.       return null;
  3896.     }
  3897.  
  3898.     /**
  3899.      * Returns if this component has a value set.
  3900.      *
  3901.      */
  3902.  
  3903.   }, {
  3904.     key: 'hasValue',
  3905.     get: function get() {
  3906.       return _lodash2.default.has(this.data, this.component.key);
  3907.     }
  3908.  
  3909.     /**
  3910.      * Get the value of this component.
  3911.      *
  3912.      * @return {*}
  3913.      */
  3914.  
  3915.   }, {
  3916.     key: 'value',
  3917.     get: function get() {
  3918.       return this.dataValue;
  3919.     }
  3920.  
  3921.     /**
  3922.      * Get the static value of this component.
  3923.      * @return {*}
  3924.      */
  3925.  
  3926.   }, {
  3927.     key: 'dataValue',
  3928.     get: function get() {
  3929.       if (!this.component.key) {
  3930.         return this.emptyValue;
  3931.       }
  3932.       if (!this.hasValue) {
  3933.         this.dataValue = this.emptyValue;
  3934.       }
  3935.       return _lodash2.default.get(this.data, this.component.key);
  3936.     }
  3937.  
  3938.     /**
  3939.      * Sets the static value of this component.
  3940.      *
  3941.      * @param value
  3942.      */
  3943.  
  3944.     , set: function set(value) {
  3945.       if (!this.component.key) {
  3946.         return value;
  3947.       }
  3948.       _lodash2.default.set(this.data, this.component.key, value);
  3949.       return value;
  3950.     }
  3951.   }, {
  3952.     key: 'label',
  3953.     get: function get() {
  3954.       return this.component.label;
  3955.     }
  3956.  
  3957.     /**
  3958.      * Set this component's label text and render it.
  3959.      *
  3960.      * @param value - The new label text.
  3961.      */
  3962.  
  3963.     , set: function set(value) {
  3964.       this.component.label = value;
  3965.       if (this.labelElement) {
  3966.         this.labelElement.innerText = value;
  3967.       }
  3968.     }
  3969.   }, {
  3970.     key: 'validationValue',
  3971.     get: function get() {
  3972.       return this.dataValue;
  3973.     }
  3974.   }, {
  3975.     key: 'errors',
  3976.     get: function get() {
  3977.       return this.error ? [this.error] : [];
  3978.     }
  3979.   }, {
  3980.     key: 'disabled',
  3981.     get: function get() {
  3982.       return this._disabled;
  3983.     }
  3984.  
  3985.     /**
  3986.      * Disable this component.
  3987.      *
  3988.      * @param {boolean} disabled
  3989.      */
  3990.  
  3991.     , set: function set(disabled) {
  3992.       var _this14 = this;
  3993.  
  3994.       // Do not allow a component to be disabled if it should be always...
  3995.       if (!disabled && this.shouldDisable) {
  3996.         return;
  3997.       }
  3998.  
  3999.       this._disabled = disabled;
  4000.  
  4001.       // Disable all inputs.
  4002.       _lodash2.default.each(this.inputs, function (input) {
  4003.         return _this14.setDisabled(input, disabled);
  4004.       });
  4005.     }
  4006.   }]);
  4007.  
  4008.   return BaseComponent;
  4009. }();
  4010.  
  4011. exports.BaseComponent = BaseComponent;
  4012.  
  4013. BaseComponent.externalLibraries = {};
  4014. BaseComponent.requireLibrary = function (name, property, src, polling) {
  4015.   if (!BaseComponent.externalLibraries.hasOwnProperty(name)) {
  4016.     BaseComponent.externalLibraries[name] = {};
  4017.     BaseComponent.externalLibraries[name].ready = new _nativePromiseOnly2.default(function (resolve, reject) {
  4018.       BaseComponent.externalLibraries[name].resolve = resolve;
  4019.       BaseComponent.externalLibraries[name].reject = reject;
  4020.     });
  4021.  
  4022.     var callbackName = name + 'Callback';
  4023.  
  4024.     if (!polling && !window[callbackName]) {
  4025.       window[callbackName] = function () {
  4026.         this.resolve();
  4027.       }.bind(BaseComponent.externalLibraries[name]);
  4028.     }
  4029.  
  4030.     // See if the plugin already exists.
  4031.     var plugin = _lodash2.default.get(window, property);
  4032.     if (plugin) {
  4033.       BaseComponent.externalLibraries[name].resolve(plugin);
  4034.     } else {
  4035.       src = Array.isArray(src) ? src : [src];
  4036.       src.forEach(function (lib) {
  4037.         var attrs = {};
  4038.         var elementType = '';
  4039.         if (typeof lib === 'string') {
  4040.           lib = {
  4041.             type: 'script',
  4042.             src: lib
  4043.           };
  4044.         }
  4045.         switch (lib.type) {
  4046.           case 'script':
  4047.             elementType = 'script';
  4048.             attrs = {
  4049.               src: lib.src,
  4050.               type: 'text/javascript',
  4051.               defer: true,
  4052.               async: true
  4053.             };
  4054.             break;
  4055.           case 'styles':
  4056.             elementType = 'link';
  4057.             attrs = {
  4058.               href: lib.src,
  4059.               rel: 'stylesheet'
  4060.             };
  4061.             break;
  4062.         }
  4063.  
  4064.         // Add the script to the top page.
  4065.         var script = document.createElement(elementType);
  4066.         for (var attr in attrs) {
  4067.           script.setAttribute(attr, attrs[attr]);
  4068.         }
  4069.         document.getElementsByTagName('head')[0].appendChild(script);
  4070.       });
  4071.  
  4072.       // if no callback is provided, then check periodically for the script.
  4073.       if (polling) {
  4074.         setTimeout(function checkLibrary() {
  4075.           var plugin = _lodash2.default.get(window, property);
  4076.           if (plugin) {
  4077.             BaseComponent.externalLibraries[name].resolve(plugin);
  4078.           } else {
  4079.             // check again after 200 ms.
  4080.             setTimeout(checkLibrary, 200);
  4081.           }
  4082.         }, 200);
  4083.       }
  4084.     }
  4085.   }
  4086.   return BaseComponent.externalLibraries[name].ready;
  4087. };
  4088.  
  4089. BaseComponent.libraryReady = function (name) {
  4090.   if (BaseComponent.externalLibraries.hasOwnProperty(name) && BaseComponent.externalLibraries[name].ready) {
  4091.     return BaseComponent.externalLibraries[name].ready;
  4092.   }
  4093.  
  4094.   return _nativePromiseOnly2.default.reject(name + ' library was not required.');
  4095. };
  4096.  
  4097. },{"../../utils":56,"../Validator":2,"i18next":77,"lodash":79,"native-promise-only":81,"tooltip.js":87,"vanilla-text-mask":88}],5:[function(require,module,exports){
  4098. 'use strict';
  4099.  
  4100. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  4101.  
  4102. Object.defineProperty(exports, "__esModule", {
  4103.   value: true
  4104. });
  4105. exports.ButtonComponent = undefined;
  4106.  
  4107. var _createClass = function () {
  4108.   function defineProperties(target, props) {
  4109.     for (var i = 0; i < props.length; i++) {
  4110.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  4111.     }
  4112.   }return function (Constructor, protoProps, staticProps) {
  4113.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  4114.   };
  4115. }();
  4116.  
  4117. var _set = function set(object, property, value, receiver) {
  4118.   var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  4119.     var parent = Object.getPrototypeOf(object);if (parent !== null) {
  4120.       set(parent, property, value, receiver);
  4121.     }
  4122.   } else if ("value" in desc && desc.writable) {
  4123.     desc.value = value;
  4124.   } else {
  4125.     var setter = desc.set;if (setter !== undefined) {
  4126.       setter.call(receiver, value);
  4127.     }
  4128.   }return value;
  4129. };
  4130.  
  4131. var _get = function get(object, property, receiver) {
  4132.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  4133.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  4134.       return undefined;
  4135.     } else {
  4136.       return get(parent, property, receiver);
  4137.     }
  4138.   } else if ("value" in desc) {
  4139.     return desc.value;
  4140.   } else {
  4141.     var getter = desc.get;if (getter === undefined) {
  4142.       return undefined;
  4143.     }return getter.call(receiver);
  4144.   }
  4145. };
  4146.  
  4147. var _lodash = require('lodash');
  4148.  
  4149. var _lodash2 = _interopRequireDefault(_lodash);
  4150.  
  4151. var _Base = require('../base/Base');
  4152.  
  4153. var _utils = require('../../utils');
  4154.  
  4155. var _utils2 = _interopRequireDefault(_utils);
  4156.  
  4157. function _interopRequireDefault(obj) {
  4158.   return obj && obj.__esModule ? obj : { default: obj };
  4159. }
  4160.  
  4161. function _classCallCheck(instance, Constructor) {
  4162.   if (!(instance instanceof Constructor)) {
  4163.     throw new TypeError("Cannot call a class as a function");
  4164.   }
  4165. }
  4166.  
  4167. function _possibleConstructorReturn(self, call) {
  4168.   if (!self) {
  4169.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  4170.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  4171. }
  4172.  
  4173. function _inherits(subClass, superClass) {
  4174.   if (typeof superClass !== "function" && superClass !== null) {
  4175.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  4176.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  4177. }
  4178.  
  4179. var ButtonComponent = exports.ButtonComponent = function (_BaseComponent) {
  4180.   _inherits(ButtonComponent, _BaseComponent);
  4181.  
  4182.   function ButtonComponent() {
  4183.     _classCallCheck(this, ButtonComponent);
  4184.  
  4185.     return _possibleConstructorReturn(this, (ButtonComponent.__proto__ || Object.getPrototypeOf(ButtonComponent)).apply(this, arguments));
  4186.   }
  4187.  
  4188.   _createClass(ButtonComponent, [{
  4189.     key: 'elementInfo',
  4190.     value: function elementInfo() {
  4191.       var info = _get(ButtonComponent.prototype.__proto__ || Object.getPrototypeOf(ButtonComponent.prototype), 'elementInfo', this).call(this);
  4192.       info.type = 'button';
  4193.       info.attr.type = ['submit', 'saveState'].indexOf(this.component.action) !== -1 ? 'submit' : 'button';
  4194.       this.component.theme = this.component.theme || 'default';
  4195.       info.attr.class = 'btn btn-' + this.component.theme;
  4196.       if (this.component.block) {
  4197.         info.attr.class += ' btn-block';
  4198.       }
  4199.       if (this.component.customClass) {
  4200.         info.attr.class += ' ' + this.component.customClass;
  4201.       }
  4202.       return info;
  4203.     }
  4204.   }, {
  4205.     key: 'getValue',
  4206.     value: function getValue() {
  4207.       return this.dataValue;
  4208.     }
  4209.   }, {
  4210.     key: 'build',
  4211.     value: function build() {
  4212.       var _this2 = this;
  4213.  
  4214.       if (this.viewOnly) {
  4215.         this.component.hidden = true;
  4216.       }
  4217.  
  4218.       this.dataValue = false;
  4219.       this.hasError = false;
  4220.       this.createElement();
  4221.       this.element.appendChild(this.button = this.ce(this.info.type, this.info.attr));
  4222.       this.addShortcut(this.button);
  4223.       this.hook('input', this.button, this.element);
  4224.  
  4225.       if (this.component.label) {
  4226.         this.labelElement = this.text(this.addShortcutToLabel());
  4227.         this.button.appendChild(this.labelElement);
  4228.         this.createTooltip(this.button, null, this.iconClass('question-sign'));
  4229.       }
  4230.       if (this.component.action === 'submit') {
  4231.         var errorContainer = this.ce('div', {
  4232.           class: 'has-error'
  4233.         });
  4234.         var error = this.ce('span', {
  4235.           class: 'help-block'
  4236.         });
  4237.         error.appendChild(this.text(this.errorMessage('error')));
  4238.         errorContainer.appendChild(error);
  4239.  
  4240.         this.on('submitButton', function () {
  4241.           _this2.loading = true;
  4242.           _this2.disabled = true;
  4243.         }, true);
  4244.         this.on('submitDone', function () {
  4245.           _this2.loading = false;
  4246.           _this2.disabled = false;
  4247.         }, true);
  4248.         this.on('change', function (value) {
  4249.           _this2.loading = false;
  4250.           var isValid = _this2.root.isValid(value.data, true);
  4251.           _this2.disabled = _this2.options.readOnly || _this2.component.disableOnInvalid && !isValid;
  4252.           if (isValid && _this2.hasError) {
  4253.             _this2.hasError = false;
  4254.             _this2.removeChild(errorContainer);
  4255.           }
  4256.         }, true);
  4257.         this.on('error', function () {
  4258.           _this2.loading = false;
  4259.           _this2.hasError = true;
  4260.           _this2.append(errorContainer);
  4261.         }, true);
  4262.       }
  4263.  
  4264.       if (this.component.action === 'url') {
  4265.         this.on('requestButton', function () {
  4266.           _this2.loading = true;
  4267.           _this2.disabled = true;
  4268.         }, true);
  4269.         this.on('requestDone', function () {
  4270.           _this2.loading = false;
  4271.           _this2.disabled = false;
  4272.         }, true);
  4273.         this.on('change', function (value) {
  4274.           _this2.loading = false;
  4275.           _this2.disabled = _this2.component.disableOnInvalid && !_this2.root.isValid(value.data, true);
  4276.         }, true);
  4277.         this.on('error', function () {
  4278.           _this2.loading = false;
  4279.         }, true);
  4280.       }
  4281.       this.addEventListener(this.button, 'click', function (event) {
  4282.         _this2.dataValue = true;
  4283.         switch (_this2.component.action) {
  4284.           case 'submit':
  4285.             event.preventDefault();
  4286.             event.stopPropagation();
  4287.             _this2.emit('submitButton', {
  4288.               state: _this2.component.state || 'submitted'
  4289.             });
  4290.             break;
  4291.           case 'event':
  4292.             _this2.emit(_this2.component.event, _this2.data);
  4293.             _this2.events.emit(_this2.component.event, _this2.data);
  4294.             _this2.emit('customEvent', {
  4295.               type: _this2.component.event,
  4296.               component: _this2.component,
  4297.               data: _this2.data,
  4298.               event: event
  4299.             });
  4300.             break;
  4301.           case 'custom':
  4302.             {
  4303.               // Get the FormioForm at the root of this component's tree
  4304.               var form = _this2.getRoot();
  4305.               // Get the form's flattened schema components
  4306.               var flattened = _utils2.default.flattenComponents(form.component.components, true);
  4307.               // Create object containing the corresponding HTML element components
  4308.               var components = {};
  4309.               _lodash2.default.each(flattened, function (component, key) {
  4310.                 var element = form.getComponent(key);
  4311.                 if (element) {
  4312.                   components[key] = element;
  4313.                 }
  4314.               });
  4315.  
  4316.               try {
  4317.                 new Function('form', 'flattened', 'components', '_merge', 'data', _this2.component.custom.toString())(form, flattened, components, _lodash2.default.merge, _this2.data);
  4318.               } catch (e) {
  4319.                 /* eslint-disable no-console */
  4320.                 console.warn('An error occurred evaluating custom logic for ' + _this2.key, e);
  4321.                 /* eslint-enable no-console */
  4322.               }
  4323.               break;
  4324.             }
  4325.           case 'url':
  4326.             _this2.emit('requestButton');
  4327.             _this2.emit('requestUrl', {
  4328.               url: _this2.component.url,
  4329.               headers: _this2.component.headers
  4330.             });
  4331.             break;
  4332.           case 'reset':
  4333.             _this2.emit('resetForm');
  4334.             break;
  4335.           case 'delete':
  4336.             _this2.emit('deleteSubmission');
  4337.             break;
  4338.           case 'oauth':
  4339.             if (_this2.root === _this2) {
  4340.               console.warn('You must add the OAuth button to a form for it to function properly');
  4341.               return;
  4342.             }
  4343.  
  4344.             // Display Alert if OAuth config is missing
  4345.             if (!_this2.component.oauth) {
  4346.               _this2.root.setAlert('danger', 'You must assign this button to an OAuth action before it will work.');
  4347.               break;
  4348.             }
  4349.  
  4350.             // Display Alert if oAuth has an error is missing
  4351.             if (_this2.component.oauth.error) {
  4352.               _this2.root.setAlert('danger', 'The Following Error Has Occured' + _this2.component.oauth.error);
  4353.               break;
  4354.             }
  4355.  
  4356.             _this2.openOauth(_this2.component.oauth);
  4357.  
  4358.             break;
  4359.         }
  4360.       });
  4361.       if (this.shouldDisable) {
  4362.         this.disabled = true;
  4363.       }
  4364.  
  4365.       function getUrlParameter(name) {
  4366.         name = name.replace(/[[]/, '\\[').replace(/[\]]/, '\\]');
  4367.         var regex = new RegExp('[\\?&]' + name + '=([^&#]*)');
  4368.         var results = regex.exec(location.search);
  4369.         return results === null ? '' : decodeURIComponent(results[1].replace(/\+/g, ' '));
  4370.       }
  4371.  
  4372.       // If this is an OpenID Provider initiated login, perform the click event immediately
  4373.       if (this.component.action === 'oauth' && this.component.oauth.authURI.indexOf(getUrlParameter('iss')) === 0) {
  4374.         this.openOauth();
  4375.       }
  4376.  
  4377.       this.autofocus();
  4378.     }
  4379.   }, {
  4380.     key: 'openOauth',
  4381.     value: function openOauth() {
  4382.       var _this3 = this;
  4383.  
  4384.       if (!this.root.formio) {
  4385.         console.warn('You must attach a Form API url to your form in order to use OAuth buttons.');
  4386.         return;
  4387.       }
  4388.  
  4389.       var settings = this.component.oauth;
  4390.  
  4391.       /*eslint-disable camelcase */
  4392.       var params = {
  4393.         response_type: 'code',
  4394.         client_id: settings.clientId,
  4395.         redirect_uri: window.location.origin || window.location.protocol + '//' + window.location.host,
  4396.         state: settings.state,
  4397.         scope: settings.scope
  4398.       };
  4399.       /*eslint-enable camelcase */
  4400.  
  4401.       // Make display optional.
  4402.       if (settings.display) {
  4403.         params.display = settings.display;
  4404.       }
  4405.  
  4406.       params = Object.keys(params).map(function (key) {
  4407.         return key + '=' + encodeURIComponent(params[key]);
  4408.       }).join('&');
  4409.  
  4410.       var url = settings.authURI + '?' + params;
  4411.       var popup = window.open(url, settings.provider, 'width=1020,height=618');
  4412.  
  4413.       var interval = setInterval(function () {
  4414.         try {
  4415.           var popupHost = popup.location.host;
  4416.           var currentHost = window.location.host;
  4417.           if (popup && !popup.closed && popupHost === currentHost && popup.location.search) {
  4418.             popup.close();
  4419.             var _params = popup.location.search.substr(1).split('&').reduce(function (params, param) {
  4420.               var split = param.split('=');
  4421.               params[split[0]] = split[1];
  4422.               return params;
  4423.             }, {});
  4424.             if (_params.error) {
  4425.               alert(_params.error_description || _params.error);
  4426.               _this3.root.setAlert('danger', _params.error_description || _params.error);
  4427.               return;
  4428.             }
  4429.             // TODO: check for error response here
  4430.             if (settings.state !== _params.state) {
  4431.               _this3.root.setAlert('danger', 'OAuth state does not match. Please try logging in again.');
  4432.               return;
  4433.             }
  4434.             var submission = { data: {}, oauth: {} };
  4435.             submission.oauth[settings.provider] = _params;
  4436.             submission.oauth[settings.provider].redirectURI = window.location.origin || window.location.protocol + '//' + window.location.host;
  4437.             _this3.root.formio.saveSubmission(submission).then(function (result) {
  4438.               _this3.root.onSubmit(result, true);
  4439.             }).catch(function (err) {
  4440.               _this3.root.onSubmissionError(err);
  4441.             });
  4442.           }
  4443.         } catch (error) {
  4444.           if (error.name !== 'SecurityError') {
  4445.             _this3.root.setAlert('danger', error.message || error);
  4446.           }
  4447.         }
  4448.         if (!popup || popup.closed || popup.closed === undefined) {
  4449.           clearInterval(interval);
  4450.         }
  4451.       }, 100);
  4452.     }
  4453.   }, {
  4454.     key: 'destroy',
  4455.     value: function destroy() {
  4456.       _get(ButtonComponent.prototype.__proto__ || Object.getPrototypeOf(ButtonComponent.prototype), 'destroy', this).apply(this, Array.prototype.slice.apply(arguments));
  4457.       this.removeShortcut(this.element);
  4458.     }
  4459.   }, {
  4460.     key: 'focus',
  4461.     value: function focus() {
  4462.       this.button.focus();
  4463.     }
  4464.   }, {
  4465.     key: 'loading',
  4466.     set: function set(loading) {
  4467.       this.setLoading(this.button, loading);
  4468.     }
  4469.   }, {
  4470.     key: 'disabled',
  4471.     set: function set(disabled) {
  4472.       _set(ButtonComponent.prototype.__proto__ || Object.getPrototypeOf(ButtonComponent.prototype), 'disabled', disabled, this);
  4473.       this.setDisabled(this.button, disabled);
  4474.     }
  4475.   }, {
  4476.     key: 'emptyValue',
  4477.     get: function get() {
  4478.       return false;
  4479.     }
  4480.   }, {
  4481.     key: 'clicked',
  4482.     get: function get() {
  4483.       return this.dataValue;
  4484.     }
  4485.   }, {
  4486.     key: 'defaultValue',
  4487.     get: function get() {
  4488.       return false;
  4489.     }
  4490.   }, {
  4491.     key: 'dataValue',
  4492.     set: function set(value) {
  4493.       if (!this.component.input) {
  4494.         return;
  4495.       }
  4496.       _set(ButtonComponent.prototype.__proto__ || Object.getPrototypeOf(ButtonComponent.prototype), 'dataValue', value, this);
  4497.     }
  4498.   }, {
  4499.     key: 'className',
  4500.     get: function get() {
  4501.       var className = _get(ButtonComponent.prototype.__proto__ || Object.getPrototypeOf(ButtonComponent.prototype), 'className', this);
  4502.       className += ' form-group';
  4503.       return className;
  4504.     }
  4505.   }]);
  4506.  
  4507.   return ButtonComponent;
  4508. }(_Base.BaseComponent);
  4509.  
  4510. },{"../../utils":56,"../base/Base":4,"lodash":79}],6:[function(require,module,exports){
  4511. 'use strict';
  4512.  
  4513. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  4514.  
  4515. Object.defineProperty(exports, "__esModule", {
  4516.   value: true
  4517. });
  4518. exports.CheckBoxComponent = undefined;
  4519.  
  4520. var _createClass = function () {
  4521.   function defineProperties(target, props) {
  4522.     for (var i = 0; i < props.length; i++) {
  4523.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  4524.     }
  4525.   }return function (Constructor, protoProps, staticProps) {
  4526.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  4527.   };
  4528. }();
  4529.  
  4530. var _set = function set(object, property, value, receiver) {
  4531.   var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  4532.     var parent = Object.getPrototypeOf(object);if (parent !== null) {
  4533.       set(parent, property, value, receiver);
  4534.     }
  4535.   } else if ("value" in desc && desc.writable) {
  4536.     desc.value = value;
  4537.   } else {
  4538.     var setter = desc.set;if (setter !== undefined) {
  4539.       setter.call(receiver, value);
  4540.     }
  4541.   }return value;
  4542. };
  4543.  
  4544. var _get = function get(object, property, receiver) {
  4545.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  4546.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  4547.       return undefined;
  4548.     } else {
  4549.       return get(parent, property, receiver);
  4550.     }
  4551.   } else if ("value" in desc) {
  4552.     return desc.value;
  4553.   } else {
  4554.     var getter = desc.get;if (getter === undefined) {
  4555.       return undefined;
  4556.     }return getter.call(receiver);
  4557.   }
  4558. };
  4559.  
  4560. var _lodash = require('lodash');
  4561.  
  4562. var _lodash2 = _interopRequireDefault(_lodash);
  4563.  
  4564. var _Base = require('../base/Base');
  4565.  
  4566. function _interopRequireDefault(obj) {
  4567.   return obj && obj.__esModule ? obj : { default: obj };
  4568. }
  4569.  
  4570. function _classCallCheck(instance, Constructor) {
  4571.   if (!(instance instanceof Constructor)) {
  4572.     throw new TypeError("Cannot call a class as a function");
  4573.   }
  4574. }
  4575.  
  4576. function _possibleConstructorReturn(self, call) {
  4577.   if (!self) {
  4578.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  4579.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  4580. }
  4581.  
  4582. function _inherits(subClass, superClass) {
  4583.   if (typeof superClass !== "function" && superClass !== null) {
  4584.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  4585.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  4586. }
  4587.  
  4588. var CheckBoxComponent = exports.CheckBoxComponent = function (_BaseComponent) {
  4589.   _inherits(CheckBoxComponent, _BaseComponent);
  4590.  
  4591.   function CheckBoxComponent() {
  4592.     _classCallCheck(this, CheckBoxComponent);
  4593.  
  4594.     return _possibleConstructorReturn(this, (CheckBoxComponent.__proto__ || Object.getPrototypeOf(CheckBoxComponent)).apply(this, arguments));
  4595.   }
  4596.  
  4597.   _createClass(CheckBoxComponent, [{
  4598.     key: 'elementInfo',
  4599.     value: function elementInfo() {
  4600.       var info = _get(CheckBoxComponent.prototype.__proto__ || Object.getPrototypeOf(CheckBoxComponent.prototype), 'elementInfo', this).call(this);
  4601.       info.type = 'input';
  4602.       info.changeEvent = 'click';
  4603.       info.attr.type = this.component.inputType;
  4604.       info.attr.class = 'form-check-input';
  4605.       if (this.component.name) {
  4606.         info.attr.name = 'data[' + this.component.name + ']';
  4607.       }
  4608.       info.attr.value = this.component.value ? this.component.value : 0;
  4609.       return info;
  4610.     }
  4611.   }, {
  4612.     key: 'build',
  4613.     value: function build() {
  4614.       if (this.viewOnly) {
  4615.         return this.viewOnlyBuild();
  4616.       }
  4617.  
  4618.       if (!this.component.input) {
  4619.         return;
  4620.       }
  4621.       this.createElement();
  4622.       this.input = this.createInput(this.element);
  4623.       this.createLabel(this.element, this.input);
  4624.       if (!this.labelElement) {
  4625.         this.addInput(this.input, this.element);
  4626.       }
  4627.       this.createDescription(this.element);
  4628.       this.restoreValue();
  4629.       if (this.shouldDisable) {
  4630.         this.disabled = true;
  4631.       }
  4632.       this.autofocus();
  4633.     }
  4634.   }, {
  4635.     key: 'createElement',
  4636.     value: function createElement() {
  4637.       var className = 'form-check ' + this.className;
  4638.       if (this.component.label) {
  4639.         className += ' checkbox';
  4640.       }
  4641.       this.element = this.ce('div', {
  4642.         id: this.id,
  4643.         class: className
  4644.       });
  4645.     }
  4646.   }, {
  4647.     key: 'labelOnTheTopOrLeft',
  4648.     value: function labelOnTheTopOrLeft() {
  4649.       return ['top', 'left'].indexOf(this.component.labelPosition) !== -1;
  4650.     }
  4651.   }, {
  4652.     key: 'labelOnTheTopOrBottom',
  4653.     value: function labelOnTheTopOrBottom() {
  4654.       return ['top', 'bottom'].indexOf(this.component.labelPosition) !== -1;
  4655.     }
  4656.   }, {
  4657.     key: 'setInputLabelStyle',
  4658.     value: function setInputLabelStyle(label) {
  4659.       if (this.component.labelPosition === 'left') {
  4660.         _lodash2.default.assign(label.style, {
  4661.           textAlign: 'center',
  4662.           paddingLeft: 0
  4663.         });
  4664.       }
  4665.  
  4666.       if (this.labelOnTheTopOrBottom()) {
  4667.         _lodash2.default.assign(label.style, {
  4668.           display: 'block',
  4669.           textAlign: 'center',
  4670.           paddingLeft: 0
  4671.         });
  4672.       }
  4673.     }
  4674.   }, {
  4675.     key: 'setInputStyle',
  4676.     value: function setInputStyle(input) {
  4677.       if (this.component.labelPosition === 'left') {
  4678.         _lodash2.default.assign(input.style, {
  4679.           position: 'initial',
  4680.           marginLeft: '7px'
  4681.         });
  4682.       }
  4683.  
  4684.       if (this.labelOnTheTopOrBottom()) {
  4685.         _lodash2.default.assign(input.style, {
  4686.           width: '100%',
  4687.           position: 'initial',
  4688.           marginLeft: 0
  4689.         });
  4690.       }
  4691.     }
  4692.   }, {
  4693.     key: 'isEmpty',
  4694.     value: function isEmpty(value) {
  4695.       return _get(CheckBoxComponent.prototype.__proto__ || Object.getPrototypeOf(CheckBoxComponent.prototype), 'isEmpty', this).call(this, value) || value === false;
  4696.     }
  4697.   }, {
  4698.     key: 'createLabel',
  4699.     value: function createLabel(container, input) {
  4700.       if (!this.component.label) {
  4701.         return null;
  4702.       }
  4703.  
  4704.       var className = 'control-label form-check-label';
  4705.       if (this.component.input && !this.options.inputsOnly && this.component.validate && this.component.validate.required) {
  4706.         className += ' field-required';
  4707.       }
  4708.  
  4709.       this.labelElement = this.ce('label', {
  4710.         class: className
  4711.       });
  4712.       this.addShortcut();
  4713.  
  4714.       var labelOnTheTopOrOnTheLeft = this.labelOnTheTopOrLeft();
  4715.  
  4716.       // Create the SPAN around the textNode for better style hooks
  4717.       this.labelSpan = this.ce('span');
  4718.  
  4719.       if (this.info.attr.id) {
  4720.         this.labelElement.setAttribute('for', this.info.attr.id);
  4721.       }
  4722.       if (!this.options.inputsOnly && labelOnTheTopOrOnTheLeft) {
  4723.         this.setInputLabelStyle(this.labelElement);
  4724.         this.setInputStyle(input);
  4725.         this.labelSpan.appendChild(this.text(this.component.label));
  4726.         this.labelElement.appendChild(this.labelSpan);
  4727.       }
  4728.       this.addInput(input, this.labelElement);
  4729.  
  4730.       if (!this.options.inputsOnly && !labelOnTheTopOrOnTheLeft) {
  4731.         this.setInputLabelStyle(this.labelElement);
  4732.         this.setInputStyle(input);
  4733.         this.labelSpan.appendChild(this.text(this.addShortcutToLabel()));
  4734.         this.labelElement.appendChild(this.labelSpan);
  4735.       }
  4736.       this.createTooltip(this.labelElement);
  4737.       container.appendChild(this.labelElement);
  4738.     }
  4739.   }, {
  4740.     key: 'createInput',
  4741.     value: function createInput(container) {
  4742.       if (!this.component.input) {
  4743.         return;
  4744.       }
  4745.       var input = this.ce(this.info.type, this.info.attr);
  4746.       this.errorContainer = container;
  4747.       return input;
  4748.     }
  4749.   }, {
  4750.     key: 'updateValueByName',
  4751.     value: function updateValueByName() {
  4752.       var component = this.getRoot().getComponent(this.component.name);
  4753.       if (component) {
  4754.         component.setValue(this.component.value, { changed: true });
  4755.       } else {
  4756.         _lodash2.default.set(this.data, this.component.name, this.component.value);
  4757.       }
  4758.     }
  4759.   }, {
  4760.     key: 'addInputEventListener',
  4761.     value: function addInputEventListener(input) {
  4762.       var _this2 = this;
  4763.  
  4764.       this.addEventListener(input, this.info.changeEvent, function () {
  4765.         // If this input has a "name", then its other input elements are elsewhere on
  4766.         // the form. To get the correct submission object, we need to refresh the whole
  4767.         // data object.
  4768.         if (_this2.component.name) {
  4769.           _this2.updateValueByName();
  4770.           _this2.emit('refreshData');
  4771.         }
  4772.  
  4773.         _this2.updateValue();
  4774.       });
  4775.     }
  4776.   }, {
  4777.     key: 'getValueAt',
  4778.     value: function getValueAt(index) {
  4779.       return !!this.inputs[index].checked;
  4780.     }
  4781.   }, {
  4782.     key: 'setValue',
  4783.     value: function setValue(value, flags) {
  4784.       flags = this.getFlags.apply(this, arguments);
  4785.       if (!this.input) {
  4786.         return;
  4787.       }
  4788.       if (value === 'on') {
  4789.         this.input.value = 1;
  4790.         this.input.checked = 1;
  4791.       } else if (value === 'off') {
  4792.         this.input.value = 0;
  4793.         this.input.checked = 0;
  4794.       } else if (value) {
  4795.         this.input.value = 1;
  4796.         this.input.checked = 1;
  4797.       } else {
  4798.         this.input.value = 0;
  4799.         this.input.checked = 0;
  4800.       }
  4801.       return this.updateValue(flags);
  4802.     }
  4803.   }, {
  4804.     key: 'getView',
  4805.     value: function getView(value) {
  4806.       return value ? 'Yes' : 'No';
  4807.     }
  4808.   }, {
  4809.     key: 'destroy',
  4810.     value: function destroy() {
  4811.       _get(CheckBoxComponent.prototype.__proto__ || Object.getPrototypeOf(CheckBoxComponent.prototype), 'destroy', this).apply(this, Array.prototype.slice.apply(arguments));
  4812.       this.removeShortcut();
  4813.     }
  4814.   }, {
  4815.     key: 'emptyValue',
  4816.     get: function get() {
  4817.       return false;
  4818.     }
  4819.   }, {
  4820.     key: 'dataValue',
  4821.     get: function get() {
  4822.       if (this.component.name) {
  4823.         return _lodash2.default.get(this.data, this.component.name, this.emptyValue);
  4824.       }
  4825.  
  4826.       return _get(CheckBoxComponent.prototype.__proto__ || Object.getPrototypeOf(CheckBoxComponent.prototype), 'dataValue', this);
  4827.     },
  4828.     set: function set(value) {
  4829.       if (this.component.name) {
  4830.         _lodash2.default.set(this.data, this.component.name, value);
  4831.         return value;
  4832.       }
  4833.  
  4834.       _set(CheckBoxComponent.prototype.__proto__ || Object.getPrototypeOf(CheckBoxComponent.prototype), 'dataValue', value, this);
  4835.       return value;
  4836.     }
  4837.   }]);
  4838.  
  4839.   return CheckBoxComponent;
  4840. }(_Base.BaseComponent);
  4841.  
  4842. },{"../base/Base":4,"lodash":79}],7:[function(require,module,exports){
  4843. 'use strict';
  4844.  
  4845. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  4846.  
  4847. Object.defineProperty(exports, "__esModule", {
  4848.   value: true
  4849. });
  4850. exports.ColumnComponent = undefined;
  4851.  
  4852. var _createClass = function () {
  4853.   function defineProperties(target, props) {
  4854.     for (var i = 0; i < props.length; i++) {
  4855.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  4856.     }
  4857.   }return function (Constructor, protoProps, staticProps) {
  4858.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  4859.   };
  4860. }();
  4861.  
  4862. var _Components = require('../Components');
  4863.  
  4864. function _classCallCheck(instance, Constructor) {
  4865.   if (!(instance instanceof Constructor)) {
  4866.     throw new TypeError("Cannot call a class as a function");
  4867.   }
  4868. }
  4869.  
  4870. function _possibleConstructorReturn(self, call) {
  4871.   if (!self) {
  4872.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  4873.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  4874. }
  4875.  
  4876. function _inherits(subClass, superClass) {
  4877.   if (typeof superClass !== "function" && superClass !== null) {
  4878.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  4879.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  4880. }
  4881.  
  4882. var ColumnComponent = exports.ColumnComponent = function (_FormioComponents) {
  4883.   _inherits(ColumnComponent, _FormioComponents);
  4884.  
  4885.   function ColumnComponent() {
  4886.     _classCallCheck(this, ColumnComponent);
  4887.  
  4888.     return _possibleConstructorReturn(this, (ColumnComponent.__proto__ || Object.getPrototypeOf(ColumnComponent)).apply(this, arguments));
  4889.   }
  4890.  
  4891.   _createClass(ColumnComponent, [{
  4892.     key: 'className',
  4893.     get: function get() {
  4894.       var comp = this.component;
  4895.       var width = ' col-sm-' + (comp.width ? comp.width : 6);
  4896.       var offset = ' col-sm-offset-' + (comp.offset ? comp.offset : 0);
  4897.       var push = ' col-sm-push-' + (comp.push ? comp.push : 0);
  4898.       var pull = ' col-sm-pull-' + (comp.pull ? comp.pull : 0);
  4899.       return 'col' + width + offset + push + pull;
  4900.     }
  4901.   }]);
  4902.  
  4903.   return ColumnComponent;
  4904. }(_Components.FormioComponents);
  4905.  
  4906. },{"../Components":1}],8:[function(require,module,exports){
  4907. 'use strict';
  4908.  
  4909. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  4910.  
  4911. Object.defineProperty(exports, "__esModule", {
  4912.   value: true
  4913. });
  4914. exports.ColumnsComponent = undefined;
  4915.  
  4916. var _createClass = function () {
  4917.   function defineProperties(target, props) {
  4918.     for (var i = 0; i < props.length; i++) {
  4919.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  4920.     }
  4921.   }return function (Constructor, protoProps, staticProps) {
  4922.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  4923.   };
  4924. }();
  4925.  
  4926. var _lodash = require('lodash');
  4927.  
  4928. var _lodash2 = _interopRequireDefault(_lodash);
  4929.  
  4930. var _Components = require('../Components');
  4931.  
  4932. function _interopRequireDefault(obj) {
  4933.   return obj && obj.__esModule ? obj : { default: obj };
  4934. }
  4935.  
  4936. function _classCallCheck(instance, Constructor) {
  4937.   if (!(instance instanceof Constructor)) {
  4938.     throw new TypeError("Cannot call a class as a function");
  4939.   }
  4940. }
  4941.  
  4942. function _possibleConstructorReturn(self, call) {
  4943.   if (!self) {
  4944.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  4945.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  4946. }
  4947.  
  4948. function _inherits(subClass, superClass) {
  4949.   if (typeof superClass !== "function" && superClass !== null) {
  4950.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  4951.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  4952. }
  4953.  
  4954. var ColumnsComponent = exports.ColumnsComponent = function (_FormioComponents) {
  4955.   _inherits(ColumnsComponent, _FormioComponents);
  4956.  
  4957.   function ColumnsComponent() {
  4958.     _classCallCheck(this, ColumnsComponent);
  4959.  
  4960.     return _possibleConstructorReturn(this, (ColumnsComponent.__proto__ || Object.getPrototypeOf(ColumnsComponent)).apply(this, arguments));
  4961.   }
  4962.  
  4963.   _createClass(ColumnsComponent, [{
  4964.     key: 'addComponents',
  4965.     value: function addComponents() {
  4966.       var _this2 = this;
  4967.  
  4968.       _lodash2.default.each(this.component.columns, function (column) {
  4969.         column.type = 'column';
  4970.         _this2.addComponent(column, _this2.element, _this2.data);
  4971.       });
  4972.     }
  4973.   }, {
  4974.     key: 'className',
  4975.     get: function get() {
  4976.       return 'row ' + this.component.customClass;
  4977.     }
  4978.   }]);
  4979.  
  4980.   return ColumnsComponent;
  4981. }(_Components.FormioComponents);
  4982.  
  4983. },{"../Components":1,"lodash":79}],9:[function(require,module,exports){
  4984. 'use strict';
  4985.  
  4986. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  4987.  
  4988. Object.defineProperty(exports, "__esModule", {
  4989.   value: true
  4990. });
  4991. exports.ContainerComponent = undefined;
  4992.  
  4993. var _createClass = function () {
  4994.   function defineProperties(target, props) {
  4995.     for (var i = 0; i < props.length; i++) {
  4996.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  4997.     }
  4998.   }return function (Constructor, protoProps, staticProps) {
  4999.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  5000.   };
  5001. }();
  5002.  
  5003. var _lodash = require('lodash');
  5004.  
  5005. var _lodash2 = _interopRequireDefault(_lodash);
  5006.  
  5007. var _Components = require('../Components');
  5008.  
  5009. function _interopRequireDefault(obj) {
  5010.   return obj && obj.__esModule ? obj : { default: obj };
  5011. }
  5012.  
  5013. function _classCallCheck(instance, Constructor) {
  5014.   if (!(instance instanceof Constructor)) {
  5015.     throw new TypeError("Cannot call a class as a function");
  5016.   }
  5017. }
  5018.  
  5019. function _possibleConstructorReturn(self, call) {
  5020.   if (!self) {
  5021.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  5022.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  5023. }
  5024.  
  5025. function _inherits(subClass, superClass) {
  5026.   if (typeof superClass !== "function" && superClass !== null) {
  5027.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  5028.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  5029. }
  5030.  
  5031. var ContainerComponent = exports.ContainerComponent = function (_FormioComponents) {
  5032.   _inherits(ContainerComponent, _FormioComponents);
  5033.  
  5034.   function ContainerComponent(component, options, data) {
  5035.     _classCallCheck(this, ContainerComponent);
  5036.  
  5037.     var _this = _possibleConstructorReturn(this, (ContainerComponent.__proto__ || Object.getPrototypeOf(ContainerComponent)).call(this, component, options, data));
  5038.  
  5039.     _this.type = 'container';
  5040.     return _this;
  5041.   }
  5042.  
  5043.   _createClass(ContainerComponent, [{
  5044.     key: 'build',
  5045.     value: function build() {
  5046.       this.element = this.ce('div', {
  5047.         class: 'formio-container-component ' + this.component.customClass
  5048.       });
  5049.       if (!this.hasValue) {
  5050.         this.dataValue = {};
  5051.       }
  5052.       this.addComponents(this.element, this.dataValue);
  5053.     }
  5054.   }, {
  5055.     key: 'getValue',
  5056.     value: function getValue() {
  5057.       if (this.viewOnly) {
  5058.         return this.dataValue;
  5059.       }
  5060.       var value = {};
  5061.       _lodash2.default.each(this.components, function (component) {
  5062.         return _lodash2.default.set(value, component.component.key, component.getValue());
  5063.       });
  5064.       return value;
  5065.     }
  5066.   }, {
  5067.     key: 'setValue',
  5068.     value: function setValue(value, flags) {
  5069.       flags = this.getFlags.apply(this, arguments);
  5070.       if (!value || !_lodash2.default.isObject(value)) {
  5071.         return;
  5072.       }
  5073.       if (this.hasValue && _lodash2.default.isEmpty(this.dataValue)) {
  5074.         flags.noValidate = true;
  5075.       }
  5076.       this.dataValue = value;
  5077.       _lodash2.default.each(this.components, function (component) {
  5078.         if (component.type === 'components') {
  5079.           component.setValue(value, flags);
  5080.         } else if (_lodash2.default.has(value, component.component.key)) {
  5081.           component.setValue(_lodash2.default.get(value, component.component.key), flags);
  5082.         } else {
  5083.           component.data = value;
  5084.           component.setValue(component.defaultValue, flags);
  5085.         }
  5086.       });
  5087.       this.updateValue(flags);
  5088.     }
  5089.   }, {
  5090.     key: 'emptyValue',
  5091.     get: function get() {
  5092.       return {};
  5093.     }
  5094.   }]);
  5095.  
  5096.   return ContainerComponent;
  5097. }(_Components.FormioComponents);
  5098.  
  5099. },{"../Components":1,"lodash":79}],10:[function(require,module,exports){
  5100. 'use strict';
  5101.  
  5102. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  5103.  
  5104. Object.defineProperty(exports, "__esModule", {
  5105.   value: true
  5106. });
  5107. exports.ContentComponent = undefined;
  5108.  
  5109. var _createClass = function () {
  5110.   function defineProperties(target, props) {
  5111.     for (var i = 0; i < props.length; i++) {
  5112.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  5113.     }
  5114.   }return function (Constructor, protoProps, staticProps) {
  5115.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  5116.   };
  5117. }();
  5118.  
  5119. var _Base = require('../base/Base');
  5120.  
  5121. function _classCallCheck(instance, Constructor) {
  5122.   if (!(instance instanceof Constructor)) {
  5123.     throw new TypeError("Cannot call a class as a function");
  5124.   }
  5125. }
  5126.  
  5127. function _possibleConstructorReturn(self, call) {
  5128.   if (!self) {
  5129.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  5130.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  5131. }
  5132.  
  5133. function _inherits(subClass, superClass) {
  5134.   if (typeof superClass !== "function" && superClass !== null) {
  5135.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  5136.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  5137. }
  5138.  
  5139. var ContentComponent = exports.ContentComponent = function (_BaseComponent) {
  5140.   _inherits(ContentComponent, _BaseComponent);
  5141.  
  5142.   function ContentComponent() {
  5143.     _classCallCheck(this, ContentComponent);
  5144.  
  5145.     return _possibleConstructorReturn(this, (ContentComponent.__proto__ || Object.getPrototypeOf(ContentComponent)).apply(this, arguments));
  5146.   }
  5147.  
  5148.   _createClass(ContentComponent, [{
  5149.     key: 'build',
  5150.     value: function build() {
  5151.       this.element = this.ce('div', {
  5152.         class: 'form-group ' + this.component.customClass
  5153.       });
  5154.       this.element.innerHTML = this.interpolate(this.component.html, { data: this.data });
  5155.     }
  5156.   }, {
  5157.     key: 'emptyValue',
  5158.     get: function get() {
  5159.       return '';
  5160.     }
  5161.   }]);
  5162.  
  5163.   return ContentComponent;
  5164. }(_Base.BaseComponent);
  5165.  
  5166. },{"../base/Base":4}],11:[function(require,module,exports){
  5167. 'use strict';
  5168.  
  5169. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  5170.  
  5171. Object.defineProperty(exports, "__esModule", {
  5172.   value: true
  5173. });
  5174. exports.CurrencyComponent = undefined;
  5175.  
  5176. var _createClass = function () {
  5177.   function defineProperties(target, props) {
  5178.     for (var i = 0; i < props.length; i++) {
  5179.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  5180.     }
  5181.   }return function (Constructor, protoProps, staticProps) {
  5182.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  5183.   };
  5184. }();
  5185.  
  5186. var _get = function get(object, property, receiver) {
  5187.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  5188.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  5189.       return undefined;
  5190.     } else {
  5191.       return get(parent, property, receiver);
  5192.     }
  5193.   } else if ("value" in desc) {
  5194.     return desc.value;
  5195.   } else {
  5196.     var getter = desc.get;if (getter === undefined) {
  5197.       return undefined;
  5198.     }return getter.call(receiver);
  5199.   }
  5200. };
  5201.  
  5202. var _vanillaTextMask = require('vanilla-text-mask');
  5203.  
  5204. var _vanillaTextMask2 = _interopRequireDefault(_vanillaTextMask);
  5205.  
  5206. var _textMaskAddons = require('text-mask-addons');
  5207.  
  5208. var _lodash = require('lodash');
  5209.  
  5210. var _lodash2 = _interopRequireDefault(_lodash);
  5211.  
  5212. var _utils = require('../../utils');
  5213.  
  5214. var _Number = require('../number/Number');
  5215.  
  5216. function _interopRequireDefault(obj) {
  5217.   return obj && obj.__esModule ? obj : { default: obj };
  5218. }
  5219.  
  5220. function _classCallCheck(instance, Constructor) {
  5221.   if (!(instance instanceof Constructor)) {
  5222.     throw new TypeError("Cannot call a class as a function");
  5223.   }
  5224. }
  5225.  
  5226. function _possibleConstructorReturn(self, call) {
  5227.   if (!self) {
  5228.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  5229.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  5230. }
  5231.  
  5232. function _inherits(subClass, superClass) {
  5233.   if (typeof superClass !== "function" && superClass !== null) {
  5234.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  5235.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  5236. }
  5237.  
  5238. var CurrencyComponent = exports.CurrencyComponent = function (_NumberComponent) {
  5239.   _inherits(CurrencyComponent, _NumberComponent);
  5240.  
  5241.   function CurrencyComponent(component, options, data) {
  5242.     _classCallCheck(this, CurrencyComponent);
  5243.  
  5244.     // Currency should default to have a delimiter unless otherwise specified.
  5245.     if (component && !component.hasOwnProperty('delimiter')) {
  5246.       component.delimiter = true;
  5247.     }
  5248.  
  5249.     var _this = _possibleConstructorReturn(this, (CurrencyComponent.__proto__ || Object.getPrototypeOf(CurrencyComponent)).call(this, component, options, data));
  5250.  
  5251.     _this.decimalLimit = _lodash2.default.get(_this.component, 'decimalLimit', 2);
  5252.     var affixes = (0, _utils.getCurrencyAffixes)({
  5253.       currency: _this.component.currency,
  5254.       decimalLimit: _this.decimalLimit,
  5255.       decimalSeparator: _this.decimalSeparator,
  5256.       lang: _this.options.language
  5257.     });
  5258.     _this.prefix = affixes.prefix;
  5259.     _this.suffix = affixes.suffix;
  5260.     return _this;
  5261.   }
  5262.  
  5263.   _createClass(CurrencyComponent, [{
  5264.     key: 'parseNumber',
  5265.     value: function parseNumber(value) {
  5266.       // Strip out the prefix and suffix before parsing.
  5267.       value = value.replace(this.prefix, '').replace(this.suffix, '');
  5268.  
  5269.       return _get(CurrencyComponent.prototype.__proto__ || Object.getPrototypeOf(CurrencyComponent.prototype), 'parseNumber', this).call(this, value);
  5270.     }
  5271.   }, {
  5272.     key: 'setInputMask',
  5273.     value: function setInputMask(input) {
  5274.       input.mask = (0, _vanillaTextMask2.default)({
  5275.         inputElement: input,
  5276.         mask: (0, _textMaskAddons.createNumberMask)({
  5277.           prefix: this.prefix,
  5278.           suffix: this.suffix,
  5279.           thousandsSeparatorSymbol: _lodash2.default.get(this.component, 'thousandsSeparator', this.delimiter),
  5280.           decimalSymbol: _lodash2.default.get(this.component, 'decimalSymbol', this.decimalSeparator),
  5281.           decimalLimit: this.decimalLimit,
  5282.           allowNegative: _lodash2.default.get(this.component, 'allowNegative', true),
  5283.           allowDecimal: _lodash2.default.get(this.component, 'allowDecimal', true)
  5284.         })
  5285.       });
  5286.     }
  5287.   }, {
  5288.     key: 'clearInput',
  5289.     value: function clearInput(input) {
  5290.       try {
  5291.         input = input.replace(this.prefix, '').replace(this.suffix, '');
  5292.       } catch (err) {
  5293.         // If value doesn't have a replace method, continue on as before.
  5294.       }
  5295.  
  5296.       return _get(CurrencyComponent.prototype.__proto__ || Object.getPrototypeOf(CurrencyComponent.prototype), 'clearInput', this).call(this, input);
  5297.     }
  5298.   }, {
  5299.     key: 'formatValue',
  5300.     value: function formatValue(value) {
  5301.       if (this.component.requireDecimals && value && !(value.indexOf(this.decimalSeparator) !== -1)) {
  5302.         return '' + value + this.decimalSeparator + _lodash2.default.repeat('0', this.decimalLimit);
  5303.       }
  5304.  
  5305.       return value;
  5306.     }
  5307.   }]);
  5308.  
  5309.   return CurrencyComponent;
  5310. }(_Number.NumberComponent);
  5311.  
  5312. },{"../../utils":56,"../number/Number":24,"lodash":79,"text-mask-addons":86,"vanilla-text-mask":88}],12:[function(require,module,exports){
  5313. 'use strict';
  5314.  
  5315. var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  5316.  
  5317. Object.defineProperty(exports, "__esModule", {
  5318.   value: true
  5319. });
  5320. exports.DataGridComponent = undefined;
  5321.  
  5322. var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
  5323.   return typeof obj === "undefined" ? "undefined" : _typeof2(obj);
  5324. } : function (obj) {
  5325.   return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof2(obj);
  5326. };
  5327.  
  5328. var _createClass = function () {
  5329.   function defineProperties(target, props) {
  5330.     for (var i = 0; i < props.length; i++) {
  5331.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  5332.     }
  5333.   }return function (Constructor, protoProps, staticProps) {
  5334.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  5335.   };
  5336. }();
  5337.  
  5338. var _get = function get(object, property, receiver) {
  5339.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  5340.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  5341.       return undefined;
  5342.     } else {
  5343.       return get(parent, property, receiver);
  5344.     }
  5345.   } else if ("value" in desc) {
  5346.     return desc.value;
  5347.   } else {
  5348.     var getter = desc.get;if (getter === undefined) {
  5349.       return undefined;
  5350.     }return getter.call(receiver);
  5351.   }
  5352. };
  5353.  
  5354. var _lodash = require('lodash');
  5355.  
  5356. var _lodash2 = _interopRequireDefault(_lodash);
  5357.  
  5358. var _Components = require('../Components');
  5359.  
  5360. function _interopRequireDefault(obj) {
  5361.   return obj && obj.__esModule ? obj : { default: obj };
  5362. }
  5363.  
  5364. function _classCallCheck(instance, Constructor) {
  5365.   if (!(instance instanceof Constructor)) {
  5366.     throw new TypeError("Cannot call a class as a function");
  5367.   }
  5368. }
  5369.  
  5370. function _possibleConstructorReturn(self, call) {
  5371.   if (!self) {
  5372.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  5373.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof2(call)) === "object" || typeof call === "function") ? call : self;
  5374. }
  5375.  
  5376. function _inherits(subClass, superClass) {
  5377.   if (typeof superClass !== "function" && superClass !== null) {
  5378.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof2(superClass)));
  5379.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  5380. }
  5381.  
  5382. var DataGridComponent = exports.DataGridComponent = function (_FormioComponents) {
  5383.   _inherits(DataGridComponent, _FormioComponents);
  5384.  
  5385.   function DataGridComponent(component, options, data) {
  5386.     _classCallCheck(this, DataGridComponent);
  5387.  
  5388.     var _this = _possibleConstructorReturn(this, (DataGridComponent.__proto__ || Object.getPrototypeOf(DataGridComponent)).call(this, component, options, data));
  5389.  
  5390.     _this.type = 'datagrid';
  5391.     _this.numRows = 0;
  5392.     _this.numColumns = 0;
  5393.     _this.rows = [];
  5394.     return _this;
  5395.   }
  5396.  
  5397.   _createClass(DataGridComponent, [{
  5398.     key: 'hasAddButton',
  5399.     value: function hasAddButton() {
  5400.       var maxLength = _lodash2.default.get(this.component, 'validate.maxLength');
  5401.       return !this.shouldDisable && (!maxLength || this.dataValue.length < maxLength);
  5402.     }
  5403.   }, {
  5404.     key: 'hasRemoveButtons',
  5405.     value: function hasRemoveButtons() {
  5406.       return !this.shouldDisable && this.dataValue.length > _lodash2.default.get(this.component, 'validate.minLength', 0);
  5407.     }
  5408.   }, {
  5409.     key: 'hasTopSubmit',
  5410.     value: function hasTopSubmit() {
  5411.       return this.hasAddButton() && ['top', 'both'].indexOf(this.addAnotherPosition) !== -1;
  5412.     }
  5413.   }, {
  5414.     key: 'hasBottomSubmit',
  5415.     value: function hasBottomSubmit() {
  5416.       return this.hasAddButton() && ['bottom', 'both'].indexOf(this.addAnotherPosition) !== -1;
  5417.     }
  5418.   }, {
  5419.     key: 'hasChanged',
  5420.     value: function hasChanged(before, after) {
  5421.       return !_lodash2.default.isEqual(before, after);
  5422.     }
  5423.   }, {
  5424.     key: 'build',
  5425.     value: function build() {
  5426.       this.createElement();
  5427.       this.createLabel(this.element);
  5428.       if (!this.dataValue.length) {
  5429.         this.addNewValue();
  5430.       }
  5431.       this.visibleColumns = true;
  5432.       this.errorContainer = this.element;
  5433.       this.buildRows();
  5434.       this.createDescription(this.element);
  5435.     }
  5436.   }, {
  5437.     key: 'setVisibleComponents',
  5438.     value: function setVisibleComponents() {
  5439.       var _this2 = this;
  5440.  
  5441.       // Add new values based on minLength.
  5442.       for (var dIndex = this.dataValue.length; dIndex < _lodash2.default.get(this.component, 'validate.minLength', 0); dIndex++) {
  5443.         this.dataValue.push({});
  5444.       }
  5445.  
  5446.       this.numColumns = this.hasRemoveButtons() ? 1 : 0;
  5447.       this.numRows = this.dataValue.length;
  5448.  
  5449.       if (this.visibleColumns === true) {
  5450.         this.numColumns += this.component.components.length;
  5451.         this.visibleComponents = this.component.components;
  5452.         return this.visibleComponents;
  5453.       }
  5454.  
  5455.       this.visibleComponents = _lodash2.default.filter(this.component.components, function (comp) {
  5456.         return _this2.visibleColumns[comp.key];
  5457.       });
  5458.       this.numColumns += this.visibleComponents.length;
  5459.     }
  5460.   }, {
  5461.     key: 'needsRebuild',
  5462.     value: function needsRebuild() {
  5463.       var previousNumColumns = this.numColumns;
  5464.       var previousNumRows = this.numRows;
  5465.       this.setVisibleComponents();
  5466.  
  5467.       if (!this.tableBuilt || this.numRows !== previousNumRows || this.numColumns !== previousNumColumns) {
  5468.         this.tableBuilt = true;
  5469.         return true;
  5470.       }
  5471.  
  5472.       // No need to rebuild since rows and columns are the same.
  5473.       return false;
  5474.     }
  5475.   }, {
  5476.     key: 'buildRows',
  5477.     value: function buildRows() {
  5478.       var _this3 = this;
  5479.  
  5480.       if (!this.needsRebuild()) {
  5481.         return;
  5482.       }
  5483.  
  5484.       this.clear();
  5485.       this.createLabel(this.element);
  5486.       var tableClass = 'table datagrid-table table-bordered form-group formio-data-grid ';
  5487.       _lodash2.default.each(['striped', 'bordered', 'hover', 'condensed'], function (prop) {
  5488.         if (_this3.component[prop]) {
  5489.           tableClass += 'table-' + prop + ' ';
  5490.         }
  5491.       });
  5492.       this.tableElement = this.ce('table', {
  5493.         class: tableClass
  5494.       });
  5495.  
  5496.       // Build the rows.
  5497.       var tableRows = [];
  5498.       this.dataValue.forEach(function (row, rowIndex) {
  5499.         return tableRows.push(_this3.buildRow(row, rowIndex));
  5500.       });
  5501.  
  5502.       // Create the header (must happen after build rows to get correct column length)
  5503.       this.tableElement.appendChild(this.createHeader());
  5504.       this.tableElement.appendChild(this.ce('tbody', null, tableRows));
  5505.  
  5506.       // Create the add row button footer element.
  5507.       if (this.hasBottomSubmit()) {
  5508.         this.tableElement.appendChild(this.ce('tfoot', null, this.ce('tr', null, this.ce('td', { colspan: this.numColumns }, this.addButton()))));
  5509.       }
  5510.  
  5511.       // Add the table to the element.
  5512.       this.element.appendChild(this.tableElement);
  5513.     }
  5514.  
  5515.     // Build the header.
  5516.  
  5517.   }, {
  5518.     key: 'createHeader',
  5519.     value: function createHeader() {
  5520.       var _this4 = this;
  5521.  
  5522.       var hasTopButton = this.hasTopSubmit();
  5523.       var hasEnd = this.hasRemoveButtons() || hasTopButton;
  5524.       return this.ce('thead', null, this.ce('tr', null, [this.visibleComponents.map(function (comp) {
  5525.         var th = _this4.ce('th');
  5526.         if (comp.validate && comp.validate.required) {
  5527.           th.setAttribute('class', 'field-required');
  5528.         }
  5529.         var title = comp.label || comp.title;
  5530.         if (title) {
  5531.           th.appendChild(_this4.text(title));
  5532.           _this4.createTooltip(th, comp);
  5533.         }
  5534.         return th;
  5535.       }), hasEnd ? this.ce('th', null, hasTopButton ? this.addButton(true) : null) : null]));
  5536.     }
  5537.   }, {
  5538.     key: 'buildRow',
  5539.     value: function buildRow(row, index) {
  5540.       var _this5 = this;
  5541.  
  5542.       this.rows[index] = {};
  5543.       return this.ce('tr', null, [this.component.components.map(function (col, colIndex) {
  5544.         return _this5.buildComponent(col, colIndex, row, index);
  5545.       }), this.hasRemoveButtons() ? this.ce('td', null, this.removeButton(index)) : null]);
  5546.     }
  5547.   }, {
  5548.     key: 'destroy',
  5549.     value: function destroy(all) {
  5550.       var _this6 = this;
  5551.  
  5552.       _get(DataGridComponent.prototype.__proto__ || Object.getPrototypeOf(DataGridComponent.prototype), 'destroy', this).call(this, all);
  5553.       _lodash2.default.each(this.rows, function (row) {
  5554.         return _lodash2.default.each(row, function (col) {
  5555.           return _this6.removeComponent(col, row);
  5556.         });
  5557.       });
  5558.       this.rows = [];
  5559.     }
  5560.   }, {
  5561.     key: 'buildComponent',
  5562.     value: function buildComponent(col, colIndex, row, rowIndex) {
  5563.       var column = _lodash2.default.cloneDeep(col);
  5564.       column.label = false;
  5565.       column.row = rowIndex + '-' + colIndex;
  5566.       var options = _lodash2.default.clone(this.options);
  5567.       options.name += '[' + colIndex + ']';
  5568.       var comp = this.createComponent(column, options, row);
  5569.       this.rows[rowIndex][column.key] = comp;
  5570.       if (this.visibleColumns === true || this.visibleColumns[column.key]) {
  5571.         return this.ce('td', null, comp.element);
  5572.       }
  5573.     }
  5574.   }, {
  5575.     key: 'checkConditions',
  5576.     value: function checkConditions(data) {
  5577.       var _this7 = this;
  5578.  
  5579.       var show = _get(DataGridComponent.prototype.__proto__ || Object.getPrototypeOf(DataGridComponent.prototype), 'checkConditions', this).call(this, data);
  5580.       // If table isn't visible, don't bother calculating columns.
  5581.       if (!show) {
  5582.         return false;
  5583.       }
  5584.       var rebuild = false;
  5585.       if (this.visibleColumns === true) {
  5586.         this.visibleColumns = {};
  5587.       }
  5588.       _lodash2.default.each(this.component.components, function (col) {
  5589.         var showColumn = false;
  5590.         _lodash2.default.each(_this7.rows, function (comps) {
  5591.           showColumn |= comps[col.key].checkConditions(data);
  5592.         });
  5593.         if (_this7.visibleColumns[col.key] && !showColumn || !_this7.visibleColumns[col.key] && showColumn) {
  5594.           rebuild = true;
  5595.         }
  5596.  
  5597.         _this7.visibleColumns[col.key] = showColumn;
  5598.         show |= showColumn;
  5599.       });
  5600.  
  5601.       // If a rebuild is needed, then rebuild the table.
  5602.       if (rebuild) {
  5603.         this.buildRows();
  5604.         this.restoreValue();
  5605.       }
  5606.  
  5607.       // Return if this table should show.
  5608.       return show;
  5609.     }
  5610.   }, {
  5611.     key: 'setValue',
  5612.     value: function setValue(value, flags) {
  5613.       flags = this.getFlags.apply(this, arguments);
  5614.       if (!value) {
  5615.         return;
  5616.       }
  5617.       if (!Array.isArray(value)) {
  5618.         if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
  5619.           value = [value];
  5620.         } else {
  5621.           return;
  5622.         }
  5623.       }
  5624.  
  5625.       var changed = flags.changed || this.hasChanged(value, this.dataValue);
  5626.       this.dataValue = value;
  5627.       this.buildRows();
  5628.       _lodash2.default.each(this.rows, function (row, index) {
  5629.         if (value.length <= index) {
  5630.           return;
  5631.         }
  5632.         _lodash2.default.each(row, function (col, key) {
  5633.           if (col.type === 'components') {
  5634.             col.setValue(value[index], flags);
  5635.           } else if (value[index].hasOwnProperty(key)) {
  5636.             col.setValue(value[index][key], flags);
  5637.           } else {
  5638.             col.data = value[index];
  5639.             col.setValue(col.defaultValue, flags);
  5640.           }
  5641.         });
  5642.       });
  5643.       return changed;
  5644.     }
  5645.  
  5646.     /**
  5647.      * Get the value of this component.
  5648.      *
  5649.      * @returns {*}
  5650.      */
  5651.  
  5652.   }, {
  5653.     key: 'getValue',
  5654.     value: function getValue() {
  5655.       if (this.viewOnly) {
  5656.         return this.dataValue;
  5657.       }
  5658.       var values = [];
  5659.       _lodash2.default.each(this.rows, function (row) {
  5660.         var value = {};
  5661.         _lodash2.default.each(row, function (col) {
  5662.           if (col && col.component && col.component.key) {
  5663.             _lodash2.default.set(value, col.component.key, col.getValue());
  5664.           }
  5665.         });
  5666.         values.push(value);
  5667.       });
  5668.       return values;
  5669.     }
  5670.   }, {
  5671.     key: 'emptyValue',
  5672.     get: function get() {
  5673.       return [{}];
  5674.     }
  5675.   }, {
  5676.     key: 'addAnotherPosition',
  5677.     get: function get() {
  5678.       return _lodash2.default.get(this.component, 'addAnotherPosition', 'bottom');
  5679.     }
  5680.   }, {
  5681.     key: 'defaultValue',
  5682.     get: function get() {
  5683.       var value = _get(DataGridComponent.prototype.__proto__ || Object.getPrototypeOf(DataGridComponent.prototype), 'defaultValue', this);
  5684.       if (_lodash2.default.isArray(value)) {
  5685.         return value;
  5686.       }
  5687.       if (value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
  5688.         return [value];
  5689.       }
  5690.       return this.emptyValue;
  5691.     }
  5692.   }]);
  5693.  
  5694.   return DataGridComponent;
  5695. }(_Components.FormioComponents);
  5696.  
  5697. },{"../Components":1,"lodash":79}],13:[function(require,module,exports){
  5698. 'use strict';
  5699.  
  5700. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  5701.  
  5702. Object.defineProperty(exports, "__esModule", {
  5703.   value: true
  5704. });
  5705. exports.DateTimeComponent = undefined;
  5706.  
  5707. var _createClass = function () {
  5708.   function defineProperties(target, props) {
  5709.     for (var i = 0; i < props.length; i++) {
  5710.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  5711.     }
  5712.   }return function (Constructor, protoProps, staticProps) {
  5713.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  5714.   };
  5715. }();
  5716.  
  5717. var _set = function set(object, property, value, receiver) {
  5718.   var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  5719.     var parent = Object.getPrototypeOf(object);if (parent !== null) {
  5720.       set(parent, property, value, receiver);
  5721.     }
  5722.   } else if ("value" in desc && desc.writable) {
  5723.     desc.value = value;
  5724.   } else {
  5725.     var setter = desc.set;if (setter !== undefined) {
  5726.       setter.call(receiver, value);
  5727.     }
  5728.   }return value;
  5729. };
  5730.  
  5731. var _get = function get(object, property, receiver) {
  5732.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  5733.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  5734.       return undefined;
  5735.     } else {
  5736.       return get(parent, property, receiver);
  5737.     }
  5738.   } else if ("value" in desc) {
  5739.     return desc.value;
  5740.   } else {
  5741.     var getter = desc.get;if (getter === undefined) {
  5742.       return undefined;
  5743.     }return getter.call(receiver);
  5744.   }
  5745. };
  5746.  
  5747. var _flatpickr = require('flatpickr');
  5748.  
  5749. var _flatpickr2 = _interopRequireDefault(_flatpickr);
  5750.  
  5751. var _lodash = require('lodash');
  5752.  
  5753. var _lodash2 = _interopRequireDefault(_lodash);
  5754.  
  5755. var _Base = require('../base/Base');
  5756.  
  5757. var _utils = require('../../utils');
  5758.  
  5759. var _moment = require('moment');
  5760.  
  5761. var _moment2 = _interopRequireDefault(_moment);
  5762.  
  5763. function _interopRequireDefault(obj) {
  5764.   return obj && obj.__esModule ? obj : { default: obj };
  5765. }
  5766.  
  5767. function _classCallCheck(instance, Constructor) {
  5768.   if (!(instance instanceof Constructor)) {
  5769.     throw new TypeError("Cannot call a class as a function");
  5770.   }
  5771. }
  5772.  
  5773. function _possibleConstructorReturn(self, call) {
  5774.   if (!self) {
  5775.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  5776.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  5777. }
  5778.  
  5779. function _inherits(subClass, superClass) {
  5780.   if (typeof superClass !== "function" && superClass !== null) {
  5781.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  5782.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  5783. }
  5784.  
  5785. var DateTimeComponent = exports.DateTimeComponent = function (_BaseComponent) {
  5786.   _inherits(DateTimeComponent, _BaseComponent);
  5787.  
  5788.   function DateTimeComponent(component, options, data) {
  5789.     _classCallCheck(this, DateTimeComponent);
  5790.  
  5791.     var _this = _possibleConstructorReturn(this, (DateTimeComponent.__proto__ || Object.getPrototypeOf(DateTimeComponent)).call(this, component, options, data));
  5792.  
  5793.     _this.validators.push('date');
  5794.     _this.closedOn = 0;
  5795.  
  5796.     var dateFormatInfo = (0, _utils.getLocaleDateFormatInfo)(_this.options.language);
  5797.     _this.defaultFormat = {
  5798.       date: dateFormatInfo.dayFirst ? 'd/m/Y ' : 'm/d/Y ',
  5799.       time: 'h:i K'
  5800.     };
  5801.     return _this;
  5802.   }
  5803.  
  5804.   _createClass(DateTimeComponent, [{
  5805.     key: 'elementInfo',
  5806.     value: function elementInfo() {
  5807.       var info = _get(DateTimeComponent.prototype.__proto__ || Object.getPrototypeOf(DateTimeComponent.prototype), 'elementInfo', this).call(this);
  5808.       info.type = 'input';
  5809.       info.attr.type = 'text';
  5810.       info.changeEvent = 'input';
  5811.       this.component.suffix = true;
  5812.       return info;
  5813.     }
  5814.   }, {
  5815.     key: 'createWrapper',
  5816.  
  5817.     // This select component can handle multiple items on its own.
  5818.     value: function createWrapper() {
  5819.       return false;
  5820.     }
  5821.   }, {
  5822.     key: 'getLocaleFormat',
  5823.     value: function getLocaleFormat() {
  5824.       var format = '';
  5825.  
  5826.       if (this.component.enableDate) {
  5827.         format += this.defaultFormat.date;
  5828.       }
  5829.  
  5830.       if (this.component.enableTime) {
  5831.         format += this.defaultFormat.time;
  5832.       }
  5833.  
  5834.       return format;
  5835.     }
  5836.   }, {
  5837.     key: 'addSuffix',
  5838.     value: function addSuffix(input, inputGroup) {
  5839.       var _this2 = this;
  5840.  
  5841.       var suffix = this.ce('span', {
  5842.         class: 'input-group-addon',
  5843.         style: 'cursor: pointer'
  5844.       });
  5845.       suffix.appendChild(this.getIcon(this.component.enableDate ? 'calendar' : 'time'));
  5846.       var calendar = this.getCalendar(input);
  5847.       if (calendar) {
  5848.         this.addEventListener(suffix, 'click', function () {
  5849.           // Make sure the calendar is not already open and that it did not just close (like from blur event).
  5850.           if (!calendar.isOpen && Date.now() - _this2.closedOn > 200) {
  5851.             calendar.open();
  5852.           }
  5853.         });
  5854.       }
  5855.       inputGroup.appendChild(suffix);
  5856.       return suffix;
  5857.     }
  5858.  
  5859.     /**
  5860.      * Get the calendar or create an instance of one.
  5861.      * @param input
  5862.      * @return {Flatpickr|flatpickr}
  5863.      */
  5864.  
  5865.   }, {
  5866.     key: 'getCalendar',
  5867.     value: function getCalendar(input) {
  5868.       if (!input.calendar && !this.options.noCalendar) {
  5869.         input.calendar = new _flatpickr2.default(input, this.config);
  5870.       }
  5871.       return input.calendar;
  5872.     }
  5873.   }, {
  5874.     key: 'getDate',
  5875.     value: function getDate(value) {
  5876.       var timestamp = parseInt(value, 10);
  5877.       if (!timestamp) {
  5878.         return null;
  5879.       }
  5880.       return new Date(timestamp * 1000);
  5881.     }
  5882.   }, {
  5883.     key: 'getValueAt',
  5884.     value: function getValueAt(index) {
  5885.       if (!this.inputs[index]) {
  5886.         return '';
  5887.       }
  5888.  
  5889.       var calendar = this.getCalendar(this.inputs[index]);
  5890.       if (!calendar) {
  5891.         return _get(DateTimeComponent.prototype.__proto__ || Object.getPrototypeOf(DateTimeComponent.prototype), 'getValueAt', this).call(this, index);
  5892.       }
  5893.  
  5894.       var dates = calendar.selectedDates;
  5895.       if (!dates || !dates.length) {
  5896.         return '';
  5897.       }
  5898.  
  5899.       return typeof dates[0].toISOString === 'function' ? dates[0].toISOString() : 'Invalid Date';
  5900.     }
  5901.   }, {
  5902.     key: 'getView',
  5903.     value: function getView(value) {
  5904.       return value ? (0, _moment2.default)(value).format((0, _utils.convertFormatToMoment)(_lodash2.default.get(this.component, 'format', ''))) : '';
  5905.     }
  5906.   }, {
  5907.     key: 'setValueAt',
  5908.     value: function setValueAt(index, value) {
  5909.       if (value) {
  5910.         // Convert to a standard ISO-8601 format. Needed for proper IE function.
  5911.         value = (0, _moment2.default)(value).toISOString();
  5912.  
  5913.         var calendar = this.getCalendar(this.inputs[index]);
  5914.         if (!calendar) {
  5915.           return _get(DateTimeComponent.prototype.__proto__ || Object.getPrototypeOf(DateTimeComponent.prototype), 'setValueAt', this).call(this, index, value);
  5916.         }
  5917.  
  5918.         calendar.setDate(value ? new Date(value) : new Date(), false);
  5919.       }
  5920.     }
  5921.   }, {
  5922.     key: 'focus',
  5923.     value: function focus() {
  5924.       var input = this.inputs[0];
  5925.       if (input) {
  5926.         input.calendar.altInput.focus();
  5927.       }
  5928.     }
  5929.   }, {
  5930.     key: 'emptyValue',
  5931.     get: function get() {
  5932.       return 0;
  5933.     }
  5934.  
  5935.     /**
  5936.      * Get the default date for the calendar.
  5937.      * @return {*}
  5938.      */
  5939.  
  5940.   }, {
  5941.     key: 'defaultDate',
  5942.     get: function get() {
  5943.       return (0, _utils.getDateSetting)(this.component.defaultDate);
  5944.     }
  5945.   }, {
  5946.     key: 'config',
  5947.     get: function get() {
  5948.       var _this3 = this;
  5949.  
  5950.       return {
  5951.         altInput: true,
  5952.         clickOpens: true,
  5953.         enableDate: true,
  5954.         mode: this.component.multiple ? 'multiple' : 'single',
  5955.         enableTime: _lodash2.default.get(this.component, 'enableTime', true),
  5956.         noCalendar: !_lodash2.default.get(this.component, 'enableDate', true),
  5957.         altFormat: this.component.useLocaleSettings ? this.getLocaleFormat() : (0, _utils.convertFormatToFlatpickr)(_lodash2.default.get(this.component, 'format', '')),
  5958.         dateFormat: 'U',
  5959.         defaultDate: this.defaultDate,
  5960.         hourIncrement: _lodash2.default.get(this.component, 'timePicker.hourStep', 1),
  5961.         minuteIncrement: _lodash2.default.get(this.component, 'timePicker.minuteStep', 5),
  5962.         minDate: (0, _utils.getDateSetting)(_lodash2.default.get(this.component, 'datePicker.minDate')),
  5963.         maxDate: (0, _utils.getDateSetting)(_lodash2.default.get(this.component, 'datePicker.maxDate')),
  5964.         onChange: function onChange() {
  5965.           return _this3.onChange();
  5966.         },
  5967.         onClose: function onClose() {
  5968.           return _this3.closedOn = Date.now();
  5969.         }
  5970.       };
  5971.     }
  5972.   }, {
  5973.     key: 'disabled',
  5974.     set: function set(disabled) {
  5975.       var _this4 = this;
  5976.  
  5977.       _set(DateTimeComponent.prototype.__proto__ || Object.getPrototypeOf(DateTimeComponent.prototype), 'disabled', disabled, this);
  5978.       _lodash2.default.each(this.inputs, function (input) {
  5979.         var calendar = _this4.getCalendar(input);
  5980.         if (calendar) {
  5981.           if (disabled) {
  5982.             calendar._input.setAttribute('disabled', 'disabled');
  5983.           } else {
  5984.             calendar._input.removeAttribute('disabled');
  5985.           }
  5986.           calendar.redraw();
  5987.         }
  5988.       });
  5989.     }
  5990.   }, {
  5991.     key: 'validationValue',
  5992.     get: function get() {
  5993.       var values = [];
  5994.       for (var i in this.inputs) {
  5995.         if (this.inputs.hasOwnProperty(i)) {
  5996.           if (!this.component.multiple) {
  5997.             return this.getDate(this.inputs[i].value);
  5998.           }
  5999.           values.push(this.getDate(this.inputs[i].value));
  6000.         }
  6001.       }
  6002.       return values;
  6003.     }
  6004.   }]);
  6005.  
  6006.   return DateTimeComponent;
  6007. }(_Base.BaseComponent);
  6008.  
  6009. },{"../../utils":56,"../base/Base":4,"flatpickr":62,"lodash":79,"moment":80}],14:[function(require,module,exports){
  6010. 'use strict';
  6011.  
  6012. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  6013.  
  6014. Object.defineProperty(exports, "__esModule", {
  6015.   value: true
  6016. });
  6017. exports.DayComponent = undefined;
  6018.  
  6019. var _slicedToArray = function () {
  6020.   function sliceIterator(arr, i) {
  6021.     var _arr = [];var _n = true;var _d = false;var _e = undefined;try {
  6022.       for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
  6023.         _arr.push(_s.value);if (i && _arr.length === i) break;
  6024.       }
  6025.     } catch (err) {
  6026.       _d = true;_e = err;
  6027.     } finally {
  6028.       try {
  6029.         if (!_n && _i["return"]) _i["return"]();
  6030.       } finally {
  6031.         if (_d) throw _e;
  6032.       }
  6033.     }return _arr;
  6034.   }return function (arr, i) {
  6035.     if (Array.isArray(arr)) {
  6036.       return arr;
  6037.     } else if (Symbol.iterator in Object(arr)) {
  6038.       return sliceIterator(arr, i);
  6039.     } else {
  6040.       throw new TypeError("Invalid attempt to destructure non-iterable instance");
  6041.     }
  6042.   };
  6043. }();
  6044.  
  6045. var _createClass = function () {
  6046.   function defineProperties(target, props) {
  6047.     for (var i = 0; i < props.length; i++) {
  6048.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  6049.     }
  6050.   }return function (Constructor, protoProps, staticProps) {
  6051.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  6052.   };
  6053. }();
  6054.  
  6055. var _set = function set(object, property, value, receiver) {
  6056.   var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  6057.     var parent = Object.getPrototypeOf(object);if (parent !== null) {
  6058.       set(parent, property, value, receiver);
  6059.     }
  6060.   } else if ("value" in desc && desc.writable) {
  6061.     desc.value = value;
  6062.   } else {
  6063.     var setter = desc.set;if (setter !== undefined) {
  6064.       setter.call(receiver, value);
  6065.     }
  6066.   }return value;
  6067. };
  6068.  
  6069. var _get = function get(object, property, receiver) {
  6070.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  6071.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  6072.       return undefined;
  6073.     } else {
  6074.       return get(parent, property, receiver);
  6075.     }
  6076.   } else if ("value" in desc) {
  6077.     return desc.value;
  6078.   } else {
  6079.     var getter = desc.get;if (getter === undefined) {
  6080.       return undefined;
  6081.     }return getter.call(receiver);
  6082.   }
  6083. };
  6084.  
  6085. var _lodash = require('lodash');
  6086.  
  6087. var _lodash2 = _interopRequireDefault(_lodash);
  6088.  
  6089. var _moment = require('moment');
  6090.  
  6091. var _moment2 = _interopRequireDefault(_moment);
  6092.  
  6093. var _Base = require('../base/Base');
  6094.  
  6095. var _utils = require('../../utils');
  6096.  
  6097. function _interopRequireDefault(obj) {
  6098.   return obj && obj.__esModule ? obj : { default: obj };
  6099. }
  6100.  
  6101. function _classCallCheck(instance, Constructor) {
  6102.   if (!(instance instanceof Constructor)) {
  6103.     throw new TypeError("Cannot call a class as a function");
  6104.   }
  6105. }
  6106.  
  6107. function _possibleConstructorReturn(self, call) {
  6108.   if (!self) {
  6109.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  6110.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  6111. }
  6112.  
  6113. function _inherits(subClass, superClass) {
  6114.   if (typeof superClass !== "function" && superClass !== null) {
  6115.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  6116.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  6117. }
  6118.  
  6119. var DayComponent = exports.DayComponent = function (_BaseComponent) {
  6120.   _inherits(DayComponent, _BaseComponent);
  6121.  
  6122.   function DayComponent(component, options, data) {
  6123.     _classCallCheck(this, DayComponent);
  6124.  
  6125.     var _this = _possibleConstructorReturn(this, (DayComponent.__proto__ || Object.getPrototypeOf(DayComponent)).call(this, component, options, data));
  6126.  
  6127.     _this.validators.push('date');
  6128.     var dateFormatInfo = (0, _utils.getLocaleDateFormatInfo)(_this.options.language);
  6129.     _this.dayFirst = _this.component.useLocaleSettings ? dateFormatInfo.dayFirst : _this.component.dayFirst;
  6130.     _this.hideDay = _lodash2.default.get(_this.component, 'fields.day.hide', false);
  6131.     _this.hideMonth = _lodash2.default.get(_this.component, 'fields.month.hide', false);
  6132.     _this.hideYear = _lodash2.default.get(_this.component, 'fields.year.hide', false);
  6133.     return _this;
  6134.   }
  6135.  
  6136.   _createClass(DayComponent, [{
  6137.     key: 'elementInfo',
  6138.     value: function elementInfo() {
  6139.       var info = _get(DayComponent.prototype.__proto__ || Object.getPrototypeOf(DayComponent.prototype), 'elementInfo', this).call(this);
  6140.       info.type = 'input';
  6141.       info.attr.type = 'hidden';
  6142.       info.changeEvent = 'change';
  6143.       return info;
  6144.     }
  6145.   }, {
  6146.     key: 'createDayInput',
  6147.     value: function createDayInput(subinputAtTheBottom) {
  6148.       var _this2 = this;
  6149.  
  6150.       var dayColumn = this.ce('div', {
  6151.         class: 'form-group col col-xs-3'
  6152.       });
  6153.  
  6154.       var id = this.component.key + '-day';
  6155.  
  6156.       var dayLabel = this.ce('label', {
  6157.         for: id,
  6158.         class: _lodash2.default.get(this.component, 'fields.day.required', false) ? 'field-required' : ''
  6159.       });
  6160.       dayLabel.appendChild(this.text(this.t('day')));
  6161.       this.setSubinputLabelStyle(dayLabel);
  6162.       if (!subinputAtTheBottom) {
  6163.         dayColumn.appendChild(dayLabel);
  6164.       }
  6165.  
  6166.       var dayInputWrapper = this.ce('div');
  6167.       this.dayInput = this.ce('input', {
  6168.         class: 'form-control',
  6169.         type: 'number',
  6170.         step: '1',
  6171.         min: '1',
  6172.         max: '31',
  6173.         placeholder: _lodash2.default.get(this.component, 'fields.day.placeholder', ''),
  6174.         id: id
  6175.       });
  6176.       this.hook('input', this.dayInput, dayInputWrapper);
  6177.       this.addEventListener(this.dayInput, 'change', function () {
  6178.         return _this2.updateValue();
  6179.       });
  6180.       dayInputWrapper.appendChild(this.dayInput);
  6181.       this.setSubinputStyle(dayInputWrapper);
  6182.       dayColumn.appendChild(dayInputWrapper);
  6183.  
  6184.       if (subinputAtTheBottom) {
  6185.         dayColumn.appendChild(dayLabel);
  6186.       }
  6187.  
  6188.       return dayColumn;
  6189.     }
  6190.   }, {
  6191.     key: 'createMonthInput',
  6192.     value: function createMonthInput(subinputAtTheBottom) {
  6193.       var monthColumn = this.ce('div', {
  6194.         class: 'form-group col col-xs-4'
  6195.       });
  6196.  
  6197.       var id = this.component.key + '-month';
  6198.  
  6199.       var monthLabel = this.ce('label', {
  6200.         for: id,
  6201.         class: _lodash2.default.get(this.component, 'fields.month.required', false) ? 'field-required' : ''
  6202.       });
  6203.       monthLabel.appendChild(this.text(this.t('month')));
  6204.       this.setSubinputLabelStyle(monthLabel);
  6205.       if (!subinputAtTheBottom) {
  6206.         monthColumn.appendChild(monthLabel);
  6207.       }
  6208.  
  6209.       var monthInputWrapper = this.ce('div');
  6210.       this.monthInput = this.ce('select', {
  6211.         class: 'form-control',
  6212.         id: id
  6213.       });
  6214.       this.hook('input', this.monthInput, monthInputWrapper);
  6215.       this.selectOptions(this.monthInput, 'monthOption', this.months);
  6216.       var self = this;
  6217.  
  6218.       // Ensure the day limits match up with the months selected.
  6219.       this.monthInput.onchange = function () {
  6220.         self.dayInput.max = new Date(self.yearInput.value, this.value, 0).getDate();
  6221.         if (self.dayInput.value > self.dayInput.max) {
  6222.           self.dayInput.value = self.dayInput.max;
  6223.         }
  6224.         self.updateValue();
  6225.       };
  6226.       monthInputWrapper.appendChild(this.monthInput);
  6227.       this.setSubinputStyle(monthInputWrapper);
  6228.       monthColumn.appendChild(monthInputWrapper);
  6229.  
  6230.       if (subinputAtTheBottom) {
  6231.         monthColumn.appendChild(monthLabel);
  6232.       }
  6233.  
  6234.       return monthColumn;
  6235.     }
  6236.   }, {
  6237.     key: 'createYearInput',
  6238.     value: function createYearInput(subinputAtTheBottom) {
  6239.       var _this3 = this;
  6240.  
  6241.       var yearColumn = this.ce('div', {
  6242.         class: 'form-group col col-xs-5'
  6243.       });
  6244.  
  6245.       var id = this.component.key + '-year';
  6246.  
  6247.       var yearLabel = this.ce('label', {
  6248.         for: id,
  6249.         class: _lodash2.default.get(this.component, 'fields.year.required', false) ? 'field-required' : ''
  6250.       });
  6251.       yearLabel.appendChild(this.text(this.t('year')));
  6252.       this.setSubinputLabelStyle(yearLabel);
  6253.       if (!subinputAtTheBottom) {
  6254.         yearColumn.appendChild(yearLabel);
  6255.       }
  6256.  
  6257.       var yearInputWrapper = this.ce('div');
  6258.       this.yearInput = this.ce('input', {
  6259.         class: 'form-control',
  6260.         type: 'number',
  6261.         step: '1',
  6262.         min: '1',
  6263.         placeholder: _lodash2.default.get(this.component, 'fields.year.placeholder', ''),
  6264.         value: new Date().getFullYear(),
  6265.         id: id
  6266.       });
  6267.  
  6268.       this.hook('input', this.yearInput, yearInputWrapper);
  6269.       this.addEventListener(this.yearInput, 'change', function () {
  6270.         return _this3.updateValue();
  6271.       });
  6272.       yearInputWrapper.appendChild(this.yearInput);
  6273.       this.setSubinputStyle(yearInputWrapper);
  6274.       yearColumn.appendChild(yearInputWrapper);
  6275.  
  6276.       if (subinputAtTheBottom) {
  6277.         yearColumn.appendChild(yearLabel);
  6278.       }
  6279.  
  6280.       return yearColumn;
  6281.     }
  6282.   }, {
  6283.     key: 'createInput',
  6284.     value: function createInput(container) {
  6285.       var inputGroup = this.ce('div', {
  6286.         class: 'input-group row',
  6287.         style: 'width: 100%'
  6288.       });
  6289.       var subinputAtTheBottom = this.component.inputsLabelPosition === 'bottom';
  6290.  
  6291.       var _createInputs = this.createInputs(subinputAtTheBottom),
  6292.           _createInputs2 = _slicedToArray(_createInputs, 3),
  6293.           dayColumn = _createInputs2[0],
  6294.           monthColumn = _createInputs2[1],
  6295.           yearColumn = _createInputs2[2];
  6296.  
  6297.       // Add the columns to the day select in the right order.
  6298.  
  6299.  
  6300.       if (this.dayFirst && !this.hideDay) {
  6301.         inputGroup.appendChild(dayColumn);
  6302.       }
  6303.       if (!this.hideMonth) {
  6304.         inputGroup.appendChild(monthColumn);
  6305.       }
  6306.       if (!this.dayFirst && !this.hideDay) {
  6307.         inputGroup.appendChild(dayColumn);
  6308.       }
  6309.       if (!this.hideYear) {
  6310.         inputGroup.appendChild(yearColumn);
  6311.       }
  6312.  
  6313.       var input = this.ce(this.info.type, this.info.attr);
  6314.       this.addInput(input, inputGroup);
  6315.       this.errorContainer = container;
  6316.       this.setInputStyles(inputGroup);
  6317.       container.appendChild(inputGroup);
  6318.     }
  6319.   }, {
  6320.     key: 'createInputs',
  6321.     value: function createInputs(subinputAtTheBottom) {
  6322.       return [this.createDayInput(subinputAtTheBottom), this.createMonthInput(subinputAtTheBottom), this.createYearInput(subinputAtTheBottom)];
  6323.     }
  6324.   }, {
  6325.     key: 'setSubinputLabelStyle',
  6326.     value: function setSubinputLabelStyle(label) {
  6327.       var inputsLabelPosition = this.component.inputsLabelPosition;
  6328.  
  6329.       if (inputsLabelPosition === 'left') {
  6330.         _lodash2.default.assign(label.style, {
  6331.           float: 'left',
  6332.           width: '30%',
  6333.           marginRight: '3%',
  6334.           textAlign: 'left'
  6335.         });
  6336.       }
  6337.  
  6338.       if (inputsLabelPosition === 'right') {
  6339.         _lodash2.default.assign(label.style, {
  6340.           float: 'right',
  6341.           width: '30%',
  6342.           marginLeft: '3%',
  6343.           textAlign: 'right'
  6344.         });
  6345.       }
  6346.     }
  6347.   }, {
  6348.     key: 'setSubinputStyle',
  6349.     value: function setSubinputStyle(input) {
  6350.       var inputsLabelPosition = this.component.inputsLabelPosition;
  6351.  
  6352.       if (['left', 'right'].indexOf(inputsLabelPosition) !== -1) {
  6353.         input.style.width = '67%';
  6354.  
  6355.         if (inputsLabelPosition === 'left') {
  6356.           input.style.marginLeft = '33%';
  6357.         } else {
  6358.           input.style.marginRight = '33%';
  6359.         }
  6360.       }
  6361.     }
  6362.  
  6363.     /**
  6364.      * Set the value at a specific index.
  6365.      *
  6366.      * @param index
  6367.      * @param value
  6368.      */
  6369.  
  6370.   }, {
  6371.     key: 'setValueAt',
  6372.     value: function setValueAt(index, value) {
  6373.       if (!value) {
  6374.         return;
  6375.       }
  6376.       var parts = value.split('/');
  6377.       if (this.component.dayFirst && !_lodash2.default.get(this.component, 'fields.day.hide', false)) {
  6378.         this.dayInput.value = parseInt(parts.shift(), 10);
  6379.       }
  6380.       if (!_lodash2.default.get(this.component, 'fields.month.hide', false)) {
  6381.         this.monthInput.value = parseInt(parts.shift(), 10);
  6382.       }
  6383.       if (!this.component.dayFirst && !_lodash2.default.get(this.component, 'fields.day.hide', false)) {
  6384.         this.dayInput.value = parseInt(parts.shift(), 10);
  6385.       }
  6386.       if (!_lodash2.default.get(this.component, 'fields.year.hide', false)) {
  6387.         this.yearInput.value = parseInt(parts.shift(), 10);
  6388.       }
  6389.     }
  6390.  
  6391.     /**
  6392.      * Get the format for the value string.
  6393.      * @returns {string}
  6394.      */
  6395.  
  6396.   }, {
  6397.     key: 'getValueAt',
  6398.  
  6399.     /**
  6400.      * Get the value at a specific index.
  6401.      *
  6402.      * @param index
  6403.      * @returns {*}
  6404.      */
  6405.     value: function getValueAt(index) {
  6406.       this.inputs[index].value = this.date.format(this.format);
  6407.       return this.inputs[index].value;
  6408.     }
  6409.   }, {
  6410.     key: 'getView',
  6411.     value: function getView() {
  6412.       var date = this.date;
  6413.       return date.isValid() ? date.format(this.format) : null;
  6414.     }
  6415.   }, {
  6416.     key: 'focus',
  6417.     value: function focus() {
  6418.       if (this.dayFirst && !this.hideDay || !this.dayFirst && this.hideMonth && !this.hideDay) {
  6419.         this.dayInput.focus();
  6420.       } else if (this.dayFirst && this.hideDay && !this.hideMonth || !this.dayFirst && !this.hideMonth) {
  6421.         this.monthInput.focus();
  6422.       } else if (this.hideDay && this.hideMonth && !this.hideYear) {
  6423.         this.yearInput.focus();
  6424.       }
  6425.     }
  6426.   }, {
  6427.     key: 'months',
  6428.     get: function get() {
  6429.       if (this._months) {
  6430.         return this._months;
  6431.       }
  6432.       this._months = [{ value: 0, label: _lodash2.default.get(this.component, 'fields.month.placeholder', '') }, { value: 1, label: this.t('january') }, { value: 2, label: this.t('february') }, { value: 3, label: this.t('march') }, { value: 4, label: this.t('april') }, { value: 5, label: this.t('may') }, { value: 6, label: this.t('june') }, { value: 7, label: this.t('july') }, { value: 8, label: this.t('august') }, { value: 9, label: this.t('september') }, { value: 10, label: this.t('october') }, { value: 11, label: this.t('november') }, { value: 12, label: this.t('december') }];
  6433.       return this._months;
  6434.     }
  6435.   }, {
  6436.     key: 'emptyValue',
  6437.     get: function get() {
  6438.       return '';
  6439.     }
  6440.   }, {
  6441.     key: 'disabled',
  6442.     set: function set(disabled) {
  6443.       _set(DayComponent.prototype.__proto__ || Object.getPrototypeOf(DayComponent.prototype), 'disabled', disabled, this);
  6444.       if (disabled) {
  6445.         this.yearInput.setAttribute('disabled', 'disabled');
  6446.         this.monthInput.setAttribute('disabled', 'disabled');
  6447.         this.dayInput.setAttribute('disabled', 'disabled');
  6448.       } else {
  6449.         this.yearInput.removeAttribute('disabled');
  6450.         this.monthInput.removeAttribute('disabled');
  6451.         this.dayInput.removeAttribute('disabled');
  6452.       }
  6453.     }
  6454.   }, {
  6455.     key: 'format',
  6456.     get: function get() {
  6457.       var format = '';
  6458.       if (this.component.dayFirst && !_lodash2.default.get(this.component, 'fields.day.hide', false)) {
  6459.         format += 'D/';
  6460.       }
  6461.       if (!_lodash2.default.get(this.component, 'fields.month.hide', false)) {
  6462.         format += 'M/';
  6463.       }
  6464.       if (!this.component.dayFirst && !_lodash2.default.get(this.component, 'fields.day.hide', false)) {
  6465.         format += 'D/';
  6466.       }
  6467.       if (!_lodash2.default.get(this.component, 'fields.year.hide', false)) {
  6468.         format += 'YYYY';
  6469.       }
  6470.       return format;
  6471.     }
  6472.  
  6473.     /**
  6474.      * Return the date object for this component.
  6475.      * @returns {Date}
  6476.      */
  6477.  
  6478.   }, {
  6479.     key: 'date',
  6480.     get: function get() {
  6481.       var day = this.dayInput.value;
  6482.       var month = this.monthInput.value;
  6483.       var year = this.yearInput.value;
  6484.       return (0, _moment2.default)([parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10)]);
  6485.     }
  6486.  
  6487.     /**
  6488.      * Return the raw value.
  6489.      *
  6490.      * @returns {Date}
  6491.      */
  6492.  
  6493.   }, {
  6494.     key: 'validationValue',
  6495.     get: function get() {
  6496.       return this.date.format();
  6497.     }
  6498.   }]);
  6499.  
  6500.   return DayComponent;
  6501. }(_Base.BaseComponent);
  6502.  
  6503. },{"../../utils":56,"../base/Base":4,"lodash":79,"moment":80}],15:[function(require,module,exports){
  6504. 'use strict';
  6505.  
  6506. var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  6507.  
  6508. Object.defineProperty(exports, "__esModule", {
  6509.   value: true
  6510. });
  6511. exports.EditGridComponent = undefined;
  6512.  
  6513. var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
  6514.   return typeof obj === "undefined" ? "undefined" : _typeof2(obj);
  6515. } : function (obj) {
  6516.   return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof2(obj);
  6517. };
  6518.  
  6519. var _createClass = function () {
  6520.   function defineProperties(target, props) {
  6521.     for (var i = 0; i < props.length; i++) {
  6522.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  6523.     }
  6524.   }return function (Constructor, protoProps, staticProps) {
  6525.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  6526.   };
  6527. }();
  6528.  
  6529. var _get = function get(object, property, receiver) {
  6530.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  6531.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  6532.       return undefined;
  6533.     } else {
  6534.       return get(parent, property, receiver);
  6535.     }
  6536.   } else if ("value" in desc) {
  6537.     return desc.value;
  6538.   } else {
  6539.     var getter = desc.get;if (getter === undefined) {
  6540.       return undefined;
  6541.     }return getter.call(receiver);
  6542.   }
  6543. };
  6544.  
  6545. var _lodash = require('lodash');
  6546.  
  6547. var _lodash2 = _interopRequireDefault(_lodash);
  6548.  
  6549. var _Components = require('../Components');
  6550.  
  6551. var _utils = require('../../utils');
  6552.  
  6553. var _utils2 = _interopRequireDefault(_utils);
  6554.  
  6555. function _interopRequireDefault(obj) {
  6556.   return obj && obj.__esModule ? obj : { default: obj };
  6557. }
  6558.  
  6559. function _classCallCheck(instance, Constructor) {
  6560.   if (!(instance instanceof Constructor)) {
  6561.     throw new TypeError("Cannot call a class as a function");
  6562.   }
  6563. }
  6564.  
  6565. function _possibleConstructorReturn(self, call) {
  6566.   if (!self) {
  6567.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  6568.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof2(call)) === "object" || typeof call === "function") ? call : self;
  6569. }
  6570.  
  6571. function _inherits(subClass, superClass) {
  6572.   if (typeof superClass !== "function" && superClass !== null) {
  6573.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof2(superClass)));
  6574.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  6575. }
  6576.  
  6577. var EditGridComponent = exports.EditGridComponent = function (_FormioComponents) {
  6578.   _inherits(EditGridComponent, _FormioComponents);
  6579.  
  6580.   function EditGridComponent(component, options, data) {
  6581.     _classCallCheck(this, EditGridComponent);
  6582.  
  6583.     var _this = _possibleConstructorReturn(this, (EditGridComponent.__proto__ || Object.getPrototypeOf(EditGridComponent)).call(this, component, options, data));
  6584.  
  6585.     _this.type = 'datagrid';
  6586.     _this.editRows = [];
  6587.     if (_this.options.components) {
  6588.       _this.create = _lodash2.default.bind(_this.options.components.create, _this.options.components, _lodash2.default, _this.options, _lodash2.default, true);
  6589.     }
  6590.     return _this;
  6591.   }
  6592.  
  6593.   _createClass(EditGridComponent, [{
  6594.     key: 'build',
  6595.     value: function build() {
  6596.       this.createElement();
  6597.       this.createLabel(this.element);
  6598.       this.buildTable();
  6599.       this.createDescription(this.element);
  6600.       this.createAddButton();
  6601.       this.element.appendChild(this.errorContainer = this.ce('div', { class: 'has-error' }));
  6602.     }
  6603.   }, {
  6604.     key: 'buildTable',
  6605.     value: function buildTable() {
  6606.       var _this2 = this;
  6607.  
  6608.       if (this.tableElement) {
  6609.         this.tableElement.innerHTML = '';
  6610.       }
  6611.  
  6612.       var tableClass = 'editgrid-listgroup list-group ';
  6613.       _lodash2.default.each(['striped', 'bordered', 'hover', 'condensed'], function (prop) {
  6614.         if (_this2.component[prop]) {
  6615.           tableClass += 'table-' + prop + ' ';
  6616.         }
  6617.       });
  6618.       this.tableElement = this.ce('ul', { class: tableClass }, [this.headerElement = this.createHeader(), this.rowElements = _lodash2.default.map(this.rows, this.createRow.bind(this)), this.footerElement = this.createFooter()]);
  6619.  
  6620.       this.element.appendChild(this.tableElement);
  6621.     }
  6622.   }, {
  6623.     key: 'createHeader',
  6624.     value: function createHeader() {
  6625.       var templateHeader = _lodash2.default.get(this.component, 'templates.header');
  6626.       if (!templateHeader) {
  6627.         return this.text('');
  6628.       }
  6629.       return this.ce('li', { class: 'list-group-item list-group-header' }, this.renderTemplate(templateHeader, {
  6630.         components: this.component.components,
  6631.         util: _utils2.default,
  6632.         value: this.dataValue,
  6633.         data: this.data
  6634.       }));
  6635.     }
  6636.   }, {
  6637.     key: 'createRow',
  6638.     value: function createRow(row, rowIndex) {
  6639.       var _this3 = this;
  6640.  
  6641.       var wrapper = this.ce('li', { class: 'list-group-item' });
  6642.       var rowTemplate = _lodash2.default.get(this.component, 'templates.row', this.defaultRowTemplate);
  6643.  
  6644.       // Store info so we can detect changes later.
  6645.       wrapper.rowData = row;
  6646.       wrapper.rowIndex = rowIndex;
  6647.       wrapper.rowOpen = this.editRows[rowIndex].isOpen;
  6648.       this.editRows[rowIndex].components = [];
  6649.  
  6650.       if (wrapper.rowOpen) {
  6651.         wrapper.appendChild(this.ce('div', { class: 'editgrid-edit' }, this.ce('div', { class: 'editgrid-body' }, [this.component.components.map(function (comp) {
  6652.           var component = _lodash2.default.cloneDeep(comp);
  6653.           component.row = _this3.row + '-' + rowIndex;
  6654.           var options = _lodash2.default.clone(_this3.options);
  6655.           options.name += '[' + rowIndex + ']';
  6656.           var instance = _this3.createComponent(component, options, _this3.editRows[rowIndex].data);
  6657.           _this3.editRows[rowIndex].components.push(instance);
  6658.           return instance.element;
  6659.         }), this.ce('div', { class: 'editgrid-actions' }, [this.ce('div', {
  6660.           class: 'btn btn-primary',
  6661.           onClick: this.saveRow.bind(this, rowIndex)
  6662.         }, this.component.saveRow || 'Save'), ' ', this.component.removeRow ? this.ce('div', {
  6663.           class: 'btn btn-danger',
  6664.           onClick: this.cancelRow.bind(this, rowIndex)
  6665.         }, this.component.removeRow || 'Cancel') : null])])));
  6666.       } else {
  6667.         var create = this.create;
  6668.         wrapper.appendChild(this.renderTemplate(rowTemplate, {
  6669.           data: this.data,
  6670.           row: row,
  6671.           rowIndex: rowIndex,
  6672.           components: this.component.components,
  6673.           getView: function getView(component, data) {
  6674.             return create(component, data).getView(data);
  6675.           },
  6676.  
  6677.           util: _utils2.default
  6678.         }, [{
  6679.           class: 'removeRow',
  6680.           event: 'click',
  6681.           action: this.removeRow.bind(this, rowIndex)
  6682.         }, {
  6683.           class: 'editRow',
  6684.           event: 'click',
  6685.           action: this.editRow.bind(this, rowIndex)
  6686.         }]));
  6687.       }
  6688.       wrapper.appendChild(this.editRows[rowIndex].errorContainer = this.ce('div', { class: 'has-error' }));
  6689.       this.checkData(this.data, { noValidate: true }, rowIndex);
  6690.       return wrapper;
  6691.     }
  6692.   }, {
  6693.     key: 'createFooter',
  6694.     value: function createFooter() {
  6695.       var footerTemplate = _lodash2.default.get(this.component, 'templates.footer');
  6696.       if (!footerTemplate) {
  6697.         return this.text('');
  6698.       }
  6699.       return this.ce('li', { class: 'list-group-item list-group-footer' }, this.renderTemplate(footerTemplate, {
  6700.         components: this.component.components,
  6701.         util: _utils2.default,
  6702.         value: this.dataValue,
  6703.         data: this.data
  6704.       }));
  6705.     }
  6706.   }, {
  6707.     key: 'checkData',
  6708.     value: function checkData(data) {
  6709.       var _this4 = this;
  6710.  
  6711.       var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  6712.       var index = arguments[2];
  6713.  
  6714.       var valid = true;
  6715.       if (flags.noCheck) {
  6716.         return;
  6717.       }
  6718.  
  6719.       // Update the value.
  6720.       var changed = this.updateValue({
  6721.         noUpdateEvent: true
  6722.       });
  6723.  
  6724.       // Iterate through all components and check conditions, and calculate values.
  6725.       this.editRows[index].components.forEach(function (comp) {
  6726.         changed |= comp.calculateValue(data, {
  6727.           noUpdateEvent: true
  6728.         });
  6729.         comp.checkConditions(_this4.editRows[index].data);
  6730.         if (!flags.noValidate) {
  6731.           valid &= comp.checkValidity(_this4.editRows[index].data, !_this4.editRows[index].isOpen);
  6732.         }
  6733.       });
  6734.  
  6735.       valid &= this.validateRow(index, false);
  6736.  
  6737.       // Trigger the change if the values changed.
  6738.       if (changed) {
  6739.         this.triggerChange(flags);
  6740.       }
  6741.  
  6742.       // Return if the value is valid.
  6743.       return valid;
  6744.     }
  6745.   }, {
  6746.     key: 'createAddButton',
  6747.     value: function createAddButton() {
  6748.       this.element.appendChild(this.ce('div', { class: 'editgrid-add' }, this.ce('button', {
  6749.         class: 'btn btn-primary',
  6750.         role: 'button',
  6751.         onClick: this.addRow.bind(this)
  6752.       }, [this.ce('span', { class: this.iconClass('plus'), 'aria-hidden': true }), ' ', this.t(this.component.addAnother ? this.component.addAnother : 'Add Another', {})])));
  6753.     }
  6754.   }, {
  6755.     key: 'refreshDOM',
  6756.     value: function refreshDOM() {
  6757.       var _this5 = this;
  6758.  
  6759.       var newHeader = this.createHeader();
  6760.       this.tableElement.replaceChild(newHeader, this.headerElement);
  6761.       this.headerElement = newHeader;
  6762.  
  6763.       var newFooter = this.createFooter();
  6764.       this.tableElement.replaceChild(newFooter, this.footerElement);
  6765.       this.footerElement = newFooter;
  6766.  
  6767.       this.editRows.forEach(function (editRow, rowIndex) {
  6768.         if (!editRow.element) {
  6769.           // New row
  6770.           editRow.element = _this5.createRow(editRow.data, rowIndex);
  6771.           _this5.tableElement.insertBefore(editRow.element, _this5.tableElement.children[rowIndex + 1]);
  6772.         } else if (editRow.element.rowData !== editRow.data || editRow.element.rowIndex !== rowIndex || editRow.element.rowOpen !== editRow.isOpen) {
  6773.           // Row has changed due to an edit or delete.
  6774.           _this5.removeRowComponents(rowIndex);
  6775.           var newRow = _this5.createRow(editRow.data, rowIndex);
  6776.           _this5.tableElement.replaceChild(newRow, editRow.element);
  6777.           editRow.element = newRow;
  6778.         }
  6779.       });
  6780.     }
  6781.   }, {
  6782.     key: 'addRow',
  6783.     value: function addRow() {
  6784.       if (this.options.readOnly) {
  6785.         return;
  6786.       }
  6787.       this.editRows.push({
  6788.         isOpen: true,
  6789.         data: {}
  6790.       });
  6791.       this.updateValue();
  6792.       this.refreshDOM();
  6793.     }
  6794.   }, {
  6795.     key: 'editRow',
  6796.     value: function editRow(rowIndex) {
  6797.       this.editRows[rowIndex].isOpen = true;
  6798.       this.editRows[rowIndex].data = _lodash2.default.cloneDeep(this.dataValue[rowIndex]);
  6799.       this.refreshDOM();
  6800.     }
  6801.   }, {
  6802.     key: 'cancelRow',
  6803.     value: function cancelRow(rowIndex) {
  6804.       if (this.options.readOnly) {
  6805.         this.editRows[rowIndex].isOpen = false;
  6806.         this.removeRowComponents(rowIndex);
  6807.         this.refreshDOM();
  6808.         return;
  6809.       }
  6810.       this.removeRowComponents(rowIndex);
  6811.       // Remove if new.
  6812.       if (!this.dataValue[rowIndex]) {
  6813.         this.removeChildFrom(this.editRows[rowIndex].element, this.tableElement);
  6814.         this.editRows.splice(rowIndex, 1);
  6815.         this.splice(rowIndex);
  6816.       } else {
  6817.         this.editRows[rowIndex].isOpen = false;
  6818.         this.editRows[rowIndex].data = this.dataValue[rowIndex];
  6819.       }
  6820.       this.refreshDOM();
  6821.     }
  6822.   }, {
  6823.     key: 'saveRow',
  6824.     value: function saveRow(rowIndex) {
  6825.       if (this.options.readOnly) {
  6826.         this.editRows[rowIndex].isOpen = false;
  6827.         this.removeRowComponents(rowIndex);
  6828.         this.refreshDOM();
  6829.         return;
  6830.       }
  6831.       if (!this.validateRow(rowIndex, true)) {
  6832.         return;
  6833.       }
  6834.       this.removeRowComponents(rowIndex);
  6835.       this.dataValue[rowIndex] = this.editRows[rowIndex].data;
  6836.       this.editRows[rowIndex].isOpen = false;
  6837.       this.checkValidity(this.data, true);
  6838.       this.updateValue();
  6839.       this.refreshDOM();
  6840.     }
  6841.   }, {
  6842.     key: 'removeRow',
  6843.     value: function removeRow(rowIndex) {
  6844.       if (this.options.readOnly) {
  6845.         return;
  6846.       }
  6847.       this.removeRowComponents(rowIndex);
  6848.       this.splice(rowIndex);
  6849.       this.removeChildFrom(this.editRows[rowIndex].element, this.tableElement);
  6850.       this.editRows.splice(rowIndex, 1);
  6851.       this.updateValue();
  6852.       this.refreshDOM();
  6853.     }
  6854.   }, {
  6855.     key: 'removeRowComponents',
  6856.     value: function removeRowComponents(rowIndex) {
  6857.       var _this6 = this;
  6858.  
  6859.       // Clean up components list.
  6860.       this.editRows[rowIndex].components.forEach(function (comp) {
  6861.         _this6.removeComponent(comp, _this6.components);
  6862.       });
  6863.       this.editRows[rowIndex].components = [];
  6864.     }
  6865.   }, {
  6866.     key: 'validateRow',
  6867.     value: function validateRow(rowIndex, dirty) {
  6868.       var _this7 = this;
  6869.  
  6870.       var check = true;
  6871.       this.editRows[rowIndex].components.forEach(function (comp) {
  6872.         comp.setPristine(!dirty);
  6873.         check &= comp.checkValidity(_this7.editRows[rowIndex].data, dirty);
  6874.       });
  6875.  
  6876.       if (this.component.validate && this.component.validate.row) {
  6877.         var custom = this.component.validate.row;
  6878.         custom = custom.replace(/({{\s+(.*)\s+}})/, function (match, $1, $2) {
  6879.           return _this7.editRows[rowIndex].data[$2];
  6880.         });
  6881.         var valid = void 0;
  6882.         try {
  6883.           var row = this.editRows[rowIndex].data;
  6884.           var data = this.data;
  6885.           valid = new Function('row', 'data', custom + '; return valid;')(row, data);
  6886.         } catch (e) {
  6887.           /* eslint-disable no-console, no-undef */
  6888.           console.warn('A syntax error occurred while computing custom values in ' + this.component.key, e);
  6889.           /* eslint-enable no-console */
  6890.         }
  6891.         this.editRows[rowIndex].errorContainer.innerHTML = '';
  6892.         if (valid !== true) {
  6893.           this.editRows[rowIndex].errorContainer.appendChild(this.ce('div', { class: 'editgrid-row-error help-block' }, valid));
  6894.           return false;
  6895.         }
  6896.       }
  6897.  
  6898.       return check;
  6899.     }
  6900.   }, {
  6901.     key: 'checkValidity',
  6902.     value: function checkValidity(data, dirty) {
  6903.       var _this8 = this;
  6904.  
  6905.       if (!_utils2.default.checkCondition(this.component, data, this.data)) {
  6906.         return true;
  6907.       }
  6908.  
  6909.       var rowsValid = true;
  6910.       var rowsClosed = true;
  6911.       this.editRows.forEach(function (editRow, rowIndex) {
  6912.         // Trigger all errors on the row.
  6913.         var rowValid = _this8.validateRow(rowIndex, false);
  6914.         // Add has-error class to row.
  6915.         if (!rowValid) {
  6916.           _this8.addClass(_this8.editRows[rowIndex].element, 'has-error');
  6917.         } else {
  6918.           _this8.removeClass(_this8.editRows[rowIndex].element, 'has-error');
  6919.         }
  6920.         rowsValid &= rowValid;
  6921.  
  6922.         // Any open rows causes validation to fail.
  6923.         rowsClosed &= !editRow.isOpen;
  6924.       });
  6925.  
  6926.       if (!rowsValid) {
  6927.         this.setCustomValidity('Please correct rows before proceeding.', dirty);
  6928.         return false;
  6929.       } else if (!rowsClosed) {
  6930.         this.setCustomValidity('Please save all rows before proceeding.', dirty);
  6931.         return false;
  6932.       }
  6933.  
  6934.       var message = this.invalid || this.invalidMessage(data, dirty);
  6935.       this.setCustomValidity(message, dirty);
  6936.       return true;
  6937.     }
  6938.   }, {
  6939.     key: 'setCustomValidity',
  6940.     value: function setCustomValidity(message, dirty) {
  6941.       if (this.errorElement && this.errorContainer) {
  6942.         this.errorElement.innerHTML = '';
  6943.         this.removeChildFrom(this.errorElement, this.errorContainer);
  6944.       }
  6945.       this.removeClass(this.element, 'has-error');
  6946.       if (this.options.highlightErrors) {
  6947.         this.removeClass(this.element, 'alert alert-danger');
  6948.       }
  6949.       if (message) {
  6950.         this.emit('componentError', this.error);
  6951.         this.createErrorElement();
  6952.         var errorMessage = this.ce('p', {
  6953.           class: 'help-block'
  6954.         });
  6955.         errorMessage.appendChild(this.text(message));
  6956.         this.appendTo(errorMessage, this.errorElement);
  6957.         // Add error classes
  6958.         this.addClass(this.element, 'has-error');
  6959.         if (dirty && this.options.highlightErrors) {
  6960.           this.addClass(this.element, 'alert alert-danger');
  6961.         }
  6962.       }
  6963.     }
  6964.   }, {
  6965.     key: 'setValue',
  6966.     value: function setValue(value) {
  6967.       var _this9 = this;
  6968.  
  6969.       if (!value) {
  6970.         return;
  6971.       }
  6972.       if (!Array.isArray(value)) {
  6973.         if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
  6974.           value = [value];
  6975.         } else {
  6976.           return;
  6977.         }
  6978.       }
  6979.  
  6980.       this.dataValue = value;
  6981.       // Refresh editRow data when data changes.
  6982.       this.dataValue.forEach(function (row, rowIndex) {
  6983.         if (_this9.editRows[rowIndex]) {
  6984.           _this9.editRows[rowIndex].data = row;
  6985.         } else {
  6986.           _this9.editRows[rowIndex] = {
  6987.             isOpen: false,
  6988.             data: row
  6989.           };
  6990.         }
  6991.       });
  6992.       // Remove any extra edit rows.
  6993.       if (this.dataValue.length < this.editRows.length) {
  6994.         for (var rowIndex = this.editRows.length - 1; rowIndex >= this.dataValue.length; rowIndex--) {
  6995.           this.removeRowComponents(rowIndex);
  6996.           this.removeChildFrom(this.editRows[rowIndex].element, this.tableElement);
  6997.           this.editRows.splice(rowIndex, 1);
  6998.         }
  6999.       }
  7000.       this.refreshDOM();
  7001.     }
  7002.  
  7003.     /**
  7004.      * Get the value of this component.
  7005.      *
  7006.      * @returns {*}
  7007.      */
  7008.  
  7009.   }, {
  7010.     key: 'getValue',
  7011.     value: function getValue() {
  7012.       return this.dataValue;
  7013.     }
  7014.   }, {
  7015.     key: 'emptyValue',
  7016.     get: function get() {
  7017.       return [];
  7018.     }
  7019.   }, {
  7020.     key: 'defaultRowTemplate',
  7021.     get: function get() {
  7022.       return '<div class="row">\n      {% util.eachComponent(components, function(component) { %}\n        <div class="col-sm-2">\n          {{ getView(component, row[component.key]) }}\n        </div>\n      {% }) %}\n      <div class="col-sm-2">\n        <div class="btn-group pull-right">\n          <div class="btn btn-default editRow">Edit</div>\n          <div class="btn btn-danger removeRow">Delete</div>\n        </div>\n      </div>\n    </div>';
  7023.     }
  7024.   }, {
  7025.     key: 'defaultValue',
  7026.     get: function get() {
  7027.       var value = _get(EditGridComponent.prototype.__proto__ || Object.getPrototypeOf(EditGridComponent.prototype), 'defaultValue', this);
  7028.       return Array.isArray(value) ? value : [];
  7029.     }
  7030.   }]);
  7031.  
  7032.   return EditGridComponent;
  7033. }(_Components.FormioComponents);
  7034.  
  7035. },{"../../utils":56,"../Components":1,"lodash":79}],16:[function(require,module,exports){
  7036. 'use strict';
  7037.  
  7038. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  7039.  
  7040. Object.defineProperty(exports, "__esModule", {
  7041.   value: true
  7042. });
  7043. exports.EmailComponent = undefined;
  7044.  
  7045. var _createClass = function () {
  7046.   function defineProperties(target, props) {
  7047.     for (var i = 0; i < props.length; i++) {
  7048.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  7049.     }
  7050.   }return function (Constructor, protoProps, staticProps) {
  7051.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  7052.   };
  7053. }();
  7054.  
  7055. var _get = function get(object, property, receiver) {
  7056.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  7057.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  7058.       return undefined;
  7059.     } else {
  7060.       return get(parent, property, receiver);
  7061.     }
  7062.   } else if ("value" in desc) {
  7063.     return desc.value;
  7064.   } else {
  7065.     var getter = desc.get;if (getter === undefined) {
  7066.       return undefined;
  7067.     }return getter.call(receiver);
  7068.   }
  7069. };
  7070.  
  7071. var _TextField = require('../textfield/TextField');
  7072.  
  7073. function _classCallCheck(instance, Constructor) {
  7074.   if (!(instance instanceof Constructor)) {
  7075.     throw new TypeError("Cannot call a class as a function");
  7076.   }
  7077. }
  7078.  
  7079. function _possibleConstructorReturn(self, call) {
  7080.   if (!self) {
  7081.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  7082.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  7083. }
  7084.  
  7085. function _inherits(subClass, superClass) {
  7086.   if (typeof superClass !== "function" && superClass !== null) {
  7087.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  7088.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  7089. }
  7090.  
  7091. var EmailComponent = exports.EmailComponent = function (_TextFieldComponent) {
  7092.   _inherits(EmailComponent, _TextFieldComponent);
  7093.  
  7094.   function EmailComponent(component, options, data) {
  7095.     _classCallCheck(this, EmailComponent);
  7096.  
  7097.     var _this = _possibleConstructorReturn(this, (EmailComponent.__proto__ || Object.getPrototypeOf(EmailComponent)).call(this, component, options, data));
  7098.  
  7099.     _this.validators.push('email');
  7100.     return _this;
  7101.   }
  7102.  
  7103.   _createClass(EmailComponent, [{
  7104.     key: 'elementInfo',
  7105.     value: function elementInfo() {
  7106.       var info = _get(EmailComponent.prototype.__proto__ || Object.getPrototypeOf(EmailComponent.prototype), 'elementInfo', this).call(this);
  7107.       info.attr.type = 'email';
  7108.       return info;
  7109.     }
  7110.   }]);
  7111.  
  7112.   return EmailComponent;
  7113. }(_TextField.TextFieldComponent);
  7114.  
  7115. },{"../textfield/TextField":36}],17:[function(require,module,exports){
  7116. 'use strict';
  7117.  
  7118. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  7119.  
  7120. Object.defineProperty(exports, "__esModule", {
  7121.   value: true
  7122. });
  7123. exports.FieldsetComponent = undefined;
  7124.  
  7125. var _createClass = function () {
  7126.   function defineProperties(target, props) {
  7127.     for (var i = 0; i < props.length; i++) {
  7128.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  7129.     }
  7130.   }return function (Constructor, protoProps, staticProps) {
  7131.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  7132.   };
  7133. }();
  7134.  
  7135. var _Components = require('../Components');
  7136.  
  7137. function _classCallCheck(instance, Constructor) {
  7138.   if (!(instance instanceof Constructor)) {
  7139.     throw new TypeError("Cannot call a class as a function");
  7140.   }
  7141. }
  7142.  
  7143. function _possibleConstructorReturn(self, call) {
  7144.   if (!self) {
  7145.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  7146.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  7147. }
  7148.  
  7149. function _inherits(subClass, superClass) {
  7150.   if (typeof superClass !== "function" && superClass !== null) {
  7151.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  7152.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  7153. }
  7154.  
  7155. var FieldsetComponent = exports.FieldsetComponent = function (_FormioComponents) {
  7156.   _inherits(FieldsetComponent, _FormioComponents);
  7157.  
  7158.   function FieldsetComponent() {
  7159.     _classCallCheck(this, FieldsetComponent);
  7160.  
  7161.     return _possibleConstructorReturn(this, (FieldsetComponent.__proto__ || Object.getPrototypeOf(FieldsetComponent)).apply(this, arguments));
  7162.   }
  7163.  
  7164.   _createClass(FieldsetComponent, [{
  7165.     key: 'build',
  7166.     value: function build() {
  7167.       this.element = this.ce('fieldset', {
  7168.         id: this.id,
  7169.         class: this.className + ' form-group ' + this.component.customClass
  7170.       });
  7171.       if (this.component.legend) {
  7172.         var legend = this.ce('legend');
  7173.         legend.appendChild(this.text(this.component.legend));
  7174.         this.createTooltip(legend);
  7175.         this.element.appendChild(legend);
  7176.       }
  7177.       this.addComponents(this.element);
  7178.     }
  7179.   }]);
  7180.  
  7181.   return FieldsetComponent;
  7182. }(_Components.FormioComponents);
  7183.  
  7184. },{"../Components":1}],18:[function(require,module,exports){
  7185. 'use strict';
  7186.  
  7187. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  7188.  
  7189. Object.defineProperty(exports, "__esModule", {
  7190.   value: true
  7191. });
  7192. exports.FileComponent = undefined;
  7193.  
  7194. var _createClass = function () {
  7195.   function defineProperties(target, props) {
  7196.     for (var i = 0; i < props.length; i++) {
  7197.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  7198.     }
  7199.   }return function (Constructor, protoProps, staticProps) {
  7200.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  7201.   };
  7202. }();
  7203.  
  7204. var _get = function get(object, property, receiver) {
  7205.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  7206.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  7207.       return undefined;
  7208.     } else {
  7209.       return get(parent, property, receiver);
  7210.     }
  7211.   } else if ("value" in desc) {
  7212.     return desc.value;
  7213.   } else {
  7214.     var getter = desc.get;if (getter === undefined) {
  7215.       return undefined;
  7216.     }return getter.call(receiver);
  7217.   }
  7218. };
  7219.  
  7220. var _Base = require('../base/Base');
  7221.  
  7222. var _utils = require('../../utils');
  7223.  
  7224. var _utils2 = _interopRequireDefault(_utils);
  7225.  
  7226. function _interopRequireDefault(obj) {
  7227.   return obj && obj.__esModule ? obj : { default: obj };
  7228. }
  7229.  
  7230. function _classCallCheck(instance, Constructor) {
  7231.   if (!(instance instanceof Constructor)) {
  7232.     throw new TypeError("Cannot call a class as a function");
  7233.   }
  7234. }
  7235.  
  7236. function _possibleConstructorReturn(self, call) {
  7237.   if (!self) {
  7238.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  7239.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  7240. }
  7241.  
  7242. function _inherits(subClass, superClass) {
  7243.   if (typeof superClass !== "function" && superClass !== null) {
  7244.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  7245.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  7246. }
  7247.  
  7248. var FileComponent = exports.FileComponent = function (_BaseComponent) {
  7249.   _inherits(FileComponent, _BaseComponent);
  7250.  
  7251.   function FileComponent(component, options, data) {
  7252.     _classCallCheck(this, FileComponent);
  7253.  
  7254.     var _this = _possibleConstructorReturn(this, (FileComponent.__proto__ || Object.getPrototypeOf(FileComponent)).call(this, component, options, data));
  7255.  
  7256.     _this.support = {
  7257.       filereader: typeof FileReader != 'undefined',
  7258.       dnd: 'draggable' in document.createElement('span'),
  7259.       formdata: !!window.FormData,
  7260.       progress: 'upload' in new XMLHttpRequest()
  7261.     };
  7262.     return _this;
  7263.   }
  7264.  
  7265.   _createClass(FileComponent, [{
  7266.     key: 'getValue',
  7267.     value: function getValue() {
  7268.       return this.dataValue;
  7269.     }
  7270.   }, {
  7271.     key: 'setValue',
  7272.     value: function setValue(value) {
  7273.       this.dataValue = value || [];
  7274.       this.refreshDOM();
  7275.     }
  7276.   }, {
  7277.     key: 'build',
  7278.     value: function build() {
  7279.       // Restore the value.
  7280.       this.restoreValue();
  7281.  
  7282.       var labelAtTheBottom = this.component.labelPosition === 'bottom';
  7283.  
  7284.       this.createElement();
  7285.       if (!labelAtTheBottom) {
  7286.         this.createLabel(this.element);
  7287.       }
  7288.       this.inputsContainer = this.ce('div');
  7289.       this.errorContainer = this.inputsContainer;
  7290.       this.createErrorElement();
  7291.       this.listContainer = this.buildList();
  7292.       this.inputsContainer.appendChild(this.listContainer);
  7293.       this.uploadContainer = this.buildUpload();
  7294.       this.hiddenFileInputElement = this.buildHiddenFileInput();
  7295.       this.hook('input', this.hiddenFileInputElement, this.inputsContainer);
  7296.       this.inputsContainer.appendChild(this.hiddenFileInputElement);
  7297.       this.inputsContainer.appendChild(this.uploadContainer);
  7298.       this.addWarnings(this.inputsContainer);
  7299.       this.buildUploadStatusList(this.inputsContainer);
  7300.       this.setInputStyles(this.inputsContainer);
  7301.       this.element.appendChild(this.inputsContainer);
  7302.       if (labelAtTheBottom) {
  7303.         this.createLabel(this.element);
  7304.       }
  7305.       this.createDescription(this.element);
  7306.       this.autofocus();
  7307.  
  7308.       // Disable if needed.
  7309.       if (this.shouldDisable) {
  7310.         this.disabled = true;
  7311.       }
  7312.     }
  7313.   }, {
  7314.     key: 'refreshDOM',
  7315.     value: function refreshDOM() {
  7316.       // Don't refresh before the initial render.
  7317.       if (this.listContainer && this.uploadContainer) {
  7318.         // Refresh file list.
  7319.         var newList = this.buildList();
  7320.         this.inputsContainer.replaceChild(newList, this.listContainer);
  7321.         this.listContainer = newList;
  7322.  
  7323.         // Refresh upload container.
  7324.         var newUpload = this.buildUpload();
  7325.         this.inputsContainer.replaceChild(newUpload, this.uploadContainer);
  7326.         this.uploadContainer = newUpload;
  7327.       }
  7328.     }
  7329.   }, {
  7330.     key: 'buildList',
  7331.     value: function buildList() {
  7332.       if (this.component.image) {
  7333.         return this.buildImageList();
  7334.       } else {
  7335.         return this.buildFileList();
  7336.       }
  7337.     }
  7338.   }, {
  7339.     key: 'buildFileList',
  7340.     value: function buildFileList() {
  7341.       var _this2 = this;
  7342.  
  7343.       return this.ce('ul', { class: 'list-group list-group-striped' }, [this.ce('li', { class: 'list-group-item list-group-header hidden-xs hidden-sm' }, this.ce('div', { class: 'row' }, [this.ce('div', { class: 'col-md-1' }), this.ce('div', { class: 'col-md-9' }, this.ce('strong', {}, 'File Name')), this.ce('div', { class: 'col-md-2' }, this.ce('strong', {}, 'Size'))])), this.dataValue.map(function (fileInfo, index) {
  7344.         return _this2.createFileListItem(fileInfo, index);
  7345.       })]);
  7346.     }
  7347.   }, {
  7348.     key: 'buildHiddenFileInput',
  7349.     value: function buildHiddenFileInput() {
  7350.       var _this3 = this;
  7351.  
  7352.       // Input needs to be in DOM and "visible" (opacity 0 is fine) for IE to display file dialog.
  7353.       return this.ce('input', {
  7354.         type: 'file',
  7355.         style: 'opacity: 0; position: absolute;',
  7356.         tabindex: -1, // prevent focus
  7357.         onChange: function onChange() {
  7358.           _this3.upload(_this3.hiddenFileInputElement.files);
  7359.         }
  7360.       });
  7361.     }
  7362.   }, {
  7363.     key: 'createFileListItem',
  7364.     value: function createFileListItem(fileInfo, index) {
  7365.       var _this4 = this;
  7366.  
  7367.       return this.ce('li', { class: 'list-group-item' }, this.ce('div', { class: 'row' }, [this.ce('div', { class: 'col-md-1' }, !this.disabled && !this.shouldDisable ? this.ce('i', {
  7368.         class: this.iconClass('remove'),
  7369.         onClick: function onClick(event) {
  7370.           if (fileInfo && _this4.component.storage === 'url') {
  7371.             _this4.options.formio.makeRequest('', fileInfo.url, 'delete');
  7372.           }
  7373.           event.preventDefault();
  7374.           _this4.splice(index);
  7375.           _this4.refreshDOM();
  7376.         }
  7377.       }) : null), this.ce('div', { class: 'col-md-9' }, this.createFileLink(fileInfo)), this.ce('div', { class: 'col-md-2' }, this.fileSize(fileInfo.size))]));
  7378.     }
  7379.   }, {
  7380.     key: 'createFileLink',
  7381.     value: function createFileLink(file) {
  7382.       return this.ce('a', {
  7383.         href: file.url, target: '_blank',
  7384.         onClick: this.getFile.bind(this, file)
  7385.       }, file.originalName || file.name);
  7386.     }
  7387.   }, {
  7388.     key: 'buildImageList',
  7389.     value: function buildImageList() {
  7390.       var _this5 = this;
  7391.  
  7392.       return this.ce('div', {}, this.dataValue.map(function (fileInfo, index) {
  7393.         return _this5.createImageListItem(fileInfo, index);
  7394.       }));
  7395.     }
  7396.   }, {
  7397.     key: 'createImageListItem',
  7398.     value: function createImageListItem(fileInfo, index) {
  7399.       var _this6 = this;
  7400.  
  7401.       var image = void 0;
  7402.  
  7403.       var fileService = this.fileService;
  7404.       if (fileService) {
  7405.         fileService.downloadFile(fileInfo).then(function (result) {
  7406.           image.src = result.url;
  7407.         });
  7408.       }
  7409.       return this.ce('div', {}, this.ce('span', {}, [image = this.ce('img', {
  7410.         src: '',
  7411.         alt: fileInfo.originalName || fileInfo.name,
  7412.         style: 'width:' + this.component.imageSize + 'px'
  7413.       }), !this.disabled ? this.ce('i', {
  7414.         class: this.iconClass('remove'),
  7415.         onClick: function onClick(event) {
  7416.           if (fileInfo && _this6.component.storage === 'url') {
  7417.             _this6.options.formio.makeRequest('', fileInfo.url, 'delete');
  7418.           }
  7419.           event.preventDefault();
  7420.           _this6.splice(index);
  7421.           _this6.refreshDOM();
  7422.         }
  7423.       }) : null]));
  7424.     }
  7425.   }, {
  7426.     key: 'buildUpload',
  7427.     value: function buildUpload() {
  7428.       // Drop event must change this pointer so need a reference to parent this.
  7429.       var element = this;
  7430.       // If this is disabled or a single value with a value, don't show the upload div.
  7431.       return this.ce('div', {}, !this.disabled && (this.component.multiple || this.dataValue.length === 0) ? this.ce('div', {
  7432.         class: 'fileSelector',
  7433.         onDragover: function onDragover(event) {
  7434.           this.className = 'fileSelector fileDragOver';
  7435.           event.preventDefault();
  7436.         },
  7437.         onDragleave: function onDragleave(event) {
  7438.           this.className = 'fileSelector';
  7439.           event.preventDefault();
  7440.         },
  7441.         onDrop: function onDrop(event) {
  7442.           this.className = 'fileSelector';
  7443.           event.preventDefault();
  7444.           element.upload(event.dataTransfer.files);
  7445.           return false;
  7446.         }
  7447.       }, [this.ce('i', { class: this.iconClass('cloud-upload') }), this.text(' Drop files to attach, or '), this.buildBrowseLink()]) : this.ce('div'));
  7448.     }
  7449.   }, {
  7450.     key: 'buildBrowseLink',
  7451.     value: function buildBrowseLink() {
  7452.       var _this7 = this;
  7453.  
  7454.       this.browseLink = this.ce('a', {
  7455.         href: '#',
  7456.         onClick: function onClick(event) {
  7457.           event.preventDefault();
  7458.           // There is no direct way to trigger a file dialog. To work around this, create an input of type file and trigger
  7459.           // a click event on it.
  7460.           if (typeof _this7.hiddenFileInputElement.trigger === 'function') {
  7461.             _this7.hiddenFileInputElement.trigger('click');
  7462.           } else {
  7463.             _this7.hiddenFileInputElement.click();
  7464.           }
  7465.         },
  7466.         class: 'browse'
  7467.       }, 'browse');
  7468.  
  7469.       return this.browseLink;
  7470.     }
  7471.   }, {
  7472.     key: 'buildUploadStatusList',
  7473.     value: function buildUploadStatusList(container) {
  7474.       var list = this.ce('div');
  7475.       this.uploadStatusList = list;
  7476.       container.appendChild(list);
  7477.     }
  7478.   }, {
  7479.     key: 'addWarnings',
  7480.     value: function addWarnings(container) {
  7481.       var hasWarnings = false;
  7482.       var warnings = this.ce('div', { class: 'alert alert-warning' });
  7483.       if (!this.component.storage) {
  7484.         hasWarnings = true;
  7485.         warnings.appendChild(this.ce('p').appendChild(this.text('No storage has been set for this field. File uploads are disabled until storage is set up.')));
  7486.       }
  7487.       if (!this.support.dnd) {
  7488.         hasWarnings = true;
  7489.         warnings.appendChild(this.ce('p').appendChild(this.text('File Drag/Drop is not supported for this browser.')));
  7490.       }
  7491.       if (!this.support.filereader) {
  7492.         hasWarnings = true;
  7493.         warnings.appendChild(this.ce('p').appendChild(this.text('File API & FileReader API not supported.')));
  7494.       }
  7495.       if (!this.support.formdata) {
  7496.         hasWarnings = true;
  7497.         warnings.appendChild(this.ce('p').appendChild(this.text('XHR2\'s FormData is not supported.')));
  7498.       }
  7499.       if (!this.support.progress) {
  7500.         hasWarnings = true;
  7501.         warnings.appendChild(this.ce('p').appendChild(this.text('XHR2\'s upload progress isn\'t supported.')));
  7502.       }
  7503.       if (hasWarnings) {
  7504.         container.appendChild(warnings);
  7505.       }
  7506.     }
  7507.   }, {
  7508.     key: 'fileSize',
  7509.     value: function fileSize(a, b, c, d, e) {
  7510.       return (b = Math, c = b.log, d = 1024, e = c(a) / c(d) | 0, a / b.pow(d, e)).toFixed(2) + ' ' + (e ? 'kMGTPEZY'[--e] + 'B' : 'Bytes');
  7511.     }
  7512.   }, {
  7513.     key: 'createUploadStatus',
  7514.     value: function createUploadStatus(fileUpload) {
  7515.       var _this8 = this;
  7516.  
  7517.       var container = void 0;
  7518.       return container = this.ce('div', { class: 'file' + (fileUpload.status === 'error' ? ' has-error' : '') }, [this.ce('div', { class: 'row' }, [this.ce('div', { class: 'fileName control-label col-sm-10' }, [fileUpload.originalName, this.ce('i', {
  7519.         class: this.iconClass('remove'),
  7520.         onClick: function onClick() {
  7521.           _this8.removeChildFrom(container, _this8.uploadStatusList);
  7522.         }
  7523.       })]), this.ce('div', { class: 'fileSize control-label col-sm-2 text-right' }, this.fileSize(fileUpload.size))]), this.ce('div', { class: 'row' }, [this.ce('div', { class: 'col-sm-12' }, [fileUpload.status === 'progress' ? this.ce('div', { class: 'progress' }, this.ce('div', {
  7524.         class: 'progress-bar',
  7525.         role: 'progressbar',
  7526.         'aria-valuenow': fileUpload.progress,
  7527.         'aria-valuemin': 0,
  7528.         'aria-valuemax': 100,
  7529.         style: 'width:' + fileUpload.progress + '%'
  7530.       }, this.ce('span', { class: 'sr-only' }, fileUpload.progress + '% Complete'))) : this.ce('div', { class: 'bg-' + fileUpload.status }, fileUpload.message)])])]);
  7531.     }
  7532.   }, {
  7533.     key: 'globStringToRegex',
  7534.     value: function globStringToRegex(str) {
  7535.       var regexp = '',
  7536.           excludes = [];
  7537.       if (str.length > 2 && str[0] === '/' && str[str.length - 1] === '/') {
  7538.         regexp = str.substring(1, str.length - 1);
  7539.       } else {
  7540.         var split = str.split(',');
  7541.         if (split.length > 1) {
  7542.           for (var i = 0; i < split.length; i++) {
  7543.             var r = this.globStringToRegex(split[i]);
  7544.             if (r.regexp) {
  7545.               regexp += '(' + r.regexp + ')';
  7546.               if (i < split.length - 1) {
  7547.                 regexp += '|';
  7548.               }
  7549.             } else {
  7550.               excludes = excludes.concat(r.excludes);
  7551.             }
  7552.           }
  7553.         } else {
  7554.           if (str.indexOf('!') === 0) {
  7555.             excludes.push('^((?!' + this.globStringToRegex(str.substring(1)).regexp + ').)*$');
  7556.           } else {
  7557.             if (str.indexOf('.') === 0) {
  7558.               str = '*' + str;
  7559.             }
  7560.             regexp = '^' + str.replace(new RegExp('[.\\\\+*?\\[\\^\\]$(){}=!<>|:\\-]', 'g'), '\\$&') + '$';
  7561.             regexp = regexp.replace(/\\\*/g, '.*').replace(/\\\?/g, '.');
  7562.           }
  7563.         }
  7564.       }
  7565.       return { regexp: regexp, excludes: excludes };
  7566.     }
  7567.   }, {
  7568.     key: 'translateScalars',
  7569.     value: function translateScalars(str) {
  7570.       if (typeof str === 'string') {
  7571.         if (str.search(/kb/i) === str.length - 2) {
  7572.           return parseFloat(str.substring(0, str.length - 2) * 1024);
  7573.         } else if (str.search(/mb/i) === str.length - 2) {
  7574.           return parseFloat(str.substring(0, str.length - 2) * 1048576);
  7575.         } else if (str.search(/gb/i) === str.length - 2) {
  7576.           return parseFloat(str.substring(0, str.length - 2) * 1073741824);
  7577.         } else if (str.search(/b/i) === str.length - 1) {
  7578.           return parseFloat(str.substring(0, str.length - 1));
  7579.         } else if (str.search(/s/i) === str.length - 1) {
  7580.           return parseFloat(str.substring(0, str.length - 1));
  7581.         } else if (str.search(/m/i) === str.length - 1) {
  7582.           return parseFloat(str.substring(0, str.length - 1) * 60);
  7583.         } else if (str.search(/h/i) === str.length - 1) {
  7584.           return parseFloat(str.substring(0, str.length - 1) * 3600);
  7585.         }
  7586.       }
  7587.       return str;
  7588.     }
  7589.   }, {
  7590.     key: 'validatePattern',
  7591.     value: function validatePattern(file, val) {
  7592.       if (!val) {
  7593.         return true;
  7594.       }
  7595.       var pattern = this.globStringToRegex(val);
  7596.       var valid = true;
  7597.       if (pattern.regexp && pattern.regexp.length) {
  7598.         var regexp = new RegExp(pattern.regexp, 'i');
  7599.         valid = file.type != null && regexp.test(file.type) || file.name != null && regexp.test(file.name);
  7600.       }
  7601.       var len = pattern.excludes.length;
  7602.       while (len--) {
  7603.         var exclude = new RegExp(pattern.excludes[len], 'i');
  7604.         valid = valid && (file.type == null || exclude.test(file.type)) && (file.name == null || exclude.test(file.name));
  7605.       }
  7606.       return valid;
  7607.     }
  7608.   }, {
  7609.     key: 'validateMinSize',
  7610.     value: function validateMinSize(file, val) {
  7611.       return file.size + 0.1 >= this.translateScalars(val);
  7612.     }
  7613.   }, {
  7614.     key: 'validateMaxSize',
  7615.     value: function validateMaxSize(file, val) {
  7616.       return file.size - 0.1 <= this.translateScalars(val);
  7617.     }
  7618.   }, {
  7619.     key: 'upload',
  7620.     value: function upload(files) {
  7621.       var _this9 = this;
  7622.  
  7623.       // Only allow one upload if not multiple.
  7624.       if (!this.component.multiple) {
  7625.         files = Array.prototype.slice.call(files, 0, 1);
  7626.       }
  7627.       if (this.component.storage && files && files.length) {
  7628.         // files is not really an array and does not have a forEach method, so fake it.
  7629.         Array.prototype.forEach.call(files, function (file) {
  7630.           var fileUpload = {
  7631.             originalName: file.name,
  7632.             name: fileName,
  7633.             size: file.size,
  7634.             status: 'info',
  7635.             message: 'Starting upload'
  7636.           };
  7637.  
  7638.           // Check file pattern
  7639.           if (_this9.component.filePattern && !_this9.validatePattern(file, _this9.component.filePattern)) {
  7640.             fileUpload.status = 'error';
  7641.             fileUpload.message = 'File is the wrong type; it must be ' + _this9.component.filePattern;
  7642.           }
  7643.  
  7644.           // Check file minimum size
  7645.           if (_this9.component.fileMinSize && !_this9.validateMinSize(file, _this9.component.fileMinSize)) {
  7646.             fileUpload.status = 'error';
  7647.             fileUpload.message = 'File is too small; it must be at least ' + _this9.component.fileMinSize;
  7648.           }
  7649.  
  7650.           // Check file maximum size
  7651.           if (_this9.component.fileMaxSize && !_this9.validateMaxSize(file, _this9.component.fileMaxSize)) {
  7652.             fileUpload.status = 'error';
  7653.             fileUpload.message = 'File is too big; it must be at most ' + _this9.component.fileMaxSize;
  7654.           }
  7655.  
  7656.           // Get a unique name for this file to keep file collisions from occurring.
  7657.           var fileName = _utils2.default.uniqueName(file.name);
  7658.           var dir = _this9.interpolate(_this9.component.dir || '', { data: _this9.data, row: _this9.row });
  7659.           var fileService = _this9.fileService;
  7660.           if (!fileService) {
  7661.             fileUpload.status = 'error';
  7662.             fileUpload.message = 'File Service not provided.';
  7663.           }
  7664.  
  7665.           var uploadStatus = _this9.createUploadStatus(fileUpload);
  7666.           _this9.uploadStatusList.appendChild(uploadStatus);
  7667.  
  7668.           if (fileUpload.status !== 'error') {
  7669.             fileService.uploadFile(_this9.component.storage, file, fileName, dir, function (evt) {
  7670.               fileUpload.status = 'progress';
  7671.               fileUpload.progress = parseInt(100.0 * evt.loaded / evt.total);
  7672.               delete fileUpload.message;
  7673.               var originalStatus = uploadStatus;
  7674.               uploadStatus = _this9.createUploadStatus(fileUpload);
  7675.               _this9.uploadStatusList.replaceChild(uploadStatus, originalStatus);
  7676.             }, _this9.component.url).then(function (fileInfo) {
  7677.               _this9.removeChildFrom(uploadStatus, _this9.uploadStatusList);
  7678.               fileInfo.originalName = file.name;
  7679.               _this9.dataValue.push(fileInfo);
  7680.               _this9.refreshDOM();
  7681.               _this9.triggerChange();
  7682.             }).catch(function (response) {
  7683.               fileUpload.status = 'error';
  7684.               fileUpload.message = response;
  7685.               delete fileUpload.progress;
  7686.               var originalStatus = uploadStatus;
  7687.               uploadStatus = _this9.createUploadStatus(fileUpload);
  7688.               _this9.uploadStatusList.replaceChild(uploadStatus, originalStatus);
  7689.             });
  7690.           }
  7691.         });
  7692.       }
  7693.     }
  7694.   }, {
  7695.     key: 'getFile',
  7696.     value: function getFile(fileInfo, event) {
  7697.       var fileService = this.fileService;
  7698.       if (!fileService) {
  7699.         return alert('File Service not provided');
  7700.       }
  7701.       fileService.downloadFile(fileInfo).then(function (file) {
  7702.         if (file) {
  7703.           window.open(file.url, '_blank');
  7704.         }
  7705.       }).catch(function (response) {
  7706.         // Is alert the best way to do this?
  7707.         // User is expecting an immediate notification due to attempting to download a file.
  7708.         alert(response);
  7709.       });
  7710.       event.preventDefault();
  7711.     }
  7712.   }, {
  7713.     key: 'focus',
  7714.     value: function focus() {
  7715.       this.browseLink.focus();
  7716.     }
  7717.   }, {
  7718.     key: 'emptyValue',
  7719.     get: function get() {
  7720.       return [];
  7721.     }
  7722.   }, {
  7723.     key: 'defaultValue',
  7724.     get: function get() {
  7725.       var value = _get(FileComponent.prototype.__proto__ || Object.getPrototypeOf(FileComponent.prototype), 'defaultValue', this);
  7726.       return Array.isArray(value) ? value : [];
  7727.     }
  7728.   }, {
  7729.     key: 'fileService',
  7730.     get: function get() {
  7731.       return this.options.fileService || this.options.formio;
  7732.     }
  7733.   }]);
  7734.  
  7735.   return FileComponent;
  7736. }(_Base.BaseComponent);
  7737.  
  7738. },{"../../utils":56,"../base/Base":4}],19:[function(require,module,exports){
  7739. 'use strict';
  7740.  
  7741. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  7742.  
  7743. Object.defineProperty(exports, "__esModule", {
  7744.   value: true
  7745. });
  7746. exports.FormComponent = undefined;
  7747.  
  7748. var _createClass = function () {
  7749.   function defineProperties(target, props) {
  7750.     for (var i = 0; i < props.length; i++) {
  7751.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  7752.     }
  7753.   }return function (Constructor, protoProps, staticProps) {
  7754.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  7755.   };
  7756. }();
  7757.  
  7758. var _get = function get(object, property, receiver) {
  7759.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  7760.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  7761.       return undefined;
  7762.     } else {
  7763.       return get(parent, property, receiver);
  7764.     }
  7765.   } else if ("value" in desc) {
  7766.     return desc.value;
  7767.   } else {
  7768.     var getter = desc.get;if (getter === undefined) {
  7769.       return undefined;
  7770.     }return getter.call(receiver);
  7771.   }
  7772. };
  7773.  
  7774. var _lodash = require('lodash');
  7775.  
  7776. var _lodash2 = _interopRequireDefault(_lodash);
  7777.  
  7778. var _Base = require('../base/Base');
  7779.  
  7780. var _nativePromiseOnly = require('native-promise-only');
  7781.  
  7782. var _nativePromiseOnly2 = _interopRequireDefault(_nativePromiseOnly);
  7783.  
  7784. var _utils = require('../../utils');
  7785.  
  7786. var _utils2 = _interopRequireDefault(_utils);
  7787.  
  7788. var _formio = require('../../formio');
  7789.  
  7790. var _formio2 = _interopRequireDefault(_formio);
  7791.  
  7792. var _formFactory = require('../../formFactory');
  7793.  
  7794. var _formFactory2 = _interopRequireDefault(_formFactory);
  7795.  
  7796. function _interopRequireDefault(obj) {
  7797.   return obj && obj.__esModule ? obj : { default: obj };
  7798. }
  7799.  
  7800. function _classCallCheck(instance, Constructor) {
  7801.   if (!(instance instanceof Constructor)) {
  7802.     throw new TypeError("Cannot call a class as a function");
  7803.   }
  7804. }
  7805.  
  7806. function _possibleConstructorReturn(self, call) {
  7807.   if (!self) {
  7808.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  7809.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  7810. }
  7811.  
  7812. function _inherits(subClass, superClass) {
  7813.   if (typeof superClass !== "function" && superClass !== null) {
  7814.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  7815.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  7816. }
  7817.  
  7818. var FormComponent = exports.FormComponent = function (_BaseComponent) {
  7819.   _inherits(FormComponent, _BaseComponent);
  7820.  
  7821.   function FormComponent(component, options, data) {
  7822.     _classCallCheck(this, FormComponent);
  7823.  
  7824.     var _this = _possibleConstructorReturn(this, (FormComponent.__proto__ || Object.getPrototypeOf(FormComponent)).call(this, component, options, data));
  7825.  
  7826.     _this.submitted = false;
  7827.     _this.subForm = null;
  7828.     _this.subFormReady = new _nativePromiseOnly2.default(function (resolve, reject) {
  7829.       _this.subFormReadyResolve = resolve;
  7830.       _this.subFormReadyReject = reject;
  7831.     });
  7832.     return _this;
  7833.   }
  7834.  
  7835.   _createClass(FormComponent, [{
  7836.     key: 'loadSubForm',
  7837.  
  7838.     /**
  7839.      * Load the subform.
  7840.      */
  7841.     value: function loadSubForm() {
  7842.       var _this2 = this;
  7843.  
  7844.       // Only load the subform if the subform isn't loaded and the conditions apply.
  7845.       if (this.subFormLoaded || !_get(FormComponent.prototype.__proto__ || Object.getPrototypeOf(FormComponent.prototype), 'checkConditions', this).call(this, this.root ? this.root.data : this.data)) {
  7846.         return this.subFormReady;
  7847.       }
  7848.       this.subFormLoaded = true;
  7849.       var srcOptions = {};
  7850.       if (this.options && this.options.base) {
  7851.         srcOptions.base = this.options.base;
  7852.       }
  7853.       if (this.options && this.options.project) {
  7854.         srcOptions.project = this.options.project;
  7855.       }
  7856.  
  7857.       // Make sure that if reference is provided, the form must submit.
  7858.       if (this.component.reference) {
  7859.         this.component.submit = true;
  7860.       }
  7861.  
  7862.       if (!this.component.src && !this.options.formio && this.component.form) {
  7863.         this.component.src = _formio2.default.getBaseUrl();
  7864.         if (this.component.project) {
  7865.           // Check to see if it is a MongoID.
  7866.           if (_utils2.default.isMongoId(this.component.project)) {
  7867.             this.component.src += '/project';
  7868.           }
  7869.           this.component.src += '/' + this.component.project;
  7870.           srcOptions.project = this.component.src;
  7871.         }
  7872.         this.component.src += '/form/' + this.component.form;
  7873.       }
  7874.  
  7875.       // Build the source based on the root src path.
  7876.       if (!this.component.src && this.options.formio) {
  7877.         var rootSrc = this.options.formio.formsUrl;
  7878.         if (this.component.path) {
  7879.           var parts = rootSrc.split('/');
  7880.           parts.pop();
  7881.           this.component.src = parts.join('/') + '/' + this.component.path;
  7882.         }
  7883.         if (this.component.form) {
  7884.           this.component.src = rootSrc + '/' + this.component.form;
  7885.         }
  7886.       }
  7887.  
  7888.       new _formio2.default(this.component.src).loadForm({ params: { live: 1 } }).then(function (formObj) {
  7889.         // Iterate through every component and hide the submit button.
  7890.         _utils2.default.eachComponent(formObj.components, function (component) {
  7891.           if (component.type === 'button' && component.action === 'submit') {
  7892.             component.hidden = true;
  7893.           }
  7894.         });
  7895.  
  7896.         _this2.subForm = (0, _formFactory2.default)(_this2.element, formObj, srcOptions);
  7897.         _this2.subForm.on('change', function () {
  7898.           return _this2.onChange();
  7899.         });
  7900.         _this2.subForm.url = _this2.component.src;
  7901.         _this2.subForm.nosubmit = false;
  7902.         _this2.subFormReadyResolve(_this2.subForm);
  7903.       }).catch(function (err) {
  7904.         return _this2.subFormReadyReject(err);
  7905.       });
  7906.       return this.subFormReady;
  7907.     }
  7908.   }, {
  7909.     key: 'checkValidity',
  7910.     value: function checkValidity(data, dirty) {
  7911.       if (this.subForm) {
  7912.         return this.subForm.checkValidity(this.dataValue.data, dirty);
  7913.       }
  7914.  
  7915.       return _get(FormComponent.prototype.__proto__ || Object.getPrototypeOf(FormComponent.prototype), 'checkValidity', this).call(this, data, dirty);
  7916.     }
  7917.   }, {
  7918.     key: 'checkConditions',
  7919.     value: function checkConditions(data) {
  7920.       if (this.subForm) {
  7921.         return this.subForm.checkConditions(this.dataValue.data);
  7922.       }
  7923.  
  7924.       if (_get(FormComponent.prototype.__proto__ || Object.getPrototypeOf(FormComponent.prototype), 'checkConditions', this).call(this, data)) {
  7925.         this.loadSubForm();
  7926.         this.restoreValue();
  7927.         return true;
  7928.       }
  7929.  
  7930.       return false;
  7931.     }
  7932.   }, {
  7933.     key: 'calculateValue',
  7934.     value: function calculateValue(data, flags) {
  7935.       if (this.subForm) {
  7936.         return this.subForm.calculateValue(this.dataValue.data, flags);
  7937.       }
  7938.  
  7939.       return _get(FormComponent.prototype.__proto__ || Object.getPrototypeOf(FormComponent.prototype), 'calculateValue', this).call(this, data, flags);
  7940.     }
  7941.  
  7942.     /**
  7943.      * Submit the form before the next page is triggered.
  7944.      */
  7945.  
  7946.   }, {
  7947.     key: 'beforeNext',
  7948.     value: function beforeNext() {
  7949.       var _this3 = this;
  7950.  
  7951.       // If we wish to submit the form on next page, then do that here.
  7952.       if (this.subForm && this.component.submit && !this.submitted) {
  7953.         this.submitted = true;
  7954.         return this.subForm.submit(true).then(function (submission) {
  7955.           _this3.dataValue = submission;
  7956.           return submission;
  7957.         });
  7958.       } else {
  7959.         return _get(FormComponent.prototype.__proto__ || Object.getPrototypeOf(FormComponent.prototype), 'beforeNext', this).call(this);
  7960.       }
  7961.     }
  7962.  
  7963.     /**
  7964.      * Submit the form before the whole form is triggered.
  7965.      */
  7966.  
  7967.   }, {
  7968.     key: 'beforeSubmit',
  7969.     value: function beforeSubmit() {
  7970.       var _this4 = this;
  7971.  
  7972.       // Ensure we submit the form.
  7973.       if (this.subForm && this.component.submit && !this.submitted) {
  7974.         this.submitted = true;
  7975.         return this.subForm.submit(true).then(function (submission) {
  7976.           _this4.dataValue = _this4.component.reference ? {
  7977.             _id: submission._id,
  7978.             form: submission.form
  7979.           } : submission;
  7980.           return _this4.dataValue;
  7981.         });
  7982.       } else {
  7983.         return _get(FormComponent.prototype.__proto__ || Object.getPrototypeOf(FormComponent.prototype), 'beforeSubmit', this).call(this);
  7984.       }
  7985.     }
  7986.   }, {
  7987.     key: 'build',
  7988.     value: function build() {
  7989.       this.createElement();
  7990.     }
  7991.   }, {
  7992.     key: 'setValue',
  7993.     value: function setValue(submission, flags) {
  7994.       var _this5 = this;
  7995.  
  7996.       // Determine if the submission has changed.
  7997.       var changed = flags.changed || this.hasChanged(submission, this.dataValue);
  7998.       this.dataValue = submission;
  7999.  
  8000.       // Update the submission on the form.
  8001.       if (submission && (submission._id || !_lodash2.default.isEmpty(submission.data))) {
  8002.         this.loadSubForm().then(function (form) {
  8003.           if (submission._id && !flags.noload) {
  8004.             var submissionUrl = form.formio.formsUrl + '/' + submission.form + '/submission/' + submission._id;
  8005.             form.setSrc(submissionUrl, _this5.options);
  8006.           } else {
  8007.             form.setSubmission(submission);
  8008.           }
  8009.         });
  8010.       }
  8011.  
  8012.       // Return if the value has changed.
  8013.       this.updateOnChange(flags, changed);
  8014.       return changed;
  8015.     }
  8016.   }, {
  8017.     key: 'getValue',
  8018.     value: function getValue() {
  8019.       return this.dataValue;
  8020.     }
  8021.   }, {
  8022.     key: 'emptyValue',
  8023.     get: function get() {
  8024.       return { data: {} };
  8025.     }
  8026.   }]);
  8027.  
  8028.   return FormComponent;
  8029. }(_Base.BaseComponent);
  8030.  
  8031. },{"../../formFactory":41,"../../formio":44,"../../utils":56,"../base/Base":4,"lodash":79,"native-promise-only":81}],20:[function(require,module,exports){
  8032. 'use strict';
  8033.  
  8034. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8035.  
  8036. Object.defineProperty(exports, "__esModule", {
  8037.   value: true
  8038. });
  8039. exports.GmapComponent = undefined;
  8040.  
  8041. var _createClass = function () {
  8042.   function defineProperties(target, props) {
  8043.     for (var i = 0; i < props.length; i++) {
  8044.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8045.     }
  8046.   }return function (Constructor, protoProps, staticProps) {
  8047.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8048.   };
  8049. }();
  8050.  
  8051. var _get = function get(object, property, receiver) {
  8052.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  8053.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  8054.       return undefined;
  8055.     } else {
  8056.       return get(parent, property, receiver);
  8057.     }
  8058.   } else if ("value" in desc) {
  8059.     return desc.value;
  8060.   } else {
  8061.     var getter = desc.get;if (getter === undefined) {
  8062.       return undefined;
  8063.     }return getter.call(receiver);
  8064.   }
  8065. };
  8066.  
  8067. var _Base = require('../base/Base');
  8068.  
  8069. function _classCallCheck(instance, Constructor) {
  8070.   if (!(instance instanceof Constructor)) {
  8071.     throw new TypeError("Cannot call a class as a function");
  8072.   }
  8073. }
  8074.  
  8075. function _possibleConstructorReturn(self, call) {
  8076.   if (!self) {
  8077.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8078.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8079. }
  8080.  
  8081. function _inherits(subClass, superClass) {
  8082.   if (typeof superClass !== "function" && superClass !== null) {
  8083.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  8084.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8085. } /* globals google */
  8086.  
  8087. var GmapComponent = exports.GmapComponent = function (_BaseComponent) {
  8088.   _inherits(GmapComponent, _BaseComponent);
  8089.  
  8090.   function GmapComponent(component, options, data) {
  8091.     _classCallCheck(this, GmapComponent);
  8092.  
  8093.     // Get the source for Google Maps API
  8094.     var _this = _possibleConstructorReturn(this, (GmapComponent.__proto__ || Object.getPrototypeOf(GmapComponent)).call(this, component, options, data));
  8095.  
  8096.     var src = 'https://maps.googleapis.com/maps/api/js?v=3&libraries=places&callback=googleMapsCallback';
  8097.     if (component.map && component.map.key) {
  8098.       src += '&key=' + component.map.key;
  8099.     }
  8100.     if (component.map && component.map.region) {
  8101.       src += '&region=' + component.map.region;
  8102.     }
  8103.     _Base.BaseComponent.requireLibrary('googleMaps', 'google.maps.places', src);
  8104.     return _this;
  8105.   }
  8106.  
  8107.   _createClass(GmapComponent, [{
  8108.     key: 'build',
  8109.     value: function build() {
  8110.       this.element = this.ce('div', {
  8111.         class: 'map-container'
  8112.       });
  8113.       this.initGoogleMap();
  8114.       this.input = this.createInput(this.element);
  8115.       this.addInput(this.input, this.element);
  8116.       var gmapElement = this.ce('div', {
  8117.         id: this.component.map.gmapId,
  8118.         style: 'min-height: 300px; height: calc(100vh - 600px);'
  8119.       });
  8120.       this.element.appendChild(gmapElement);
  8121.     }
  8122.   }, {
  8123.     key: 'setValue',
  8124.     value: function setValue(value, flags) {
  8125.       flags = this.getFlags.apply(this, arguments);
  8126.       flags.noValidate = true;
  8127.       _get(GmapComponent.prototype.__proto__ || Object.getPrototypeOf(GmapComponent.prototype), 'setValue', this).call(this, value, flags);
  8128.     }
  8129.   }, {
  8130.     key: 'addInput',
  8131.     value: function addInput(input, container) {
  8132.       var _this2 = this;
  8133.  
  8134.       _get(GmapComponent.prototype.__proto__ || Object.getPrototypeOf(GmapComponent.prototype), 'addInput', this).call(this, input, container);
  8135.       var that = this;
  8136.       _Base.BaseComponent.libraryReady('googleMaps').then(function () {
  8137.         var autocompleteOptions = {};
  8138.         if (_this2.component.map) {
  8139.           autocompleteOptions = _this2.component.map.autocompleteOptions || {};
  8140.         }
  8141.         var autocomplete = new google.maps.places.Autocomplete(input, autocompleteOptions);
  8142.         autocomplete.addListener('place_changed', function () {
  8143.           that.marker.setVisible(false);
  8144.           var place = autocomplete.getPlace();
  8145.           if (!place.geometry) {
  8146.             console.log("Autocomplete's returned place contains no geometry");
  8147.             return;
  8148.           }
  8149.  
  8150.           // If the place has a geometry, then present it on a map.
  8151.           if (place.geometry.viewport) {
  8152.             that.map.fitBounds(place.geometry.viewport);
  8153.           } else {
  8154.             that.map.setCenter(place.geometry.location);
  8155.             that.map.setZoom(17); // Why 17? Because it looks good.
  8156.           }
  8157.           that.marker.setIcon( /** @type {google.maps.Icon} */{
  8158.             url: place.icon,
  8159.             size: new google.maps.Size(71, 71),
  8160.             origin: new google.maps.Point(0, 0),
  8161.             anchor: new google.maps.Point(17, 34),
  8162.             scaledSize: new google.maps.Size(35, 35)
  8163.           });
  8164.           that.marker.setPosition(place.geometry.location);
  8165.           that.marker.setVisible(true);
  8166.           that.setValue(place.name);
  8167.         });
  8168.       });
  8169.     }
  8170.   }, {
  8171.     key: 'elementInfo',
  8172.     value: function elementInfo() {
  8173.       var info = _get(GmapComponent.prototype.__proto__ || Object.getPrototypeOf(GmapComponent.prototype), 'elementInfo', this).call(this);
  8174.       info.attr.class += ' Gmap-search';
  8175.       return info;
  8176.     }
  8177.   }, {
  8178.     key: 'initGoogleMap',
  8179.     value: function initGoogleMap() {
  8180.       var _this3 = this;
  8181.  
  8182.       _Base.BaseComponent.libraryReady('googleMaps').then(function () {
  8183.         var defaultLatlng = new google.maps.LatLng(45.5041482, -73.5574125);
  8184.         var options = {
  8185.           zoom: 19,
  8186.           center: defaultLatlng,
  8187.           mapTypeId: google.maps.MapTypeId.ROADMAP,
  8188.           styles: [{
  8189.             'featureType': 'poi',
  8190.             'stylers': [{
  8191.               'visibility': 'off'
  8192.             }]
  8193.           }, {
  8194.             'featureType': 'transit',
  8195.             'stylers': [{
  8196.               'visibility': 'off'
  8197.             }]
  8198.           }]
  8199.         };
  8200.  
  8201.         var mapElement = document.getElementById(_this3.component.map.gmapId);
  8202.         if (!mapElement) {
  8203.           return;
  8204.         }
  8205.         _this3.map = new google.maps.Map(mapElement, options);
  8206.         _this3.addMarker(defaultLatlng, 'Default Marker', _this3.map);
  8207.       });
  8208.     }
  8209.   }, {
  8210.     key: 'addMarker',
  8211.     value: function addMarker(latlng, title, map) {
  8212.       var that = this;
  8213.       this.marker = new google.maps.Marker({
  8214.         position: latlng,
  8215.         map: map,
  8216.         title: title,
  8217.         draggable: true
  8218.       });
  8219.       this.marker.addListener('dragend', function (event) {
  8220.         var geocoder = new google.maps.Geocoder();
  8221.         var latlng = { lat: parseFloat(event.latLng.lat()), lng: parseFloat(event.latLng.lng()) };
  8222.         geocoder.geocode({ 'location': latlng }, function (results, status) {
  8223.           if (status === google.maps.GeocoderStatus.OK) {
  8224.             if (results[1]) {
  8225.               that.setValue(results[0].formatted_address);
  8226.             } else {
  8227.               console.log('No results found');
  8228.             }
  8229.           } else {
  8230.             console.log('Geocoder failed due to: ' + status);
  8231.           }
  8232.         });
  8233.       });
  8234.     }
  8235.   }, {
  8236.     key: 'emptyValue',
  8237.     get: function get() {
  8238.       return '';
  8239.     }
  8240.   }]);
  8241.  
  8242.   return GmapComponent;
  8243. }(_Base.BaseComponent);
  8244.  
  8245. },{"../base/Base":4}],21:[function(require,module,exports){
  8246. 'use strict';
  8247.  
  8248. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8249.  
  8250. Object.defineProperty(exports, "__esModule", {
  8251.   value: true
  8252. });
  8253. exports.HiddenComponent = undefined;
  8254.  
  8255. var _createClass = function () {
  8256.   function defineProperties(target, props) {
  8257.     for (var i = 0; i < props.length; i++) {
  8258.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8259.     }
  8260.   }return function (Constructor, protoProps, staticProps) {
  8261.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8262.   };
  8263. }();
  8264.  
  8265. var _get = function get(object, property, receiver) {
  8266.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  8267.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  8268.       return undefined;
  8269.     } else {
  8270.       return get(parent, property, receiver);
  8271.     }
  8272.   } else if ("value" in desc) {
  8273.     return desc.value;
  8274.   } else {
  8275.     var getter = desc.get;if (getter === undefined) {
  8276.       return undefined;
  8277.     }return getter.call(receiver);
  8278.   }
  8279. };
  8280.  
  8281. var _Base = require('../base/Base');
  8282.  
  8283. function _classCallCheck(instance, Constructor) {
  8284.   if (!(instance instanceof Constructor)) {
  8285.     throw new TypeError("Cannot call a class as a function");
  8286.   }
  8287. }
  8288.  
  8289. function _possibleConstructorReturn(self, call) {
  8290.   if (!self) {
  8291.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8292.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8293. }
  8294.  
  8295. function _inherits(subClass, superClass) {
  8296.   if (typeof superClass !== "function" && superClass !== null) {
  8297.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  8298.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8299. }
  8300.  
  8301. var HiddenComponent = exports.HiddenComponent = function (_BaseComponent) {
  8302.   _inherits(HiddenComponent, _BaseComponent);
  8303.  
  8304.   function HiddenComponent() {
  8305.     _classCallCheck(this, HiddenComponent);
  8306.  
  8307.     return _possibleConstructorReturn(this, (HiddenComponent.__proto__ || Object.getPrototypeOf(HiddenComponent)).apply(this, arguments));
  8308.   }
  8309.  
  8310.   _createClass(HiddenComponent, [{
  8311.     key: 'elementInfo',
  8312.     value: function elementInfo() {
  8313.       var info = _get(HiddenComponent.prototype.__proto__ || Object.getPrototypeOf(HiddenComponent.prototype), 'elementInfo', this).call(this);
  8314.       info.type = 'input';
  8315.       info.attr.type = 'hidden';
  8316.       info.changeEvent = 'change';
  8317.       return info;
  8318.     }
  8319.   }, {
  8320.     key: 'createLabel',
  8321.     value: function createLabel() {
  8322.       return;
  8323.     }
  8324.   }]);
  8325.  
  8326.   return HiddenComponent;
  8327. }(_Base.BaseComponent);
  8328.  
  8329. },{"../base/Base":4}],22:[function(require,module,exports){
  8330. 'use strict';
  8331.  
  8332. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8333.  
  8334. Object.defineProperty(exports, "__esModule", {
  8335.   value: true
  8336. });
  8337. exports.HTMLComponent = undefined;
  8338.  
  8339. var _createClass = function () {
  8340.   function defineProperties(target, props) {
  8341.     for (var i = 0; i < props.length; i++) {
  8342.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8343.     }
  8344.   }return function (Constructor, protoProps, staticProps) {
  8345.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8346.   };
  8347. }();
  8348.  
  8349. var _lodash = require('lodash');
  8350.  
  8351. var _lodash2 = _interopRequireDefault(_lodash);
  8352.  
  8353. var _Base = require('../base/Base');
  8354.  
  8355. function _interopRequireDefault(obj) {
  8356.   return obj && obj.__esModule ? obj : { default: obj };
  8357. }
  8358.  
  8359. function _classCallCheck(instance, Constructor) {
  8360.   if (!(instance instanceof Constructor)) {
  8361.     throw new TypeError("Cannot call a class as a function");
  8362.   }
  8363. }
  8364.  
  8365. function _possibleConstructorReturn(self, call) {
  8366.   if (!self) {
  8367.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8368.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8369. }
  8370.  
  8371. function _inherits(subClass, superClass) {
  8372.   if (typeof superClass !== "function" && superClass !== null) {
  8373.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  8374.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8375. }
  8376.  
  8377. var HTMLComponent = exports.HTMLComponent = function (_BaseComponent) {
  8378.   _inherits(HTMLComponent, _BaseComponent);
  8379.  
  8380.   function HTMLComponent() {
  8381.     _classCallCheck(this, HTMLComponent);
  8382.  
  8383.     return _possibleConstructorReturn(this, (HTMLComponent.__proto__ || Object.getPrototypeOf(HTMLComponent)).apply(this, arguments));
  8384.   }
  8385.  
  8386.   _createClass(HTMLComponent, [{
  8387.     key: 'setHTML',
  8388.     value: function setHTML() {
  8389.       this.element.innerHTML = this.interpolate(this.component.content, { data: this.data, row: this.row });
  8390.     }
  8391.   }, {
  8392.     key: 'build',
  8393.     value: function build() {
  8394.       var _this2 = this;
  8395.  
  8396.       this.element = this.ce(this.component.tag, {
  8397.         class: this.component.className
  8398.       });
  8399.       _lodash2.default.each(this.component.attrs, function (attr) {
  8400.         if (attr.attr) {
  8401.           _this2.element.setAttribute(attr.attr, attr.value);
  8402.         }
  8403.       });
  8404.       if (this.component.content) {
  8405.         this.setHTML();
  8406.       }
  8407.  
  8408.       if (this.component.refreshOnChange) {
  8409.         this.on('change', function () {
  8410.           return _this2.setHTML();
  8411.         });
  8412.       }
  8413.     }
  8414.   }]);
  8415.  
  8416.   return HTMLComponent;
  8417. }(_Base.BaseComponent);
  8418.  
  8419. },{"../base/Base":4,"lodash":79}],23:[function(require,module,exports){
  8420. 'use strict';
  8421.  
  8422. Object.defineProperty(exports, "__esModule", {
  8423.   value: true
  8424. });
  8425.  
  8426. var _Address = require('./address/Address');
  8427.  
  8428. var _Base = require('./base/Base');
  8429.  
  8430. var _Content = require('./content/Content');
  8431.  
  8432. var _Container = require('./container/Container');
  8433.  
  8434. var _DataGrid = require('./datagrid/DataGrid');
  8435.  
  8436. var _DateTime = require('./datetime/DateTime');
  8437.  
  8438. var _Day = require('./day/Day');
  8439.  
  8440. var _EditGrid = require('./editrgrid/EditGrid');
  8441.  
  8442. var _HTML = require('./html/HTML');
  8443.  
  8444. var _Hidden = require('./hidden/Hidden');
  8445.  
  8446. var _Form = require('./form/Form');
  8447.  
  8448. var _TextField = require('./textfield/TextField');
  8449.  
  8450. var _PhoneNumber = require('./phonenumber/PhoneNumber');
  8451.  
  8452. var _Email = require('./email/Email');
  8453.  
  8454. var _Time = require('./time/Time');
  8455.  
  8456. var _Checkbox = require('./checkbox/Checkbox');
  8457.  
  8458. var _Currency = require('./currency/Currency');
  8459.  
  8460. var _Fieldset = require('./fieldset/Fieldset');
  8461.  
  8462. var _Signature = require('./signature/Signature');
  8463.  
  8464. var _Select = require('./select/Select');
  8465.  
  8466. var _Resource = require('./resource/Resource');
  8467.  
  8468. var _TextArea = require('./textarea/TextArea');
  8469.  
  8470. var _Button = require('./button/Button');
  8471.  
  8472. var _Number = require('./number/Number');
  8473.  
  8474. var _Password = require('./password/Password');
  8475.  
  8476. var _Panel = require('./panel/Panel');
  8477.  
  8478. var _Column = require('./columns/Column');
  8479.  
  8480. var _Columns = require('./columns/Columns');
  8481.  
  8482. var _Table = require('./table/Table');
  8483.  
  8484. var _Unknown = require('./unknown/Unknown');
  8485.  
  8486. var _Radio = require('./radio/Radio');
  8487.  
  8488. var _SelectBoxes = require('./selectboxes/SelectBoxes');
  8489.  
  8490. var _Survey = require('./survey/Survey');
  8491.  
  8492. var _Well = require('./well/Well');
  8493.  
  8494. var _Gmap = require('./gmap/Gmap');
  8495.  
  8496. var _File = require('./file/File');
  8497.  
  8498. var FormioComponentsIndex = {
  8499.   address: _Address.AddressComponent,
  8500.   base: _Base.BaseComponent,
  8501.   content: _Content.ContentComponent,
  8502.   container: _Container.ContainerComponent,
  8503.   datagrid: _DataGrid.DataGridComponent,
  8504.   datetime: _DateTime.DateTimeComponent,
  8505.   day: _Day.DayComponent,
  8506.   htmlelement: _HTML.HTMLComponent,
  8507.   hidden: _Hidden.HiddenComponent,
  8508.   editgrid: _EditGrid.EditGridComponent,
  8509.   form: _Form.FormComponent,
  8510.   textfield: _TextField.TextFieldComponent,
  8511.   phoneNumber: _PhoneNumber.PhoneNumberComponent,
  8512.   email: _Email.EmailComponent,
  8513.   time: _Time.TimeComponent,
  8514.   checkbox: _Checkbox.CheckBoxComponent,
  8515.   currency: _Currency.CurrencyComponent,
  8516.   fieldset: _Fieldset.FieldsetComponent,
  8517.   signature: _Signature.SignatureComponent,
  8518.   select: _Select.SelectComponent,
  8519.   resource: _Resource.ResourceComponent,
  8520.   textarea: _TextArea.TextAreaComponent,
  8521.   button: _Button.ButtonComponent,
  8522.   number: _Number.NumberComponent,
  8523.   password: _Password.PasswordComponent,
  8524.   panel: _Panel.PanelComponent,
  8525.   column: _Column.ColumnComponent,
  8526.   columns: _Columns.ColumnsComponent,
  8527.   table: _Table.TableComponent,
  8528.   unknown: _Unknown.UnknownComponent,
  8529.   radio: _Radio.RadioComponent,
  8530.   selectboxes: _SelectBoxes.SelectBoxesComponent,
  8531.   survey: _Survey.SurveyComponent,
  8532.   well: _Well.WellComponent,
  8533.   gmap: _Gmap.GmapComponent,
  8534.   file: _File.FileComponent,
  8535.   create: function create(component, options, data, nobuild) {
  8536.     var comp = null;
  8537.     if (!component.type) {
  8538.       return null;
  8539.     } else if (this.hasOwnProperty(component.type)) {
  8540.       comp = new this[component.type](component, options, data);
  8541.     } else {
  8542.       comp = new _Unknown.UnknownComponent(component, options, data);
  8543.     }
  8544.     if (!nobuild) {
  8545.       comp.build();
  8546.       comp.isBuilt = true;
  8547.     }
  8548.     return comp;
  8549.   }
  8550. };
  8551.  
  8552. module.exports = FormioComponentsIndex;
  8553. exports.default = FormioComponentsIndex;
  8554.  
  8555. },{"./address/Address":3,"./base/Base":4,"./button/Button":5,"./checkbox/Checkbox":6,"./columns/Column":7,"./columns/Columns":8,"./container/Container":9,"./content/Content":10,"./currency/Currency":11,"./datagrid/DataGrid":12,"./datetime/DateTime":13,"./day/Day":14,"./editrgrid/EditGrid":15,"./email/Email":16,"./fieldset/Fieldset":17,"./file/File":18,"./form/Form":19,"./gmap/Gmap":20,"./hidden/Hidden":21,"./html/HTML":22,"./number/Number":24,"./panel/Panel":25,"./password/Password":26,"./phonenumber/PhoneNumber":27,"./radio/Radio":28,"./resource/Resource":29,"./select/Select":30,"./selectboxes/SelectBoxes":31,"./signature/Signature":32,"./survey/Survey":33,"./table/Table":34,"./textarea/TextArea":35,"./textfield/TextField":36,"./time/Time":37,"./unknown/Unknown":38,"./well/Well":39}],24:[function(require,module,exports){
  8556. 'use strict';
  8557.  
  8558. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8559.  
  8560. Object.defineProperty(exports, "__esModule", {
  8561.   value: true
  8562. });
  8563. exports.NumberComponent = undefined;
  8564.  
  8565. var _createClass = function () {
  8566.   function defineProperties(target, props) {
  8567.     for (var i = 0; i < props.length; i++) {
  8568.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8569.     }
  8570.   }return function (Constructor, protoProps, staticProps) {
  8571.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8572.   };
  8573. }();
  8574.  
  8575. var _get = function get(object, property, receiver) {
  8576.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  8577.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  8578.       return undefined;
  8579.     } else {
  8580.       return get(parent, property, receiver);
  8581.     }
  8582.   } else if ("value" in desc) {
  8583.     return desc.value;
  8584.   } else {
  8585.     var getter = desc.get;if (getter === undefined) {
  8586.       return undefined;
  8587.     }return getter.call(receiver);
  8588.   }
  8589. };
  8590.  
  8591. var _vanillaTextMask = require('vanilla-text-mask');
  8592.  
  8593. var _vanillaTextMask2 = _interopRequireDefault(_vanillaTextMask);
  8594.  
  8595. var _lodash = require('lodash');
  8596.  
  8597. var _lodash2 = _interopRequireDefault(_lodash);
  8598.  
  8599. var _textMaskAddons = require('text-mask-addons');
  8600.  
  8601. var _Base = require('../base/Base');
  8602.  
  8603. var _utils = require('../../utils');
  8604.  
  8605. var _utils2 = _interopRequireDefault(_utils);
  8606.  
  8607. function _interopRequireDefault(obj) {
  8608.   return obj && obj.__esModule ? obj : { default: obj };
  8609. }
  8610.  
  8611. function _classCallCheck(instance, Constructor) {
  8612.   if (!(instance instanceof Constructor)) {
  8613.     throw new TypeError("Cannot call a class as a function");
  8614.   }
  8615. }
  8616.  
  8617. function _possibleConstructorReturn(self, call) {
  8618.   if (!self) {
  8619.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8620.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8621. }
  8622.  
  8623. function _inherits(subClass, superClass) {
  8624.   if (typeof superClass !== "function" && superClass !== null) {
  8625.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  8626.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8627. }
  8628.  
  8629. var NumberComponent = exports.NumberComponent = function (_BaseComponent) {
  8630.   _inherits(NumberComponent, _BaseComponent);
  8631.  
  8632.   function NumberComponent(component, options, data) {
  8633.     _classCallCheck(this, NumberComponent);
  8634.  
  8635.     var _this = _possibleConstructorReturn(this, (NumberComponent.__proto__ || Object.getPrototypeOf(NumberComponent)).call(this, component, options, data));
  8636.  
  8637.     _this.validators = _this.validators.concat(['min', 'max']);
  8638.  
  8639.     var separators = _utils2.default.getNumberSeparators(_this.options.language);
  8640.  
  8641.     _this.decimalSeparator = options.decimalSeparator = options.decimalSeparator || separators.decimalSeparator;
  8642.  
  8643.     if (_this.component.delimiter) {
  8644.       if (options.hasOwnProperty('thousandsSeparator')) {
  8645.         console.warn("Property 'thousandsSeparator' is deprecated. Please use i18n to specify delimiter.");
  8646.       }
  8647.  
  8648.       _this.delimiter = options.thousandsSeparator || separators.delimiter;
  8649.     } else {
  8650.       _this.delimiter = '';
  8651.     }
  8652.  
  8653.     _this.decimalLimit = _utils2.default.getNumberDecimalLimit(_this.component);
  8654.  
  8655.     // Currencies to override BrowserLanguage Config. Object key {}
  8656.     if (_lodash2.default.has(_this.options, 'languageOverride.' + _this.options.language)) {
  8657.       var override = _lodash2.default.get(_this.options, 'languageOverride.' + _this.options.language);
  8658.       _this.decimalSeparator = override.decimalSeparator;
  8659.       _this.delimiter = override.delimiter;
  8660.     }
  8661.     return _this;
  8662.   }
  8663.  
  8664.   _createClass(NumberComponent, [{
  8665.     key: 'parseNumber',
  8666.     value: function parseNumber(value) {
  8667.       // Remove delimiters and convert decimal separator to dot.
  8668.       value = value.split(this.delimiter).join('').replace(this.decimalSeparator, '.');
  8669.  
  8670.       if (this.component.validate && this.component.validate.integer) {
  8671.         return parseInt(value, 10);
  8672.       } else {
  8673.         return parseFloat(value);
  8674.       }
  8675.     }
  8676.   }, {
  8677.     key: 'setInputMask',
  8678.     value: function setInputMask(input) {
  8679.       input.setAttribute('pattern', '\\d*');
  8680.       input.mask = (0, _vanillaTextMask2.default)({
  8681.         inputElement: input,
  8682.         mask: (0, _textMaskAddons.createNumberMask)({
  8683.           prefix: '',
  8684.           suffix: '',
  8685.           thousandsSeparatorSymbol: _lodash2.default.get(this.component, 'thousandsSeparator', this.delimiter),
  8686.           decimalSymbol: _lodash2.default.get(this.component, 'decimalSymbol', this.decimalSeparator),
  8687.           decimalLimit: _lodash2.default.get(this.component, 'decimalLimit', this.decimalLimit),
  8688.           allowNegative: _lodash2.default.get(this.component, 'allowNegative', true),
  8689.           allowDecimal: _lodash2.default.get(this.component, 'allowDecimal', !(this.component.validate && this.component.validate.integer))
  8690.         })
  8691.       });
  8692.     }
  8693.   }, {
  8694.     key: 'elementInfo',
  8695.     value: function elementInfo() {
  8696.       var info = _get(NumberComponent.prototype.__proto__ || Object.getPrototypeOf(NumberComponent.prototype), 'elementInfo', this).call(this);
  8697.       info.attr.type = 'text';
  8698.       info.attr.inputmode = 'numeric';
  8699.       info.changeEvent = 'input';
  8700.       return info;
  8701.     }
  8702.   }, {
  8703.     key: 'getValueAt',
  8704.     value: function getValueAt(index) {
  8705.       if (!this.inputs.length || !this.inputs[index]) {
  8706.         return null;
  8707.       }
  8708.  
  8709.       var val = this.inputs[index].value;
  8710.  
  8711.       if (!val) {
  8712.         return null;
  8713.       }
  8714.  
  8715.       return this.parseNumber(val);
  8716.     }
  8717.   }, {
  8718.     key: 'clearInput',
  8719.     value: function clearInput(input) {
  8720.       var value = parseFloat(input);
  8721.  
  8722.       if (!_lodash2.default.isNaN(value)) {
  8723.         value = String(value).replace('.', this.decimalSeparator);
  8724.       } else {
  8725.         value = null;
  8726.       }
  8727.  
  8728.       return value;
  8729.     }
  8730.   }, {
  8731.     key: 'formatValue',
  8732.     value: function formatValue(value) {
  8733.       return value;
  8734.     }
  8735.   }, {
  8736.     key: 'setValueAt',
  8737.     value: function setValueAt(index, value) {
  8738.       return _get(NumberComponent.prototype.__proto__ || Object.getPrototypeOf(NumberComponent.prototype), 'setValueAt', this).call(this, index, this.formatValue(this.clearInput(value)));
  8739.     }
  8740.   }, {
  8741.     key: 'focus',
  8742.     value: function focus() {
  8743.       var input = this.inputs[0];
  8744.       if (input) {
  8745.         input.focus();
  8746.         input.setSelectionRange(0, input.value.length);
  8747.       }
  8748.     }
  8749.   }, {
  8750.     key: 'emptyValue',
  8751.     get: function get() {
  8752.       return 0;
  8753.     }
  8754.   }]);
  8755.  
  8756.   return NumberComponent;
  8757. }(_Base.BaseComponent);
  8758.  
  8759. },{"../../utils":56,"../base/Base":4,"lodash":79,"text-mask-addons":86,"vanilla-text-mask":88}],25:[function(require,module,exports){
  8760. 'use strict';
  8761.  
  8762. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8763.  
  8764. Object.defineProperty(exports, "__esModule", {
  8765.   value: true
  8766. });
  8767. exports.PanelComponent = undefined;
  8768.  
  8769. var _createClass = function () {
  8770.   function defineProperties(target, props) {
  8771.     for (var i = 0; i < props.length; i++) {
  8772.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8773.     }
  8774.   }return function (Constructor, protoProps, staticProps) {
  8775.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8776.   };
  8777. }();
  8778.  
  8779. var _Components = require('../Components');
  8780.  
  8781. function _classCallCheck(instance, Constructor) {
  8782.   if (!(instance instanceof Constructor)) {
  8783.     throw new TypeError("Cannot call a class as a function");
  8784.   }
  8785. }
  8786.  
  8787. function _possibleConstructorReturn(self, call) {
  8788.   if (!self) {
  8789.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8790.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8791. }
  8792.  
  8793. function _inherits(subClass, superClass) {
  8794.   if (typeof superClass !== "function" && superClass !== null) {
  8795.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  8796.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8797. }
  8798.  
  8799. var PanelComponent = exports.PanelComponent = function (_FormioComponents) {
  8800.   _inherits(PanelComponent, _FormioComponents);
  8801.  
  8802.   function PanelComponent() {
  8803.     _classCallCheck(this, PanelComponent);
  8804.  
  8805.     return _possibleConstructorReturn(this, (PanelComponent.__proto__ || Object.getPrototypeOf(PanelComponent)).apply(this, arguments));
  8806.   }
  8807.  
  8808.   _createClass(PanelComponent, [{
  8809.     key: 'build',
  8810.     value: function build() {
  8811.       var panelClass = 'card border-' + this.bootstrap4Theme(this.component.theme) + ' ';
  8812.       panelClass += 'panel panel-' + this.component.theme + ' ';
  8813.       panelClass += this.component.customClass;
  8814.       this.element = this.ce('div', {
  8815.         class: panelClass
  8816.       });
  8817.       if (this.component.title) {
  8818.         var heading = this.ce('div', {
  8819.           class: 'card-header panel-heading'
  8820.         });
  8821.         var title = this.ce('h3', {
  8822.           class: 'card-title panel-title'
  8823.         });
  8824.         title.appendChild(this.text(this.component.title));
  8825.         this.createTooltip(title);
  8826.         heading.appendChild(title);
  8827.         this.element.appendChild(heading);
  8828.       }
  8829.       var body = this.ce('div', {
  8830.         class: 'card-body panel-body'
  8831.       });
  8832.       this.addComponents(body);
  8833.       this.element.appendChild(body);
  8834.     }
  8835.   }]);
  8836.  
  8837.   return PanelComponent;
  8838. }(_Components.FormioComponents);
  8839.  
  8840. },{"../Components":1}],26:[function(require,module,exports){
  8841. 'use strict';
  8842.  
  8843. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8844.  
  8845. Object.defineProperty(exports, "__esModule", {
  8846.   value: true
  8847. });
  8848. exports.PasswordComponent = undefined;
  8849.  
  8850. var _createClass = function () {
  8851.   function defineProperties(target, props) {
  8852.     for (var i = 0; i < props.length; i++) {
  8853.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8854.     }
  8855.   }return function (Constructor, protoProps, staticProps) {
  8856.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8857.   };
  8858. }();
  8859.  
  8860. var _get = function get(object, property, receiver) {
  8861.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  8862.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  8863.       return undefined;
  8864.     } else {
  8865.       return get(parent, property, receiver);
  8866.     }
  8867.   } else if ("value" in desc) {
  8868.     return desc.value;
  8869.   } else {
  8870.     var getter = desc.get;if (getter === undefined) {
  8871.       return undefined;
  8872.     }return getter.call(receiver);
  8873.   }
  8874. };
  8875.  
  8876. var _TextField = require('../textfield/TextField');
  8877.  
  8878. function _classCallCheck(instance, Constructor) {
  8879.   if (!(instance instanceof Constructor)) {
  8880.     throw new TypeError("Cannot call a class as a function");
  8881.   }
  8882. }
  8883.  
  8884. function _possibleConstructorReturn(self, call) {
  8885.   if (!self) {
  8886.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8887.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8888. }
  8889.  
  8890. function _inherits(subClass, superClass) {
  8891.   if (typeof superClass !== "function" && superClass !== null) {
  8892.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  8893.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8894. }
  8895.  
  8896. var PasswordComponent = exports.PasswordComponent = function (_TextFieldComponent) {
  8897.   _inherits(PasswordComponent, _TextFieldComponent);
  8898.  
  8899.   function PasswordComponent() {
  8900.     _classCallCheck(this, PasswordComponent);
  8901.  
  8902.     return _possibleConstructorReturn(this, (PasswordComponent.__proto__ || Object.getPrototypeOf(PasswordComponent)).apply(this, arguments));
  8903.   }
  8904.  
  8905.   _createClass(PasswordComponent, [{
  8906.     key: 'elementInfo',
  8907.     value: function elementInfo() {
  8908.       var info = _get(PasswordComponent.prototype.__proto__ || Object.getPrototypeOf(PasswordComponent.prototype), 'elementInfo', this).call(this);
  8909.       info.attr.type = 'password';
  8910.       return info;
  8911.     }
  8912.   }]);
  8913.  
  8914.   return PasswordComponent;
  8915. }(_TextField.TextFieldComponent);
  8916.  
  8917. },{"../textfield/TextField":36}],27:[function(require,module,exports){
  8918. 'use strict';
  8919.  
  8920. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8921.  
  8922. Object.defineProperty(exports, "__esModule", {
  8923.   value: true
  8924. });
  8925. exports.PhoneNumberComponent = undefined;
  8926.  
  8927. var _TextField = require('../textfield/TextField');
  8928.  
  8929. function _classCallCheck(instance, Constructor) {
  8930.   if (!(instance instanceof Constructor)) {
  8931.     throw new TypeError("Cannot call a class as a function");
  8932.   }
  8933. }
  8934.  
  8935. function _possibleConstructorReturn(self, call) {
  8936.   if (!self) {
  8937.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  8938.   }return call && ((typeof call === 'undefined' ? 'undefined' : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  8939. }
  8940.  
  8941. function _inherits(subClass, superClass) {
  8942.   if (typeof superClass !== "function" && superClass !== null) {
  8943.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === 'undefined' ? 'undefined' : _typeof(superClass)));
  8944.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  8945. }
  8946.  
  8947. var PhoneNumberComponent = exports.PhoneNumberComponent = function (_TextFieldComponent) {
  8948.   _inherits(PhoneNumberComponent, _TextFieldComponent);
  8949.  
  8950.   function PhoneNumberComponent() {
  8951.     _classCallCheck(this, PhoneNumberComponent);
  8952.  
  8953.     return _possibleConstructorReturn(this, (PhoneNumberComponent.__proto__ || Object.getPrototypeOf(PhoneNumberComponent)).apply(this, arguments));
  8954.   }
  8955.  
  8956.   return PhoneNumberComponent;
  8957. }(_TextField.TextFieldComponent);
  8958.  
  8959. },{"../textfield/TextField":36}],28:[function(require,module,exports){
  8960. 'use strict';
  8961.  
  8962. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  8963.  
  8964. Object.defineProperty(exports, "__esModule", {
  8965.   value: true
  8966. });
  8967. exports.RadioComponent = undefined;
  8968.  
  8969. var _createClass = function () {
  8970.   function defineProperties(target, props) {
  8971.     for (var i = 0; i < props.length; i++) {
  8972.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  8973.     }
  8974.   }return function (Constructor, protoProps, staticProps) {
  8975.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  8976.   };
  8977. }();
  8978.  
  8979. var _get = function get(object, property, receiver) {
  8980.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  8981.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  8982.       return undefined;
  8983.     } else {
  8984.       return get(parent, property, receiver);
  8985.     }
  8986.   } else if ("value" in desc) {
  8987.     return desc.value;
  8988.   } else {
  8989.     var getter = desc.get;if (getter === undefined) {
  8990.       return undefined;
  8991.     }return getter.call(receiver);
  8992.   }
  8993. };
  8994.  
  8995. var _lodash = require('lodash');
  8996.  
  8997. var _lodash2 = _interopRequireDefault(_lodash);
  8998.  
  8999. var _Base = require('../base/Base');
  9000.  
  9001. function _interopRequireDefault(obj) {
  9002.   return obj && obj.__esModule ? obj : { default: obj };
  9003. }
  9004.  
  9005. function _classCallCheck(instance, Constructor) {
  9006.   if (!(instance instanceof Constructor)) {
  9007.     throw new TypeError("Cannot call a class as a function");
  9008.   }
  9009. }
  9010.  
  9011. function _possibleConstructorReturn(self, call) {
  9012.   if (!self) {
  9013.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  9014.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  9015. }
  9016.  
  9017. function _inherits(subClass, superClass) {
  9018.   if (typeof superClass !== "function" && superClass !== null) {
  9019.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  9020.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  9021. }
  9022.  
  9023. var RadioComponent = exports.RadioComponent = function (_BaseComponent) {
  9024.   _inherits(RadioComponent, _BaseComponent);
  9025.  
  9026.   function RadioComponent() {
  9027.     _classCallCheck(this, RadioComponent);
  9028.  
  9029.     return _possibleConstructorReturn(this, (RadioComponent.__proto__ || Object.getPrototypeOf(RadioComponent)).apply(this, arguments));
  9030.   }
  9031.  
  9032.   _createClass(RadioComponent, [{
  9033.     key: 'elementInfo',
  9034.     value: function elementInfo() {
  9035.       var info = _get(RadioComponent.prototype.__proto__ || Object.getPrototypeOf(RadioComponent.prototype), 'elementInfo', this).call(this);
  9036.       info.type = 'input';
  9037.       info.changeEvent = 'click';
  9038.       info.attr.class = 'form-check-input';
  9039.       return info;
  9040.     }
  9041.   }, {
  9042.     key: 'createInput',
  9043.     value: function createInput(container) {
  9044.       var _this2 = this;
  9045.  
  9046.       var inputGroup = this.ce('div', {
  9047.         class: 'input-group'
  9048.       });
  9049.       var labelOnTheTopOrOnTheLeft = this.optionsLabelOnTheTopOrLeft();
  9050.       var wrappers = [];
  9051.  
  9052.       if (this.component.inputType === 'radio') {
  9053.         this.info.attr.name += this.id;
  9054.       }
  9055.  
  9056.       _lodash2.default.each(this.component.values, function (value) {
  9057.         var wrapperClass = 'form-check ' + _this2.optionWrapperClass;
  9058.         var labelWrapper = _this2.ce('div', {
  9059.           class: wrapperClass
  9060.         });
  9061.         var label = _this2.ce('label', {
  9062.           class: 'control-label form-check-label'
  9063.         });
  9064.  
  9065.         _this2.addShortcut(label, value.shortcut);
  9066.  
  9067.         // Create the SPAN around the textNode for better style hooks
  9068.         var labelSpan = _this2.ce('span');
  9069.  
  9070.         // Determine the attributes for this input.
  9071.         var inputId = '' + _this2.id + _this2.row + '-' + value.value;
  9072.         _this2.info.attr.id = inputId;
  9073.         _this2.info.attr.value = value.value;
  9074.         label.setAttribute('for', _this2.info.attr.id);
  9075.  
  9076.         // Create the input.
  9077.         var input = _this2.ce('input');
  9078.         _lodash2.default.each(_this2.info.attr, function (value, key) {
  9079.           input.setAttribute(key, value);
  9080.         });
  9081.  
  9082.         if (labelOnTheTopOrOnTheLeft) {
  9083.           label.appendChild(labelSpan);
  9084.         }
  9085.  
  9086.         _this2.setInputLabelStyle(label);
  9087.         _this2.setInputStyle(input);
  9088.  
  9089.         _this2.addInput(input, label);
  9090.  
  9091.         labelSpan.appendChild(_this2.text(_this2.addShortcutToLabel(value.label, value.shortcut)));
  9092.         if (!labelOnTheTopOrOnTheLeft) {
  9093.           label.appendChild(labelSpan);
  9094.         }
  9095.         labelWrapper.appendChild(label);
  9096.  
  9097.         inputGroup.appendChild(labelWrapper);
  9098.         wrappers.push(labelWrapper);
  9099.       });
  9100.       this.wrappers = wrappers;
  9101.       container.appendChild(inputGroup);
  9102.       this.errorContainer = container;
  9103.     }
  9104.   }, {
  9105.     key: 'optionsLabelOnTheTopOrLeft',
  9106.     value: function optionsLabelOnTheTopOrLeft() {
  9107.       return ['top', 'left'].indexOf(this.component.optionsLabelPosition) !== -1;
  9108.     }
  9109.   }, {
  9110.     key: 'optionsLabelOnTheTopOrBottom',
  9111.     value: function optionsLabelOnTheTopOrBottom() {
  9112.       return ['top', 'bottom'].indexOf(this.component.optionsLabelPosition) !== -1;
  9113.     }
  9114.   }, {
  9115.     key: 'setInputLabelStyle',
  9116.     value: function setInputLabelStyle(label) {
  9117.       if (this.component.optionsLabelPosition === 'left') {
  9118.         _lodash2.default.assign(label.style, {
  9119.           textAlign: 'center',
  9120.           paddingLeft: 0
  9121.         });
  9122.       }
  9123.  
  9124.       if (this.optionsLabelOnTheTopOrBottom()) {
  9125.         _lodash2.default.assign(label.style, {
  9126.           display: 'block',
  9127.           textAlign: 'center',
  9128.           paddingLeft: 0
  9129.         });
  9130.       }
  9131.     }
  9132.   }, {
  9133.     key: 'setInputStyle',
  9134.     value: function setInputStyle(input) {
  9135.       if (this.component.optionsLabelPosition === 'left') {
  9136.         _lodash2.default.assign(input.style, {
  9137.           position: 'initial',
  9138.           marginLeft: '7px'
  9139.         });
  9140.       }
  9141.  
  9142.       if (this.optionsLabelOnTheTopOrBottom()) {
  9143.         _lodash2.default.assign(input.style, {
  9144.           width: '100%',
  9145.           position: 'initial',
  9146.           marginLeft: 0
  9147.         });
  9148.       }
  9149.     }
  9150.   }, {
  9151.     key: 'getValue',
  9152.     value: function getValue() {
  9153.       if (this.viewOnly) {
  9154.         return this.dataValue;
  9155.       }
  9156.       var value = '';
  9157.       _lodash2.default.each(this.inputs, function (input) {
  9158.         if (input.checked) {
  9159.           value = input.value;
  9160.           if (value === 'true') {
  9161.             value = true;
  9162.           } else if (value === 'false') {
  9163.             value = false;
  9164.           } else if (!isNaN(parseInt(value, 10)) && isFinite(value)) {
  9165.             value = parseInt(value, 10);
  9166.           }
  9167.         }
  9168.       });
  9169.       return value;
  9170.     }
  9171.   }, {
  9172.     key: 'getView',
  9173.     value: function getView(value) {
  9174.       if (!value) {
  9175.         return '';
  9176.       }
  9177.       if (!_lodash2.default.isString(value)) {
  9178.         return _lodash2.default.toString(value);
  9179.       }
  9180.  
  9181.       var option = _lodash2.default.find(this.component.values, function (v) {
  9182.         return v.value === value;
  9183.       });
  9184.  
  9185.       return _lodash2.default.get(option, 'label');
  9186.     }
  9187.   }, {
  9188.     key: 'setValueAt',
  9189.     value: function setValueAt(index, value) {
  9190.       if (this.inputs && this.inputs[index]) {
  9191.         var inputValue = this.inputs[index].value;
  9192.         if (inputValue === 'true') {
  9193.           inputValue = true;
  9194.         } else if (inputValue === 'false') {
  9195.           inputValue = false;
  9196.         } else if (!isNaN(parseInt(inputValue, 10)) && isFinite(inputValue)) {
  9197.           inputValue = parseInt(inputValue, 10);
  9198.         }
  9199.  
  9200.         this.inputs[index].checked = inputValue === value;
  9201.       }
  9202.     }
  9203.   }, {
  9204.     key: 'updateValue',
  9205.     value: function updateValue(value, flags) {
  9206.       var _this3 = this;
  9207.  
  9208.       var changed = _get(RadioComponent.prototype.__proto__ || Object.getPrototypeOf(RadioComponent.prototype), 'updateValue', this).call(this, value, flags);
  9209.       if (changed) {
  9210.         //add/remove selected option class
  9211.         var _value = this.dataValue;
  9212.         var optionSelectedClass = 'radio-selected';
  9213.  
  9214.         _lodash2.default.each(this.wrappers, function (wrapper, index) {
  9215.           var input = _this3.inputs[index];
  9216.           if (input.value === _value) {
  9217.             //add class to container when selected
  9218.             _this3.addClass(wrapper, optionSelectedClass);
  9219.           } else {
  9220.             _this3.removeClass(wrapper, optionSelectedClass);
  9221.           }
  9222.         });
  9223.       }
  9224.       return changed;
  9225.     }
  9226.   }, {
  9227.     key: 'destroy',
  9228.     value: function destroy() {
  9229.       _get(RadioComponent.prototype.__proto__ || Object.getPrototypeOf(RadioComponent.prototype), 'destroy', this).apply(this, Array.prototype.slice.apply(arguments));
  9230.     }
  9231.   }, {
  9232.     key: 'optionWrapperClass',
  9233.     get: function get() {
  9234.       var inputType = this.component.inputType;
  9235.       var wrapperClass = this.component.inline ? 'form-check-inline ' + inputType + '-inline' : inputType;
  9236.       return wrapperClass;
  9237.     }
  9238.   }]);
  9239.  
  9240.   return RadioComponent;
  9241. }(_Base.BaseComponent);
  9242.  
  9243. },{"../base/Base":4,"lodash":79}],29:[function(require,module,exports){
  9244. 'use strict';
  9245.  
  9246. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  9247.  
  9248. Object.defineProperty(exports, "__esModule", {
  9249.   value: true
  9250. });
  9251. exports.ResourceComponent = undefined;
  9252.  
  9253. var _createClass = function () {
  9254.   function defineProperties(target, props) {
  9255.     for (var i = 0; i < props.length; i++) {
  9256.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  9257.     }
  9258.   }return function (Constructor, protoProps, staticProps) {
  9259.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  9260.   };
  9261. }();
  9262.  
  9263. var _get = function get(object, property, receiver) {
  9264.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  9265.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  9266.       return undefined;
  9267.     } else {
  9268.       return get(parent, property, receiver);
  9269.     }
  9270.   } else if ("value" in desc) {
  9271.     return desc.value;
  9272.   } else {
  9273.     var getter = desc.get;if (getter === undefined) {
  9274.       return undefined;
  9275.     }return getter.call(receiver);
  9276.   }
  9277. };
  9278.  
  9279. var _Select = require('../select/Select');
  9280.  
  9281. var _dialogPolyfill = require('dialog-polyfill');
  9282.  
  9283. var _dialogPolyfill2 = _interopRequireDefault(_dialogPolyfill);
  9284.  
  9285. var _formio = require('../../formio.form');
  9286.  
  9287. var _formio2 = _interopRequireDefault(_formio);
  9288.  
  9289. function _interopRequireDefault(obj) {
  9290.   return obj && obj.__esModule ? obj : { default: obj };
  9291. }
  9292.  
  9293. function _classCallCheck(instance, Constructor) {
  9294.   if (!(instance instanceof Constructor)) {
  9295.     throw new TypeError("Cannot call a class as a function");
  9296.   }
  9297. }
  9298.  
  9299. function _possibleConstructorReturn(self, call) {
  9300.   if (!self) {
  9301.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  9302.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  9303. }
  9304.  
  9305. function _inherits(subClass, superClass) {
  9306.   if (typeof superClass !== "function" && superClass !== null) {
  9307.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  9308.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  9309. }
  9310.  
  9311. var ResourceComponent = exports.ResourceComponent = function (_SelectComponent) {
  9312.   _inherits(ResourceComponent, _SelectComponent);
  9313.  
  9314.   function ResourceComponent(component, options, data) {
  9315.     _classCallCheck(this, ResourceComponent);
  9316.  
  9317.     var _this = _possibleConstructorReturn(this, (ResourceComponent.__proto__ || Object.getPrototypeOf(ResourceComponent)).call(this, component, options, data));
  9318.  
  9319.     _this.component.dataSrc = 'resource';
  9320.     _this.component.data = {
  9321.       resource: _this.component.resource
  9322.     };
  9323.     return _this;
  9324.   }
  9325.  
  9326.   /**
  9327.    * Creates a new button to add a resource instance
  9328.    * @returns {HTMLElement} - The "Add Resource" button html element.
  9329.    */
  9330.  
  9331.   _createClass(ResourceComponent, [{
  9332.     key: 'addButton',
  9333.     value: function addButton() {
  9334.       var _this2 = this;
  9335.  
  9336.       var addButton = this.ce('button', {
  9337.         class: 'btn btn-primary'
  9338.       });
  9339.       var addIcon = this.ce('i', {
  9340.         class: this.iconClass('plus')
  9341.       });
  9342.       addButton.appendChild(addIcon);
  9343.       addButton.appendChild(this.text(' ' + (this.component.addResourceLabel || 'Add Resource')));
  9344.  
  9345.       this.addEventListener(addButton, 'click', function (event) {
  9346.         event.preventDefault();
  9347.  
  9348.         // HTML for dialog
  9349.         var template = '' + ('<div class="row">' + '<div class="col-sm-12">' + '<b id="close" class="formio-dialog-close pull-right">X</b>' + '</div>' + '</div>' + '<div class="row">' + '<div class="col-sm-12">' + '<div class="panel panel-default">' + '<div class="panel-heading">' + '<h3 class="panel-title">') + (_this2.component.addResourceLabel || 'Add Resource') + '</h3>' + '</div>' + '<div class="panel-body">' + '<div id="formio"></div>' + '</div>' + '</div>' + '</div>' + '</div>';
  9350.  
  9351.         _this2.dialog = _this2.ce('dialog', {
  9352.           class: 'formio-dialog'
  9353.         });
  9354.         _this2.dialog.innerHTML = template;
  9355.         addButton.ownerDocument.body.appendChild(_this2.dialog);
  9356.         _dialogPolyfill2.default.registerDialog(_this2.dialog);
  9357.  
  9358.         var self = _this2;
  9359.         var close = _this2.dialog.querySelector('#close');
  9360.         var form = new _formio2.default(_this2.dialog.querySelector('#formio'));
  9361.  
  9362.         close.onclick = function () {
  9363.           self.dialog.close();
  9364.         };
  9365.  
  9366.         form.on('submit', function (submission) {
  9367.           self.setValue(submission);
  9368.           self.dialog.close();
  9369.         });
  9370.         form.src = Formio.getBaseUrl() + '/form/' + self.component.resource;
  9371.  
  9372.         _this2.dialog.onclose = function () {
  9373.           self.removeChildFrom(self.dialog, self.dialog.parentElement);
  9374.         };
  9375.  
  9376.         _this2.dialog.showModal();
  9377.       });
  9378.  
  9379.       return addButton;
  9380.     }
  9381.   }, {
  9382.     key: 'addInput',
  9383.     value: function addInput(input, container) {
  9384.       // Add Resource button
  9385.       if (this.component.addResource) {
  9386.         var table = this.ce('table', {
  9387.           class: 'table table-bordered'
  9388.         });
  9389.         var template = '<tbody>' + '<tr>' + '<td id="select">' + '</td>' + '</tr>' + '<tr>' + '<td id="button" colspan="2">' + '</td>' + '</tr>' + '</tbody>';
  9390.         container.appendChild(table);
  9391.         table.innerHTML = template;
  9392.         table.querySelector('#button').appendChild(this.addButton());
  9393.         _get(ResourceComponent.prototype.__proto__ || Object.getPrototypeOf(ResourceComponent.prototype), 'addInput', this).call(this, input, table.querySelector('#select'));
  9394.       } else {
  9395.         _get(ResourceComponent.prototype.__proto__ || Object.getPrototypeOf(ResourceComponent.prototype), 'addInput', this).call(this, input, container);
  9396.       }
  9397.     }
  9398.   }]);
  9399.  
  9400.   return ResourceComponent;
  9401. }(_Select.SelectComponent);
  9402.  
  9403. },{"../../formio.form":42,"../select/Select":30,"dialog-polyfill":60}],30:[function(require,module,exports){
  9404. 'use strict';
  9405.  
  9406. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  9407.  
  9408. Object.defineProperty(exports, "__esModule", {
  9409.   value: true
  9410. });
  9411. exports.SelectComponent = undefined;
  9412.  
  9413. var _createClass = function () {
  9414.   function defineProperties(target, props) {
  9415.     for (var i = 0; i < props.length; i++) {
  9416.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  9417.     }
  9418.   }return function (Constructor, protoProps, staticProps) {
  9419.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  9420.   };
  9421. }();
  9422.  
  9423. var _set = function set(object, property, value, receiver) {
  9424.   var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  9425.     var parent = Object.getPrototypeOf(object);if (parent !== null) {
  9426.       set(parent, property, value, receiver);
  9427.     }
  9428.   } else if ("value" in desc && desc.writable) {
  9429.     desc.value = value;
  9430.   } else {
  9431.     var setter = desc.set;if (setter !== undefined) {
  9432.       setter.call(receiver, value);
  9433.     }
  9434.   }return value;
  9435. };
  9436.  
  9437. var _get = function get(object, property, receiver) {
  9438.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  9439.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  9440.       return undefined;
  9441.     } else {
  9442.       return get(parent, property, receiver);
  9443.     }
  9444.   } else if ("value" in desc) {
  9445.     return desc.value;
  9446.   } else {
  9447.     var getter = desc.get;if (getter === undefined) {
  9448.       return undefined;
  9449.     }return getter.call(receiver);
  9450.   }
  9451. };
  9452.  
  9453. var _choices = require('choices.js/assets/scripts/dist/choices.js');
  9454.  
  9455. var _choices2 = _interopRequireDefault(_choices);
  9456.  
  9457. var _lodash = require('lodash');
  9458.  
  9459. var _lodash2 = _interopRequireDefault(_lodash);
  9460.  
  9461. var _Base = require('../base/Base');
  9462.  
  9463. var _formio = require('../../formio');
  9464.  
  9465. var _formio2 = _interopRequireDefault(_formio);
  9466.  
  9467. function _interopRequireDefault(obj) {
  9468.   return obj && obj.__esModule ? obj : { default: obj };
  9469. }
  9470.  
  9471. function _classCallCheck(instance, Constructor) {
  9472.   if (!(instance instanceof Constructor)) {
  9473.     throw new TypeError("Cannot call a class as a function");
  9474.   }
  9475. }
  9476.  
  9477. function _possibleConstructorReturn(self, call) {
  9478.   if (!self) {
  9479.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  9480.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  9481. }
  9482.  
  9483. function _inherits(subClass, superClass) {
  9484.   if (typeof superClass !== "function" && superClass !== null) {
  9485.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  9486.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  9487. }
  9488.  
  9489. // Duck-punch the setValueByChoice to ensure we compare using _.isEqual.
  9490. _choices2.default.prototype.setValueByChoice = function (value) {
  9491.   var _this = this;
  9492.  
  9493.   if (!this.isTextElement) {
  9494.     var choices = this.store.getChoices();
  9495.     // If only one value has been passed, convert to array
  9496.     var choiceValue = Array.isArray(value) ? value : [value];
  9497.  
  9498.     // Loop through each value and
  9499.     choiceValue.forEach(function (val) {
  9500.       var foundChoice = choices.find(function (choice) {
  9501.         // Check 'value' property exists and the choice isn't already selected
  9502.         return _lodash2.default.isEqual(choice.value, val);
  9503.       });
  9504.  
  9505.       if (foundChoice) {
  9506.         if (!foundChoice.selected) {
  9507.           _this._addItem(foundChoice.value, foundChoice.label, foundChoice.id, foundChoice.groupId, foundChoice.customProperties, foundChoice.placeholder, foundChoice.keyCode);
  9508.         } else if (!_this.config.silent) {
  9509.           console.warn('Attempting to select choice already selected');
  9510.         }
  9511.       } else if (!_this.config.silent) {
  9512.         console.warn('Attempting to select choice that does not exist');
  9513.       }
  9514.     });
  9515.   }
  9516.   return this;
  9517. };
  9518.  
  9519. var SelectComponent = exports.SelectComponent = function (_BaseComponent) {
  9520.   _inherits(SelectComponent, _BaseComponent);
  9521.  
  9522.   function SelectComponent(component, options, data) {
  9523.     _classCallCheck(this, SelectComponent);
  9524.  
  9525.     // Trigger an update.
  9526.     var _this2 = _possibleConstructorReturn(this, (SelectComponent.__proto__ || Object.getPrototypeOf(SelectComponent)).call(this, component, options, data));
  9527.  
  9528.     _this2.triggerUpdate = _lodash2.default.debounce(_this2.updateItems.bind(_this2), 100);
  9529.  
  9530.     // Keep track of the select options.
  9531.     _this2.selectOptions = [];
  9532.  
  9533.     // See if this should use the template.
  9534.     _this2.useTemplate = _this2.component.dataSrc !== 'values' && _this2.component.template;
  9535.  
  9536.     // If this component has been activated.
  9537.     _this2.activated = false;
  9538.  
  9539.     // If they wish to refresh on a value, then add that here.
  9540.     if (_this2.component.refreshOn) {
  9541.       _this2.on('change', function (event) {
  9542.         if (_this2.component.refreshOn === 'data') {
  9543.           _this2.refreshItems();
  9544.         } else if (event.changed && event.changed.component.key === _this2.component.refreshOn) {
  9545.           _this2.refreshItems();
  9546.         }
  9547.       });
  9548.     }
  9549.     return _this2;
  9550.   }
  9551.  
  9552.   _createClass(SelectComponent, [{
  9553.     key: 'refreshItems',
  9554.     value: function refreshItems() {
  9555.       this.triggerUpdate();
  9556.       if (this.component.clearOnRefresh) {
  9557.         this.setValue(null);
  9558.       }
  9559.     }
  9560.   }, {
  9561.     key: 'elementInfo',
  9562.     value: function elementInfo() {
  9563.       var info = _get(SelectComponent.prototype.__proto__ || Object.getPrototypeOf(SelectComponent.prototype), 'elementInfo', this).call(this);
  9564.       info.type = 'select';
  9565.       info.changeEvent = 'change';
  9566.       return info;
  9567.     }
  9568.   }, {
  9569.     key: 'createWrapper',
  9570.     value: function createWrapper() {
  9571.       return false;
  9572.     }
  9573.   }, {
  9574.     key: 'itemTemplate',
  9575.     value: function itemTemplate(data) {
  9576.       if (!data) {
  9577.         return '';
  9578.       }
  9579.  
  9580.       // Perform a fast interpretation if we should not use the template.
  9581.       if (data && !this.useTemplate) {
  9582.         return this.t(data.label || data);
  9583.       }
  9584.       if (typeof data === 'string') {
  9585.         return this.t(data);
  9586.       }
  9587.  
  9588.       var template = this.component.template ? this.interpolate(this.component.template, { item: data }) : data.label;
  9589.       if (template) {
  9590.         var label = template.replace(/<\/?[^>]+(>|$)/g, '');
  9591.         return template.replace(label, this.t(label));
  9592.       } else {
  9593.         return JSON.stringify(data);
  9594.       }
  9595.     }
  9596.   }, {
  9597.     key: 'itemValue',
  9598.     value: function itemValue(data) {
  9599.       return this.component.valueProperty && _lodash2.default.isObject(data) ? _lodash2.default.get(data, this.component.valueProperty) : data;
  9600.     }
  9601.   }, {
  9602.     key: 'createInput',
  9603.     value: function createInput(container) {
  9604.       this.selectContainer = container;
  9605.       this.selectInput = _get(SelectComponent.prototype.__proto__ || Object.getPrototypeOf(SelectComponent.prototype), 'createInput', this).call(this, container);
  9606.     }
  9607.  
  9608.     /**
  9609.      * Adds an option to the select dropdown.
  9610.      *
  9611.      * @param value
  9612.      * @param label
  9613.      */
  9614.  
  9615.   }, {
  9616.     key: 'addOption',
  9617.     value: function addOption(value, label, attr) {
  9618.       var option = {
  9619.         value: value,
  9620.         label: label
  9621.       };
  9622.  
  9623.       this.selectOptions.push(option);
  9624.       if (this.choices) {
  9625.         return;
  9626.       }
  9627.  
  9628.       option.element = document.createElement('option');
  9629.       if (this.dataValue === option.value) {
  9630.         option.element.setAttribute('selected', 'selected');
  9631.         option.element.selected = 'selected';
  9632.       }
  9633.       option.element.innerHTML = label;
  9634.       if (attr) {
  9635.         _lodash2.default.each(attr, function (value, key) {
  9636.           option.element.setAttribute(key, value);
  9637.         });
  9638.       }
  9639.       this.selectInput.appendChild(option.element);
  9640.     }
  9641.   }, {
  9642.     key: 'addValueOptions',
  9643.     value: function addValueOptions(items) {
  9644.       var _this3 = this;
  9645.  
  9646.       items = items || [];
  9647.       if (!this.selectOptions.length) {
  9648.         if (this.choices) {
  9649.           // Add the currently selected choices if they don't already exist.
  9650.           var currentChoices = Array.isArray(this.dataValue) ? this.dataValue : [this.dataValue];
  9651.           _lodash2.default.each(currentChoices, function (choice) {
  9652.             _this3.addCurrentChoices(choice, items);
  9653.           });
  9654.         } else if (!this.component.multiple) {
  9655.           this.addPlaceholder(this.selectInput);
  9656.         }
  9657.       }
  9658.     }
  9659.   }, {
  9660.     key: 'setItems',
  9661.     value: function setItems(items) {
  9662.       var _this4 = this;
  9663.  
  9664.       // If the items is a string, then parse as JSON.
  9665.       if (typeof items == 'string') {
  9666.         try {
  9667.           items = JSON.parse(items);
  9668.         } catch (err) {
  9669.           console.warn(err.message);
  9670.           items = [];
  9671.         }
  9672.       }
  9673.  
  9674.       if (!this.choices && this.selectInput) {
  9675.         if (this.loading) {
  9676.           this.removeChildFrom(this.selectInput, this.selectContainer);
  9677.         }
  9678.  
  9679.         this.selectInput.innerHTML = '';
  9680.       }
  9681.  
  9682.       this.selectOptions = [];
  9683.  
  9684.       // If they provided select values, then we need to get them instead.
  9685.       if (this.component.selectValues) {
  9686.         items = _lodash2.default.get(items, this.component.selectValues);
  9687.       }
  9688.  
  9689.       // Add the value options.
  9690.       this.addValueOptions(items);
  9691.  
  9692.       items = customOperation('sortSelectDropDown', {"type":"getItems", "component": this.component, "items": items});
  9693.       // Iterate through each of the items.
  9694.       _lodash2.default.each(items, function (item) {
  9695.         _this4.addOption(_this4.itemValue(item), _this4.itemTemplate(item));
  9696.       });
  9697.  
  9698.       if (this.choices) {
  9699.         this.choices.setChoices(this.selectOptions, 'value', 'label', true);
  9700.       } else if (this.loading) {
  9701.         // Re-attach select input.
  9702.         this.appendTo(this.selectInput, this.selectContainer);
  9703.       }
  9704.  
  9705.       // We are no longer loading.
  9706.       this.loading = false;
  9707.  
  9708.       // If a value is provided, then select it.
  9709.       if (this.dataValue) {
  9710.         this.setValue(this.dataValue, true);
  9711.       } else {
  9712.         // If a default value is provided then select it.
  9713.         var defaultValue = this.defaultValue;
  9714.         if (defaultValue) {
  9715.           this.setValue(defaultValue);
  9716.         }
  9717.       }
  9718.     }
  9719.   }, {
  9720.     key: 'loadItems',
  9721.     value: function loadItems(url, search, headers, options, method, body) {
  9722.       var _this5 = this;
  9723.  
  9724.       options = options || {};
  9725.  
  9726.       // Ensure we have a method and remove any body if method is get
  9727.       method = method || 'GET';
  9728.       if (method.toUpperCase() === 'GET') {
  9729.         body = null;
  9730.       }
  9731.  
  9732.       var query = this.component.dataSrc === 'url' ? {} : {
  9733.         limit: 100,
  9734.         skip: 0
  9735.       };
  9736.  
  9737.       // Allow for url interpolation.
  9738.       url = this.interpolate(url, {
  9739.         data: this.data,
  9740.         formioBase: _formio2.default.getBaseUrl()
  9741.       });
  9742.  
  9743.       // Add search capability.
  9744.       if (this.component.searchField && search) {
  9745.         if (Array.isArray(search)) {
  9746.           query[this.component.searchField + '__in'] = search.join(',');
  9747.         } else {
  9748.           query[this.component.searchField] = search;
  9749.         }
  9750.       }
  9751.  
  9752.       // Add filter capability
  9753.       if (this.component.filter) {
  9754.         var filter = this.interpolate(this.component.filter, { data: this.data });
  9755.         url += (!(url.indexOf('?') !== -1) ? '?' : '&') + filter;
  9756.       }
  9757.  
  9758.       // If they wish to return only some fields.
  9759.       if (this.component.selectFields) {
  9760.         query.select = this.component.selectFields;
  9761.       }
  9762.  
  9763.       if (!_lodash2.default.isEmpty(query)) {
  9764.         // Add the query string.
  9765.         url += (!(url.indexOf('?') !== -1) ? '?' : '&') + _formio2.default.serialize(query);
  9766.       }
  9767.  
  9768.       // Make the request.
  9769.       options.header = headers;
  9770.       this.loading = true;
  9771.       _formio2.default.makeRequest(this.options.formio, 'select', url, method, body, options).then(function (response) {
  9772.         return _this5.setItems(response);
  9773.       }).catch(function (err) {
  9774.         _this5.loading = false;
  9775.         _this5.events.emit('formio.error', err);
  9776.         console.warn('Unable to load resources for ' + _this5.component.key);
  9777.       });
  9778.     }
  9779.  
  9780.     /**
  9781.      * Get the request headers for this select dropdown.
  9782.      */
  9783.  
  9784.   }, {
  9785.     key: 'updateCustomItems',
  9786.     value: function updateCustomItems() {
  9787.       var data = _lodash2.default.cloneDeep(this.data);
  9788.       var row = _lodash2.default.cloneDeep(this.row);
  9789.       try {
  9790.         this.setItems(new Function('data', 'row', 'var values = []; ' + this.component.data.custom.toString() + '; return values;')(data, row));
  9791.       } catch (error) {
  9792.         this.setItems([]);
  9793.       }
  9794.     }
  9795.   }, {
  9796.     key: 'updateItems',
  9797.     value: function updateItems(searchInput, forceUpdate) {
  9798.       if (!this.component.data) {
  9799.         console.warn('Select component ' + this.component.key + ' does not have data configuration.');
  9800.         return;
  9801.       }
  9802.  
  9803.       switch (this.component.dataSrc) {
  9804.         case 'values':
  9805.           this.component.valueProperty = 'value';
  9806.           this.setItems(this.component.data.values);
  9807.           break;
  9808.         case 'json':
  9809.           this.setItems(this.component.data.json);
  9810.           break;
  9811.         case 'custom':
  9812.           this.updateCustomItems();
  9813.           break;
  9814.         case 'resource':
  9815.           {
  9816.             if (!forceUpdate && !this.active) {
  9817.               // If we are lazyLoading, wait until activated.
  9818.               return;
  9819.             }
  9820.             var resourceUrl = this.options.formio ? this.options.formio.formsUrl : _formio2.default.getProjectUrl() + '/form';
  9821.             resourceUrl += '/' + this.component.data.resource + '/submission';
  9822.  
  9823.             try {
  9824.               this.loadItems(resourceUrl, searchInput, this.requestHeaders);
  9825.             } catch (err) {
  9826.               console.warn('Unable to load resources for ' + this.component.key);
  9827.             }
  9828.             break;
  9829.           }
  9830.         case 'url':
  9831.           {
  9832.             if (!forceUpdate && !this.active) {
  9833.               // If we are lazyLoading, wait until activated.
  9834.               return;
  9835.             }
  9836.             var url = this.component.data.url;
  9837.             var method = void 0;
  9838.             var body = void 0;
  9839.  
  9840.             if (url.substr(0, 1) === '/') {
  9841.               url = _formio2.default.getBaseUrl() + this.component.data.url;
  9842.             }
  9843.  
  9844.             if (!this.component.data.method) {
  9845.               method = 'GET';
  9846.             } else {
  9847.               method = this.component.data.method;
  9848.               if (method.toUpperCase() === 'POST') {
  9849.                 body = this.component.data.body;
  9850.               } else {
  9851.                 body = null;
  9852.               }
  9853.             }
  9854.             this.loadItems(url, searchInput, this.requestHeaders, { noToken: true }, method, body);
  9855.             break;
  9856.           }
  9857.       }
  9858.     }
  9859.   }, {
  9860.     key: 'addPlaceholder',
  9861.     value: function addPlaceholder(input) {
  9862.       if (!this.component.placeholder || !input) {
  9863.         return;
  9864.       }
  9865.       var placeholder = document.createElement('option');
  9866.       placeholder.setAttribute('placeholder', true);
  9867.       placeholder.appendChild(this.text(this.component.placeholder));
  9868.       input.appendChild(placeholder);
  9869.     }
  9870.  
  9871.     /**
  9872.      * Activate this select control.
  9873.      */
  9874.  
  9875.   }, {
  9876.     key: 'activate',
  9877.     value: function activate() {
  9878.       if (this.active) {
  9879.         return;
  9880.       }
  9881.       this.activated = true;
  9882.       if (this.choices) {
  9883.         this.choices.setChoices([{
  9884.           value: '',
  9885.           label: '<i class="' + this.iconClass('refresh') + '" style="font-size:1.3em;"></i>'
  9886.         }], 'value', 'label', true);
  9887.       } else {
  9888.         this.addOption('', this.t('loading...'));
  9889.       }
  9890.       this.refreshItems();
  9891.     }
  9892.   }, {
  9893.     key: 'addInput',
  9894.     value: function addInput(input, container) {
  9895.       var _this6 = this;
  9896.  
  9897.       _get(SelectComponent.prototype.__proto__ || Object.getPrototypeOf(SelectComponent.prototype), 'addInput', this).call(this, input, container);
  9898.       if (this.component.multiple) {
  9899.         input.setAttribute('multiple', true);
  9900.       }
  9901.  
  9902.       if (this.component.widget === 'html5') {
  9903.         this.triggerUpdate();
  9904.         this.addEventListener(input, 'focus', function () {
  9905.           return _this6.update();
  9906.         });
  9907.         return;
  9908.       }
  9909.  
  9910.       var useSearch = this.component.hasOwnProperty('searchEnabled') ? this.component.searchEnabled : true;
  9911.       var placeholderValue = this.t(this.component.placeholder);
  9912.       var choicesOptions = {
  9913.         removeItemButton: this.component.removeItemButton || this.component.multiple || false,
  9914.         itemSelectText: '',
  9915.         classNames: {
  9916.           containerOuter: 'choices form-group formio-choices',
  9917.           containerInner: 'form-control'
  9918.         },
  9919.         placeholder: !!this.component.placeholder,
  9920.         placeholderValue: placeholderValue,
  9921.         searchPlaceholderValue: placeholderValue,
  9922.         shouldSort: false,
  9923.         position: this.component.dropdown || 'auto',
  9924.         searchEnabled: useSearch,
  9925.         itemComparer: function itemComparer(choice, item) {
  9926.           return _lodash2.default.isEqual(choice, item);
  9927.         }
  9928.       };
  9929.  
  9930.       var tabIndex = input.tabIndex;
  9931.       this.addPlaceholder(input);
  9932.       this.choices = new _choices2.default(input, choicesOptions);
  9933.  
  9934.       if (this.component.multiple) {
  9935.         this.focusableElement = this.choices.input;
  9936.       } else {
  9937.         this.focusableElement = this.choices.containerInner;
  9938.         this.choices.containerOuter.setAttribute('tabIndex', '-1');
  9939.         this.addEventListener(this.choices.containerOuter, 'focus', function () {
  9940.           return _this6.focusableElement.focus();
  9941.         });
  9942.       }
  9943.       this.focusableElement.setAttribute('tabIndex', tabIndex);
  9944.  
  9945.       this.setInputStyles(this.choices.containerOuter);
  9946.  
  9947.       // If a search field is provided, then add an event listener to update items on search.
  9948.       if (this.component.searchField) {
  9949.         this.addEventListener(input, 'search', function (event) {
  9950.           return _this6.triggerUpdate(event.detail.value);
  9951.         });
  9952.         this.addEventListener(input, 'stopSearch', function () {
  9953.           return _this6.triggerUpdate();
  9954.         });
  9955.       }
  9956.  
  9957.       this.addEventListener(input, 'showDropdown', function () {
  9958.         return _this6.update();
  9959.       });
  9960.  
  9961.       // Force the disabled state with getters and setters.
  9962.       this.disabled = this.disabled;
  9963.       this.triggerUpdate();
  9964.     }
  9965.   }, {
  9966.     key: 'update',
  9967.     value: function update() {
  9968.       if (this.component.dataSrc === 'custom') {
  9969.         this.updateCustomItems();
  9970.       }
  9971.  
  9972.       // Activate the control.
  9973.       this.activate();
  9974.     }
  9975.   }, {
  9976.     key: 'addCurrentChoices',
  9977.     value: function addCurrentChoices(value, items) {
  9978.       var _this7 = this;
  9979.       //console.log("value= ", value);
  9980.       //console.log("items= ", items);
  9981.       if (value) {
  9982.         var found = false;
  9983.         if (items && items.length) {
  9984.           _lodash2.default.each(items, function (choice) {
  9985.             if (choice._id && value._id && choice._id === value._id) {
  9986.               found = true;
  9987.               return false;
  9988.             }
  9989.             found |= _lodash2.default.isEqual(_this7.itemValue(choice), value);
  9990.             return found ? false : true;
  9991.           });
  9992.         }
  9993.  
  9994.         // Add the default option if no item is found.
  9995.         if (!found) {
  9996.           this.addOption(this.itemValue(value), this.itemTemplate(value));
  9997.         }
  9998.       }
  9999.     }
  10000.   }, {
  10001.     key: 'getView',
  10002.     value: function getView(data) {
  10003.       return this.itemTemplate(data);
  10004.     }
  10005.   }, {
  10006.     key: 'getValue',
  10007.     value: function getValue(flags) {
  10008.       flags = flags || {};
  10009.       if (!flags.changed && this.dataValue) {
  10010.         return this.dataValue;
  10011.       }
  10012.       var value = '';
  10013.       if (this.choices) {
  10014.         value = this.choices.getValue(true);
  10015.  
  10016.         // Make sure we don't get the placeholder
  10017.         if (!this.component.multiple && this.component.placeholder && value === this.t(this.component.placeholder)) {
  10018.           value = '';
  10019.         }
  10020.       } else {
  10021.         var values = [];
  10022.         _lodash2.default.each(this.selectOptions, function (selectOption) {
  10023.           if (selectOption.element && selectOption.element.selected) {
  10024.             values.push(selectOption.value);
  10025.           }
  10026.         });
  10027.         value = this.component.multiple ? values : values.shift();
  10028.       }
  10029.       return value;
  10030.     }
  10031.   }, {
  10032.     key: 'setValue',
  10033.     value: function setValue(value, flags) {
  10034.       flags = this.getFlags.apply(this, arguments);
  10035.       var hasPreviousValue = Array.isArray(this.dataValue) ? this.dataValue.length : this.dataValue;
  10036.       var hasValue = Array.isArray(value) ? value.length : value;
  10037.       var changed = flags.changed || this.hasChanged(value, this.dataValue);
  10038.       this.dataValue = value;
  10039.  
  10040.       // Do not set the value if we are loading... that will happen after it is done.
  10041.       if (this.loading) {
  10042.         return changed;
  10043.       }
  10044.  
  10045.       // Determine if we need to perform an initial lazyLoad api call if searchField is provided.
  10046.       if (this.component.searchField && this.component.lazyLoad && !this.lazyLoadInit && !this.active && !this.selectOptions.length && hasValue) {
  10047.         this.loading = true;
  10048.         this.lazyLoadInit = true;
  10049.         this.triggerUpdate(this.dataValue, true);
  10050.         return changed;
  10051.       }
  10052.  
  10053.       // Add the value options.
  10054.       this.addValueOptions();
  10055.  
  10056.       if (this.choices) {
  10057.         // Now set the value.
  10058.         if (hasValue) {
  10059.           this.choices.removeActiveItems().setChoices(this.selectOptions, 'value', 'label', true).setValueByChoice(Array.isArray(value) ? value : [value]);
  10060.         } else if (hasPreviousValue) {
  10061.           this.choices.removeActiveItems();
  10062.         }
  10063.       } else {
  10064.         if (hasValue) {
  10065.           var values = Array.isArray(value) ? value : [value];
  10066.           _lodash2.default.each(this.selectOptions, function (selectOption) {
  10067.             _lodash2.default.each(values, function (val) {
  10068.               if (_lodash2.default.isEqual(val, selectOption.value)) {
  10069.                 selectOption.element.selected = true;
  10070.                 selectOption.element.setAttribute('selected', 'selected');
  10071.                 return false;
  10072.               }
  10073.             });
  10074.           });
  10075.         } else {
  10076.           _lodash2.default.each(this.selectOptions, function (selectOption) {
  10077.             selectOption.element.selected = false;
  10078.             selectOption.element.removeAttribute('selected');
  10079.           });
  10080.         }
  10081.       }
  10082.  
  10083.       this.updateOnChange(flags, changed);
  10084.       return changed;
  10085.     }
  10086.  
  10087.     /**
  10088.      * Check if a component is eligible for multiple validation
  10089.      *
  10090.      * @return {boolean}
  10091.      */
  10092.  
  10093.   }, {
  10094.     key: 'validateMultiple',
  10095.     value: function validateMultiple() {
  10096.       // Select component will contain one input when flagged as multiple.
  10097.       return false;
  10098.     }
  10099.  
  10100.     /**
  10101.      * Ouput this select dropdown as a string value.
  10102.      * @return {*}
  10103.      */
  10104.  
  10105.   }, {
  10106.     key: 'asString',
  10107.     value: function asString(value) {
  10108.       value = value || this.getValue();
  10109.  
  10110.       if (this.component.dataSrc === 'values') {
  10111.         value = _lodash2.default.find(this.component.data.values, ['value', value]);
  10112.       }
  10113.  
  10114.       if (_lodash2.default.isString(value)) {
  10115.         return value;
  10116.       }
  10117.  
  10118.       return _lodash2.default.isObject(value) ? this.itemTemplate(value) : '-';
  10119.     }
  10120.   }, {
  10121.     key: 'setupValueElement',
  10122.     value: function setupValueElement(element) {
  10123.       element.innerHTML = this.asString();
  10124.     }
  10125.   }, {
  10126.     key: 'destroy',
  10127.     value: function destroy() {
  10128.       _get(SelectComponent.prototype.__proto__ || Object.getPrototypeOf(SelectComponent.prototype), 'destroy', this).call(this);
  10129.       if (this.choices) {
  10130.         this.choices.destroyed = true;
  10131.         this.choices.destroy();
  10132.         this.choices = null;
  10133.       }
  10134.     }
  10135.   }, {
  10136.     key: 'focus',
  10137.     value: function focus() {
  10138.       this.focusableElement.focus();
  10139.     }
  10140.   }, {
  10141.     key: 'requestHeaders',
  10142.     get: function get() {
  10143.       var _this8 = this;
  10144.  
  10145.       // Create the headers object.
  10146.       var headers = new Headers();
  10147.  
  10148.       // Add custom headers to the url.
  10149.       if (this.component.data && this.component.data.headers) {
  10150.         try {
  10151.           _lodash2.default.each(this.component.data.headers, function (header) {
  10152.             if (header.key) {
  10153.               headers.set(header.key, _this8.interpolate(header.value, {
  10154.                 data: _this8.data
  10155.               }));
  10156.             }
  10157.           });
  10158.         } catch (err) {
  10159.           console.warn(err.message);
  10160.         }
  10161.       }
  10162.  
  10163.       return headers;
  10164.     }
  10165.   }, {
  10166.     key: 'active',
  10167.     get: function get() {
  10168.       return !this.component.lazyLoad || this.activated;
  10169.     }
  10170.   }, {
  10171.     key: 'disabled',
  10172.     set: function set(disabled) {
  10173.       _set(SelectComponent.prototype.__proto__ || Object.getPrototypeOf(SelectComponent.prototype), 'disabled', disabled, this);
  10174.       if (!this.choices) {
  10175.         return;
  10176.       }
  10177.       if (disabled) {
  10178.         this.setDisabled(this.choices.containerInner, true);
  10179.         this.focusableElement.removeAttribute('tabIndex');
  10180.         this.choices.disable();
  10181.       } else {
  10182.         this.setDisabled(this.choices.containerInner, false);
  10183.         this.focusableElement.setAttribute('tabIndex', this.component.tabindex || 0);
  10184.         this.choices.enable();
  10185.       }
  10186.     }
  10187.   }]);
  10188.  
  10189.   return SelectComponent;
  10190. }(_Base.BaseComponent);
  10191.  
  10192. },{"../../formio":44,"../base/Base":4,"choices.js/assets/scripts/dist/choices.js":59,"lodash":79}],31:[function(require,module,exports){
  10193. 'use strict';
  10194.  
  10195. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  10196.  
  10197. Object.defineProperty(exports, "__esModule", {
  10198.   value: true
  10199. });
  10200. exports.SelectBoxesComponent = undefined;
  10201.  
  10202. var _createClass = function () {
  10203.   function defineProperties(target, props) {
  10204.     for (var i = 0; i < props.length; i++) {
  10205.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  10206.     }
  10207.   }return function (Constructor, protoProps, staticProps) {
  10208.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  10209.   };
  10210. }();
  10211.  
  10212. var _get = function get(object, property, receiver) {
  10213.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  10214.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  10215.       return undefined;
  10216.     } else {
  10217.       return get(parent, property, receiver);
  10218.     }
  10219.   } else if ("value" in desc) {
  10220.     return desc.value;
  10221.   } else {
  10222.     var getter = desc.get;if (getter === undefined) {
  10223.       return undefined;
  10224.     }return getter.call(receiver);
  10225.   }
  10226. };
  10227.  
  10228. var _lodash = require('lodash');
  10229.  
  10230. var _lodash2 = _interopRequireDefault(_lodash);
  10231.  
  10232. var _Radio = require('../radio/Radio');
  10233.  
  10234. function _interopRequireDefault(obj) {
  10235.   return obj && obj.__esModule ? obj : { default: obj };
  10236. }
  10237.  
  10238. function _classCallCheck(instance, Constructor) {
  10239.   if (!(instance instanceof Constructor)) {
  10240.     throw new TypeError("Cannot call a class as a function");
  10241.   }
  10242. }
  10243.  
  10244. function _possibleConstructorReturn(self, call) {
  10245.   if (!self) {
  10246.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  10247.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  10248. }
  10249.  
  10250. function _inherits(subClass, superClass) {
  10251.   if (typeof superClass !== "function" && superClass !== null) {
  10252.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  10253.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  10254. }
  10255.  
  10256. var SelectBoxesComponent = exports.SelectBoxesComponent = function (_RadioComponent) {
  10257.   _inherits(SelectBoxesComponent, _RadioComponent);
  10258.  
  10259.   function SelectBoxesComponent(component, options, data) {
  10260.     _classCallCheck(this, SelectBoxesComponent);
  10261.  
  10262.     var _this = _possibleConstructorReturn(this, (SelectBoxesComponent.__proto__ || Object.getPrototypeOf(SelectBoxesComponent)).call(this, component, options, data));
  10263.  
  10264.     _this.component.inputType = 'checkbox';
  10265.     return _this;
  10266.   }
  10267.  
  10268.   _createClass(SelectBoxesComponent, [{
  10269.     key: 'elementInfo',
  10270.     value: function elementInfo() {
  10271.       var info = _get(SelectBoxesComponent.prototype.__proto__ || Object.getPrototypeOf(SelectBoxesComponent.prototype), 'elementInfo', this).call(this);
  10272.       info.attr.name += '[]';
  10273.       info.attr.type = 'checkbox';
  10274.       info.attr.class = 'form-check-input';
  10275.       return info;
  10276.     }
  10277.  
  10278.     /**
  10279.      * Only empty if the values are all false.
  10280.      *
  10281.      * @param value
  10282.      * @return {boolean}
  10283.      */
  10284.  
  10285.   }, {
  10286.     key: 'isEmpty',
  10287.     value: function isEmpty(value) {
  10288.       var empty = true;
  10289.       for (var key in value) {
  10290.         if (value.hasOwnProperty(key) && value[key]) {
  10291.           empty = false;
  10292.           break;
  10293.         }
  10294.       }
  10295.  
  10296.       return empty;
  10297.     }
  10298.   }, {
  10299.     key: 'getValue',
  10300.     value: function getValue() {
  10301.       if (this.viewOnly) {
  10302.         return this.dataValue;
  10303.       }
  10304.       var value = {};
  10305.       _lodash2.default.each(this.inputs, function (input) {
  10306.         value[input.value] = !!input.checked;
  10307.       });
  10308.       return value;
  10309.     }
  10310.  
  10311.     /**
  10312.      * Set the value of this component.
  10313.      *
  10314.      * @param value
  10315.      * @param flags
  10316.      */
  10317.  
  10318.   }, {
  10319.     key: 'setValue',
  10320.     value: function setValue(value, flags) {
  10321.       value = value || {};
  10322.       flags = this.getFlags.apply(this, arguments);
  10323.       if (Array.isArray(value)) {
  10324.         _lodash2.default.each(value, function (val) {
  10325.           value[val] = true;
  10326.         });
  10327.       }
  10328.  
  10329.       _lodash2.default.each(this.inputs, function (input) {
  10330.         if (_lodash2.default.isUndefined(value[input.value])) {
  10331.           value[input.value] = false;
  10332.         }
  10333.         input.checked = !!value[input.value];
  10334.       });
  10335.  
  10336.       this.updateValue(flags);
  10337.     }
  10338.   }, {
  10339.     key: 'getView',
  10340.     value: function getView(value) {
  10341.       if (!value) {
  10342.         return '';
  10343.       }
  10344.       return (0, _lodash2.default)(this.component.values || []).filter(function (v) {
  10345.         return value[v.value];
  10346.       }).map('label').join(', ');
  10347.     }
  10348.   }]);
  10349.  
  10350.   return SelectBoxesComponent;
  10351. }(_Radio.RadioComponent);
  10352.  
  10353. },{"../radio/Radio":28,"lodash":79}],32:[function(require,module,exports){
  10354. 'use strict';
  10355.  
  10356. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  10357.  
  10358. Object.defineProperty(exports, "__esModule", {
  10359.   value: true
  10360. });
  10361. exports.SignatureComponent = undefined;
  10362.  
  10363. var _createClass = function () {
  10364.   function defineProperties(target, props) {
  10365.     for (var i = 0; i < props.length; i++) {
  10366.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  10367.     }
  10368.   }return function (Constructor, protoProps, staticProps) {
  10369.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  10370.   };
  10371. }();
  10372.  
  10373. var _set = function set(object, property, value, receiver) {
  10374.   var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  10375.     var parent = Object.getPrototypeOf(object);if (parent !== null) {
  10376.       set(parent, property, value, receiver);
  10377.     }
  10378.   } else if ("value" in desc && desc.writable) {
  10379.     desc.value = value;
  10380.   } else {
  10381.     var setter = desc.set;if (setter !== undefined) {
  10382.       setter.call(receiver, value);
  10383.     }
  10384.   }return value;
  10385. };
  10386.  
  10387. var _get = function get(object, property, receiver) {
  10388.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  10389.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  10390.       return undefined;
  10391.     } else {
  10392.       return get(parent, property, receiver);
  10393.     }
  10394.   } else if ("value" in desc) {
  10395.     return desc.value;
  10396.   } else {
  10397.     var getter = desc.get;if (getter === undefined) {
  10398.       return undefined;
  10399.     }return getter.call(receiver);
  10400.   }
  10401. };
  10402.  
  10403. var _signature_pad = require('signature_pad/dist/signature_pad.js');
  10404.  
  10405. var _signature_pad2 = _interopRequireDefault(_signature_pad);
  10406.  
  10407. var _Base = require('../base/Base');
  10408.  
  10409. function _interopRequireDefault(obj) {
  10410.   return obj && obj.__esModule ? obj : { default: obj };
  10411. }
  10412.  
  10413. function _classCallCheck(instance, Constructor) {
  10414.   if (!(instance instanceof Constructor)) {
  10415.     throw new TypeError("Cannot call a class as a function");
  10416.   }
  10417. }
  10418.  
  10419. function _possibleConstructorReturn(self, call) {
  10420.   if (!self) {
  10421.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  10422.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  10423. }
  10424.  
  10425. function _inherits(subClass, superClass) {
  10426.   if (typeof superClass !== "function" && superClass !== null) {
  10427.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  10428.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  10429. }
  10430.  
  10431. var SignatureComponent = exports.SignatureComponent = function (_BaseComponent) {
  10432.   _inherits(SignatureComponent, _BaseComponent);
  10433.  
  10434.   function SignatureComponent(component, options, data) {
  10435.     _classCallCheck(this, SignatureComponent);
  10436.  
  10437.     var _this = _possibleConstructorReturn(this, (SignatureComponent.__proto__ || Object.getPrototypeOf(SignatureComponent)).call(this, component, options, data));
  10438.  
  10439.     _this.currentWidth = 0;
  10440.     _this.scale = 1;
  10441.     if (!_this.component.width) {
  10442.       _this.component.width = '100%';
  10443.     }
  10444.     if (!_this.component.height) {
  10445.       _this.component.height = '200px';
  10446.     }
  10447.     return _this;
  10448.   }
  10449.  
  10450.   _createClass(SignatureComponent, [{
  10451.     key: 'elementInfo',
  10452.     value: function elementInfo() {
  10453.       var info = _get(SignatureComponent.prototype.__proto__ || Object.getPrototypeOf(SignatureComponent.prototype), 'elementInfo', this).call(this);
  10454.       info.type = 'input';
  10455.       info.attr.type = 'hidden';
  10456.       return info;
  10457.     }
  10458.   }, {
  10459.     key: 'setValue',
  10460.     value: function setValue(value, flags) {
  10461.       flags = this.getFlags.apply(this, arguments);
  10462.       _get(SignatureComponent.prototype.__proto__ || Object.getPrototypeOf(SignatureComponent.prototype), 'setValue', this).call(this, value, flags);
  10463.       if (value && !flags.noSign && this.signaturePad) {
  10464.         this.signaturePad.fromDataURL(value);
  10465.         this.signatureImage.setAttribute('src', value);
  10466.         this.showCanvas(false);
  10467.       }
  10468.     }
  10469.   }, {
  10470.     key: 'showCanvas',
  10471.     value: function showCanvas(show) {
  10472.       if (show) {
  10473.         this.canvas.style.display = 'inherit';
  10474.         this.signatureImage.style.display = 'none';
  10475.       } else {
  10476.         this.canvas.style.display = 'none';
  10477.         this.signatureImage.style.display = 'inherit';
  10478.       }
  10479.     }
  10480.   }, {
  10481.     key: 'destroy',
  10482.     value: function destroy() {
  10483.       _get(SignatureComponent.prototype.__proto__ || Object.getPrototypeOf(SignatureComponent.prototype), 'destroy', this).call(this);
  10484.       if (this.signaturePad) {
  10485.         this.signaturePad.off();
  10486.       }
  10487.     }
  10488.   }, {
  10489.     key: 'checkSize',
  10490.     value: function checkSize(force, scale) {
  10491.       if (force || this.padBody.offsetWidth !== this.currentWidth) {
  10492.         this.scale = force ? scale : this.scale;
  10493.         this.currentWidth = this.padBody.offsetWidth;
  10494.         this.canvas.width = this.currentWidth * this.scale;
  10495.         this.canvas.height = this.padBody.offsetHeight * this.scale;
  10496.         var ctx = this.canvas.getContext('2d');
  10497.         ctx.setTransform(1, 0, 0, 1, 0, 0);
  10498.         ctx.scale(1 / this.scale, 1 / this.scale);
  10499.         ctx.fillStyle = this.signaturePad.backgroundColor;
  10500.         ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
  10501.         this.signaturePad.clear();
  10502.       }
  10503.     }
  10504.   }, {
  10505.     key: 'build',
  10506.     value: function build() {
  10507.       var _this2 = this;
  10508.  
  10509.       if (this.viewOnly) {
  10510.         return this.viewOnlyBuild();
  10511.       }
  10512.  
  10513.       this.element = this.createElement();
  10514.       var classNames = this.element.getAttribute('class');
  10515.       classNames += ' signature-pad';
  10516.       this.element.setAttribute('class', classNames);
  10517.  
  10518.       this.input = this.createInput(this.element);
  10519.       this.padBody = this.ce('div', {
  10520.         class: 'signature-pad-body',
  10521.         style: 'width: ' + this.component.width + ';height: ' + this.component.height,
  10522.         tabindex: this.component.tabindex || 0
  10523.       });
  10524.  
  10525.       // Create the refresh button.
  10526.       this.refresh = this.ce('a', {
  10527.         class: 'btn btn-sm btn-default btn-secondary signature-pad-refresh'
  10528.       });
  10529.       var refreshIcon = this.getIcon('refresh');
  10530.       this.refresh.appendChild(refreshIcon);
  10531.       this.padBody.appendChild(this.refresh);
  10532.  
  10533.       // The signature canvas.
  10534.       this.canvas = this.ce('canvas', {
  10535.         class: 'signature-pad-canvas',
  10536.         height: this.component.height
  10537.       });
  10538.       this.padBody.appendChild(this.canvas);
  10539.  
  10540.       this.signatureImage = this.ce('img', {
  10541.         style: 'width: 100%;display: none;'
  10542.       });
  10543.       this.padBody.appendChild(this.signatureImage);
  10544.  
  10545.       this.element.appendChild(this.padBody);
  10546.  
  10547.       // Add the footer.
  10548.       if (this.component.footer) {
  10549.         this.signatureFooter = this.ce('div', {
  10550.           class: 'signature-pad-footer'
  10551.         });
  10552.         this.signatureFooter.appendChild(this.text(this.component.footer));
  10553.         this.createTooltip(this.signatureFooter);
  10554.         this.element.appendChild(this.signatureFooter);
  10555.       }
  10556.  
  10557.       // Create the signature pad.
  10558.       this.signaturePad = new _signature_pad2.default(this.canvas, {
  10559.         minWidth: this.component.minWidth,
  10560.         maxWidth: this.component.maxWidth,
  10561.         penColor: this.component.penColor,
  10562.         backgroundColor: this.component.backgroundColor
  10563.       });
  10564.       this.refresh.addEventListener('click', function (event) {
  10565.         event.preventDefault();
  10566.         _this2.showCanvas(true);
  10567.         _this2.signaturePad.clear();
  10568.       });
  10569.       this.signaturePad.onEnd = function () {
  10570.         return _this2.setValue(_this2.signaturePad.toDataURL(), {
  10571.           noSign: true
  10572.         });
  10573.       };
  10574.  
  10575.       // Ensure the signature is always the size of its container.
  10576.       setTimeout(function checkWidth() {
  10577.         this.checkSize();
  10578.         setTimeout(checkWidth.bind(this), 200);
  10579.       }.bind(this), 200);
  10580.  
  10581.       // Restore values.
  10582.       this.restoreValue();
  10583.  
  10584.       if (this.shouldDisable) {
  10585.         this.disabled = true;
  10586.       }
  10587.  
  10588.       this.autofocus();
  10589.     }
  10590.   }, {
  10591.     key: 'createViewOnlyLabel',
  10592.     value: function createViewOnlyLabel(container) {
  10593.       this.labelElement = this.ce('dt');
  10594.       this.labelElement.appendChild(this.text(this.component.footer));
  10595.       this.createTooltip(this.labelElement);
  10596.       container.appendChild(this.labelElement);
  10597.     }
  10598.   }, {
  10599.     key: 'getView',
  10600.     value: function getView(value) {
  10601.       return value ? 'Yes' : 'No';
  10602.     }
  10603.   }, {
  10604.     key: 'focus',
  10605.     value: function focus() {
  10606.       this.padBody.focus();
  10607.     }
  10608.   }, {
  10609.     key: 'disabled',
  10610.     set: function set(disabled) {
  10611.       _set(SignatureComponent.prototype.__proto__ || Object.getPrototypeOf(SignatureComponent.prototype), 'disabled', disabled, this);
  10612.       this.showCanvas(!disabled);
  10613.       if (this.signaturePad) {
  10614.         if (disabled) {
  10615.           this.signaturePad.off();
  10616.           this.refresh.classList.add('disabled');
  10617.         } else {
  10618.           this.signaturePad.on();
  10619.           this.refresh.classList.remove('disabled');
  10620.         }
  10621.       }
  10622.     }
  10623.   }]);
  10624.  
  10625.   return SignatureComponent;
  10626. }(_Base.BaseComponent);
  10627.  
  10628. },{"../base/Base":4,"signature_pad/dist/signature_pad.js":85}],33:[function(require,module,exports){
  10629. 'use strict';
  10630.  
  10631. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  10632.  
  10633. Object.defineProperty(exports, "__esModule", {
  10634.   value: true
  10635. });
  10636. exports.SurveyComponent = undefined;
  10637.  
  10638. var _createClass = function () {
  10639.   function defineProperties(target, props) {
  10640.     for (var i = 0; i < props.length; i++) {
  10641.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  10642.     }
  10643.   }return function (Constructor, protoProps, staticProps) {
  10644.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  10645.   };
  10646. }();
  10647.  
  10648. var _lodash = require('lodash');
  10649.  
  10650. var _lodash2 = _interopRequireDefault(_lodash);
  10651.  
  10652. var _Base = require('../base/Base');
  10653.  
  10654. function _interopRequireDefault(obj) {
  10655.   return obj && obj.__esModule ? obj : { default: obj };
  10656. }
  10657.  
  10658. function _classCallCheck(instance, Constructor) {
  10659.   if (!(instance instanceof Constructor)) {
  10660.     throw new TypeError("Cannot call a class as a function");
  10661.   }
  10662. }
  10663.  
  10664. function _possibleConstructorReturn(self, call) {
  10665.   if (!self) {
  10666.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  10667.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  10668. }
  10669.  
  10670. function _inherits(subClass, superClass) {
  10671.   if (typeof superClass !== "function" && superClass !== null) {
  10672.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  10673.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  10674. }
  10675.  
  10676. var SurveyComponent = exports.SurveyComponent = function (_BaseComponent) {
  10677.   _inherits(SurveyComponent, _BaseComponent);
  10678.  
  10679.   function SurveyComponent() {
  10680.     _classCallCheck(this, SurveyComponent);
  10681.  
  10682.     return _possibleConstructorReturn(this, (SurveyComponent.__proto__ || Object.getPrototypeOf(SurveyComponent)).apply(this, arguments));
  10683.   }
  10684.  
  10685.   _createClass(SurveyComponent, [{
  10686.     key: 'build',
  10687.     value: function build() {
  10688.       var _this2 = this;
  10689.  
  10690.       if (this.viewOnly) {
  10691.         this.viewOnlyBuild();
  10692.       } else {
  10693.         this.createElement();
  10694.         var labelAtTheBottom = this.component.labelPosition === 'bottom';
  10695.         if (!labelAtTheBottom) {
  10696.           this.createLabel(this.element);
  10697.         }
  10698.         this.table = this.ce('table', {
  10699.           class: 'table table-striped table-bordered'
  10700.         });
  10701.         this.setInputStyles(this.table);
  10702.  
  10703.         // Build header.
  10704.         var thead = this.ce('thead');
  10705.         var thr = this.ce('tr');
  10706.         thr.appendChild(this.ce('td'));
  10707.         _lodash2.default.each(this.component.values, function (value) {
  10708.           var th = _this2.ce('th', {
  10709.             style: 'text-align: center;'
  10710.           });
  10711.           th.appendChild(_this2.text(value.label));
  10712.           thr.appendChild(th);
  10713.         });
  10714.         thead.appendChild(thr);
  10715.         this.table.appendChild(thead);
  10716.         // Build the body.
  10717.         var tbody = this.ce('tbody');
  10718.         _lodash2.default.each(this.component.questions, function (question) {
  10719.           var tr = _this2.ce('tr');
  10720.           var td = _this2.ce('td');
  10721.           td.appendChild(_this2.text(question.label));
  10722.           tr.appendChild(td);
  10723.           _lodash2.default.each(_this2.component.values, function (value) {
  10724.             var td = _this2.ce('td', {
  10725.               style: 'text-align: center;'
  10726.             });
  10727.             var input = _this2.ce('input', {
  10728.               type: 'radio',
  10729.               name: 'data[' + _this2.component.key + '][' + question.value + ']',
  10730.               value: value.value,
  10731.               id: _this2.id + '-' + question.value + '-' + value.value
  10732.             });
  10733.             _this2.addInput(input, td);
  10734.             tr.appendChild(td);
  10735.           });
  10736.           tbody.appendChild(tr);
  10737.         });
  10738.         this.table.appendChild(tbody);
  10739.         this.element.appendChild(this.table);
  10740.         if (labelAtTheBottom) {
  10741.           this.createLabel(this.element);
  10742.         }
  10743.         this.createDescription(this.element);
  10744.         this.restoreValue();
  10745.         if (this.shouldDisable) {
  10746.           this.disabled = true;
  10747.         }
  10748.         this.autofocus();
  10749.       }
  10750.     }
  10751.   }, {
  10752.     key: 'setValue',
  10753.     value: function setValue(value, flags) {
  10754.       var _this3 = this;
  10755.  
  10756.       flags = this.getFlags.apply(this, arguments);
  10757.       if (!value) {
  10758.         return;
  10759.       }
  10760.       var key = 'data[' + this.component.key + ']';
  10761.       _lodash2.default.each(this.component.questions, function (question) {
  10762.         _lodash2.default.each(_this3.inputs, function (input) {
  10763.           if (input.name === key + '[' + question.value + ']') {
  10764.             input.checked = input.value === value[question.value];
  10765.           }
  10766.         });
  10767.       });
  10768.       this.updateValue(flags);
  10769.     }
  10770.   }, {
  10771.     key: 'getValue',
  10772.     value: function getValue() {
  10773.       var _this4 = this;
  10774.  
  10775.       if (this.viewOnly) {
  10776.         return this.dataValue;
  10777.       }
  10778.       var value = {};
  10779.       var key = 'data[' + this.component.key + ']';
  10780.       _lodash2.default.each(this.component.questions, function (question) {
  10781.         _lodash2.default.each(_this4.inputs, function (input) {
  10782.           if (input.checked && input.name === key + '[' + question.value + ']') {
  10783.             value[question.value] = input.value;
  10784.             return false;
  10785.           }
  10786.         });
  10787.       });
  10788.       return value;
  10789.     }
  10790.   }, {
  10791.     key: 'getView',
  10792.     value: function getView(value) {
  10793.       var _this5 = this;
  10794.  
  10795.       if (!value) {
  10796.         return '';
  10797.       }
  10798.       var table = this.ce('table', {
  10799.         class: 'table table-striped table-bordered table-condensed'
  10800.       });
  10801.       var tbody = this.ce('tbody');
  10802.  
  10803.       _lodash2.default.each(value, function (value, question) {
  10804.         var row = _this5.ce('tr');
  10805.  
  10806.         var questionCell = _this5.ce('th');
  10807.         var valueCell = _this5.ce('td');
  10808.  
  10809.         var questionText = _lodash2.default.find(_this5.component.questions, ['value', question]).label;
  10810.         var valueText = _lodash2.default.find(_this5.component.values, ['value', value]).label;
  10811.  
  10812.         questionCell.appendChild(_this5.text(questionText));
  10813.         valueCell.appendChild(_this5.text(valueText));
  10814.  
  10815.         row.appendChild(questionCell);
  10816.         row.appendChild(valueCell);
  10817.  
  10818.         tbody.appendChild(row);
  10819.       });
  10820.  
  10821.       table.appendChild(tbody);
  10822.       return table.outerHTML;
  10823.     }
  10824.   }]);
  10825.  
  10826.   return SurveyComponent;
  10827. }(_Base.BaseComponent);
  10828.  
  10829. },{"../base/Base":4,"lodash":79}],34:[function(require,module,exports){
  10830. 'use strict';
  10831.  
  10832. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  10833.  
  10834. Object.defineProperty(exports, "__esModule", {
  10835.   value: true
  10836. });
  10837. exports.TableComponent = undefined;
  10838.  
  10839. var _createClass = function () {
  10840.   function defineProperties(target, props) {
  10841.     for (var i = 0; i < props.length; i++) {
  10842.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  10843.     }
  10844.   }return function (Constructor, protoProps, staticProps) {
  10845.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  10846.   };
  10847. }();
  10848.  
  10849. var _lodash = require('lodash');
  10850.  
  10851. var _lodash2 = _interopRequireDefault(_lodash);
  10852.  
  10853. var _Components = require('../Components');
  10854.  
  10855. function _interopRequireDefault(obj) {
  10856.   return obj && obj.__esModule ? obj : { default: obj };
  10857. }
  10858.  
  10859. function _classCallCheck(instance, Constructor) {
  10860.   if (!(instance instanceof Constructor)) {
  10861.     throw new TypeError("Cannot call a class as a function");
  10862.   }
  10863. }
  10864.  
  10865. function _possibleConstructorReturn(self, call) {
  10866.   if (!self) {
  10867.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  10868.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  10869. }
  10870.  
  10871. function _inherits(subClass, superClass) {
  10872.   if (typeof superClass !== "function" && superClass !== null) {
  10873.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  10874.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  10875. }
  10876.  
  10877. var TableComponent = exports.TableComponent = function (_FormioComponents) {
  10878.   _inherits(TableComponent, _FormioComponents);
  10879.  
  10880.   function TableComponent() {
  10881.     _classCallCheck(this, TableComponent);
  10882.  
  10883.     return _possibleConstructorReturn(this, (TableComponent.__proto__ || Object.getPrototypeOf(TableComponent)).apply(this, arguments));
  10884.   }
  10885.  
  10886.   _createClass(TableComponent, [{
  10887.     key: 'build',
  10888.     value: function build() {
  10889.       var _this2 = this;
  10890.  
  10891.       this.element = this.ce('div', {
  10892.         class: 'table-responsive'
  10893.       });
  10894.  
  10895.       var tableClass = 'table ';
  10896.       _lodash2.default.each(['striped', 'bordered', 'hover', 'condensed'], function (prop) {
  10897.         if (_this2.component[prop]) {
  10898.           tableClass += 'table-' + prop + ' ';
  10899.         }
  10900.       });
  10901.       var table = this.ce('table', {
  10902.         class: tableClass
  10903.       });
  10904.  
  10905.       // Build the header.
  10906.       if (this.component.header && this.component.header.length) {
  10907.         var thead = this.ce('thead');
  10908.         var thr = this.ce('tr');
  10909.         _lodash2.default.each(this.component.header, function (header) {
  10910.           var th = _this2.ce('th');
  10911.           th.appendChild(_this2.text(header));
  10912.           thr.appendChild(th);
  10913.         });
  10914.         thead.appendChild(thr);
  10915.         table.appendChild(thead);
  10916.       }
  10917.  
  10918.       // Build the body.
  10919.       var tbody = this.ce('tbody');
  10920.       _lodash2.default.each(this.component.rows, function (row) {
  10921.         var tr = _this2.ce('tr');
  10922.         _lodash2.default.each(row, function (column) {
  10923.           var td = _this2.ce('td');
  10924.           _lodash2.default.each(column.components, function (comp) {
  10925.             _this2.addComponent(comp, td);
  10926.           });
  10927.           tr.appendChild(td);
  10928.         });
  10929.         tbody.appendChild(tr);
  10930.       });
  10931.       table.appendChild(tbody);
  10932.       this.element.appendChild(table);
  10933.     }
  10934.   }]);
  10935.  
  10936.   return TableComponent;
  10937. }(_Components.FormioComponents);
  10938.  
  10939. },{"../Components":1,"lodash":79}],35:[function(require,module,exports){
  10940. 'use strict';
  10941.  
  10942. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  10943.  
  10944. Object.defineProperty(exports, "__esModule", {
  10945.   value: true
  10946. });
  10947. exports.TextAreaComponent = undefined;
  10948.  
  10949. var _createClass = function () {
  10950.   function defineProperties(target, props) {
  10951.     for (var i = 0; i < props.length; i++) {
  10952.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  10953.     }
  10954.   }return function (Constructor, protoProps, staticProps) {
  10955.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  10956.   };
  10957. }();
  10958.  
  10959. var _get = function get(object, property, receiver) {
  10960.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  10961.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  10962.       return undefined;
  10963.     } else {
  10964.       return get(parent, property, receiver);
  10965.     }
  10966.   } else if ("value" in desc) {
  10967.     return desc.value;
  10968.   } else {
  10969.     var getter = desc.get;if (getter === undefined) {
  10970.       return undefined;
  10971.     }return getter.call(receiver);
  10972.   }
  10973. };
  10974.  
  10975. var _TextField = require('../textfield/TextField');
  10976.  
  10977. var _Base = require('../base/Base');
  10978.  
  10979. function _classCallCheck(instance, Constructor) {
  10980.   if (!(instance instanceof Constructor)) {
  10981.     throw new TypeError("Cannot call a class as a function");
  10982.   }
  10983. }
  10984.  
  10985. function _possibleConstructorReturn(self, call) {
  10986.   if (!self) {
  10987.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  10988.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  10989. }
  10990.  
  10991. function _inherits(subClass, superClass) {
  10992.   if (typeof superClass !== "function" && superClass !== null) {
  10993.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  10994.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  10995. } /* globals Quill */
  10996.  
  10997. var TextAreaComponent = exports.TextAreaComponent = function (_TextFieldComponent) {
  10998.   _inherits(TextAreaComponent, _TextFieldComponent);
  10999.  
  11000.   function TextAreaComponent(component, options, data) {
  11001.     _classCallCheck(this, TextAreaComponent);
  11002.  
  11003.     // Never submit on enter for text areas.
  11004.     var _this = _possibleConstructorReturn(this, (TextAreaComponent.__proto__ || Object.getPrototypeOf(TextAreaComponent)).call(this, component, options, data));
  11005.  
  11006.     _this.options.submitOnEnter = false;
  11007.     return _this;
  11008.   }
  11009.  
  11010.   _createClass(TextAreaComponent, [{
  11011.     key: 'wysiwygDefault',
  11012.     value: function wysiwygDefault() {
  11013.       return {
  11014.         theme: 'snow',
  11015.         placeholder: this.component.placeholder,
  11016.         modules: {
  11017.           toolbar: [[{ 'size': ['small', false, 'large', 'huge'] }], // custom dropdown
  11018.           [{ 'header': [1, 2, 3, 4, 5, 6, false] }], [{ 'font': [] }], ['bold', 'italic', 'underline', 'strike', { 'script': 'sub' }, { 'script': 'super' }, 'clean'], [{ 'color': [] }, { 'background': [] }], [{ 'list': 'ordered' }, { 'list': 'bullet' }, { 'indent': '-1' }, { 'indent': '+1' }, { 'align': [] }], ['blockquote', 'code-block'], ['link', 'image', 'video', 'formula', 'source']]
  11019.         }
  11020.       };
  11021.     }
  11022.   }, {
  11023.     key: 'createInput',
  11024.     value: function createInput(container) {
  11025.       var _this2 = this;
  11026.  
  11027.       if (!this.component.wysiwyg) {
  11028.         return _get(TextAreaComponent.prototype.__proto__ || Object.getPrototypeOf(TextAreaComponent.prototype), 'createInput', this).call(this, container);
  11029.       }
  11030.  
  11031.       // Normalize the configurations.
  11032.       if (this.component.wysiwyg.toolbarGroups) {
  11033.         console.warn('The WYSIWYG settings are configured for CKEditor. For this renderer, you will need to use configurations for the Quill Editor. See https://quilljs.com/docs/configuration for more information.');
  11034.         this.component.wysiwyg = this.wysiwygDefault();
  11035.       }
  11036.       if (typeof this.component.wysiwyg === 'boolean') {
  11037.         this.component.wysiwyg = this.wysiwygDefault();
  11038.       }
  11039.  
  11040.       // Add the input.
  11041.       this.input = this.ce('div', {
  11042.         class: 'formio-wysiwyg-editor'
  11043.       });
  11044.       container.appendChild(this.input);
  11045.  
  11046.       // Lazy load the quill css.
  11047.       _Base.BaseComponent.requireLibrary('quill-css-' + this.component.wysiwyg.theme, 'Quill', [{ type: 'styles', src: 'https://cdn.quilljs.com/1.3.5/quill.' + this.component.wysiwyg.theme + '.css' }], true);
  11048.  
  11049.       // Lazy load the quill library.
  11050.       this.quillReady = _Base.BaseComponent.requireLibrary('quill', 'Quill', 'https://cdn.quilljs.com/1.3.5/quill.min.js', true).then(function () {
  11051.         _this2.quill = new Quill(_this2.input, _this2.component.wysiwyg);
  11052.         _this2.quill.root.spellcheck = _this2.component.spellcheck;
  11053.  
  11054.         /** This block of code adds the [source] capabilities.  See https://codepen.io/anon/pen/ZyEjrQ **/
  11055.         var txtArea = document.createElement('textarea');
  11056.         txtArea.setAttribute('class', 'quill-source-code');
  11057.         _this2.quill.addContainer('ql-custom').appendChild(txtArea);
  11058.  
  11059.         // Allows users to skip toolbar items when tabbing though form
  11060.         var elm = document.querySelectorAll('.ql-formats > button');
  11061.         for (var i = 0; i < elm.length; i++) {
  11062.           elm[i].setAttribute('tabindex', '-1');
  11063.         }
  11064.  
  11065.         var qlSource = document.querySelector('.ql-source');
  11066.         if (qlSource) {
  11067.           qlSource.addEventListener('click', function () {
  11068.             if (txtArea.style.display === 'inherit') {
  11069.               _this2.quill.clipboard.dangerouslyPasteHTML(txtArea.value);
  11070.             }
  11071.             txtArea.style.display = txtArea.style.display === 'none' ? 'inherit' : 'none';
  11072.           });
  11073.         }
  11074.         /** END CODEBLOCK **/
  11075.  
  11076.         _this2.quill.on('text-change', function () {
  11077.           txtArea.value = _this2.quill.root.innerHTML;
  11078.           _this2.updateValue(true);
  11079.         });
  11080.  
  11081.         if (_this2.options.readOnly || _this2.component.disabled) {
  11082.           _this2.quill.disable();
  11083.         }
  11084.  
  11085.         return _this2.quill;
  11086.       });
  11087.  
  11088.       return this.input;
  11089.     }
  11090.   }, {
  11091.     key: 'isEmpty',
  11092.     value: function isEmpty(value) {
  11093.       if (this.quill) {
  11094.         return !value || value === '<p><br></p>';
  11095.       } else {
  11096.         return _get(TextAreaComponent.prototype.__proto__ || Object.getPrototypeOf(TextAreaComponent.prototype), 'isEmpty', this).call(this, value);
  11097.       }
  11098.     }
  11099.   }, {
  11100.     key: 'setValue',
  11101.     value: function setValue(value, flags) {
  11102.       var _this3 = this;
  11103.  
  11104.       if (!this.component.wysiwyg) {
  11105.         return _get(TextAreaComponent.prototype.__proto__ || Object.getPrototypeOf(TextAreaComponent.prototype), 'setValue', this).call(this, value, flags);
  11106.       }
  11107.  
  11108.       this.quillReady.then(function (quill) {
  11109.         quill.clipboard.dangerouslyPasteHTML(value);
  11110.         _this3.updateValue(flags);
  11111.       });
  11112.     }
  11113.   }, {
  11114.     key: 'getValue',
  11115.     value: function getValue() {
  11116.       if (this.viewOnly) {
  11117.         return this.dataValue;
  11118.       }
  11119.       return this.quill ? this.quill.root.innerHTML : _get(TextAreaComponent.prototype.__proto__ || Object.getPrototypeOf(TextAreaComponent.prototype), 'getValue', this).call(this);
  11120.     }
  11121.   }, {
  11122.     key: 'elementInfo',
  11123.     value: function elementInfo() {
  11124.       var info = _get(TextAreaComponent.prototype.__proto__ || Object.getPrototypeOf(TextAreaComponent.prototype), 'elementInfo', this).call(this);
  11125.       info.type = 'textarea';
  11126.       if (this.component.rows) {
  11127.         info.attr.rows = this.component.rows;
  11128.       }
  11129.       return info;
  11130.     }
  11131.   }, {
  11132.     key: 'defaultValue',
  11133.     get: function get() {
  11134.       var defaultValue = _get(TextAreaComponent.prototype.__proto__ || Object.getPrototypeOf(TextAreaComponent.prototype), 'defaultValue', this);
  11135.       if (this.component.wysiwyg && !defaultValue) {
  11136.         defaultValue = '<p><br></p>';
  11137.       }
  11138.       return defaultValue;
  11139.     }
  11140.   }]);
  11141.  
  11142.   return TextAreaComponent;
  11143. }(_TextField.TextFieldComponent);
  11144.  
  11145. },{"../base/Base":4,"../textfield/TextField":36}],36:[function(require,module,exports){
  11146. 'use strict';
  11147.  
  11148. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  11149.  
  11150. Object.defineProperty(exports, "__esModule", {
  11151.   value: true
  11152. });
  11153. exports.TextFieldComponent = undefined;
  11154.  
  11155. var _createClass = function () {
  11156.   function defineProperties(target, props) {
  11157.     for (var i = 0; i < props.length; i++) {
  11158.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  11159.     }
  11160.   }return function (Constructor, protoProps, staticProps) {
  11161.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  11162.   };
  11163. }();
  11164.  
  11165. var _get = function get(object, property, receiver) {
  11166.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  11167.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  11168.       return undefined;
  11169.     } else {
  11170.       return get(parent, property, receiver);
  11171.     }
  11172.   } else if ("value" in desc) {
  11173.     return desc.value;
  11174.   } else {
  11175.     var getter = desc.get;if (getter === undefined) {
  11176.       return undefined;
  11177.     }return getter.call(receiver);
  11178.   }
  11179. };
  11180.  
  11181. var _Base = require('../base/Base');
  11182.  
  11183. function _classCallCheck(instance, Constructor) {
  11184.   if (!(instance instanceof Constructor)) {
  11185.     throw new TypeError("Cannot call a class as a function");
  11186.   }
  11187. }
  11188.  
  11189. function _possibleConstructorReturn(self, call) {
  11190.   if (!self) {
  11191.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  11192.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  11193. }
  11194.  
  11195. function _inherits(subClass, superClass) {
  11196.   if (typeof superClass !== "function" && superClass !== null) {
  11197.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  11198.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  11199. }
  11200.  
  11201. var TextFieldComponent = exports.TextFieldComponent = function (_BaseComponent) {
  11202.   _inherits(TextFieldComponent, _BaseComponent);
  11203.  
  11204.   function TextFieldComponent() {
  11205.     _classCallCheck(this, TextFieldComponent);
  11206.  
  11207.     return _possibleConstructorReturn(this, (TextFieldComponent.__proto__ || Object.getPrototypeOf(TextFieldComponent)).apply(this, arguments));
  11208.   }
  11209.  
  11210.   _createClass(TextFieldComponent, [{
  11211.     key: 'elementInfo',
  11212.     value: function elementInfo() {
  11213.       var info = _get(TextFieldComponent.prototype.__proto__ || Object.getPrototypeOf(TextFieldComponent.prototype), 'elementInfo', this).call(this);
  11214.       info.type = 'input';
  11215.  
  11216.       if (this.component.hasOwnProperty('spellcheck')) {
  11217.         info.attr.spellcheck = this.component.spellcheck;
  11218.       }
  11219.  
  11220.       if (this.component.mask) {
  11221.         info.attr.type = 'password';
  11222.       } else {
  11223.         info.attr.type = 'text';
  11224.       }
  11225.       info.changeEvent = 'input';
  11226.       return info;
  11227.     }
  11228.   }, {
  11229.     key: 'emptyValue',
  11230.     get: function get() {
  11231.       return '';
  11232.     }
  11233.   }]);
  11234.  
  11235.   return TextFieldComponent;
  11236. }(_Base.BaseComponent);
  11237.  
  11238. },{"../base/Base":4}],37:[function(require,module,exports){
  11239. 'use strict';
  11240.  
  11241. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  11242.  
  11243. Object.defineProperty(exports, "__esModule", {
  11244.   value: true
  11245. });
  11246. exports.TimeComponent = undefined;
  11247.  
  11248. var _createClass = function () {
  11249.   function defineProperties(target, props) {
  11250.     for (var i = 0; i < props.length; i++) {
  11251.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  11252.     }
  11253.   }return function (Constructor, protoProps, staticProps) {
  11254.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  11255.   };
  11256. }();
  11257.  
  11258. var _get = function get(object, property, receiver) {
  11259.   if (object === null) object = Function.prototype;var desc = Object.getOwnPropertyDescriptor(object, property);if (desc === undefined) {
  11260.     var parent = Object.getPrototypeOf(object);if (parent === null) {
  11261.       return undefined;
  11262.     } else {
  11263.       return get(parent, property, receiver);
  11264.     }
  11265.   } else if ("value" in desc) {
  11266.     return desc.value;
  11267.   } else {
  11268.     var getter = desc.get;if (getter === undefined) {
  11269.       return undefined;
  11270.     }return getter.call(receiver);
  11271.   }
  11272. };
  11273.  
  11274. var _moment = require('moment');
  11275.  
  11276. var _moment2 = _interopRequireDefault(_moment);
  11277.  
  11278. var _TextField = require('../textfield/TextField');
  11279.  
  11280. function _interopRequireDefault(obj) {
  11281.   return obj && obj.__esModule ? obj : { default: obj };
  11282. }
  11283.  
  11284. function _classCallCheck(instance, Constructor) {
  11285.   if (!(instance instanceof Constructor)) {
  11286.     throw new TypeError("Cannot call a class as a function");
  11287.   }
  11288. }
  11289.  
  11290. function _possibleConstructorReturn(self, call) {
  11291.   if (!self) {
  11292.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  11293.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  11294. }
  11295.  
  11296. function _inherits(subClass, superClass) {
  11297.   if (typeof superClass !== "function" && superClass !== null) {
  11298.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  11299.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  11300. }
  11301.  
  11302. var TimeComponent = exports.TimeComponent = function (_TextFieldComponent) {
  11303.   _inherits(TimeComponent, _TextFieldComponent);
  11304.  
  11305.   function TimeComponent() {
  11306.     _classCallCheck(this, TimeComponent);
  11307.  
  11308.     return _possibleConstructorReturn(this, (TimeComponent.__proto__ || Object.getPrototypeOf(TimeComponent)).apply(this, arguments));
  11309.   }
  11310.  
  11311.   _createClass(TimeComponent, [{
  11312.     key: 'elementInfo',
  11313.     value: function elementInfo() {
  11314.       var info = _get(TimeComponent.prototype.__proto__ || Object.getPrototypeOf(TimeComponent.prototype), 'elementInfo', this).call(this);
  11315.       info.attr.type = 'time';
  11316.       return info;
  11317.     }
  11318.   }, {
  11319.     key: 'getValueAt',
  11320.     value: function getValueAt(index) {
  11321.       if (!this.inputs.length || !this.inputs[index]) {
  11322.         return null;
  11323.       }
  11324.       var val = this.inputs[index].value;
  11325.       if (!val) {
  11326.         return null;
  11327.       }
  11328.  
  11329.       return (0, _moment2.default)(val, this.component.format).format('HH:mm:ss');
  11330.     }
  11331.   }, {
  11332.     key: 'setValueAt',
  11333.     value: function setValueAt(index, value) {
  11334.       this.inputs[index].value = (0, _moment2.default)(value, 'HH:mm:ss').format(this.component.format);
  11335.     }
  11336.   }]);
  11337.  
  11338.   return TimeComponent;
  11339. }(_TextField.TextFieldComponent);
  11340.  
  11341. },{"../textfield/TextField":36,"moment":80}],38:[function(require,module,exports){
  11342. 'use strict';
  11343.  
  11344. var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  11345.  
  11346. Object.defineProperty(exports, "__esModule", {
  11347.   value: true
  11348. });
  11349. exports.UnknownComponent = undefined;
  11350.  
  11351. var _createClass = function () {
  11352.   function defineProperties(target, props) {
  11353.     for (var i = 0; i < props.length; i++) {
  11354.       var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);
  11355.     }
  11356.   }return function (Constructor, protoProps, staticProps) {
  11357.     if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;
  11358.   };
  11359. }();
  11360.  
  11361. var _Base = require('../base/Base');
  11362.  
  11363. function _classCallCheck(instance, Constructor) {
  11364.   if (!(instance instanceof Constructor)) {
  11365.     throw new TypeError("Cannot call a class as a function");
  11366.   }
  11367. }
  11368.  
  11369. function _possibleConstructorReturn(self, call) {
  11370.   if (!self) {
  11371.     throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  11372.   }return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self;
  11373. }
  11374.  
  11375. function _inherits(subClass, superClass) {
  11376.   if (typeof superClass !== "function" && superClass !== null) {
  11377.     throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof(superClass)));
  11378.   }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  11379. }
  11380.  
  11381. var UnknownComponent = exports.UnknownComponent = function (_BaseComponent) {
  11382.   _inherits(UnknownComponent, _BaseComponent);
  11383.  
  11384.   function UnknownComponent() {
  11385.     _classCallCheck(this, UnknownComponent);
  11386.  
  11387.     return _possibleConstructorReturn(this, (UnknownComponent.__pr